53

I am writing an android app in which I need to answer an incoming call, do some work and then end the call. After all the Googling I could find two different ways to achieve this both of which do not work with recent versions of Android, specifically after 4.1, Jelly Bean.

I.) Access "com.android.internal.telephony.ITelephony" using Java Reflection in the Broadcast receiver for "android.intent.action.PHONE_STATE". Below sample code can be found in hundreds of related post:

public class PhoneCallReceiver extends BroadcastReceiver {
 Context context = null;
 private static final String TAG = "Phone call";
 private ITelephony telephonyService;

@Override
 public void onReceive(Context context, Intent intent) {
  if (!intent.getAction().equals("android.intent.action.PHONE_STATE")) 
    return;

  Log.v(TAG, "Receving....");
  TelephonyManager telephony = (TelephonyManager) 
  context.getSystemService(Context.TELEPHONY_SERVICE);  
  try {
      Log.v(TAG, "Get getTeleService...");
      Class c = Class.forName(telephony.getClass().getName());
      Method m = c.getDeclaredMethod("getITelephony");
      m.setAccessible(true);
      telephonyService = (ITelephony) m.invoke(telephony);
      telephonyService.silenceRinger();
      Log.v(TAG, "Answering Call now...");
      telephonyService.answerRingingCall();
      Log.v(TAG, "Call answered...");
      //telephonyService.endCall();
  } catch (Exception e) {
   e.printStackTrace();
   Log.e(TAG,
           "FATAL ERROR: could not connect to telephony subsystem");
   Log.e(TAG, "Exception object: " + e);
  }
 }
}

The problem with this code is that

<uses-permission android:name="android.permission.MODIFY_PHONE_STATE" /> 

is required for this method to work, and this permission has been defined as "for system apps only" from android v 2.3. In short, normal user apps can not define this permission in the manifest file anymore.

II.) Another way is to simulate pushing of the Headset hook which makes Android answer the call. This is done by broadcasting the "Intent.ACTION_MEDIA_BUTTON" as shown in below code.

public class PhoneCallReceiver extends BroadcastReceiver {
 Context context = null;
 private static final String TAG = "Phone call";

 @Override
 public void onReceive(Context context, Intent intent) {
     if (!intent.getAction().equals("android.intent.action.PHONE_STATE")) 
         return;

     String state = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
     if (state.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
         String number = intent.getStringExtra(TelephonyManager.EXTRA_INCOMING_NUMBER);

         Intent answer = new Intent(Intent.ACTION_MEDIA_BUTTON);
         answer.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_HEADSETHOOK));
         context.sendOrderedBroadcast(answer, null);
         Log.d(TAG, "Answered incoming call from: " + number);
     }   
     return;
 } 
}

This method works till Android 4.1 after which android has restricted user apps from broadcasting "Intent.ACTION_MEDIA_BUTTON".

So my conclusion is that currently there is no way how we can achieve this in Android 4.1 or later.

Has anybody else found any other solution or workaround to this problem?

Cœur
  • 37,241
  • 25
  • 195
  • 267
Piyush
  • 728
  • 1
  • 8
  • 11
  • 3
    The answer is that Google doesn't want you to do this. That's why they're blocking every method found. Even if you find a 3rd way, I'd expect it to not work on the next version of the OS. – Gabe Sechan Mar 18 '13 at 16:14
  • 7
    Apparently Google has restricted these features as a security measure. I understand that making a new call from a user app should be prohibited, but why restrict apps from answering an incoming call. Due to this, users must be missing call barring or local answering machine on Android isnt it ? – Piyush Mar 18 '13 at 16:14
  • @Gabe Sechan Where did you find the information that Google are preventing these activities? I'd be interested in reading the official word – WonderWorker Apr 18 '13 at 10:37
  • 2
    The fact that every method people have used has been shut off in the next release. – Gabe Sechan Apr 18 '13 at 14:16

9 Answers9

17

This works from Android 2.2 to 4.0 and now after adding the try catch to the last line it works for 4.1.2 and 4.2 Frankly speaking dont know how it works but it works for me.

