Android BroadcastReceiver Tutorial und Beispiele

*Ein BroadcastReceiver ist eine Android-Komponente, die dafür verantwortlich ist, auf systemweite Broadcast-Ereignisse oder -Intents zu hören.

In Android werden die meisten Systemereignisse durch Intent-Objekte übertragen. Zu diesem Zweck werden diese "Intent"-Objekte mit den Methoden "Context.sendBroadcast()" an die BroadcastReceiver gesendet.

Wenn ein solches Ereignis gesendet wird, empfängt der BroadcastReceiver das Ereignis und reagiert, indem er entweder eine Benachrichtigung in der Statusleiste erzeugt oder eine bestimmte Aufgabe ausführt.

Ein BroadcastReceiver ist eine Android-Komponente wie Activity und Service und muss daher in den meisten Fällen in der Android-Manifestdatei registriert werden.

Im Gegensatz zur Activity haben BroadcastReceiver jedoch keine Benutzeroberfläche.

BroadcastReceiver als Klasse ist abstrakt und hat daher normalerweise eine Methode namens "onReceive()", die wir überschreiben, um die Aufgabe auszuführen, die wir haben wollen, wenn die Aufgabe empfangen wird.

Die meisten Standard-Systemereignisse sind als Action-Strings definiert und können in der API-Dokumentation für die Klasse "Intent" nachgelesen werden.

Nehmen wir zum Beispiel an, dass Ihre Anwendung benachrichtigt werden muss, wenn der Benutzer das Ladegerät an das Gerät anschließt oder von diesem trennt:

ACTION_POWER_DISCONNECTED`
ACTION_POWER_CONNECTED`.

Hier ist ein Beispiel.

public class PhoneChargerConnectedListener extends BroadcastReceiver {
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        if (Intent.ACTION_POWER_CONNECTED.equals(action)) {
            context.startService(
            new Intent(MyService.ACTION_POWER_CONNECTED));
        } else if (Intent.ACTION_POWER_DISCONNECTED.equals(action)) {
        context.startService(
        new Intent(MyService.ACTION_POWER_DISCONNECTED));
        }
    }
}

In dieser Methode ist das einzige, was Sie tun, Context.startService() aufzurufen, um das Ereignis an einen Service zu delegieren, der die eigentliche Arbeit ausführt.

Wie registriere ich `BroadcastReceiver`?

Nun, wir können broadcastReceiver auf zwei Arten registrieren.

1. Über AndroidManifest.xml

Die Standardmethode für die Implementierung von BroadcastReceivern ist, sie im Android-Manifest zu deklarieren.
Dadurch ist es möglich, dass der BroadcastReceiver Ihren Service benachrichtigt, obwohl der Benutzer Ihre Anwendung noch nicht gestartet hat.

Dies ist besonders nützlich für Anwendungen, die bei bestimmten Systemereignissen ohne Benutzerinteraktion gestartet werden sollen.

<receiver android_name=".PhoneChargerConnectedListener">
    <intent-filter>
        <action android_name="android.intent.action.ACTION_POWER_CONNECTED"/>
        <action android_name="android.intent.action.ACTION_POWER_DISCONNECTED"/>
    </intent-filter>
</receiver>

Diese Methode ist auch der einfachste Weg.

Indem Sie AndroidManifest.xml verwenden, um BroadcastReceiver zu registrieren, wird Ihre Anwendung die Broadcasts erhalten, bis Sie die Anwendung deinstallieren. Das bedeutet, dass Sie ein wenig Kontrolle über den Lebenszyklus des BroadcastReceivers opfern, da Sie ihn nicht einfach registrieren und wieder abmelden können, wenn Sie es wünschen.

Um das zu tun, prüft man den nächsten Weg der Registrierung von Broadcast-Receivern.

2. Programmatisch

BroadcastReceiver können auch programmatisch innerhalb von Activities und Services registriert werden.

Tatsächlich können einige Broadcast Intents nur programmatisch registriert werden. Andererseits funktionieren einige nur, wenn Sie sie in Ihrem Manifest deklarieren.

Wenn Sie einen BroadcastReceiver programmatisch registrieren, müssen Sie auch daran denken, ihn im passenden Callback wieder abzumelden.

Hier ist ein Beispiel:

public class MyActivity extends AppCompatActivity {
    private PhoneChargerConnectedListener myPhoneChargerConnectedListener;
    @Override
    protected void onResume() {
        super.onResume();
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(Intent.ACTION_POWER_CONNECTED);
        intentFilter.addAction(Intent.ACTION_POWER_DISCONNECTED);
        myPhoneChargerConnectedListener = new PhoneChargerConnectedListener();
        registerReceiver(myPhoneChargerConnectedListener, intentFilter);
    }
    @Override
    protected void onPause() {
        super.onPause();
        unregisterReceiver(myPhoneChargerConnectedListener);
    }
}

