So tätigen Sie Anrufe und verwenden SMS in Android-Apps

German (Deutsch) translation by Władysław Łucyszyn (you can also view the original English article)

In diesem Tutorial erfahren Sie mehr über die Android-Telefonie- und SMS-API. Sie erfahren, wie Sie über Ihre App einen Anruf tätigen und Telefonanrufereignisse überwachen sowie SMS senden und empfangen.

1. So tätigen Sie einen Anruf

Zu Beginn zeige ich Ihnen, wie Sie einen Anruf über Ihre Anwendung entweder über die Telefonwähler-App oder direkt über Ihre App einleiten können, um es Ihren Benutzern zu erleichtern.

Erstellen Sie ein neues Android Studio-Projekt

Starten Sie Android Studio und erstellen Sie ein neues Projekt mit einer leeren Aktivität namens MainActivity.

Android Studio create a new Activity screenshot

Den Bildschirm auslegen

Im Moment hat unser Layout nur ein EditText-Feld und eine Wähltaste:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
        xmlns:android="https://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/activity_main"
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:gravity="center_horizontal|center_vertical"
        tools:context="com.chikeandroid.tutsplust_telephony.MainActivity">

    <EditText
            android:id="@+id/et_phone_no"
            android:hint="Enter Phone number"
            android:inputType="phone"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"/>
    
    <Button
            android:id="@+id/btn_dial"
            android:layout_gravity="center_horizontal"
            android:text="Dial"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"/>
</LinearLayout>

Emulator dial screen with phone number given

Ändern Sie die `MainActivity`-Klasse

Im Codeblock unten erstellen wir einen ACTION_DIAL-Intent, um den Telefonwähler anzuzeigen. Die Telefonnummer wird von unserem tel-URI-Schema geparst: tel:XXXXXXXX. Beachten Sie, dass Sie dafür keine Berechtigung benötigen:

import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.text.TextUtils;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button mDialButton = (Button) findViewById(R.id.btn_dial);
        final EditText mPhoneNoEt = (EditText) findViewById(R.id.et_phone_no);

        mDialButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                String phoneNo = mPhoneNoEt.getText().toString();
                if(!TextUtils.isEmpty(phoneNo)) {
                    String dial = "tel:" + phoneNo;
                    startActivity(new Intent(Intent.ACTION_DIAL, Uri.parse(dial)));
                }else {
                    Toast.makeText(MainActivity.this, "Enter a phone number", Toast.LENGTH_SHORT).show();
                }
            }
        });
    }
}

Wenn Sie die App ausführen und auf die Wählschaltfläche klicken, werden Sie zur Wähl-App weitergeleitet und müssen von dort aus die Nummer wählen. Sie können diesen Ablauf ändern, um den Anruf tatsächlich von Ihrer App aus zu tätigen, indem Sie stattdessen einfach den Intent ACTION_DIAL in ACTION_CALL ändern. Dies erfordert jedoch die Berechtigung android.permission.CALL_PHONE.

Emulator screen defualt phone dialer with the phone number

2. Überwachung von Telefonanrufereignissen

In diesem Abschnitt erfahren Sie, wie Sie Telefonanrufereignisse im Android-System überwachen. Das Telefon kann sich in drei Zuständen befinden:

idle (wenn es nicht benutzt wird)
ringing (bei eingehendem Anruf)
off-hook (wenn der Anruf entgegengenommen wird)

Berechtigung hinzufügen

Wir benötigen die Berechtigung READ_PHONE_STATE, um den Telefonstatus überwachen zu können. Fügen Sie es zu AndroidManifest.xml hinzu:

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

Erstellen Sie das `PhoneStateListener`-Objekt

Wir erstellen ein Objekt der PhoneStateListener-Klasse und überschreiben dann seine onCallStateChanged()-Methode (in IntelliJ ist dies einfach mit Control-O zu tun und dann die zu überschreibende Methode auszuwählen oder zu suchen). Wir behandeln Änderungen an den Anrufstatusänderungen, indem wir einen Toast anzeigen. Beachten Sie, dass wir auch auf die eingehenden Telefonnummern zugreifen können, wenn diese Methode ausgelöst wird:

