¿Cómo hacer una llamada telefónica en Android y volver a mi actividad cuando finaliza la llamada?
Estoy iniciando una actividad para hacer una llamada telefónica, pero cuando presioné el botón 'finalizar llamada', no vuelve a mi actividad. ¿Puede decirme cómo puedo iniciar una actividad de llamada que vuelve a mí cuando se presiona el botón "Finalizar llamada"? Así es como hago la llamada telefónica:
String url = "tel:3334444";
Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse(url));
use un PhoneStateListener para ver cuándo finaliza la llamada. Lo más probable es que necesite activar las acciones del oyente para esperar a que comience la llamada (espere hasta que 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 IDLE.
es posible que deba ejecutar el oyente en un servicio para asegurarse de que permanezca activo y que 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 Manifest.xmlarchivo agregue el siguiente permiso:
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
Esto se refiere a la pregunta de Starter.
El problema con tu código es que no estás 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 olvide agregar 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 DIALse utilice.
Tuvimos el mismo problema y logramos resolverlo usando a PhoneStateListenerpara identificar cuándo termina la llamada, pero además teníamos que realizar finish()la actividad original antes de comenzar nuevamente con startActivity, de lo contrario, el registro de llamadas estaría frente a ella.
Encontré que EndCallListener es el ejemplo más funcional; para obtener el comportamiento descrito (finalizar(), llamar, reiniciar), agregué algunas SharedPreferences para que el oyente tuviera una referencia para administrar este comportamiento.
My OnClick, inicialise y EndCallListener solo responden a 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
<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 como esto en su Manifiesto si necesita volver a la apariencia anterior a 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 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()
use 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 descubrir 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.
Hacer una llamada desde fuera de su aplicación mientras aún está disponible no reiniciará su actividad (a menos que sea el mismo que el último número de BParty al que llamó).
:)
Nov 04 '2011 11:11
puedes usar startActivityForResult()
May 10 '2011 11:05