In diesem Fall haben wir den BroadcastReceiver programmatisch mit der Methode registerReceiver() der Context-Klasse registriert. Mit Hilfe dieser Methode können wir den Lebenszyklus unserer BroadcastReceiver steuern, indem wir sie je nach Bedarf registrieren und entregistrieren.

`BroadcastReceiver` Beispiel mit AlarmManager

Schauen wir uns ein einfaches Beispiel für einen BroadcastReceiver mit AlarmManager an.

Wir werden eine Aktivität und eine Klasse haben.

(a). MainActivity.java

Beginnen Sie mit der Erstellung einer Aktivität in Ihrem android studio.

Hier haben wir unsere MainActivity Klasse. Diese Klasse wird von AppCompatActivity abgeleitet, die sich in der Support-Bibliothek befindet.

Wir werden drei Methoden haben:

onCreate(),
initializeViews(),
go().

Die Benutzeroberfläche dieser Aktivität wird von content_main.xml mit der setContentView() Methode aufgefüllt.

Die von uns verwendeten Ansichten sind EditTexts und Buttons.
Wir referenzieren sie aus unserer Layout-Spezifikation mit findViewById().

Wir werden unseren Alarm in der Methode go() initialisieren und starten.

package com.tutorials.hp.alarmmanagerstarter;

import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.Intent;
import android.os.Bundle;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {

    Button startBtn;
    EditText timeTxt;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

         initializeViews();

        FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
        fab.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                        .setAction("Action", null).show();
            }
        });

    }

    /*
    INITIALIZE VIEWS
     */
    private void initializeViews()
    {
        timeTxt= (EditText) findViewById(R.id.timeTxt);
        startBtn= (Button) findViewById(R.id.startBtn);

        startBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
               go();
            }
        });
    }

    /*
    INITIALIZE AND START OUR ALARM
     */
    private void go()
    {
        //GET TIME IN SECONDS AND INITIALIZE INTENT
        int time=Integer.parseInt(timeTxt.getText().toString());
        Intent i=new Intent(this,MyReceiver.class);

        //PASS CONTEXT,YOUR PRIVATE REQUEST CODE,INTENT OBJECT AND FLAG
        PendingIntent pi=PendingIntent.getBroadcast(this,0,i,0);

        //INITIALIZE ALARM MANAGER
        AlarmManager alarmManager= (AlarmManager) getSystemService(ALARM_SERVICE);

        //SET THE ALARM
        alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis()+(time*1000),pi);
        Toast.makeText(MainActivity.this, "Alarm set in "+time+" seconds", Toast.LENGTH_SHORT).show();
    }

}

(b). MyReciever.java

Unsere MyReciever-Klasse.
Leitet sich von android.content.BroadcastReceiver Klasse ab.
Methoden: onReceive().
In unsereronReceive() Methode zeigen wir eine Toastnachricht an, um das Klingeln eines Alarms zu simulieren.

package com.tutorials.hp.alarmmanagerstarter;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.widget.Toast;

public class MyReceiver extends BroadcastReceiver {
    /*
    RING ALARM WHEN IN WHEN WE RECEIVE OUR BROADCAST
     */
    @Override
    public void onReceive(Context context, Intent intent) {
        Toast.makeText(context, "Alarm Ringing...", Toast.LENGTH_SHORT).show();
    }
}

(c) activity_main.xml

Unsere Haupt-Activity-Layout-Datei.
Soll zu MainActivity aufgeblasen werden.
Root-Tag ist relativeLayout.
Enthält einen EditText und einen Button.

<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout

    android_layout_width="match_parent"
    android_layout_height="match_parent"
    tools_context="com.tutorials.hp.alarmmanagerstarter.MainActivity"
    >

    <EditText
        android_id="@+id/timeTxt"
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_layout_alignParentLeft="true"
        android_layout_alignParentTop="true"
        android_layout_marginTop="28dp"
        android_ems="10"
        android_hint="Number of seconds"
        android_inputType="numberDecimal" />

    <Button
        android_id="@+id/startBtn"
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_layout_alignRight="@+id/timeTxt"
        android_layout_below="@+id/timeTxt"
        android_layout_marginRight="60dp"
        android_layout_marginTop="120dp"
        android_text="Start" />
</RelativeLayout>

(d). AndroidManifest.xml

