Ik start een activiteit om te bellen, maar toen ik op de knop ‘oproep beëindigen’ drukte, keerde deze niet terug naar mijn activiteit. Kunt u mij vertellen hoe ik een oproepactiviteit kan starten die bij mij terugkomt wanneer op de knop ‘Oproep beëindigen’ wordt gedrukt? Dit is hoe ik telefoneer:
String url = "tel:3334444";
Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse(url));
Antwoord 1, autoriteit 100%
gebruik een PhoneStateListener om te zien wanneer het gesprek is beëindigd. je zult hoogstwaarschijnlijk de luisteraaracties moeten activeren om te wachten tot de oproep start (wacht tot je bent gewijzigd van PHONE_STATE_OFFHOOK naar PHONE_STATE_IDLE) en dan wat code schrijven om je app weer in de IDLE-status te brengen.
het kan zijn dat u de listener in een service moet uitvoeren om ervoor te zorgen dat deze actief blijft en dat uw app opnieuw wordt gestart. enkele voorbeeldcode:
EndCallListener callListener = new EndCallListener();
TelephonyManager mTM = (TelephonyManager)this.getSystemService(Context.TELEPHONY_SERVICE);
mTM.listen(callListener, PhoneStateListener.LISTEN_CALL_STATE);
Luisterdefinitie:
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");
}
}
}
Voeg in uw Manifest.xml-bestand de volgende machtiging toe:
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
Antwoord 2, autoriteit 47%
Dit betreft de vraag van Starter.
Het probleem met uw code is dat u het nummer niet correct doorgeeft.
De code moet zijn:
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);
}
};
Vergeet niet de machtiging toe te voegen aan het manifestbestand.
<uses-permission android:name="android.permission.CALL_PHONE"></uses-permission>
of
<uses-permission android:name="android.permission.CALL_PRIVILEGED"></uses-permission>
voor noodnummer indien DIALwordt gebruikt.
Antwoord 3, autoriteit 24%
We hadden hetzelfde probleem en zijn erin geslaagd om het op te lossen door een PhoneStateListenerte gebruiken om te bepalen wanneer het gesprek eindigt, maar bovendien moesten we de oorspronkelijke activiteit finish()voordat het opnieuw starten met startActivity, anders zou het oproeplogboek ervoor staan.
Antwoord 4, autoriteit 12%
Ik vond de EndCallListener het meest functionele voorbeeld, om het beschreven gedrag te krijgen (finish(), call, restart) heb ik een paar SharedPreferences toegevoegd zodat de listener een referentie had om dit gedrag te beheren.
Mijn OnClick, initialize en EndCallListener reageren alleen op oproepen van de app. Andere oproepen genegeerd.
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);
}
}
}
voeg deze toe aan 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>
en zoiets in je manifest als je terug moet naar de look en feel van voor het gesprek
<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>
en zet deze in je ‘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()
Gebruik dit om het gedrag initilaise voor uw onclick in myactivity b.v. Na 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();
}
U moet merken dat het klikken op uw lijst met telefoonnummers is voltooid, uw Active, maakt de oproep naar het nummer en keert terug naar uw ActivTy wanneer het gesprek eindigt.
Een oproep van buiten uw app maken terwijl het nog steeds is, start uw Activy niet opnieuw (tenzij het hetzelfde is als het laatste BParty-nummer genaamd).
🙂
Antwoord 5, Autoriteit 7%
U kunt StartactiviteitSRESULT ()
gebruiken
Antwoord 6, Autoriteit 6%
Dit is een oplossing vanuit mijn standpunt:
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);
}
Natuurlijk in activiteit (klasse) definitie moet u weergeven bekijken.OnclickListener.
Antwoord 7, Autoriteit 6%
Hier is mijn voorbeeld, eerst moet de gebruiker schrijven in het nummer dat hij / zij wil kiezen en drukt vervolgens op een beltoets en wordt gericht op de telefoon. NA CALL annulering wordt de gebruiker teruggestuurd naar de toepassing. Voor dit moet de knop een onclick-methode (‘makephonecall’ in dit voorbeeld) in de XML hebben. U moet ook de toestemming in het manifest registreren.
manifest
<uses-permission android:name="android.permission.CALL_PHONE"></uses-permission>
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
Activiteit
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" />
Antwoord 8, autoriteit 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);
}
Antwoord 9, autoriteit 5%
Als je een listener gaat gebruiken, moet je deze toestemming ook aan het manifest toevoegen.
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
Antwoord 10, autoriteit 3%
Binnen PhoneStateListener nadat u hebt gezien dat het gesprek is beëindigd, kunt u beter het volgende gebruiken:
Intent intent = new Intent(CallDispatcherActivity.this, CallDispatcherActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
Waarbij CallDispatcherActivity de activiteit is waarbij de gebruiker een oproep heeft gedaan (in mijn geval naar een coördinator van een taxiservice). Dit verwijdert gewoon de Android-telefonie-app van bovenaf, de gebruiker krijgt terug in plaats van lelijke code die ik hier zag.
Antwoord 11, autoriteit 3%
Om terug te keren naar uw Activity, moet u luisteren naar TelephonyStates. Op die listenerkun je een Intentsturen om je Activityopnieuw te openen zodra de telefoon inactief is.
Zo zal ik het tenminste doen.
Antwoord 12, autoriteit 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" />
Antwoord 13, autoriteit 2%
Probeer het volgende te gebruiken:
finish();
aan het einde van de activiteit. Het zal je doorverwijzen naar je vorige activiteit.
Antwoord 14, autoriteit 2%
Wanneer PhoneStateListenerwordt gebruikt, moet men ervoor zorgen dat PHONE_STATE_IDLEna een PHONE_STATE_OFFHOOKwordt gebruikt om de actie te starten die moet worden uitgevoerd na de oproep . Als de trigger plaatsvindt bij het zien van PHONE_STATE_IDLE, doe je dit voor de oproep. Omdat u de statusverandering zult zien PHONE_STATE_IDLE -> PHONE_STATE_OFFHOOK -> PHONE_STATE_IDLE.
Antwoord 15, autoriteit 2%
// plaats in setonclicklistener deze 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);
// toestemming geven voor oproep in manifest:
<uses-permission android:name="android.permission.CALL_PHONE"></uses-permission>
Antwoord 16
@Dmitri Novikov, FLAG_ACTIVITY_CLEAR_TOPwist elke actieve instantie bovenop de nieuwe. Het kan dus de oude instantie beëindigen voordat het proces is voltooid.
Antwoord 17
Voeg dit is uw xml: android:autoLink="phone"
Antwoord 18
Stappen:
1)Voeg de vereiste rechten toe aan het bestand 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)Maak een luisteraar voor de veranderingen in de telefoonstatus.
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)Initialiseer de luisteraar in uw OnCreate
EndCallListener callListener = new EndCallListener();
TelephonyManager mTM = (TelephonyManager)this.getSystemService(Context.TELEPHONY_SERVICE);
mTM.listen(callListener, PhoneStateListener.LISTEN_CALL_STATE);
maar als je de laatste staat van je applicatie wilt hervatten of terug wilt halen uit de backstack, vervang dan FLAG_ACTIVITY_CLEAR_TOPdoor FLAG_ACTIVITY_SINGLE_TOP
Refereer naar dit antwoord
Antwoord 19
Intent callIntent = new Intent(Intent.ACTION_CALL);
callIntent .setData(Uri.parse("tel:+91-XXXXXXXXX"));
startActivity(callIntent );
Antwoord 20
Als je je gesprek start, ziet het er goed uit.
Er is echter een verschil tussen Android 11+ en down als je je app op de voorgrond plaatst.
Android 10 of minder heb je nodig om een nieuwe intentie te starten, Android 11+ gebruik je gewoon BringTaskToFront
In de oproepstatus 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);
}
Ik stel de MyActivity.MyActivityTaskIdin wanneer ik mijn activiteit aanroep, zoals zo, als dit niet werkt, stel deze variabele dan in op de bovenliggende activiteitenpagina van de pagina waarnaar u wilt terugkeren.
MyActivity.MyActivityTaskId = this.getTaskId();
MyActivityTaskIdis een statische variabele in mijn activiteitenklasse
public static int MyActivityTaskId = 0;
Ik hoop dat dit voor u werkt. Ik gebruik de bovenstaande code iets anders, ik open mijn app zodra de oproep wordt beantwoord, zodat de gebruiker de details van de beller kan zien.
Ik heb ook wat dingen ingesteld in de AndroidManifest.xml:
/*Dont really know if this makes a difference*/
<activity android:name="MyActivity" android:taskAffinity="" android:launchMode="singleTask" />
en rechten:
<uses-permission android:name="android.permission.GET_TASKS" />
<uses-permission android:name="android.permission.REORDER_TASKS" />
Stel alstublieft vragen als en wanneer u vastloopt.