How to make a phone call in android and come back to my activity when the call is done?

Question

I am launching an activity to make a phone call, but when I pressed the 'end call' button, it does not go back to my activity. Can you please tell me how can I launch a call activity which comes back to me when 'End call' button is pressed? This is how I'm making the phone call:

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

score 106 · Answer 1 · edited Feb 09 '15 at 07:43

use a PhoneStateListener to see when the call is ended. you will most likely need to trigger the listener actions to wait for a the call to start (wait until changed from PHONE_STATE_OFFHOOK to PHONE_STATE_IDLE again) and then write some code to bring your app back up on the IDLE state.

you may need to run the listener in a service to ensure it stays up and your app is restarted. some example code:

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

Listener definition:

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");
        }
    }
}

In your Manifest.xml file add the following permission:

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

As Gp2mv3 has noted, don't forget to add the READ_PHONE_STATE permission to the AndroidManifest.xml. — Display name, Jun 30 '12 at 19:06
@moonlightcheese Can you add code to come back to our app from call app? — Geek, Jul 15 '13 at 17:16
this is dangerous because it will always open your app activity every time you call — user924, Apr 05 '18 at 18:05

score 50 · Answer 2 · edited Jun 13 '12 at 11:11

50

This is regarding the question asked by Starter.

The problem with your code is that you are not passing the number properly.

The code should be:

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

Do not forget to add the permission in manifest file.

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

or

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

for emergency number in case DIAL is used.

edited Jun 13 '12 at 11:11

Ed Daniel

522
11
22

answered Mar 23 '10 at 09:09

Pria

2,743
4
27
30

7

I'm having a hard time to see how your code is different from the code in the original question – Ilya Saunkin Aug 22 '11 at 21:35
The code is not different. You need to add the permission in the manifest file. – Pria Mar 01 '12 at 12:08
4

android.permission.CALL_PRIVILEGED Permission is only granted to system apps not available at app level. – CoDe Mar 02 '14 at 11:25
and what is that? it won't return back to your activity – user924 Apr 05 '18 at 17:59

score 25 · Answer 3 · edited Feb 09 '15 at 07:45

25

We had the same problem and managed to solve it by using a PhoneStateListener to identify when the call ends, but additionally we had to finish() the original activity before starting it again with startActivity, otherwise the call log would be in front of it.

edited Feb 09 '15 at 07:45

Sami Eltamawy

9,874
8
48
66

answered May 26 '11 at 20:28

André Lima

651
1
6
11

5

you can avoid this by using a different method. if you build a ContentObserver that observes the android call log, then the app will not start until the call log change is made. i actually had to dump the PhoneStateListener in favor of this model, as my app needed call log data, and the listener was returning before those changes were made. http://pastebin.com/bq2s9EVa – moonlightcheese Sep 28 '11 at 15:48
11

@André: your link appears to be broken – aggregate1166877 Oct 11 '12 at 12:28
I would give you a million reputation (if I had a lot:)) Thanks for making my day! – keybee Aug 22 '13 at 18:06
1

The problem with links I say! – Dheeraj Bhaskar Mar 20 '14 at 19:38
Internet Archive to the rescue... http://web.archive.org/web/20120123224619/http://umamao.com/questions/Como-fazer-uma-app-de-Android-chamar-o-discador-e-faz%C3%AA-lo-retornar-%C3%A0-app-ap%C3%B3s-o-t%C3%A9rmino-da-chamada – Basic Jul 24 '15 at 00:57

score 13 · Answer 4 · answered Nov 04 '11 at 11:02

I found the EndCallListener the most functional example, to get the behaviour described (finish(), call, restart) I added a few SharedPreferences so the Listener had a reference to manage this behaviour.

My OnClick, initialise and EndCallListener only respond to calls from app. Other calls ignored.

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);

        }

    }
}

add these to 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>

and something like this in your Manifest if you need to return to the look and feel before the call

  <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>

and put these in your '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 this to initilaise the behaviour for your onClick in myActivity e.g. after 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();

}

You should find that clicking your list of phone numbers finishes your activty, makes the call to the number and returns to your activty when the call ends.

Making a call from outside your app while it's still around won't restart your activty (unless it's the same as the last BParty number called).

:)

