¿Cómo puedo 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 'terminar llamada', no vuelve a mi actividad. ¿Podría decirme por favor cómo puedo iniciar una actividad de llamada que vuelve a mí cuando se pulsa el botón 'Finalizar llamada'? Así es como estoy haciendo la llamada telefónica:

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

21 Solutions collect form web for “¿Cómo puedo hacer una llamada telefónica en android y volver a mi actividad cuando se realiza la llamada?”

Use un PhoneStateListener para ver cuándo se termina la llamada. Es muy probable que necesite activar las acciones del oyente para esperar a que se inicie la llamada (espere hasta que cambie de PHONE_STATE_OFFHOOK a PHONE_STATE_IDLE nuevamente) y, a continuación, escriba un código para que la aplicación vuelva a estar en el estado IDLE.

Es posible que deba ejecutar el oyente en un servicio para asegurarse de que se mantiene actualizado y su aplicación se reinicia. Algunos ejemplos de código:

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

Definición del 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 el archivo Manifest.xml , agregue el siguiente permiso:

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

Esto se refiere a la pregunta formulada por Starter.

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

El código debe 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 olvide añadir el permiso en el archivo de manifiesto.

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

o

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

Para el número de emergencia en caso de que se utilice DIAL .

Tuvimos el mismo problema y PhoneStateListener solucionarlo usando un PhoneStateListener para identificar cuándo termina la llamada, pero además tuvimos que finish() la actividad original antes de iniciarla de nuevo con startActivity , de lo contrario el registro de llamadas estaría delante de ella.

He encontrado el EndCallListener el ejemplo más funcional, para obtener el comportamiento descrito (finish (), llamada, reiniciar) He añadido algunas SharedPreferences para que el Listener tenía una referencia para gestionar este comportamiento.

Mi OnClick, initialise y EndCallListener sólo responden a las llamadas de 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); } } } 

Agrega estos a strings.xml

 <string name="main_show_phone_call_list">android.intent.action.SHOW_PHONE_CALL_LIST</string> <string name="last_phone_call_state_key">activityLpcsKey</string> <string name="last_phone_call_bparty_key">activityLpbpKey</string> 

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

  <activity android:label="@string/app_name" android:name="com.myPackage.myActivity" android:windowSoftInputMode="stateHidden" android:configChanges="keyboardHidden" > <intent-filter> <action android:name="android.intent.action.MAIN" /> <action android:name="android.intent.action.SHOW_PHONE_CALL_LIST" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> 

Y poner estos en su '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() 

Utilizar esto para initilaise el comportamiento de su onClick en myActivity, por ejemplo, después 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(); } 

Usted debe encontrar que hacer clic en su lista de números de teléfono termina su activty, hace la llamada al número y vuelve a su activty cuando termina la llamada.

Realizar una llamada desde fuera de la aplicación mientras esté en movimiento no reiniciará tu actividad (a menos que sea igual al último número de BParty que se llama).

🙂

Puede utilizar startActivityForResult ()

Esta es la 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) usted tiene que implementar View.OnClickListener.

Aquí está mi ejemplo, primero el usuario consigue escribir en el número que él / ella desea marcar y después presiona un botón de la llamada y consigue dirigido al teléfono. Después de la cancelación de llamada, el usuario se devuelve a la aplicación. Para ello, el botón debe tener un método onClick ('makePhoneCall' en este ejemplo) en el xml. También debe registrar el permiso en el manifiesto.

Manifiesto

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

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

  <EditText android:layout_width="wrap_content" android:layout_height="wrap_content" android:inputType="phone" android:ems="10" android:id="@+id/phoneNumber" android:layout_marginTop="67dp" android:layout_below="@+id/textView" android:layout_centerHorizontal="true" /> <Button android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Call" android:id="@+id/makePhoneCall" android:onClick="makePhoneCall" android:layout_alignParentBottom="true" android:layout_centerHorizontal="true" /> 

Si va a usar un oyente, tendrá que agregar este permiso también al manifiesto.

 <uses-permission android:name="android.permission.READ_PHONE_STATE" /> 
 @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); } 

Dentro de PhoneStateListener después de ver la llamada se termina mejor uso:

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

Donde CallDispatcherActivity es la actividad en la que el usuario ha lanzado una llamada (a un distribuidor de servicio de taxi, en mi caso). Esto acaba de quitar la aplicación de telefonía Android de la parte superior, el usuario recibe en lugar de código feo que vi aquí.

Para volver a su Activity , tendrá que escuchar TelephonyStates . En ese listener puede enviar una Intent de volver a abrir su Activity una vez que el teléfono esté inactivo.

Al menos eso es lo que voy a hacer.

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

  Intent callIntent = new Intent(Intent.ACTION_CALL); callIntent.setData(Uri.parse("tel:"+number)); startActivity(callIntent); **Add permission :** <uses-permission android:name="android.permission.CALL_PHONE" /> 

Trate de usar:

 finish(); 

Al final de la actividad. Se le redirigirá a su actividad anterior.

Cuando se utiliza PhoneStateListener es necesario asegurarse de que PHONE_STATE_IDLE después de un PHONE_STATE_OFFHOOK se utiliza para activar la acción que se va a realizar después de la llamada. Si el desencadenador ocurre al ver PHONE_STATE_IDLE , terminará haciéndolo antes de la llamada. Porque verá el cambio de estado PHONE_STATE_IDLE -> PHONE_STATE_OFFHOOK -> PHONE_STATE_IDLE.

// en setonclicklistener ponga 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 la llamada en el manifiesto:

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

@Dmitri Novikov, FLAG_ACTIVITY_CLEAR_TOP borra cualquier instancia activa encima de la nueva. Por lo tanto, puede finalizar la instancia anterior antes de completar el proceso.

Añadir esto 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 iniciar su llamada, se ve bien.

Hay una diferencia entre android 11+ y abajo en llevar su aplicación al frente sin embargo.

Android 10 o menos necesita iniciar una nueva intención, android 11+ simplemente usa 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); } 

Establecer MyActivity.MyActivityTaskId al hacer la llamada en mi actividad como así, esto no funciona, establecer esta variable en la página de actividad principal de la página que desea volver a.

 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í. Yo uso el código anterior un poco diferente, abro mi aplicación tan pronto como se responde la llamada sothat el usuario puede ver los detalles de la persona que llama.

He establecido algunas cosas en el AndroidManifest.xml también:

 /*Dont really know if this makes a difference*/ <activity android:name="MyActivity" android:taskAffinity="" android:launchMode="singleTask" /> 

Y permisos:

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

Por favor haga preguntas si o cuando usted consigue atascado.

Pasos:

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

 <!--For using the phone calls --> <uses-permission android:name="android.permission.CALL_PHONE" /> <!--For reading phone call state--> <uses-permission android:name="android.permission.READ_PHONE_STATE" /> 

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) Inicializar el oyente en su OnCreate

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

Pero si desea reanudar el último estado de su aplicación o volverlo a recuperar de la pila posterior , sustituya FLAG_ACTIVITY_CLEAR_TOP por FLAG_ACTIVITY_SINGLE_TOP

Hacer referencia a esta respuesta

  • ¿Cómo detecta un sistema operativo Android una llamada entrante?
  • Listener para el final de la llamada en Android
  • Android: Hacer una llamada telefónica desde el servicio
  • Desvío de llamadas de android mediante programación
  • Cómo contestar una llamada mediante programación
  • Android: Receptor de llamadas entrantes sin permiso
  • No se ha encontrado actividad para manejar la acción intencional.
  • Aplicación de marcador de Android
  • FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.