Wir müssen unsere Klasse BroadcastReceiver in unserem Android-Manifest registrieren.

Hier ist mein Manifest in voller Länge:

<?xml version="1.0" encoding="utf-8"?>
<manifest
    package="com.tutorials.hp.alarmmanagerstarter">
    <application
        android_allowBackup="true"
        android_icon="@mipmap/ic_launcher"
        android_label="@string/app_name"
        android_supportsRtl="true"
        android_theme="@style/AppTheme">
        <activity
            android_name=".MainActivity"
            android_label="@string/app_name"
            android_theme="@style/AppTheme.NoActionBar">
            <intent-filter>
                <action android_name="android.intent.action.MAIN" />

                <category android_name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <receiver android_name="MyReceiver" >
        </receiver>
    </application>

</manifest>

Schnelle `BroadcastReceiver` Beispiele

1. Mit `BroadcastReceiver` auf Netzwerkstatusänderungen hören

Zuerst müssen wir eine Java-Klasse erstellen, die dann von android.content.BroadcastReceiver abgeleitet wird.

Als Instanzfelder werden wir einen booleschen Wert "isNetWorkConnected" haben, der für uns ein "true" oder "false" enthält und angibt, ob das Netzwerk verbunden ist oder nicht.

Wir werden auch ein Context-Objekt haben.

Wir stellen zwei Konstruktoren zur Verfügung, von denen einer das "Context"-Objekt in unsere Klasse injiziert.
Dann überschreiben wir die Methode onReceive() der Klasse BroadcastReceiver. Normalerweise empfängt diese Methode zwei Objekte, ein Context-Objekt und ein Intent-Objekt.

Hier werden wir einen ConnectivityManager mit der Methode getSystemService() der Klasse Context initialisieren.

Mit der Instanz des ConnectivityManager rufen wir die Methode getActiveNetworkInfo() auf, um Netzwerkinformationen zu erhalten, die wir in einem android.net.NetworkInfo-Objekt speichern.

Schließlich setzen wir den Wert von "isConnected()" auf den booleschen Wert "isNetWorkConnected".

Dann haben wir noch die Methode isNetWorkAvailable(), die im Grunde prüft, ob das Netzwerk verfügbar ist.

Es ist nur eine öffentliche Methode, die die Instanz dieser Klasse benötigt, um aufgerufen zu werden, wie wir in Kürze sehen werden.

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.widget.Toast;
import java.util.concurrent.CopyOnWriteArrayList;

public class NetWorkStateReceiver extends BroadcastReceiver {
    public boolean isNetWorkConnected;
    private Context mContext;

    public NetWorkStateReceiver() {
        super();
    }
    public NetWorkStateReceiver(Context context) {
        mContext = context;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        ConnectivityManager connectivityManager = (ConnectivityManager)
                context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();

        if (networkInfo != null && networkInfo.isConnected()) {
            isNetWorkConnected = true;
        } else {
            isNetWorkConnected = false;
            Toast.makeText(context, "No network Connection", Toast.LENGTH_SHORT).show();
        }

    }

    /**
     * Check if network is available
     * @return boolean value
     */
    public boolean isNetWorkAvailable() {
        ConnectivityManager connectivityManager = (ConnectivityManager)
                mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
        if (networkInfo != null) {
            return networkInfo.isConnected();
        }
        return false;
    }
}

Dann kannst du in deiner MainActivity oder wo auch immer, mit der Instanzierung der oben genannten Klasse beginnen:

    publi class MainActivity extends AppCompatActivity{
        NetWorkStateReceiver receiver;
        @Override
        public void onCreate(Bundle savedInstanceState){
            .....
           receiver = new NetWorkStateReceiver(this);
           if(receiver.isNetWorkAvailable())
           {
               //do something network is available
           }
        }
    }

In Ihrer AndroidManifest.xml müssen Sie zunächst die entsprechenden Berechtigungen hinzufügen sowie Ihren BroadcastReceiver registrieren:

<?xml version="1.0" encoding="utf-8"?>
<manifest
    >

    <uses-permission android_name="android.permission.INTERNET" />
    <uses-permission android_name="android.permission.ACCESS_NETWORK_STATE" />
    <application>
        ....
        <receiver
            android_name=".broadcasts.NetWorkStateReceiver"
            android_enabled="true"
            android_exported="true" />
        ....
    </application>

2. Wie man einen eigenen `BroadcastReceiver` erstellt

Hier ist eine eigene abstrakte BroadcastReciever-Klasse. Offensichtlich leitet sie sich vom BroadcastReceiver ab. Wir fahren fort und definieren die wichtigen Methoden in dieser Klasse wie die registerReceiver(), unregisterReceiver() und sendBroadcast() Methoden neu.