// ... 
PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
    @Override
    public void onCallStateChanged(int state, String incomingNumber) {
        super.onCallStateChanged(state, incomingNumber);

        switch (state) {
            case TelephonyManager.CALL_STATE_IDLE:
                Toast.makeText(MainActivity.this, "CALL_STATE_IDLE", Toast.LENGTH_SHORT).show();
                break;
            case TelephonyManager.CALL_STATE_RINGING:
                Toast.makeText(MainActivity.this, "CALL_STATE_RINGING", Toast.LENGTH_SHORT).show();
                break;
            case TelephonyManager.CALL_STATE_OFFHOOK:
                Toast.makeText(MainActivity.this, "CALL_STATE_OFFHOOK", Toast.LENGTH_SHORT).show();
                break;
        }
    }
};
// ...

Abhängig von Ihren Anwendungsanforderungen können Sie auch eine dieser anderen Ereignismethoden überschreiben: onCellInfoChanged(), onCallForwardingIndicatorChanged(), onCellLocationChanged() oder onSignalStrengthChanged().

Anhören des Anrufstatus

Um mit dem Abhören des Anrufstatus zu beginnen, müssen wir den TelephonyManager vom Systemdienst abrufen und in onCreate() initialisieren.

// ...
private TelephonyManager mTelephonyManager;
@Override
protected void onCreate(Bundle savedInstanceState) {
   // ... 
   mTelephonyManager = (TelephonyManager) getSystemService(getApplicationContext().TELEPHONY_SERVICE);
}

In der Methode onResume() können wir mit dem Hören beginnen, indem wir die Methode TelephonyManager listen() verwenden, indem wir ihr die PhoneStateListener-Instanz und den statischen LISTEN_CALL_STATE übergeben. Wir beenden das Zuhören in der Methode onStop(), indem wir LISTEN_NONE als zweites Argument an listen() übergeben.

// ...
@Override
protected void onResume() {
    super.onResume();
    mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
}
@Override
protected void onStop() {
    super.onStop();
    mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
}
// ...

Andere mögliche Telefonhöroptionen sind LISTEN_CELL_LOCATION, LISTEN_SIGNAL_STRENGTH, LISTEN_CALL_FORWARDING_INDICATOR und LISTEN_CELL_INFO.

Führen Sie abschließend die App aus und stellen Sie sicher, dass ein eingehender Anruf eingeht.

Diese Überwachung funktioniert nur, wenn sich die App im Vordergrund befindet. Damit dies im Hintergrund funktioniert (wenn unsere Anwendung nicht ausgeführt wird), müssen wir einen BroadcastReceiver erstellen, damit wir auch dann, wenn die App nicht ausgeführt wird, den Status von Telefonanrufen überwachen können. Abhängig von Ihren App-Anforderungen kann dies eine viel bessere Möglichkeit sein, um auf Änderungen des Anrufstatus zu achten. Wie das geht, zeige ich Ihnen im nächsten Abschnitt.

Beachten Sie, dass wir nur eingehende Anrufe überwachen. Damit wir ausgehende Anrufe überwachen können, benötigen wir zusätzliche Berechtigungen. Um ausgehende Anrufe zu überwachen, fügen Sie die folgende Zeile in Ihre AndroidManifest.xml-Datei ein.

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

So verwenden Sie den Emulator, um Anrufe zu tätigen und SMS-Nachrichten zu senden Message

Sie können Ihren Emulator verwenden, um einen Anruf oder das Senden einer SMS-Nachricht zu simulieren, aber Sie müssen ein wenig einrichten. Öffnen Sie Ihren Emulator, klicken Sie auf die letzte Schaltfläche in der rechten Navigationsleiste, um den erweiterten Steuerungsdialog zu öffnen, und wählen Sie dann die Telefonsteuerungsschaltfläche aus.