Log.d(tag, "InSecond Method Ans Call");
// froyo and beyond trigger on buttonUp instead of buttonDown
Intent buttonUp = new Intent(Intent.ACTION_MEDIA_BUTTON);
buttonUp.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_HEADSETHOOK));
sendOrderedBroadcast(buttonUp, "android.permission.CALL_PRIVILEGED");

Intent headSetUnPluggedintent = new Intent(Intent.ACTION_HEADSET_PLUG);
headSetUnPluggedintent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
headSetUnPluggedintent.putExtra("state", 0);
headSetUnPluggedintent.putExtra("name", "Headset");
try {
    sendOrderedBroadcast(headSetUnPluggedintent, null);
} catch (Exception e) { 
    e.printStackTrace();
}

This is working for me in Android 4.1.2 as well as i have tested on 4.2 This still gives an exception which is handled.

Edit for End Call

Hope this helps all the people looking for total solution for answer and end call.

/**
 * Reject button click listener will reject the incoming call.
 */
private class RejectCallOnClickListener implements OnClickListener {
    @Override
    public void onClick(View v) {
        Log.d(tag, "OnRejectButton: " + "Reject OnClick");
        ignoreCall();
        exitCleanly();
    }
}

/**
 * ignore incoming calls
 */
private void ignoreCall() {
    if (USE_ITELEPHONY)
        ignoreCallAidl();
    else
        ignoreCallPackageRestart();
}
/**
 * AIDL/ITelephony technique for ignoring calls
 */
private void ignoreCallAidl() {
    try {
        // telephonyService.silenceRinger();

        telephonyService.endCall();
    } catch (RemoteException e) {
        e.printStackTrace();
        Log.d(tag, "ignoreCall: " + "Error: " + e.getMessage());

    } catch (Exception e) {
        e.printStackTrace();
        Log.d(tag, "ignoreCall" + "Error: " + e.getMessage());

    }
}
/**
 * package restart technique for ignoring calls
 */
private void ignoreCallPackageRestart() {
    ActivityManager am = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
    am.restartPackage("com.android.providers.telephony");
    am.restartPackage("com.android.phone");
}
/**
 * cleanup and exit routine
 */
private void exitCleanly() {
    unHookReceiver();
    this.finish();

}
Nick Cardoso
  • 20,807
  • 14
  • 73
  • 124
PravinDodia
  • 3,271
  • 1
  • 18
  • 22
  • I have used the code in VirtualModelz APP You Can check the working app VirtualModelz, it works on 2.2 and 4.1.2 if you want i can share market link. it works for sure. – PravinDodia May 19 '13 at 20:39
  • 1
    @ PravinDodia Can anyone help me I need a working version of ending a call from a particular number using any technique. I need a working version on 2.3.3+ Device can you help me ? – Pro_Zeck May 26 '13 at 01:11
  • @Pro_Zeck are you trying to end the call from your own activity (Screen). ? if yes then let me see what can be done with 4.1.2 os as they don't allow to do that from any activity which is not in system. – PravinDodia May 27 '13 at 13:37
  • @ pravinDodia yes I am creating s list called blacklist whose number I want to block and I want this function of your which you seem to solved it. Can you talk on Skype (aftab_sikander) – Pro_Zeck May 27 '13 at 19:45
  • @Pro_Zeck Sure we can talk over skype (pravindodia). – PravinDodia May 27 '13 at 23:21
  • @PravinDodia, yes it works... not quite sure how it is working by just adding a try-catch. – Piyush Jul 03 '13 at 07:43
  • @PravinDodia: Hi, is it possible to end call programmatically ? – Mehul Joisar Feb 24 '14 at 12:26
  • @MehulJoisar yes it is possible to end the call programmatically!!! i have updated the code so that you can have a better understanding for start call and end call. – PravinDodia Feb 24 '14 at 15:28
  • @PravinDodia: when should I use `ignoreCallAidl()` and when should I use `ignoreCallPackageRestart()` ? – Mehul Joisar Feb 25 '14 at 04:47
  • @MehulJoisar It depends i have use if else case for my case but for your case you can use in try 1 method, if it fails you's can keep the other method so that , it will end the call for sure. Though ignoreCallAidl is from the telephony method, and the ignorecallpackageRestart, is to restart the whole telephony package. – PravinDodia Feb 26 '14 at 13:15
  • 1
    am.restartPackage() is deprecated - it's a wrapper for killBackgroundProcess(String) and the system will take care of restarting the service appropriately. So code inside ignoreCallPackageRestart() should be am.killBackgroundProcesses("com.android.providers.telephony"); am.killBackgroundProcesses("com.android.phone"); – DritanX Nov 13 '15 at 18:13
  • -keep class com.android.internal.telephony.ITelephony { *; } -keep class com.android.internal.telephony.ITelephony$* { *; } add these two line to proguard, or it will failed in release mode – hoot Aug 13 '16 at 05:11
  • @PravinDodia I am facing issue mentioned in this question, can you please help me out: https://stackoverflow.com/questions/53866038/how-to-block-a-call-when-first-call-is-ongoing – Suhas Bachewar Dec 20 '18 at 10:11
  • @Suhas Bachewar I have checked your question and at present there is no API or alternative solution to achieve your scenario, it can only be done using Phone network API and Advance Call State listener which are System API, so until and unless your phone is rooted or you sign your app with system, it cannot be achieved. – PravinDodia Dec 20 '18 at 10:24
  • @PravinDodia Thanks for the update.. can you please share the link to show as proof to my seniors. :P – Suhas Bachewar Dec 20 '18 at 10:27
  • @SuhasBachewar you need proof of something which cannot be achieved ? its logical and functionality is limited to OEM Please follow the below link for Precise Call State listener https://stackoverflow.com/questions/32821952/how-to-use-precisecallstate review the comments. – PravinDodia Dec 20 '18 at 12:00
