Comment accrocher des appels sortants dans Android?

La capture de l'appel sortant dans un BroadcastReceiver a été mentionné et qui est certainement la meilleure façon de le faire si vous voulez mettre fin à l'appel avant de composer.

Une fois de numérotation ou en appel, cependant, cette technique ne fonctionne plus. La seule façon de raccrocher que j'ai rencontré jusqu'à présent, c'est de le faire par le biais de Java La réflexion. Comme il ne fait pas partie de l'API publique, vous devez faire attention à l'utiliser, et ne pas compter sur elle. Tout changement à la composition interne d'Android va briser efficacement votre demande.

Prasanta le blog de Paul démontre comment il peut être accompli, que j'ai résumées ci-dessous.

L'obtention de la ITelephony objet:

TelephonyManager tm = (TelephonyManager) context
        .getSystemService(Context.TELEPHONY_SERVICE);
try {
    //Java reflection to gain access to TelephonyManager's
    //ITelephony getter
    Log.v(TAG, "Get getTeleService...");
    Class c = Class.forName(tm.getClass().getName());
    Method m = c.getDeclaredMethod("getITelephony");
    m.setAccessible(true);
    com.android.internal.telephony.ITelephony telephonyService =
            (ITelephony) m.invoke(tm);
} catch (Exception e) {
    e.printStackTrace();
    Log.e(TAG,
            "FATAL ERROR: could not connect to telephony subsystem");
    Log.e(TAG, "Exception object: " + e);
}

La fin de l'appel:

telephonyService.endCall();

1. Créer un BroadcastReceiver avec une priorité de 0.
2. De la colombie-britannique intercepter le ACTION_NEW_OUTGOING_CALL intention dans son onReceive méthode
3. appel setResultData(null) dans la même méthode

Cela permettra d'éviter l'appel, de l'ouverture (tant que votre récepteur est le dernier processus de l'intention, je pense)

Voici la plus à jour du code, qui va travailler pour Android P trop, parce qu'il a une officielle de l'API pour elle (ici) :

dans le manifeste, ajouter ceci:

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

Dans le code, utilisez ceci:

Java:

@SuppressLint("PrivateApi")
public static boolean endCall(Context context) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
final TelecomManager telecomManager = (TelecomManager) context.getSystemService(Context.TELECOM_SERVICE);
if (telecomManager != null && ContextCompat.checkSelfPermission(context, Manifest.permission.ANSWER_PHONE_CALLS) == PackageManager.PERMISSION_GRANTED) {
telecomManager.endCall();
return true;
}
return false;
}
//use unofficial API for older Android versions, as written here: https://stackoverflow.com/a/8380418/878126
try {
final Class<?> telephonyClass = Class.forName("com.android.internal.telephony.ITelephony");
final Class<?> telephonyStubClass = telephonyClass.getClasses()[0];
final Class<?> serviceManagerClass = Class.forName("android.os.ServiceManager");
final Class<?> serviceManagerNativeClass = Class.forName("android.os.ServiceManagerNative");
final Method getService = serviceManagerClass.getMethod("getService", String.class);
final Method tempInterfaceMethod = serviceManagerNativeClass.getMethod("asInterface", IBinder.class);
final Binder tmpBinder = new Binder();
tmpBinder.attachInterface(null, "fake");
final Object serviceManagerObject = tempInterfaceMethod.invoke(null, tmpBinder);
final IBinder retbinder = (IBinder) getService.invoke(serviceManagerObject, "phone");
final Method serviceMethod = telephonyStubClass.getMethod("asInterface", IBinder.class);
final Object telephonyObject = serviceMethod.invoke(null, retbinder);
final Method telephonyEndCall = telephonyClass.getMethod("endCall");
telephonyEndCall.invoke(telephonyObject);
return true;
} catch (Exception e) {
e.printStackTrace();
LogManager.e(e);
}
return false;
}

ou dans Kotlin:

@SuppressLint("PrivateApi")
fun endCall(context: Context): Boolean {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
if (ContextCompat.checkSelfPermission(context, Manifest.permission.ANSWER_PHONE_CALLS) == PackageManager.PERMISSION_GRANTED) {
telecomManager.endCall()
return true
}
return false
}
//use unofficial API for older Android versions, as written here: https://stackoverflow.com/a/8380418/878126
try {
val telephonyClass = Class.forName("com.android.internal.telephony.ITelephony")
val telephonyStubClass = telephonyClass.classes[0]
val serviceManagerClass = Class.forName("android.os.ServiceManager")
val serviceManagerNativeClass = Class.forName("android.os.ServiceManagerNative")
val getService = serviceManagerClass.getMethod("getService", String::class.java)
val tempInterfaceMethod = serviceManagerNativeClass.getMethod("asInterface", IBinder::class.java)
val tmpBinder = Binder()
tmpBinder.attachInterface(null, "fake")
val serviceManagerObject = tempInterfaceMethod.invoke(null, tmpBinder)
val retbinder = getService.invoke(serviceManagerObject, "phone") as IBinder
val serviceMethod = telephonyStubClass.getMethod("asInterface", IBinder::class.java)
val telephonyObject = serviceMethod.invoke(null, retbinder)
val telephonyEndCall = telephonyClass.getMethod("endCall")
telephonyEndCall.invoke(telephonyObject)
return true
} catch (e: Exception) {
e.printStackTrace()
return false
}
}

Compte tenu de la possibilité pour les merveilleux de mal, je serais surpris si cela est autorisé.

Ce fil dit catégoriquement qu' l'API ne peut pas mettre fin à un appel. D'autres ont essayé.