Using emulator to make call and send SMS

3. Überwachung von Telefonanrufereignissen im Hintergrund

Erstellen Sie einen BroadcastReceiver

Genau wie im vorherigen Abschnitt müssen wir einen Ereignis-Listener erstellen, um Änderungen des Telefonstatus zu überwachen. Der Hauptunterschied besteht darin, dass wir diesmal die BroadcastReceiver-Basisklasse erweitern, sodass wir auch dann auf den Anrufstatus achten können, wenn die Anwendung nicht ausgeführt wird. Achten Sie darauf, den Hörer nicht mehr als einmal zu registrieren! Unser Scheck dafür ist in Zeile 36.

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;
import android.widget.Toast;

public class PhoneCallStateReceiver extends BroadcastReceiver {
    private TelephonyManager mTelephonyManager;
    public static boolean isListening = false;

    @Override
    public void onReceive(final Context context, Intent intent) {

        mTelephonyManager = (TelephonyManager) context.getSystemService(context.TELEPHONY_SERVICE);

        PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
            @Override
            public void onCallStateChanged(int state, String incomingNumber) {
                super.onCallStateChanged(state, incomingNumber);

                switch (state) {
                    case TelephonyManager.CALL_STATE_IDLE:
                        Toast.makeText(context, "CALL_STATE_IDLE", Toast.LENGTH_SHORT).show();
                        break;
                    case TelephonyManager.CALL_STATE_RINGING:
                        Toast.makeText(context, "CALL_STATE_RINGING", Toast.LENGTH_SHORT).show();
                        break;
                    case TelephonyManager.CALL_STATE_OFFHOOK:
                        Toast.makeText(context, "CALL_STATE_OFFHOOK", Toast.LENGTH_SHORT).show();
                        break;
                }
            }
        };

        if(!isListening) {
            mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
            isListening = true;
        }
    }
}

Ändern Sie AndroidManifest.xml

Ein Rundfunkempfänger funktioniert nur, wenn er registriert ist. Wir müssen dem Android-System unseren Broadcast-Empfänger mitteilen, indem wir ihn in der Datei AndroidManifest.xml registrieren, indem wir unsere PhoneCallStateReceiver-Klasse mit dem <intent-filter> verbinden, der den System-Broadcast beschreibt, den wir empfangen möchten – in diesem Fall PHONE_STATE.

<receiver android:name=".PhoneCallStateReceiver">
        <intent-filter>
            <action android:name="android.intent.action.PHONE_STATE"/>
        </intent-filter>
</receiver>

Ausgehende Anrufe überwachen

Bei ausgehenden Anrufen müssen Sie die Aktionsabsicht NEW_OUTGOING_CALL <action android:name="android.intent.action.NEW_OUTGOING_CALL"/> in den <intent-filter> des Empfängers in AndroidManifest.xml aufnehmen.

Um die Telefonnummer des beabsichtigten ausgehenden Anrufs zu erhalten, erhalten wir innerhalb der onReceive(Context, Intent)-Methode die Nummer aus dem Intent als Extra. Um zu verhindern, dass dieser beabsichtigte Aufruf durchgeführt wird, können wir setResultData() aufrufen und ihm ein Null-Argument übergeben. Die resultData wird als die eigentliche anzurufende Nummer verwendet.

@Override
public void onReceive(final Context context, Intent intent) {
    // for outgoing call
    String outgoingPhoneNo = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER).toString();
    // prevent outgoing call
    setResultData(null); 
}

In unserem Tutorial hier auf Envato Tuts+ erfahren Sie mehr über Broadcasts und Broadcast-Empfänger:

Android SDK

Android von Grund auf: Android-Übertragungen verstehen

Ashraff Hathibelagal

4. Senden von SMS-Nachrichten