8

My application has been using the following code to answer the phone for about 6 months:

Intent i = new Intent(Intent.ACTION_MEDIA_BUTTON);
i.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP,
            KeyEvent.KEYCODE_HEADSETHOOK));
context.sendOrderedBroadcast(i, null);

I have tested this on Android Versions from 2.2 to 4.2.2. I have not seen a SecurityException broadcasting "Intent.ACTION_MEDIA_BUTTON" in my testing n a 4.2.2 device, nor have I seen crash reports from the Play Store indicating such exceptions are occurring.

I will say that this does not always work. It does not work on HTC devices due to the fact that HTC devices have a HeadsetObeserver that listen for the actually plugging in of a wired headset. Without this event, which it is currently a SecurityException for a third party app to broadcast, the HeadsetHook KeyEvent goes ignored.

The previous answers are misleading. The following code block does nothing:

Intent headSetUnPluggedintent = new Intent(Intent.ACTION_HEADSET_PLUG);
headSetUnPluggedintent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
headSetUnPluggedintent.putExtra("state", 0);
headSetUnPluggedintent.putExtra("name", "Headset");
try {
    sendOrderedBroadcast(headSetUnPluggedintent, null);
} catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

except generate a SecurityException and catch it.

In the other answers where the code works, it is because of the KeyEvent.KEYCODE_HEADSETHOOK being broadcast.

maddesa
  • 1,014
  • 7
  • 18
8

Try this Answer for end the call using pro grammatically. Its working fine for me.

try {

    String serviceManagerName = "android.os.ServiceManager";
    String serviceManagerNativeName = "android.os.ServiceManagerNative";
    String telephonyName = "com.android.internal.telephony.ITelephony";

    Class telephonyClass;
    Class telephonyStubClass;
    Class serviceManagerClass;
    Class serviceManagerStubClass;
    Class serviceManagerNativeClass;
    Class serviceManagerNativeStubClass;

    Method telephonyCall;
    Method telephonyEndCall;
    Method telephonyAnswerCall;
    Method getDefault;

    Method[] temps;
    Constructor[] serviceManagerConstructor;

    // Method getService;
    Object telephonyObject;
    Object serviceManagerObject;

    telephonyClass = Class.forName(telephonyName);
    telephonyStubClass = telephonyClass.getClasses()[0];
    serviceManagerClass = Class.forName(serviceManagerName);
    serviceManagerNativeClass = Class.forName(serviceManagerNativeName);

    Method getService = // getDefaults[29];
            serviceManagerClass.getMethod("getService", String.class);

    Method tempInterfaceMethod = serviceManagerNativeClass.getMethod(
            "asInterface", IBinder.class);

    Binder tmpBinder = new Binder();
    tmpBinder.attachInterface(null, "fake");

    serviceManagerObject = tempInterfaceMethod.invoke(null, tmpBinder);
    IBinder retbinder = (IBinder) getService.invoke(serviceManagerObject, "phone");
    Method serviceMethod = telephonyStubClass.getMethod("asInterface", IBinder.class);

    telephonyObject = serviceMethod.invoke(null, retbinder);
    //telephonyCall = telephonyClass.getMethod("call", String.class);
    telephonyEndCall = telephonyClass.getMethod("endCall");
    //telephonyAnswerCall = telephonyClass.getMethod("answerRingingCall");

    telephonyEndCall.invoke(telephonyObject);

} catch (Exception e) {
    e.printStackTrace();
    Log.error(DialerActivity.this,
            "FATAL ERROR: could not connect to telephony subsystem");
    Log.error(DialerActivity.this, "Exception object: " + e);
}
netpork
  • 552
  • 7
  • 20
