que - no puedo contestar llamadas android

¿Puedo colgar una llamada programáticamente en Android?

Question

Espero bloquear algunas llamadas inestables, así que necesito colgar algunas llamadas programáticamente en Android.

El siguiente fragmento es de ¿Cómo colgar la llamada saliente en Android?
¿Significa que la técnica de colgar la llamada se bloqueará en cualquier momento en la versión de Android?
¿Significa que no puedo escribir una aplicación para colgar una llamada?

La única forma de colgar que he encontrado hasta ahora, es hacerlo a través de Java Reflection. Como no forma parte de la API pública, debe tener cuidado de usarla y no confiar en ella. Cualquier cambio en la composición interna de Android efectivamente romperá su aplicación.

Answer 1

Esto es completamente sin pruebas, pero ¿no podría simplemente activar y desactivar el modo de avión cuando aparece una llamada que coincide con su lista negra?

Aparte de eso, esto parecía funcionar en pre kitkat http://androidsourcecode.blogspot.in/2010/10/blocking-incoming-call-android.html

Answer 2

Si estás en la prueba JUnit entonces esta es la forma;

mInstrumentation = InstrumentationRegistry.getInstrumentation();
mInstrumentation.getUiAutomation().executeShellCommand( "input keyevent " + KeyEvent.KEYCODE_ENDCALL );

Puede funcionar también desde fuera de la prueba, pero no lo he probado.

Answer 3

Does it mean the technique of hang up call will be block at any time in further Android version?

Existe la posibilidad de que el Equipo Android vuelva todo al revés para este servicio concreto. En cuanto a mí, creo que tal posibilidad es bastante insignificante.

Does it mean I can''t write an app to hang up a call?

Si el enfoque propuesto funciona, ¿por qué no? Solo hágalo, teniendo en cuenta (en algún lugar en el fondo de su mente, sí :)) que en algún lugar en el futuro distante algo podría complicarse, y tendrá que buscar otro truco sucio que rompa la API sin óxido, que no lo hace. te permiten colgar una llamada

Answer 4

Primero, debe declarar este permiso en AndroidManifest.xml

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

Luego, configura un servicio BroadcastReceiver para android.intent.action.PHONE_STATE (llamadas entrantes) y android.intent.action.NEW_OUTGOING_CALL (llamadas salientes) agregando lo siguiente a AndroidManifest.xml

AndroidManifest.xml

<receiver android:name=".PhoneStateReceiver">
<intent-filter android:priority="0">
<action android:name="android.intent.action.PHONE_STATE" />
<action android:name="android.intent.action.NEW_OUTGOING_CALL" />
</intent-filter>
</receiver>

PhoneStateReceiver.JAVA

import java.lang.reflect.Method;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.telephony.TelephonyManager;
import android.util.Log;
public class PhoneStateReceiver extends BroadcastReceiver {
public static String TAG="PhoneStateReceiver";
@Override
public void onReceive(Context context, Intent intent) {
if (intent.getAction().equals("android.intent.action.PHONE_STATE")) {
String state = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
Log.d(TAG,"PhoneStateReceiver**Call State=" + state);
if (state.equals(TelephonyManager.EXTRA_STATE_IDLE)) {
Log.d(TAG,"PhoneStateReceiver**Idle");
} else if (state.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
// Incoming call
String incomingNumber =
intent.getStringExtra(TelephonyManager.EXTRA_INCOMING_NUMBER);
Log.d(TAG,"PhoneStateReceiver**Incoming call " + incomingNumber);
if (!killCall(context)) { // Using the method defined earlier
Log.d(TAG,"PhoneStateReceiver **Unable to kill incoming call");
}
} else if (state.equals(TelephonyManager.EXTRA_STATE_OFFHOOK)) {
Log.d(TAG,"PhoneStateReceiver **Offhook");
}
} else if (intent.getAction().equals("android.intent.action.NEW_OUTGOING_CALL")) {
// Outgoing call
String outgoingNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
Log.d(TAG,"PhoneStateReceiver **Outgoing call " + outgoingNumber);
setResultData(null); // Kills the outgoing call
} else {
Log.d(TAG,"PhoneStateReceiver **unexpected intent.action=" + intent.getAction());
}
}
public boolean killCall(Context context) {
try {
// Get the boring old TelephonyManager
TelephonyManager telephonyManager =
(TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
// Get the getITelephony() method
Class classTelephony = Class.forName(telephonyManager.getClass().getName());
Method methodGetITelephony = classTelephony.getDeclaredMethod("getITelephony");
// Ignore that the method is supposed to be private
methodGetITelephony.setAccessible(true);
// Invoke getITelephony() to get the ITelephony interface
Object telephonyInterface = methodGetITelephony.invoke(telephonyManager);
// Get the endCall method from ITelephony
Class telephonyInterfaceClass =
Class.forName(telephonyInterface.getClass().getName());
Method methodEndCall = telephonyInterfaceClass.getDeclaredMethod("endCall");
// Invoke endCall()
methodEndCall.invoke(telephonyInterface);
} catch (Exception ex) { // Many things can go wrong with reflection calls
Log.d(TAG,"PhoneStateReceiver **" + ex.toString());
return false;
}
return true;
}
}

MainActivity.JAVA

import android.Manifest;
import android.content.pm.PackageManager;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
public class MainActivity extends AppCompatActivity {
public static final int MY_PERMISSIONS_REQUEST_READ_PHONE_STATE = 101;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
if (ContextCompat.checkSelfPermission(this,
Manifest.permission.READ_PHONE_STATE)
!= PackageManager.PERMISSION_GRANTED) {
// Should we show an explanation?
if (ActivityCompat.shouldShowRequestPermissionRationale(this,
Manifest.permission.READ_PHONE_STATE)) {
// Show an explanation to the user *asynchronously* -- don''t block
// this thread waiting for the user''s response! After the user
// sees the explanation, try again to request the permission.
} else {
// No explanation needed, we can request the permission.
ActivityCompat.requestPermissions(this,
new String[]{Manifest.permission.READ_PHONE_STATE},
MY_PERMISSIONS_REQUEST_READ_PHONE_STATE);
// MY_PERMISSIONS_REQUEST_READ_PHONE_STATE is an
// app-defined int constant. The callback method gets the
// result of the request.
}
}
}
@Override
public void onRequestPermissionsResult(int requestCode,
String permissions[], int[] grantResults) {
switch (requestCode) {
case MY_PERMISSIONS_REQUEST_READ_PHONE_STATE: {
// If request is cancelled, the result arrays are empty.
if (grantResults.length > 0
&& grantResults[0] == PackageManager.PERMISSION_GRANTED) {
// permission was granted, yay!
} else {
// permission denied, boo! Disable the
// functionality that depends on this permission.
}
return;
}
// other ''case'' lines to check for other
// permissions this app might request
}
}
}