import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.support.v4.content.LocalBroadcastManager;

public abstract class LocalBroadcastCommunicator extends BroadcastReceiver {

    // The action name used to send and alsoe receive intents
    private static String sAction = null;

    private static <T> void registerReceiver(LocalBroadcastCommunicator receiver, Context context) {
        sAction = receiver.getClass().getName();
        LocalBroadcastManager.getInstance(context).registerReceiver(receiver, new IntentFilter(sAction));
    }

    private static <T> void unregisterReceiver(LocalBroadcastCommunicator receiver, Context context) {
        LocalBroadcastManager.getInstance(context).unregisterReceiver(receiver);
    }

    public static void sendBroadcast(Context context, Intent intent) {
        if(sAction == null) {
            /* If sAction is null at this point, no receiver has been registered yet and there's no
             * point in sending a broadcast. */
            return;
        }

        intent.setAction(sAction);
        LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
    }

    public void registerReceiver(Context context) {
        registerReceiver(this, context);
    }

    public void unregisterReceiver(Context context) {
        unregisterReceiver(this, context);
    }
}

Full Examples

1. Anzeige einer Benachrichtigung bei niedrigem Batteriestand mit `BroadcastReceiver`

Wir erstellen einen einfachen BatteryManager unter Verwendung der BroadcasteReceiver-Klasse. Wir werden den Batteriestand in einem TextView anzeigen und den Fortschritt in der Fortschrittsleiste darstellen.

Hier sind einige der APIs, die Sie vielleicht nicht kennen, die wir verwenden:

(a). BroadcastReceiver"

Dies ist die Basisklasse für Code, der Intents empfängt, die von sendBroadcast() gesendet werden.

(b). IntentFilter

IntentFilter ist eine strukturierte Beschreibung von Intent-Werten, die abgeglichen werden sollen. Ein IntentFilter kann mit Aktionen, Kategorien und Daten (entweder über ihren Typ, ihr Schema und/oder ihren Pfad) in einem Intent übereinstimmen.

(c). BatterieManager

Diese Klasse enthält Strings und Konstanten, die für Werte im ACTION_BATTERY_CHANGED Intent verwendet werden.

HauptActivity.java

Dies ist die wichtigste Activity.

package com.example.ankitkumar.broadcastreceiver_batterymanager;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.BatteryManager;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.widget.ProgressBar;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {
    TextView batteryLevel;
    ProgressBar myProgressBar;

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        batteryLevel = (TextView)findViewById(R.id.textView);
        myProgressBar = (ProgressBar)findViewById(R.id.progressBar);
        IntentFilter intentFilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
        registerReceiver(myBroadcastReceiver, intentFilter);

    }

    BroadcastReceiver myBroadcastReceiver = new BroadcastReceiver() {
        public void onReceive(Context context, Intent intent) {
            context.unregisterReceiver(this);
            int currentLevel = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
            int scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
            int level = -1;
            if (currentLevel >= 0 && scale > 0) {
                level = (currentLevel * 100) / scale;
            }
            batteryLevel.setText("Battery Level remaining :"+  level +"%");
            myProgressBar.setProgress(level);
        }
    };
}

activity_main.xml

Dies ist das Hauptlayout der Activity.
Hier werden wir eine TextView haben, um den Batteriestand anzuzeigen und einen Fortschrittsbalken, um den Prozentsatz der Batterie anzuzeigen.

<?xml version="1.0" encoding="UTF-8"?>

<RelativeLayout
        tools_context="com.example.ankitkumar.broadcastreceiver_batterymanager.MainActivity" android_paddingTop="@dimen/activity_vertical_margin" android_paddingRight="@dimen/activity_horizontal_margin" android_paddingLeft="@dimen/activity_horizontal_margin" android_paddingBottom="@dimen/activity_vertical_margin" android_layout_height="match_parent" android_layout_width="match_parent" android_id="@+id/activity_main"  >

<TextView
        android_layout_height="wrap_content" android_layout_width="wrap_content" android_id="@+id/textView" android_layout_centerHorizontal="true" android_layout_centerVertical="true" android_textSize="20sp" android_text="Hello World!"/>

<ProgressBar
        android_layout_height="20dp" android_layout_width="match_parent" android_id="@+id/progressBar" android_layout_alignParentRight="true" android_layout_alignParentEnd="true" android_layout_below="@+id/textView" android_layout_marginTop="25dp" android_max="100" style="?android:attr/progressBarStyleHorizontal"/>

</RelativeLayout>