Jebasuthan
  • 5,538
  • 6
  • 35
  • 55
7

As a conclusion to this thread, here is the code that works for me for Android 4.2.2.

--> Call is answered by simulating push of headset hook and keeping the broadcast in try-catch as mentioned by @PravinDodia in abouve thread. (Observe that an exception is thrown and handled in catch and the call is answered anyway. So I guess we can just ignore this exception and continue living life as if nothing happened! )

--> Call is disconnected using ITelephony.

public class PhoneCallReceiver extends BroadcastReceiver {
 Context context = null;
 private static final String TAG = "Phone call";

 @Override
 public void onReceive(Context context, Intent intent) {
     if (!intent.getAction().equals("android.intent.action.PHONE_STATE")) 
         return;
     else {
         String state = intent.getStringExtra(TelephonyManager.EXTRA_STATE);

         if (state.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
             answerPhoneHeadsethook(context, intent);
             return;
         }
         else if(state.equals(TelephonyManager.EXTRA_STATE_OFFHOOK)){
             Log.d(TAG, "CALL ANSWERED NOW!!");
             try {
                    synchronized(this) {
                        Log.d(TAG, "Waiting for 10 sec ");
                        this.wait(10000);
                    }
                }
                catch(Exception e) {
                    Log.d(TAG, "Exception while waiting !!");
                    e.printStackTrace();
                }
             disconnectPhoneItelephony(context);
             return;
         }
         else {
             Log.d(TAG, "ALL DONE ...... !!");
         }
     }  
 }

 public void answerPhoneHeadsethook(Context context, Intent intent) {
     String state = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
     if (state.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
         String number = intent.getStringExtra(TelephonyManager.EXTRA_INCOMING_NUMBER);
         Log.d(TAG, "Incoming call from: " + number);
         Intent buttonUp = new Intent(Intent.ACTION_MEDIA_BUTTON);             
         buttonUp.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_HEADSETHOOK));
         try {
             context.sendOrderedBroadcast(buttonUp, "android.permission.CALL_PRIVILEGED");
             Log.d(TAG, "ACTION_MEDIA_BUTTON broadcasted...");
         }
         catch (Exception e) {
             Log.d(TAG, "Catch block of ACTION_MEDIA_BUTTON broadcast !");
         }

         Intent headSetUnPluggedintent = new Intent(Intent.ACTION_HEADSET_PLUG);
         headSetUnPluggedintent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
         headSetUnPluggedintent.putExtra("state", 1); // 0 = unplugged  1 = Headset with microphone 2 = Headset without microphone
         headSetUnPluggedintent.putExtra("name", "Headset");
         // TODO: Should we require a permission?
         try {
             context.sendOrderedBroadcast(headSetUnPluggedintent, null);
             Log.d(TAG, "ACTION_HEADSET_PLUG broadcasted ...");
         }
         catch (Exception e) {
                // TODO Auto-generated catch block
                //e.printStackTrace();
                Log.d(TAG, "Catch block of ACTION_HEADSET_PLUG broadcast");
                Log.d(TAG, "Call Answered From Catch Block !!");
         }
         Log.d(TAG, "Answered incoming call from: " + number);  
    }
    Log.d(TAG, "Call Answered using headsethook");
 }

 public static void disconnectPhoneItelephony(Context context) {
     ITelephony telephonyService;
     Log.v(TAG, "Now disconnecting using ITelephony....");
      TelephonyManager telephony = (TelephonyManager) 
      context.getSystemService(Context.TELEPHONY_SERVICE);  
      try {
          Log.v(TAG, "Get getTeleService...");
          Class c = Class.forName(telephony.getClass().getName());
          Method m = c.getDeclaredMethod("getITelephony");
          m.setAccessible(true);
          telephonyService = (ITelephony) m.invoke(telephony);
          //telephonyService.silenceRinger();
          Log.v(TAG, "Disconnecting Call now...");
          //telephonyService.answerRingingCall();
          //telephonyService.endcall();
          Log.v(TAG, "Call disconnected...");
          telephonyService.endCall();
      } catch (Exception e) {
       e.printStackTrace();
       Log.e(TAG,
               "FATAL ERROR: could not connect to telephony subsystem");
       Log.e(TAG, "Exception object: " + e);
      }
 }
}