Sie haben nur zwei Möglichkeiten zum Senden von SMS: Verwenden der SMS-Client-Anwendung des Geräts oder Überspringen des Clients, indem Sie die SMS direkt von Ihrer App aus senden. Wir werden uns beide Szenarien ansehen und Sie können entscheiden, welches für Ihren Anwendungsfall besser ist. Beginnen wir mit dem Senden einer SMS mit dem SMS-Client des Geräts.

Einrichten des Layouts

Zuerst müssen wir unser Hauptlayout so ändern, dass es ein EditText-Feld für die Nachricht und eine Schaltfläche Nachricht senden enthält.

<!--/ ... /-->
<EditText
        android:id="@+id/et_message"
        android:hint="Enter message"
        android:inputType="textCapSentences|textMultiLine"
        android:maxLength="2000"
        android:maxLines="12"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>

<Button
        android:id="@+id/btn_send_message"
        android:layout_gravity="center_horizontal"
        android:text="Send Messange"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>
<!--/ ... /-->

Ändern Sie die MainActivity

Erstellen Sie in unserer onCreate()-Methode in unserer MainActivity-Klasse eine Absicht mit ACTION_SENDTO als erstem Argument und einem smsto:<phone number>-URI als zweitem Argument. Die Textnachricht ist der Wert des sms_body-Extras:

// ...
Button sendMessageBtn = (Button) findViewById(R.id.btn_send_message);
final EditText messagetEt = (EditText) findViewById(R.id.et_message);
sendMessageBtn.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        String message = messagetEt.getText().toString();
        String phoneNo = mPhoneNoEt.getText().toString();
        if(!TextUtils.isEmpty(message) && !TextUtils.isEmpty(phoneNo)) {
            Intent smsIntent = new Intent(Intent.ACTION_SENDTO, Uri.parse("smsto:" + phoneNo));
            smsIntent.putExtra("sms_body", message);
            startActivity(smsIntent);
        }
    }
});
// ...

Hier überwacht der SMS-Client den Status der Nachrichtenzustellung.

Führen Sie die App aus

Wenn alle erforderlichen Felder ausgefüllt sind, wird durch Klicken auf die Schaltfläche SMS senden der SMS-Client des Benutzers geöffnet oder dem Benutzer die Möglichkeit geboten, eine App auszuwählen, falls noch keine ausgewählt wurde.

5. Direktes Senden von SMS-Nachrichten

Als Nächstes sehen wir uns an, wie Sie die SMS direkt aus unserer Anwendung senden können, anstatt den SMS-Client des Geräts zu verwenden.

Berechtigung in AndroidManifest.xml hinzufügen

Wie üblich müssen wir die Berechtigung in AndroidManifest.xml registrieren.

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

Ändern Sie die MainActivity-Klasse

Als Nächstes müssen wir für Android 6.0 (API-Level 23) und höher während der Laufzeit die SEND_SMS-Berechtigung anfordern.

Um mehr über Android-Laufzeitberechtigungen und deren Änderungen in Version 6.0 zu erfahren, sehen Sie sich unser Tutorial hier auf Envato Tuts+ an:

Android M

Informationen zu Berechtigungen in Android M

Paul Trebilcox-Ruiz

Um eine SMS zu senden, rufen wir die Standardinstanz von SmsManager ab und rufen dann ihre sendTextMessage()-Methode auf, wobei wir die Telefonnummer als erstes Argument und die Nachricht als zweites Argument übergeben:

// ...
final int SEND_SMS_PERMISSION_REQUEST_CODE = 111;
private  Button mSendMessageBtn;