Download

No.	Ort	Link
1.	GitHub	Herunterladen
2.	GitHub	Durchsuchen
2.	GitHub	Ursprünglicher Ersteller: @AnkitKumar111

2. Verwenden Sie `BroadcastReceiver`, um eingehende SMS zu hören und anzuzeigen

Wir hören die eingehenden SMS ab, lesen sie und zeigen sie in einer Toast-Nachricht an.

MainActivity.java

Dies ist die Hauptaktivität.

package com.example.ankitkumar.msgreceive;

import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //checking wether the permission is already granted
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_SMS) != PackageManager.PERMISSION_GRANTED) {

            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_SMS}, 1);

        }

    }

}

IcomingSMS.java

Unsere Datei "IncomingSMS.java". Hier sind einige der APIs, die wir verwenden:

(a). SmsManager

Dies ist eine Klasse, die im Paket android.telephony definiert ist und für die Verwaltung von SMS-Operationen wie das Senden von Daten-, Text- und pdu-SMS-Nachrichten zuständig ist.

(b). SmsMessage

Dies stellt eine Short Message Service Nachricht dar.

package com.example.ankitkumar.msgreceive;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.telephony.SmsManager;
import android.telephony.SmsMessage;
import android.util.Log;
import android.widget.Toast;
import static android.telephony.SmsMessage.createFromPdu;

public class IncomingSms extends BroadcastReceiver {

    // Get the object of SmsManager
    final SmsManager sms = SmsManager.getDefault();

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

        // Retrieves a map of extended data from the intent.
        final Bundle bundle = intent.getExtras();

        try {

            if (bundle != null) {

                final Object[] pdusObj = (Object[]) bundle.get("pdus");

                for (int i = 0; i < pdusObj.length; i++) {

                    SmsMessage currentMessage = createFromPdu((byte[]) pdusObj[i]);
                    String phoneNumber = currentMessage.getDisplayOriginatingAddress();

                    String senderNum = phoneNumber;
                    String message = currentMessage.getDisplayMessageBody();

                    Log.i("SmsReceiver", "senderNum: " + senderNum + "; message: " + message);

                    int duration = Toast.LENGTH_LONG;
                    final Toast toast = Toast.makeText(context, "senderNum: " + senderNum + ", message: " + message, duration);
                    toast.show();

                    //Countdown Timer for extending normal time of toast notification
                    new CountDownTimer(9000, 1000) {

                        public void onTick(long millisUntilFinished) {
                            toast.show();
                        }

                        public void onFinish() {
                            toast.show();
                        }

                    }.start();
                } // end for loop
            } // bundle is null

        } catch (Exception e) {
            Log.e("SmsReceiver", "Exception smsReceiver" + e);

        }
    }

}

activity_main.xml

Dies ist das Hauptlayout der Aktivität.

<?xml version="1.0" encoding="UTF-8"?>

<RelativeLayout
        tools_context="com.example.ankitkumar.msgreceive.MainActivity" android_background="#f2f2f2" android_layout_height="match_parent" android_layout_width="match_parent"  >

<ImageView
        android_background="@drawable/ic_sms" android_layout_height="200sp" android_layout_width="200sp" android_contentDescription="@string/app_name" android_layout_centerInParent="true" android_alpha="0.4"/>

</RelativeLayout>

Download

Nr.	Ort	Link
1.	GitHub	Download
2.	GitHub	Durchsuchen
2.	GitHub	Original Creator: @AnkitKumar111

Android `LocalBroadcastManager`

Android LocalBroadcastManager mit IntentService Tutorial und Beispiel.

Dies ist ein androides LocalBroadcastManager Tutorial und Beispiel. Wir wollen sehen, was LocalBroadcastManager ist und wie man ihn mit einem IntentService verwendet.

Video-Tutorial

Manche Leute bevorzugen immer Video-Tutorials. In diesem Fall gibt es hier die Video-Version dieses Tutorials.

Was Sie in diesem Tutorial lernen

Hier sind einige der Inhalte, die Sie in diesem Tutorial lernen werden.

Was ein LocalBroadcastManager ist und seine API Definition.
Die Vorteile von LocalBroadcastManager.
Wie man LocalBroadcastManager mit IntentService verwendet.

Was ist `LocalBroadcastManager`?

Nun, LocalBroadcastManager ist eine Hilfsklasse, die es uns erlaubt, uns zu registrieren und Broadcasts von Intents an lokale Objekte innerhalb unseres Prozesses zu senden.

Hier ist seine API Definition:

public final class LocalBroadcastManager
extends Object