At least the disconnect functionality works and we know how it works. So those who want to develop a Call Barring application can go ahead. For those like me who want to answer a call, I guess we can use this for now and only hope that it does not stop working in the next version.

Piyush
  • 728
  • 1
  • 8
  • 11
3

Try this :

Intent buttonDown = new Intent(Intent.ACTION_MEDIA_BUTTON);
buttonDown.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_HEADSETHOOK));
context.sendOrderedBroadcast(buttonDown, "android.permission.CALL_PRIVILEGED");

// froyo and beyond trigger on buttonUp instead of buttonDown
Intent buttonUp = new Intent(Intent.ACTION_MEDIA_BUTTON);
buttonUp.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_HEADSETHOOK));
context.sendOrderedBroadcast(buttonUp, "android.permission.CALL_PRIVILEGED");

Add permissions in AndroidManifest.xml file as

<uses-permission android:name="android.permission.MODIFY_PHONE_STATE"/>
Jebasuthan
  • 5,538
  • 6
  • 35
  • 55
Raj008
  • 3,539
  • 2
  • 28
  • 26
3

ITelephony method does not work on 4.4 and I find the headset/media button method still allows a fairly long ring before hangup.

This chaps blog post shows a new method that I have tested as working on 4.4.2 Galaxy s4 and HTC one mini that hangs up much more quickly and you don't get a missed call entry either.

http://aprogrammersday.blogspot.co.uk/2014/05/disconnect-block-drop-calls-android-4.html

The technique uses a runtime exec as below, apparently you may need to use a different number for some devices.

public class HangupPhoneCallReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {

        if (TelephonyManager.EXTRA_STATE_RINGING.equals(intent.getStringExtra(TelephonyManager.EXTRA_STATE))) {

            Executor eS = Executors.newSingleThreadExecutor();
            eS.execute(new Runnable() {
                @Override
                public void run() {
                    Runtime runtime = Runtime.getRuntime();
                    try {
                        Log.d(TAG, "service call phone 5 \n");
                        runtime.exec("service call phone 5 \n");
                    } catch (Exception exc) {
                        Log.e(TAG, exc.getMessage());
                    }
                }
            });

            return;
        }
    }
}
Chris.D
  • 1,516
  • 13
  • 19
  • 1
    thanks for the referral Chris, please feel free to connect and discuss ideas through the blog of my e-mail which is naeem.akram.malik at gmail dot com. – Naeem A. Malik Feb 20 '15 at 07:59
  • It is working on Nexus4/kitkat; this saved my day. Thanks chris and naeem. – kashili kashili Mar 31 '15 at 23:31
  • this solution work perfectly with android 4.X but doesn't work on android 50 and 5.1. Do you have any solution to cope with this problem ? – user2659694 May 14 '15 at 16:14
2

Call disconnecting using IT Telephony doesn't work on some devices like Samsung S Duos. But you can still make ringer silent :)

Akhil Dad
  • 1,804
  • 22
  • 35
  • S5 Duos/Lollipop: it does work (both outgoing or incoming calls are ended). SIM2 tested only. – chksr Jul 26 '15 at 10:46
1

To end call in older version then 9.0 use this:

TelephonyManager tm = (TelephonyManager)context.getSystemService(TELEPHONY_SERVICE);