@Override
protected void onCreate(Bundle savedInstanceState) {
    // ...
    mSendMessageBtn = (Button) findViewById(R.id.btn_send_message);
    final EditText messagetEt = (EditText) findViewById(R.id.et_message);

    mSendMessageBtn.setEnabled(false);
    if(checkPermission(Manifest.permission.SEND_SMS)) {
        mSendMessageBtn.setEnabled(true);
    }else {
        ActivityCompat.requestPermissions(this, new String[] {Manifest.permission.SEND_SMS}, 
                SEND_SMS_PERMISSION_REQUEST_CODE);
    }
    mSendMessageBtn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            String message = messagetEt.getText().toString();
            String phoneNo = mPhoneNoEt.getText().toString();
            if(!TextUtils.isEmpty(message) && !TextUtils.isEmpty(phoneNo)) {
             
                if(checkPermission(Manifest.permission.SEND_SMS)) {
                    SmsManager smsManager = SmsManager.getDefault();
                    smsManager.sendTextMessage(phoneNo, null, message, null, null);
                }else {
                    Toast.makeText(MainActivity.this, "Permission denied", Toast.LENGTH_SHORT).show();
                }
            }
        }
    });  
}

private boolean checkPermission(String permission) {
    int checkPermission = ContextCompat.checkSelfPermission(this, permission);
    return (checkPermission == PackageManager.PERMISSION_GRANTED);
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    switch (requestCode) {
        case SEND_SMS_PERMISSION_REQUEST_CODE: {
            if(grantResults.length > 0 && (grantResults[0] == PackageManager.PERMISSION_GRANTED)) {
                mSendMessageBtn.setEnabled(true);
            }
            return;
        }
    }
}
// ...

Um den Zustellungsstatus zu überwachen, verfügt die SMSManager-Methode sendTextMessage() über zwei optionale PendingIntent-Parameter: sentIntent und deliveryIntent.

void sendTextMessage (String destinationAddress, 
                String scAddress, 
                String text, 
                PendingIntent sentIntent, 
                PendingIntent deliveryIntent)

Wenn Sie sentIntent verwenden möchten, achten Sie bei Erfolg auf den Ergebniscode Activity.RESULT_OK oder einen von RESULT_ERROR_GENERIC_FAILURE, RESULT_ERROR_RADIO_OFF und RESULT_ERROR_NULL_PDU, um einen Fehler anzuzeigen.

6. Empfangen einer SMS-Nachricht

Damit Ihre App beginnen kann, SMS-Nachrichten vom Telefon des Benutzers zu empfangen, ist es am besten, einen Broadcast-Empfänger zu registrieren, damit er benachrichtigt werden kann, wenn eine neue SMS eingeht, auch wenn Ihre App nicht im Vordergrund ausgeführt wird.

Berechtigung hinzufügen

Fügen Sie die Berechtigung RECEIVE_SMS zu AndroidManifest.xml hinzu:

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

Als nächstes müssen wir überprüfen, ob die App zur Laufzeit berechtigt ist, SMS-Nachrichten zu empfangen. Überprüfen Sie daher in der MainActivity-Klasse die RECEIVE_SMS-Berechtigung. Wenn es nicht gefunden wird, fordern Sie es an.

// ...
@Override
protected void onCreate(Bundle savedInstanceState) {
    // ...
    if(!checkPermission(Manifest.permission.RECEIVE_SMS)) {
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.RECEIVE_SMS}, 222);
    }
}
// ...

Erstellen Sie einen Broadcast-Empfänger

Wir rufen jedes Objekt der SmsMessage-Klasse ab, indem wir die Methode createFromPdu(byte[] pdu) verwenden und ihm eine PDU (Protokolldateneinheit) übergeben. Wir fügen es dann zu unserem Nachrichten-Array hinzu.

Um API 23 und höher zu unterstützen, sollten Sie das Format String extra angeben (entweder "3gpp" für GSM/UMTS/LTE-Nachrichten im 3GPP-Format oder "3gpp2" für CDMA/LTE-Nachrichten im 3GPP2-Format).

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.os.Bundle;
import android.telephony.SmsMessage;
import android.widget.Toast;