java.lang.Object
   ↳    android.support.v4.content.LocalBroadcastManager

Vorteile von `LocalBroadcastManager`

Hier sind einige der Vorteile von LocalBroadcastManager gegenüber dem Senden von globalen Broadcasts mit der Methode sendBroadcast(Intent):

Ihre Anwendungsdaten bleiben privat, da diese Klasse nur mit einzelnen Objekten innerhalb Ihres Anwendungsprozesses arbeitet.
Sie ist sicherer, da sie nur innerhalb Ihres Anwendungsprozesses arbeitet.
Sie ist auch effizienter als das Senden eines globalen Broadcasts durch das System.

(a). BroadcastSenderIntentService

Dies ist unsere IntentService Klasse. Wir werden von android.app.IntentService ableiten und die Methode onHandleIntent() überschreiben. Innerhalb dieser Methode werden wir eine schwere Aufgabe simulieren, indem wir die Methode sleep() unserer Klasse thread aufrufen.

package info.camposha.localbroadcastandintentservice;

import android.app.IntentService;
import android.content.Intent;
import android.support.v4.content.LocalBroadcastManager;

public class BroadcastSenderIntentService extends IntentService {

    public BroadcastSenderIntentService() {
        super("BroadcastSenderIntentService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        String message = getString(R.string.running);
        Intent broadcastIntent = new Intent();
        broadcastIntent.setAction(MainActivity.MESSAGE_SENT_ACTION);
        broadcastIntent.putExtra(MainActivity.MESSAGE_EXTRA, message);
        LocalBroadcastManager.getInstance(this).sendBroadcast(broadcastIntent);

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }

        message = getString(R.string.finished);
        broadcastIntent = new Intent();
        broadcastIntent.setAction(MainActivity.MESSAGE_SENT_ACTION);
        broadcastIntent.putExtra(MainActivity.MESSAGE_EXTRA, message);
        LocalBroadcastManager.getInstance(this).sendBroadcast(broadcastIntent);
    }

}

(b). MainActivity.java

Hier ist unsere Haupt Activity. Wir beginnen mit der Definition mehrerer String-Konstanten, die beim Senden und Empfangen unserer Intents hilfreich sein werden, da sie als Bezeichner fungieren.

package info.camposha.localbroadcastandintentservice;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.support.v4.content.LocalBroadcastManager;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    public static final String MESSAGE_SENT_ACTION = "info.camposha.MESSAGE_RECEIVED_ACTION";
    public static final String MESSAGE_EXTRA = "info.camposha.MESSAGE_EXTRA";

    private static final String MESSAGE_FROM_SERVICE_KEY = "info.camposha.MESSAGE_FROM_SERVICE_KEY";

    private BroadcastReceiver receiver;
    private TextView serviceMessageView;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        serviceMessageView = findViewById(R.id.service_message_textview);

        if (savedInstanceState != null) {
            serviceMessageView.setText(savedInstanceState.getString(MESSAGE_FROM_SERVICE_KEY));
        }else{
            serviceMessageView.setText("Null");
        }
    }

    @Override
    protected void onResume() {
        super.onResume();

        receiver = new BroadcastReceiver() {

            @Override
            public void onReceive(Context context, Intent intent) {
                Bundle bundle = intent.getExtras();
                String message = bundle.getString(MESSAGE_EXTRA);

                serviceMessageView.setText(message);
            }
        };

        LocalBroadcastManager.getInstance(this).registerReceiver(receiver, new IntentFilter(MESSAGE_SENT_ACTION));
    }

    @Override
    protected void onPause() {
        super.onPause();

        if (receiver != null) {
            LocalBroadcastManager.getInstance(this).unregisterReceiver(receiver);
            receiver = null;
        }
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putString(MESSAGE_FROM_SERVICE_KEY, serviceMessageView.getText().toString());
    }

    public void onStartServiceClicked(View view) {
        startService(new Intent(this, BroadcastSenderIntentService.class));
    }

}

activity_main.xml

Hier ist das Layout unserer Hauptaktivität. Wir haben hier eine Textansicht und eine Schaltfläche.

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        tools_context=".MainActivity">

        <TextView
            android_id="@+id/headerLabel"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_alignParentTop="true"
            android_layout_centerHorizontal="true"
            android_fontFamily="casual"
            android_text="LocalBroadcastReceiver"
            android_textAllCaps="true"
            android_textSize="24sp"
            android_textStyle="bold" />

        <LinearLayout
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_centerHorizontal="true"
            android_layout_centerVertical="true"
            android_gravity="center"
            android_orientation="vertical" >

            <TextView
                android_id="@+id/textView1"
                android_layout_width="wrap_content"
                android_layout_height="wrap_content"
                android_text="@string/service_status"
                android_textSize="16dp" />

            <TextView
                android_id="@+id/service_message_textview"
                android_layout_width="wrap_content"
                android_layout_height="wrap_content"
                android_text="@string/not_running"
                android_textSize="16dp" />
        </LinearLayout>

        <Button
            android_id="@+id/button1"
            android_onClick="onStartServiceClicked"
            android_text="@string/start_service"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_alignParentBottom="true"
            android_layout_centerHorizontal="true"
            android_layout_marginBottom="12dp"
            android_fontFamily="serif-monospace" />

