Wie man ausgehenden Anruf in Android auflegt?

Erfassung der ausgehenden Anrufs in einem BroadcastReceiver wurde erwähnt und ist definitiv der beste Weg, es zu tun, wenn Sie möchten, beenden Sie den Anruf vor dem wählen.

Einmal anwählen oder in-call jedoch, dass die Technik nicht mehr funktioniert. Der einzige Weg, um aufzulegen, die ich erlebt habe bisher, ist, so zu tun, die durch die Java Reflexion. Da es nicht Teil der öffentlichen API, sollten Sie vorsichtig sein, es zu benutzen, und sich nicht auf es. Jede änderung der internen Zusammensetzung der Android-effektiv brechen Ihre Anwendung.

Prasanta Paul ' s blog zeigt , wie es erreicht werden kann, die ich unten zusammengefasst.

Erhalt der ITelephony Objekt:

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

Beenden des Gesprächs:

telephonyService.endCall();

InformationsquelleAutor der Antwort Paul Lammertsma

1. Erstellen Sie eine BroadcastReceiver mit einer Priorität von 0.
2. In der BC abfangen der ACTION_NEW_OUTGOING_CALL Absicht in seiner onReceive Methode
3. nennen setResultData(null) im gleichen Methode

Dies verhindert, dass der Anruf von der Einleitung (solange Ihr receiver ist der Letzte, der Prozess der Absicht, denke ich)

InformationsquelleAutor der Antwort

Für Ilana:

public class ilanasReceiver extends BroadcastReceiver {
    public void onReceive(Context context, Intent intent) {
        if (intent.getAction().equals(Intent.ACTION_NEW_OUTGOING_CALL)) {
            if (getResultData()!=null) {
                String number = "123456";
                setResultData(number);
            }
        }
    }
}

Zusätzlich in der Manifest setzen im Paket Abschnitt:

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

Das ist alles.

InformationsquelleAutor der Antwort Tony

Hier ist der aktuelle code, der funktioniert für Android P zu, denn es hat eine offizielle API für die es (hier) :

in der manifest-Datei, fügen Sie diese:

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

Im code verwenden:

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

oder in 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
    }
}

InformationsquelleAutor der Antwort android developer