¿Cómo hacer una llamada telefónica en Android y volver a mi actividad cuando se realiza la llamada?

Estoy lanzando una actividad para hacer una llamada telefónica, pero cuando presioné el botón ‘finalizar llamada’, no vuelve a mi actividad. ¿Puede decirme por favor cómo puedo iniciar una actividad de llamada que me devuelve cuando se presiona el botón “Fin de llamada”? Así es como estoy haciendo la llamada telefónica:

String url = "tel:3334444"; Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse(url)); 

use PhoneStateListener para ver cuándo finaliza la llamada. lo más probable es que necesite desencadenar las acciones del oyente para esperar el inicio de una llamada (espere hasta que se cambie de PHONE_STATE_OFFHOOK a PHONE_STATE_IDLE nuevamente) y luego escriba algún código para que su aplicación vuelva al estado INACTIVO.

Es posible que necesite ejecutar el oyente en un servicio para asegurarse de que se mantenga activo y su aplicación se reinicie. algún código de ejemplo:

 EndCallListener callListener = new EndCallListener(); TelephonyManager mTM = (TelephonyManager)this.getSystemService(Context.TELEPHONY_SERVICE); mTM.listen(callListener, PhoneStateListener.LISTEN_CALL_STATE); 

Definición de oyente:

 private class EndCallListener extends PhoneStateListener { @Override public void onCallStateChanged(int state, String incomingNumber) { if(TelephonyManager.CALL_STATE_RINGING == state) { Log.i(LOG_TAG, "RINGING, number: " + incomingNumber); } if(TelephonyManager.CALL_STATE_OFFHOOK == state) { //wait for phone to go offhook (probably set a boolean flag) so you know your app initiated the call. Log.i(LOG_TAG, "OFFHOOK"); } if(TelephonyManager.CALL_STATE_IDLE == state) { //when this state occurs, and your flag is set, restart your app Log.i(LOG_TAG, "IDLE"); } } } 

En su archivo Manifest.xml , agregue el siguiente permiso:

  

Esto es con respecto a la pregunta formulada por Starter.

El problema con su código es que no está pasando el número correctamente.

El código debería ser:

 private OnClickListener next = new OnClickListener() { public void onClick(View v) { EditText num=(EditText)findViewById(R.id.EditText01); String number = "tel:" + num.getText().toString().trim(); Intent callIntent = new Intent(Intent.ACTION_CALL, Uri.parse(number)); startActivity(callIntent); } }; 

No olvides agregar el permiso en el archivo de manifiesto.

  

o

  

para el número de emergencia en caso de que se use DIAL .

Tuvimos el mismo problema y PhoneStateListener resolverlo utilizando un PhoneStateListener para identificar cuándo termina la llamada, pero adicionalmente tuvimos que finish() la actividad original antes de volver a startActivity con startActivity , de lo contrario el registro de llamadas estaría delante de él.

Encontré el EndCallListener el ejemplo más funcional, para obtener el comportamiento descrito (finalizar (), llamar, reiniciar) Agregué algunas SharedPreferences para que el Listener tuviera una referencia para administrar este comportamiento.

My OnClick, initialise y EndCallListener solo responden a las llamadas desde la aplicación. Otras llamadas ignoradas.

 import android.content.Intent; import android.content.SharedPreferences; import android.preference.PreferenceManager; import android.telephony.PhoneStateListener; import android.telephony.TelephonyManager; import android.util.Log; public class EndCallListener extends PhoneStateListener { private String TAG ="EndCallListener"; private int LAUNCHED = -1; SharedPreferences prefs = PreferenceManager .getDefaultSharedPreferences( myActivity.mApp.getBaseContext()); SharedPreferences.Editor _ed = prefs.edit(); @Override public void onCallStateChanged(int state, String incomingNumber) { String _prefKey = myActivity.mApp .getResources().getString(R.string.last_phone_call_state_key), _bPartyNumber = myActivity.mApp .getResources().getString(R.string.last_phone_call_bparty_key); int mLastCallState = prefs.getInt(_prefKey, LAUNCHED); //Save current call sate for next call _ed.putInt(_prefKey,state); _ed.commit(); if(TelephonyManager.CALL_STATE_RINGING == state) { Log.i(TAG, " >> RINGING, number: " + incomingNumber); } if(TelephonyManager.CALL_STATE_IDLE == state && mLastCallState != LAUNCHED ) { //when this state occurs, and your flag is set, restart your app if (incomingNumber.equals(_bPartyNumber) == true) { //Call relates to last app initiated call Intent _startMyActivity = myActivity.mApp .getPackageManager() .getLaunchIntentForPackage( myActivity.mApp.getResources() .getString(R.string.figjam_package_path)); _startMyActivity.setAction( myActivity.mApp.getResources() .getString(R.string.main_show_phone_call_list)); myActivity.mApp .startActivity(_startMyActivity); Log.i(TAG, "IDLE >> Starting MyActivity with intent"); } else Log.i(TAG, "IDLE after calling "+incomingNumber); } } } 

agréguelos a strings.xml

 android.intent.action.SHOW_PHONE_CALL_LIST activityLpcsKey activityLpbpKey 

y algo así en su Manifiesto si necesita volver a la apariencia antes de la llamada

         

y ponlos en tu ‘myActivity’

 public static Activity mApp=null; //Before onCreate() ... onCreate( ... ) { ... if (mApp == null) mApp = this; //Links your resources to other classes ... //Test if we've been called to show phone call list Intent _outcome = getIntent(); String _phoneCallAction = mApp.getResources().getString(R.string.main_show_phone_call_list); String _reqAction = _outcome.getAction();//Can be null when no intent involved //Decide if we return to the Phone Call List view if (_reqAction != null &&_reqAction.equals(_phoneCallAction) == true) { //DO something to return to look and feel } ... myListView.setOnItemClickListener(new OnItemClickListener() { //Act on item when selected @Override public void onItemClick(AdapterView a, View v, int position, long id) { myListView.moveToPosition(position); String _bPartyNumber = "tel:"+myListView.getString(myListView.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER)); //Provide an initial state for the listener to access. initialiseCallStatePreferences(_bPartyNumber); //Setup the listener so we can restart myActivity EndCallListener _callListener = new EndCallListener(); TelephonyManager _TM = (TelephonyManager)mApp.getSystemService(Context.TELEPHONY_SERVICE); _TM.listen(_callListener, PhoneStateListener.LISTEN_CALL_STATE); Intent _makeCall = new Intent(Intent.ACTION_CALL, Uri.parse(_bPartyNumber)); _makeCall.setComponent(new ComponentName("com.android.phone","com.android.phone.OutgoingCallBroadcaster")); startActivity(_makeCall); finish(); //Wait for call to enter the IDLE state and then we will be recalled by _callListener } }); }//end of onCreate() 

utilice esto para iniciar el comportamiento de su onClick en myActivity, por ejemplo, después de onCreate ()

 private void initialiseCallStatePreferences(String _BParty) { final int LAUNCHED = -1; SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences( mApp.getBaseContext()); SharedPreferences.Editor _ed = prefs.edit(); String _prefKey = mApp.getString(R.string.last_phone_call_state_key), _bPartyKey = mApp.getString(R.string.last_phone_call_bparty_key); //Save default call state before next call _ed.putInt(_prefKey,LAUNCHED); _ed.putString(_bPartyKey,_BParty); _ed.commit(); } 

Debería encontrar que al hacer clic en su lista de números de teléfono finaliza su actividad, realiza la llamada al número y regresa a su actividad cuando finaliza la llamada.

Realizar una llamada desde el exterior de su aplicación mientras aún está activo no reiniciará su actividad (a menos que sea igual al último número de BParty llamado).

🙂

puedes usar startActivityForResult ()

Esta es una solución desde mi punto de vista:

 ok.setOnClickListener(this); @Override public void onClick(View view) { if(view == ok){ Intent intent = new Intent(Intent.ACTION_CALL); intent.setData(Uri.parse("tel:" + num)); activity.startActivity(intent); } 

Por supuesto, en la definición de la actividad (clase), debe implementar View.OnClickListener.

Aquí está mi ejemplo, primero el usuario tiene que escribir el número que quiere marcar y luego presiona un botón de llamada y se lo dirige al teléfono. Después de la cancelación de la llamada, el usuario vuelve a la aplicación. Para esto, el botón necesita tener un método onClick (‘makePhoneCall’ en este ejemplo) en el xml. También necesita registrar el permiso en el manifiesto.

Manifiesto

   

Actividad

 import android.net.Uri; import android.os.Bundle; import android.app.Activity; import android.content.Intent; import android.view.View; import android.widget.EditText; import android.widget.Toast; public class PhoneCall extends Activity { EditText phoneTo; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_phone_call); phoneTo = (EditText) findViewById(R.id.phoneNumber); } public void makePhoneCall(View view) { try { String number = phoneTo.getText().toString(); Intent phoneIntent = new Intent(Intent.ACTION_CALL); phoneIntent.setData(Uri.parse("tel:"+ number)); startActivity(phoneIntent); } catch (android.content.ActivityNotFoundException ex) { Toast.makeText(PhoneCall.this, "Call failed, please try again later!", Toast.LENGTH_SHORT).show(); } } } 

XML

    
 @Override public void onClick(View view) { Intent phoneIntent = new Intent(Intent.ACTION_CALL); phoneIntent.setData(Uri.parse("tel:91-000-000-0000")); if (ActivityCompat.checkSelfPermission(mContext, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) { return; } startActivity(phoneIntent); } 

Si vas a usar un oyente, necesitarás agregar este permiso al manifiesto también.

  

Dentro de PhoneStateListener después de ver que la llamada ha finalizado, mejor uso:

 Intent intent = new Intent(CallDispatcherActivity.this, CallDispatcherActivity.class); intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); startActivity(intent); 

Donde CallDispatcherActivity es la actividad donde el usuario ha lanzado una llamada (a un despachador de servicio de taxi, en mi caso). Esto simplemente elimina la aplicación de telefonía Android de la parte superior, el usuario vuelve en lugar del código feo que vi aquí.

Para volver a tu Activity , deberás escuchar TelephonyStates . En ese listener puede enviar un Intent para volver a abrir su Activity una vez que el teléfono esté inactivo.

Al menos así es como lo haré.

Perfecto tutorial aquí ! Siempre revisa este blog porque tiene muchos excelentes tutoriales.

  Intent callIntent = new Intent(Intent.ACTION_CALL); callIntent.setData(Uri.parse("tel:"+number)); startActivity(callIntent); **Add permission :**  

Intenta usar:

 finish(); 

al final de la actividad. Te redirigirá a tu actividad anterior.

Cuando se usa PhoneStateListener es necesario asegurarse de que PHONE_STATE_IDLE sigue a PHONE_STATE_OFFHOOK se use para activar la acción después de la llamada. Si el activador ocurre al ver PHONE_STATE_IDLE , terminará haciéndolo antes de la llamada. Como verá el estado, cambie PHONE_STATE_IDLE -> PHONE_STATE_OFFHOOK -> PHONE_STATE_IDLE.

// en setonclicklistener pon este código:

 EditText et_number=(EditText)findViewById(R.id.id_of_edittext); String my_number = et_number.getText().toString().trim(); Intent callIntent = new Intent(Intent.ACTION_CALL, Uri.parse(my_number)); startActivity(callIntent); 

// dar permiso para el manifiesto de llamada:

  

@Dmitri Novikov, FLAG_ACTIVITY_CLEAR_TOP borra cualquier instancia activa en la parte superior de la nueva. Por lo tanto, puede terminar la instancia anterior antes de que complete el proceso.

Agregue este es su xml: android:autoLink="phone"

  Intent callIntent = new Intent(Intent.ACTION_CALL); callIntent .setData(Uri.parse("tel:+91-XXXXXXXXX")); startActivity(callIntent ); 

para obtener más información, haga clic aquí http://androiddhina.blogspot.in/2015/10/how-to-make-phone-call-from-android.html

Al comenzar su llamada, se ve bien.

Hay una diferencia entre Android 11+ y Down en llevar tu aplicación al frente sin embargo.

Android 10 o menos, necesitas comenzar un nuevo bash, android 11+ simplemente usas BringTaskToFront

En el estado de llamada IDLE:

 if (Build.VERSION.SDK_INT >= 11) { ActivityManager am = (ActivityManager) activity.getSystemService(Activity.ACTIVITY_SERVICE); am.moveTaskToFront(MyActivity.MyActivityTaskId, ActivityManager.MOVE_TASK_WITH_HOME); } else { Intent intent = new Intent(activity, MyActivity.class); activity.startActivity(intent); } 

Configuré el MyActivity.MyActivityTaskId al hacer la llamada en mi actividad, por lo que, si esto no funciona, configura esta variable en la página de actividad principal de la página a la que desea volver.

 MyActivity.MyActivityTaskId = this.getTaskId(); 

MyActivityTaskId es una variable estática en mi clase de actividad

 public static int MyActivityTaskId = 0; 

Espero que esto funcione para tí. Utilizo el código anterior de una manera diferente, abro mi aplicación tan pronto como se responde la llamada para que el usuario pueda ver los detalles de la persona que llama.

También he configurado algunas cosas en AndroidManifest.xml :

 /*Dont really know if this makes a difference*/  

y permisos:

   

Por favor haz preguntas si te quedas atascado.

Pasos:

1) Agregue los permisos necesarios en el archivo Manifest.xml .

     

2) Crear un oyente para los cambios de estado del teléfono.

 public class EndCallListener extends PhoneStateListener { @Override public void onCallStateChanged(int state, String incomingNumber) { if(TelephonyManager.CALL_STATE_RINGING == state) { } if(TelephonyManager.CALL_STATE_OFFHOOK == state) { //wait for phone to go offhook (probably set a boolean flag) so you know your app initiated the call. } if(TelephonyManager.CALL_STATE_IDLE == state) { //when this state occurs, and your flag is set, restart your app Intent i = context.getPackageManager().getLaunchIntentForPackage( context.getPackageName()); //For resuming the application from the previous state i.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); //Uncomment the following if you want to restart the application instead of bring to front. //i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); context.startActivity(i); } } } 

3) Inicializa el oyente en tu OnCreate

 EndCallListener callListener = new EndCallListener(); TelephonyManager mTM = (TelephonyManager)this.getSystemService(Context.TELEPHONY_SERVICE); mTM.listen(callListener, PhoneStateListener.LISTEN_CALL_STATE); 

pero si desea reanudar su último estado de la aplicación o recuperarlo de la stack de respaldo , entonces reemplace FLAG_ACTIVITY_CLEAR_TOP con FLAG_ACTIVITY_SINGLE_TOP

Referencia esta respuesta