如何以编程方式回答/结束Android 4.1中的通话？

时间：2013-03-18 16:11:12

标签： android telephony

我正在编写一个Android应用程序，我需要接听来电，做一些工作然后结束通话。 在所有谷歌搜索之后，我可以找到两种不同的方法来实现这一点，这两种方法都不适用于Android的最新版本，特别是在4.1，Jelly Bean之后。

我。）使用广播接收器中的Java Reflection“android.intent.action.PHONE_STATE”访问“com.android.internal.telephony.ITelephony”。下面的示例代码可以在数百个相关帖子中找到：

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);
  }
 }
}

此代码存在的问题是

<uses-permission android:name="android.permission.MODIFY_PHONE_STATE" />
此方法需要

才能使用，并且此权限已从android v 2.3定义为“仅适用于系统应用程序”。简而言之，普通用户应用程序无法再在清单文件中定义此权限。

II。）另一种方法是模拟推动Headset钩子，这使Android接听电话。这是通过广播“Intent.ACTION_MEDIA_BUTTON”来完成的，如下面的代码所示。

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;
 } 
}

此方法适用于Android 4.1，之后android限制用户应用广播“Intent.ACTION_MEDIA_BUTTON”。

所以我的结论是，目前我们无法在Android 4.1或更高版本中实现这一目标。

是否还有其他人为此问题找到了其他解决方案或解决方法？

9 个答案:

答案 0 :(得分：16)

这适用于Android 2.2到4.0，现在将try catch添加到最后一行后，它适用于4.1.2和4.2坦率地说不知道它是如何工作的，但它对我有用。

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();
}

这对我在Android 4.1.2中工作以及我在4.2上测试过 这仍然是一个处理的例外。

编辑结束通话

希望这有助于所有寻求答案和结束通话的整体解决方案的人。

/**
 * 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();

}

答案 1 :(得分：8)

我的应用程序使用以下代码接听电话约6个月：

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);

我在2.2到4.2.2的Android版本上测试了这个。我没有在4.2.2设备的测试中看到一个SecurityException广播“Intent.ACTION_MEDIA_BUTTON”，也没有看到Play商店的崩溃报告表明发生了这种异常。

我会说这并不总是有效。它不适用于HTC设备，因为HTC设备有一个HeadsetObeserver，可以监听有线耳机的实际插入情况。如果没有此事件（当前是第三方应用程序要广播的SecurityException），则会忽略HeadsetHook KeyEvent。

之前的答案具有误导性。以下代码块不执行任何操作：

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();
}

除了生成SecurityException并捕获它。

在代码工作的其他答案中，这是因为正在广播KeyEvent.KEYCODE_HEADSETHOOK。

答案 2 :(得分：7)

作为这个主题的结论，这里是适用于Android 4.2.2的代码。

- ＆GT;通过模拟推耳机挂钩并将播放保持在@PravinDodia所提及的试用捕捉中来回答呼叫。 （观察一个异常被抛出并在catch中处理，无论如何都要回答。所以我想我们可以忽略这个异常并继续过生活，好像什么也没发生！）

- ＆GT;使用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);
      }
 }
}

至少断开连接功能是有效的，我们知道它是如何工作的。那些想要开发Call Barring应用程序的人可以继续。 对于像我这样想接听电话的人，我想我们现在可以使用它，只希望它不会停止在下一个版本中工作。

答案 3 :(得分：7)

试试这个 使用编程方式结束通话的答案。它对我来说很好。

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);
}

答案 4 :(得分：3)

试试这个： 

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");

将 AndroidManifest.xml 文件中的权限添加为

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

答案 5 :(得分：3)

ITelephony方法在4.4上不起作用，我发现耳机/媒体按钮方法在挂断之前仍允许相当长的响铃。

这篇chaps博客文章展示了我测试过的新方法，即4.4.2 Galaxy s4和HTC one mini，它可以更快地挂断，并且你也没有得到一个未接来电条目。

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

该技术使用如下运行时执行程序，显然您可能需要为某些设备使用不同的数字。

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;
        }
    }
}

答案 6 :(得分：2)

使用IT电话断开连接电话在某些设备（如Samsung S Duos）上无效。但你仍然可以使铃声保持沉默：）

答案 7 :(得分：0)

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

答案 8 :(得分：0)

         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);
            }
        }
相关问题
最新问题