Method m1 = null;
try {
    m1 = tm.getClass().getDeclaredMethod("getITelephony");
} catch (NoSuchMethodException e) {
    e.printStackTrace();
}
m1.setAccessible(true);
Object iTelephony = null;
try {
    iTelephony = m1.invoke(tm);
} catch (IllegalAccessException e) {
    e.printStackTrace();
} catch (InvocationTargetException e) {
    e.printStackTrace();
}

Method m3 = null;
try {
    m3 = iTelephony.getClass().getDeclaredMethod("endCall");
} catch (NoSuchMethodException e) {
    e.printStackTrace();
}

try {
    m3.invoke(iTelephony);
} catch (IllegalAccessException e) {
    e.printStackTrace();
} catch (InvocationTargetException e) {
    e.printStackTrace();
}
    

& for pie

TelecomManager telecomManager = (TelecomManager) context.getSystemService(Context.TELECOM_SERVICE);
if (telecomManager != null) {
    return telecomManager.endCall();
}

Make sure your compile SDK version is 28
ansonk163
  • 63
  • 3
ritu patel
  • 46
  • 3
1
private void PhoneControl(int nControl) {
    if(nControl == PHONE_END_CALL) { // End call, all Android version
        try {
            TelecomManager telecomManager = (TelecomManager) context.getSystemService(Context.TELECOM_SERVICE);
            if (telecomManager != null) {
                telecomManager.endCall();
            }
        }catch (Exception e) {}
        try {
            TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
            if(tm == null)
                return;
            tm.getClass().getMethod("endCall").invoke(tm);
            bIsEnding = true;
        } catch (Exception e) {


            /* Do Nothing */ }
    }

    if(nControl == PHONE_ACCEPT_CALL) { // Accept phone call
//      if(!bCallAccepted) { // Call déjà accepté => pas d'action (évite double action)
            bCallAccepted = true;
            if(Build.VERSION.SDK_INT >= 26) { // Pris en charge Android >= 8.0
                if(context.checkSelfPermission("android.permission.ANSWER_PHONE_CALLS") == PackageManager.PERMISSION_GRANTED) {
                    TelecomManager tm = (TelecomManager) context.getSystemService(Context.TELECOM_SERVICE);
                    if(tm != null)
                        tm.acceptRingingCall();
                }
            }
            if(Build.VERSION.SDK_INT >= 23 && Build.VERSION.SDK_INT < 26) { // Hangup in Android 6.x and 7.x
                MediaSessionManager mediaSessionManager =  (MediaSessionManager) context.getSystemService(Context.MEDIA_SESSION_SERVICE);
                if(mediaSessionManager != null) {
                    try {
                        List<MediaController> mediaControllerList = mediaSessionManager.getActiveSessions
                                (new ComponentName(context, NotificationReceiverService.class));

                        for (MediaController m : mediaControllerList) {
                            if ("com.android.server.telecom".equals(m.getPackageName())) {
                                m.dispatchMediaButtonEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_HEADSETHOOK));
                                m.dispatchMediaButtonEvent(new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_HEADSETHOOK));
                                break;
                            }
                        }
                    } catch (Exception e) {
//                      Toast.makeText(instance, "sdfsdf123123"+e, Toast.LENGTH_LONG).show();
                        Intent answerCalintent = new Intent(context, AcceptCallActivity.class);
                        answerCalintent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
                                Intent.FLAG_ACTIVITY_CLEAR_TASK  |
                                Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
                        context.startActivity(answerCalintent);
                        /* Do Nothing */ }
                }


