Wie ausgehender Anruf in Android auflegen?

Question

Ich entwickle eine Anwendung, wo eine der Dinge, die wir brauchen, ist, den ausgehenden Anruf zu steuern, zumindest um es aus unserer Anwendung zu stoppen.

Ich habe versucht, Intent.ACTION_CALL aus einer bestehenden Aktivität mit:

Intent callIntent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:" + phoneNumber)); 
startActivity(callIntent); 

Aber das Gespräch zu stoppen scheint durch die API nicht anerkannt werden.

Können Sie einen Workaround vorschlagen?

Zum Beispiel: Flugmodus während des Anrufs aktivieren? Nur ein Beispiel; Dieser Hack hat nicht für mich funktioniert.

Answer 1

In Anbetracht der Möglichkeit für wunderbare Unfug würde ich überrascht sein, wenn dies erlaubt ist.

Dieser Thread sagt flach, dass the API cannot end a call. Andere have tried.

Answer 2

1. erstellen BroadcastReceiver mit einer Priorität von 0.
2. Im BC Intercept von der ACTION_NEW_OUTGOING_CALL Absicht in seiner onReceive Methode
3. Aufruf setResultData(null) in der gleichen Methode

Diese den Anruf verhindern initiieren (solange Ihr Empfänger der letzte ist, der die Absicht verarbeitet, denke ich)

Answer 3

Sie können versuchen, dann Di aktivieren sabling Flugzeugmodus:

android.provider.Settings.System.putInt(getContentResolver(), 
     android.provider.Settings.System.AIRPLANE_MODE_ON, 1); 

Intent intent = new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED); 
intent.putExtra("state", 1); 
sendBroadcast(new Intent("android.intent.action.AIRPLANE_MODE")); 
sendBroadcast(intent); 
android.provider.Settings.System.putInt(getContentResolver(), 
     android.provider.Settings.System.AIRPLANE_MODE_ON, 0); 

intent.putExtra("state", 0); 
sendBroadcast(new Intent("android.intent.action.AIRPLANE_MODE")); 
sendBroadcast(intent); 

Answer 4

Gemäß der Dokumentation auf ACTION_NEW_OUTGOING_CALL

Die Absicht wird den folgenden zusätzlichen Wert haben:

EXTRA_PHONE_NUMBER - die Rufnummer ursprünglich gewählt werden.

Sobald die Übertragung beendet ist, wird resultData als die tatsächlich anzurufende Nummer verwendet. Wenn null, wird kein Anruf getätigt.

Answer 5

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 Manifest setzen in Paket Abschnitt:

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

Das ist alles.

Answer 6

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

Diese Methode funktioniert jedoch nicht mehr, sobald sie gewählt oder angerufen wird. Die einzige Möglichkeit, aufzulegen, die ich bis jetzt gefunden habe, ist Java Reflection. Da es nicht Teil der öffentlichen API ist, sollten Sie vorsichtig sein, es zu verwenden, und sich nicht auf esverlassen.Jede Änderung an der internen Zusammensetzung von Android wird Ihre Anwendung effektiv brechen.

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

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

Gespräch beenden:

telephonyService.endCall(); 

Answer 7

Versuchen Sie folgendes:

(verwendete ich Reflection to access advanced telephony features und Somethings ändern)

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

try { 
    //String serviceManagerName = "android.os.IServiceManager"; 
    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); 
}