Sorry but this code looks somewhat ugly. Thanks for the answer though — Pierre, Jan 09 '14 at 19:46

score 7 · Answer 5 · answered May 10 '11 at 11:23

7

you can use startActivityForResult()

answered May 10 '11 at 11:23

yakr

1
1
1

1

Using android 5.0 the onActivityResult method is call emmediately the call starts!! – Panciz Jun 08 '17 at 01:58

score 6 · Answer 6 · answered Nov 05 '09 at 12:57

This is solution from my point of view:

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);

    }

Of course in Activity (class) definition you have to implement View.OnClickListener .

Oyee · Answer 7 · 2015-04-14T14:24:57.610

Here is my example, first the user gets to write in the number he/she wants to dial and then presses a call button and gets directed to the phone. After call cancelation the user gets sent back to the application. In order to this the button needs to have a onClick method ('makePhoneCall' in this example) in the xml. You also need to register the permission in the manifest.

Manifest

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

Activity

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" />

you don't even what you are talking about. READ_PHONE_STATE - you don't use it in your example code, why did you add it? of course it will return you back to your app activity if you press cancellation button, but author of the question asked about how to get back to activity after call was accepted — user924, Apr 05 '18 at 18:03

score 6 · Answer 8 · edited Apr 02 '16 at 14:48

6

@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);
}

edited Apr 02 '16 at 14:48

pp_

3,435
4
19
27

answered Apr 02 '16 at 14:08

erluxman

18,155
20
92
126

score 5 · Answer 9 · answered Jun 07 '11 at 14:42

5

If you are going to use a listener you will need to add this permission to the manifest as well.

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

answered Jun 07 '11 at 14:42

martincm

13
1
6

score 3 · Answer 10 · answered Jun 28 '12 at 14:30

3

Inside PhoneStateListener after seeing the call is finished better use:

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

Where CallDispatcherActivity is the activity where the user has launched a call (to a taxi service dispatcher, in my case). This just removes Android telephony app from the top, the user gets back instead of ugly code I saw here.

answered Jun 28 '12 at 14:30

Dmitri Novikov

123
1
12

1

And don't forget to remove the listener after the phone call is done,like this: `((TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE)).listen(this, LISTEN_NONE);` – Dmitri Novikov Jun 28 '12 at 15:59
I've tried using your approach but the activity (called ControlPanel) is not being reactivated. The display continues to show the phone dialer interface and the loggers on the onResume and onNewIntent entry points within ControlPanel are completely silent. Here's the intent: `Intent intentRestart = new Intent(ControlPanel.this, ControlPanel.class);`. I should point out that the PhoneStateListener is also within ControlPanel. I.e., My goal is to restore the UI to the state it was in prior to initiating the phone call. Any suggestions? – PeteH Apr 21 '13 at 05:39
Try logging inside your PhoneStateListener implementation. – Dmitri Novikov Apr 22 '13 at 09:01

score 3 · Answer 11 · answered Feb 26 '14 at 09:53

3

  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" />

answered Feb 26 '14 at 09:53

ritesh4326

687
7
9

score 3 · Answer 12 · edited Jul 24 '12 at 08:19

3

To return to your Activity, you will need to listen to TelephonyStates. On that listener you can send an Intent to re-open your Activity once the phone is idle.

At least thats how I will do it.

edited Jul 24 '12 at 08:19

Abhilasha

929
1
17
37

answered Nov 10 '10 at 18:16

Aimeric

219
2
2

score 2 · Answer 13 · edited Oct 22 '12 at 00:28

2

When PhoneStateListener is used, one need to make sure PHONE_STATE_IDLE following a PHONE_STATE_OFFHOOK is used to trigger the action to be done after the call. If the trigger happens upon seeing PHONE_STATE_IDLE, you will end up doing it before the call. Because you will see the state change PHONE_STATE_IDLE -> PHONE_STATE_OFFHOOK -> PHONE_STATE_IDLE.

edited Oct 22 '12 at 00:28

Rathakrishnan Ramasamy

1,612
2
25
46

answered Oct 21 '12 at 05:23

PonMaran

66
3