//                new Thread(new Runnable() {
//
//                    @Override
//                    public void run() {
//                        try {
//                            Runtime.getRuntime().exec("input keyevent " +
//                                     Integer.toString(KeyEvent.KEYCODE_HEADSETHOOK));
//                        } catch (IOException e) {
//                             // Runtime.exec(String) had an I/O problem, try to fall back
//                             String enforcedPerm = "android.permission.CALL_PRIVILEGED";
//                             Intent btnDown = new Intent(Intent.ACTION_MEDIA_BUTTON).putExtra(
//                             Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_DOWN,
//                                      KeyEvent.KEYCODE_HEADSETHOOK));
//                             Intent btnUp = new Intent(Intent.ACTION_MEDIA_BUTTON).putExtra(
//                                        Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP,
//                                        KeyEvent.KEYCODE_HEADSETHOOK));
//
//                             context.sendOrderedBroadcast(btnDown, enforcedPerm);
//                             context.sendOrderedBroadcast(btnUp, enforcedPerm);
//                         }
//                     }
//
//                  }).start();
            }
            if(Build.VERSION.SDK_INT < 23) { // Prend en charge jusqu'à Android 5.1
                try {
                    if(Build.MANUFACTURER.equalsIgnoreCase("HTC")) { // Uniquement pour HTC
                        AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
                        if(audioManager!=null && !audioManager.isWiredHeadsetOn()) {
                            Intent i = new Intent(Intent.ACTION_HEADSET_PLUG);
                            i.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
                            i.putExtra("state", 0);
                            i.putExtra("name", "Orasi");
                            try {
                                context.sendOrderedBroadcast(i, null);
                            } catch (Exception e) { /* Do Nothing */ }
                        }
                    }
                    Runtime.getRuntime().exec("input keyevent " +
                            Integer.toString(KeyEvent.KEYCODE_HEADSETHOOK));
                } catch (Exception e) {
                    // Runtime.exec(String) had an I/O problem, try to fall back
                    String enforcedPerm = "android.permission.CALL_PRIVILEGED";
                    Intent btnDown = new Intent(Intent.ACTION_MEDIA_BUTTON).putExtra(
                            Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_DOWN,
                                    KeyEvent.KEYCODE_HEADSETHOOK));
                    Intent btnUp = new Intent(Intent.ACTION_MEDIA_BUTTON).putExtra(
                            Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP,
                                    KeyEvent.KEYCODE_HEADSETHOOK));

                    context.sendOrderedBroadcast(btnDown, enforcedPerm);
                    context.sendOrderedBroadcast(btnUp, enforcedPerm);
                }
            }
//       }
    }
}
    
<!--Incoming call state Listen-->
    <uses-permission android:name="android.permission.READ_CONTACTS" />
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />

    <!--    Store Data in Device/Shared pref-->
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

    <!--Get Incoming Number-->
    <uses-permission android:name="android.permission.READ_CALL_LOG" />

    <!--Answer call-->
    <uses-permission android:name="android.permission.ANSWER_PHONE_CALLS" />
    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
    <uses-permission
        android:name="android.permission.MODIFY_PHONE_STATE"
        tools:ignore="ProtectedPermissions" />


    <!--End Calll-->
    <uses-permission android:name="android.permission.CALL_PHONE" />

    public class NotificationReceiverService extends NotificationListenerService {
        public NotificationReceiverService() {
        }
    }

<service
    android:name=".notifications.NotificationReceiverService"
    android:enabled="true"
    android:exported="true"
    android:permission="android.permission.BIND_NOTIFICATION_LISTENER_SERVICE">

    <intent-filter>
        <action android:name="android.service.notification.NotificationListenerService" />
    </intent-filter>
</service>


if(Build.VERSION.SDK_INT >= 26) { // Permission necessaire
    if(checkSelfPermission("android.permission.ANSWER_PHONE_CALLS") != PackageManager.PERMISSION_GRANTED) {
        String szPermissions[] = {"android.permission.ANSWER_PHONE_CALLS"};
        requestPermissions(szPermissions, 0);
    }
}
if(Build.VERSION.SDK_INT < 26 && Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP_MR1 )
{ // Permission pour Android 6.x et 7.x
    ContentResolver contentResolver = getContentResolver();
    String enabledNotificationListeners = Settings.Secure.getString(contentResolver, "enabled_notification_listeners");
    String packageName = getPackageName();
    if (enabledNotificationListeners == null || !enabledNotificationListeners.contains(packageName)) {
        Intent intent2 = null;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP_MR1) {
            intent2 = new Intent(Settings.ACTION_NOTIFICATION_LISTENER_SETTINGS);
        }
        startActivity(intent2);


        final Handler handler = new Handler();
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                //Do something after 100ms
                Intent intent=new Intent(MainActivity.this, Main2Activity.class);
                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(intent);

            }
        }, 1000);
    }
}
ansonk163
  • 63
  • 3
Manthan Patel
  • 1,784
  • 19
  • 23