public class SMSReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        Bundle bundle = intent.getExtras();
        if(bundle != null) {
            Object[] pdus = (Object[]) bundle.get("pdus");
            String format = bundle.getString("format");

            final SmsMessage[] messages = new SmsMessage[pdus.length];
            for(int i = 0; i < pdus.length; i++) {
                if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                    messages[i] = SmsMessage.createFromPdu((byte[]) pdus[i], format);
                }else {
                    messages[i] = SmsMessage.createFromPdu((byte[]) pdus[i]);
                }
                String senderPhoneNo = messages[i].getDisplayOriginatingAddress();
                Toast.makeText(context, "Message " + messages[0].getMessageBody() + ", from " + senderPhoneNo, Toast.LENGTH_SHORT).show();
            }
        }
    }
}

Führen Sie nun die App aus, schließen Sie sie und senden Sie Ihrem emulierten Telefon eine SMS.

Emulator showing a toast when it receives an SMS in the background

Abschluss

In diesem Tutorial haben Sie Folgendes gelernt:

einen Anruf über Ihre App tätigen
Überwachung von Telefonanrufereignissen
Senden von SMS-Nachrichten entweder über die Geräte-Messaging-App oder direkt über Ihre eigene App
Empfangen von SMS-Nachrichten im Hintergrund

Es gibt noch viel mehr, was Sie mit Telefonanrufen und SMS-Nachrichten in Android tun können. Besuchen Sie die Android-Telefonie-API und die SMSManager-API-Dokumentation, um mehr zu erfahren.

Sehen Sie sich in der Zwischenzeit einige unserer anderen Beiträge zur Android-Entwicklung an!

Android-Sensoren im Detail: Näherung und Gyroskop
Gyroskope und Näherungssensoren sind heute auf den meisten Android-Handys verfügbar. Indem Sie sie kreativ verwenden, können Sie Ihrem Benutzer eine ganz neue Dimension verleihen...

Ashraff Hathibelagal
27.01.2017

Android SDK
6 Gebote und Verbote für eine großartige Android-Benutzererfahrung
Die beliebtesten Android-Apps haben eines gemeinsam: Sie alle bieten ein großartiges Benutzererlebnis. In diesem Beitrag werde ich einige Tipps geben, die Ihrer App helfen...

Jessica Thornsby
02.02.2017

Android SDK
Hintergrundaudio in Android mit MediaSessionCompat
Eine der beliebtesten Anwendungen für mobile Geräte ist die Wiedergabe von Audio über Musik-Streaming-Dienste, heruntergeladene Podcasts oder eine beliebige andere Anzahl von Audiodateien...

Paul Trebilcox-Ruiz
09.11.2016

Android SDK
Migrieren Sie eine Android-App zu Material Design
Vor Jahren, als Android noch ein aufstrebendes mobiles Betriebssystem war, war es eher für seine hässliche Benutzeroberfläche berüchtigt. Weil es kein Design gab...

Ashraff Hathibelagal
18 Okt 2016

Android

So tätigen Sie Anrufe und verwenden SMS in Android-Apps

1. So tätigen Sie einen Anruf

Erstellen Sie ein neues Android Studio-Projekt

Den Bildschirm auslegen

Ändern Sie die MainActivity-Klasse

2. Überwachung von Telefonanrufereignissen

Berechtigung hinzufügen

Erstellen Sie das PhoneStateListener-Objekt

Anhören des Anrufstatus

So verwenden Sie den Emulator, um Anrufe zu tätigen und SMS-Nachrichten zu senden Message

3. Überwachung von Telefonanrufereignissen im Hintergrund

Erstellen Sie einen BroadcastReceiver

Ändern Sie AndroidManifest.xml

Ausgehende Anrufe überwachen

4. Senden von SMS-Nachrichten

Einrichten des Layouts

Ändern Sie die MainActivity

Führen Sie die App aus

5. Direktes Senden von SMS-Nachrichten

Berechtigung in AndroidManifest.xml hinzufügen

Ändern Sie die MainActivity-Klasse

6. Empfangen einer SMS-Nachricht

Berechtigung hinzufügen

Erstellen Sie einen Broadcast-Empfänger

Abschluss

Ändern Sie die `MainActivity`-Klasse

Erstellen Sie das `PhoneStateListener`-Objekt