</RelativeLayout>

AndroidManifest.xml

In unseren Android-Manifes müssen wir sicherstellen, dass wir den Service registrieren. Hier ist meines:

<?xml version="1.0" encoding="utf-8"?>
<manifest
    package="info.camposha.localbroadcastandintentservice">

    <application
        android_allowBackup="true"
        android_icon="@mipmap/ic_launcher"
        android_label="@string/app_name"
        android_roundIcon="@mipmap/ic_launcher_round"
        android_supportsRtl="true"
        android_theme="@style/AppTheme">
        <activity android_name=".MainActivity">
            <intent-filter>
                <action android_name="android.intent.action.MAIN" />

                <category android_name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service
            android_name=".BroadcastSenderIntentService" />
    </application>

</manifest>

Kotlin `LocalBroadcastManager` Beispiel

Ein Kotlin AndroidX localbroadcastmanager Beispiel mit IntentService und BroadcastReceiver.

Video-Tutorial hier ansehen:

Schritt 1: Abhängigkeiten hinzufügen

Fügen Sie AndroiX localbroadcastmanager als Abhängigkeit in Ihrer gradle-Datei hinzu:

    implementation 'androidx.localbroadcastmanager:localbroadcastmanager:1.0.0'

Schritt 2: Layout entwerfen

Entwerfen Sie ein Layout mit einer Textvew und einem Button:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:gravity="center"
    android:orientation="vertical">

    <TextView
        android:id="@+id/dateText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Initial value"
        android:textSize="20dp"
        android:textStyle="bold"/>

    <Button
        android:id="@+id/startButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        android:text="Start Service"/>

</LinearLayout>

Schritt 3: `IntentService` erstellen

Wir erstellen eine Intentservice Klasse und überschreiben die onHandleIntent Methode:

package info.camposha.ms_localbroadcastmanager

import android.app.IntentService
import android.content.Intent
import android.util.Log
import androidx.localbroadcastmanager.content.LocalBroadcastManager
import java.util.*

//IntentService is a ntentService is a base class for Services that handle asynchronous
// requests (expressed as Intents) on demand.
class MyIntentService : IntentService("MyIntentService") {
    override fun onHandleIntent(arg0: Intent?) {
        val intent = Intent(CUSTOM_ACTION)
        //get date to send
        intent.putExtra("DATE", Date().toString())
        Log.d(MyIntentService::class.java.simpleName, "sending broadcast")

        // send local broadcast
        //LocalBroadcastManager is a Helper to register for and send broadcasts of Intents
        // to local objects within your process.
        LocalBroadcastManager.getInstance(this).sendBroadcast(intent)
    }

    companion object {
        const val CUSTOM_ACTION = "YOUR_CUSTOM_ACTION"
    }
}

Schritt 4: MainActivity erstellen

Wir erstellen unseren Launcher Activity:

package info.camposha.ms_localbroadcastmanager

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.os.Bundle
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import androidx.localbroadcastmanager.content.LocalBroadcastManager
import kotlinx.android.synthetic.main.activity_main.*

//Our main activity
class MainActivity : AppCompatActivity(), View.OnClickListener {
    //override onCreate
    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        startButton.setOnClickListener(this)
    }

    //when activity is paused
    override fun onPause() {
        super.onPause()
        // unregister local broadcast
        LocalBroadcastManager.getInstance(this).unregisterReceiver(mReceiver)
    }

    //when activity is resumed
    override fun onResume() {
        super.onResume()

        // register local broadcast
        val filter = IntentFilter(MyIntentService.CUSTOM_ACTION)
        LocalBroadcastManager.getInstance(this).registerReceiver(mReceiver, filter)
    }

    /**
    Create a BroadcastReceiver

     * BroadcastReceiver is a Base class for code that will receive intents sent by sendBroadcast().
     * Broadcast receiver to receive the data
     */
    private val mReceiver: BroadcastReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context, intent: Intent) {
            val date = intent.getStringExtra("DATE")
            dateText.text = date
        }
    }

    //when user clicks the start button, start our intent service
    override fun onClick(view: View) {
        if (view.id == R.id.startButton) {
            // start intent service
            val intent = Intent(this, MyIntentService::class.java)
            startService(intent)
        }
    }
}