isn't it possible the app stops when the ongoing call screen opens? – lisovaccaro Jan 21 '13 at 19:30
Listener object once set to listen the TelephonyManager with `((TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE)).listen(new PhoneStateListener(), PhoneStateListener.LISTEN_CALL_STATE)` will continue to listen the phone state and be active until explicitly stopped with `((TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE)).listen(this, LISTEN_NONE)` – PonMaran Sep 14 '14 at 04:42

score 2 · Answer 14 · answered Apr 23 '13 at 10:10

// in setonclicklistener put this code:

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);

// give permission for call in manifest:

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

score 2 · Answer 15 · edited Dec 15 '11 at 17:58

2

Try using:

finish();

at the end of activity. It will redirect you to your previous activity.

edited Dec 15 '11 at 17:58

answered May 25 '11 at 09:19

Ankit Kedia

141
2
5

score 1 · Answer 16 · edited Oct 21 '12 at 06:10

1

@Dmitri Novikov, FLAG_ACTIVITY_CLEAR_TOP clears any active instance on top of the new one. So, it may end the old instance before it completes the process.

edited Oct 21 '12 at 06:10

Rathakrishnan Ramasamy

1,612
2
25
46

answered Oct 21 '12 at 05:51

PonMaran

66
3

score 1 · Answer 17 · answered Oct 29 '12 at 09:31

1

Add this is your xml: android:autoLink="phone"

answered Oct 29 '12 at 09:31

Roman Marius

456
3
9
21

2

Please elaborate. "Which xml"? – Anas Azeem Oct 19 '13 at 11:29

score 1 · Answer 18 · edited May 23 '17 at 12:02

Steps:

1)Add the required permissions in the Manifest.xml file.

<!--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)Create a listener for the phone state changes.

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)Initialize the listener in your OnCreate

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

but if you want to resume your application last state or to bring it back from the back stack, then replace FLAG_ACTIVITY_CLEAR_TOP with FLAG_ACTIVITY_SINGLE_TOP

Reference this Answer

score 1 · Answer 19 · edited Oct 19 '20 at 06:16

1

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

edited Oct 19 '20 at 06:16

Martijn Pieters

1,048,767
296
4,058
3,343

answered Oct 08 '15 at 06:43

Dhina k

1,481
18
24

score 0 · Answer 20 · answered Jun 29 '14 at 06:45

When starting your call, it looks fine.

There is a difference between android 11+ and down in bringing your app to the front though.

Android 10 or less you need to start a new intent, android 11+ you simply use BringTaskToFront

In the call state 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);
}

I set the MyActivity.MyActivityTaskId when making the call on my activity like so, it this doesnt work, set this variable on the parent activity page of the page you want to get back to.

MyActivity.MyActivityTaskId = this.getTaskId();

MyActivityTaskId is a static variable on my activity class

public static int MyActivityTaskId = 0;

I hope this will work for you. I use the above code a bit differently, I open my app as soon as the call is answered sothat the user can see the details of the caller.

I have set some stuff in the AndroidManifest.xml as well:

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

and permissions:

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

Please ask questions if or when you get stuck.

score 0 · Answer 21 · answered Mar 03 '22 at 11:13

To call from app use simple intent for call, after that if you want to listen the call status then use below code

1] implement this in your class -

implements AudioManager.OnAudioFocusChangeListener

2] Add below code with overridden method

    AudioManager audioManager = (AudioManager) getSystemService(AUDIO_SERVICE); //public static final String AUDIO_SERVICE = "audio";
    audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
    assert audioManager != null;
    audioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC,
            AudioManager.AUDIOFOCUS_GAIN);

@Override
public void onAudioFocusChange(int focusChange) {
        switch (focusChange) {
            case AudioManager.AUDIOFOCUS_LOSS: {
                //here you can pause your playing audio
                break;
            }
            case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT: {
                 //here you can pause your playing audio
                break;
            }
            case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK: {
                break;
            }
            case AudioManager.AUDIOFOCUS_GAIN: {
                 //here you will return back to the activity when your call is finsihed
               //resume your audio here
                break;
            }
        }
    }

3]Add this

@Override public void onDestroy() { audioManager.abandonAudioFocus(this); }

How to make a phone call in android and come back to my activity when the call is done?

21 Answers21

Linked

Related