Schritt 5: Komponenten registrieren

Registrieren Sie zwei Komponenten in der android manifext Datei:

MainActivity
IntentService

 <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service android:name=".MyIntentService"/>

Schritt 6: Ausführen

Führen Sie das Projekt aus und Sie werden folgendes erhalten:

Code herunterladen

Laden Sie den Code hier herunter.

Categorized in:

Komponenten

Android BroadcastReceiver Tutorial und Beispiele

Wie registriere ich `BroadcastReceiver`?

1. Über AndroidManifest.xml

2. Programmatisch

`BroadcastReceiver` Beispiel mit AlarmManager

(a). MainActivity.java

(b). MyReciever.java

(c) activity_main.xml

(d). AndroidManifest.xml

Schnelle `BroadcastReceiver` Beispiele

1. Mit `BroadcastReceiver` auf Netzwerkstatusänderungen hören

2. Wie man einen eigenen `BroadcastReceiver` erstellt

Full Examples

1. Anzeige einer Benachrichtigung bei niedrigem Batteriestand mit `BroadcastReceiver`

2. Verwenden Sie `BroadcastReceiver`, um eingehende SMS zu hören und anzuzeigen

Android `LocalBroadcastManager`

Video-Tutorial

Was Sie in diesem Tutorial lernen

Was ist `LocalBroadcastManager`?

Vorteile von `LocalBroadcastManager`

(a). BroadcastSenderIntentService

(b). MainActivity.java

activity_main.xml

AndroidManifest.xml

Kotlin `LocalBroadcastManager` Beispiel

Schritt 1: Abhängigkeiten hinzufügen

Schritt 2: Layout entwerfen

Schritt 3: `IntentService` erstellen

Schritt 4: MainActivity erstellen

Schritt 5: Komponenten registrieren

Schritt 6: Ausführen

Code herunterladen

Other Stories

Filter ListView mit Spinner oder SearchView

Kotlin Android BottomNavigation Examples

Press ESC to close

Or check our Popular Categories...

Wie registriere ich BroadcastReceiver?

1. Über AndroidManifest.xml

2. Programmatisch

BroadcastReceiver Beispiel mit AlarmManager

(a). MainActivity.java

(b). MyReciever.java

(c) activity_main.xml

(d). AndroidManifest.xml

Schnelle BroadcastReceiver Beispiele

1. Mit BroadcastReceiver auf Netzwerkstatusänderungen hören

2. Wie man einen eigenen BroadcastReceiver erstellt

Full Examples

1. Anzeige einer Benachrichtigung bei niedrigem Batteriestand mit BroadcastReceiver

2. Verwenden Sie BroadcastReceiver, um eingehende SMS zu hören und anzuzeigen

Android LocalBroadcastManager

Video-Tutorial

Was Sie in diesem Tutorial lernen

Was ist LocalBroadcastManager?

Vorteile von LocalBroadcastManager

(a). BroadcastSenderIntentService

(b). MainActivity.java

activity_main.xml

AndroidManifest.xml

Kotlin LocalBroadcastManager Beispiel

Schritt 1: Abhängigkeiten hinzufügen

Schritt 2: Layout entwerfen

Schritt 3: IntentService erstellen

Schritt 4: MainActivity erstellen

Schritt 5: Komponenten registrieren

Schritt 6: Ausführen

Code herunterladen

Related Articles

Android ContentProvider Beispiel

Android Service tutorial und Beispiele

Other Stories

Filter ListView mit Spinner oder SearchView

Kotlin Android BottomNavigation Examples

Wie registriere ich `BroadcastReceiver`?

`BroadcastReceiver` Beispiel mit AlarmManager

Schnelle `BroadcastReceiver` Beispiele

1. Mit `BroadcastReceiver` auf Netzwerkstatusänderungen hören

2. Wie man einen eigenen `BroadcastReceiver` erstellt

1. Anzeige einer Benachrichtigung bei niedrigem Batteriestand mit `BroadcastReceiver`

2. Verwenden Sie `BroadcastReceiver`, um eingehende SMS zu hören und anzuzeigen

Android `LocalBroadcastManager`

Was ist `LocalBroadcastManager`?

Vorteile von `LocalBroadcastManager`

Kotlin `LocalBroadcastManager` Beispiel

Schritt 3: `IntentService` erstellen