Android
Rundfunkempfänger

Einführung

Einführung in den Broadcast-Empfänger

Ein Broadcast-Empfänger ist eine Android-Komponente, mit der Sie sich für System- oder Anwendungsereignisse registrieren können.

Ein Empfänger kann über die AndroidManifest.xml Datei oder dynamisch über die Context.registerReceiver() -Methode registriert werden.

public class MyReceiver extends BroadcastReceiver {
   @Override
   public void onReceive(Context context, Intent intent) {
      //Your implementation goes here.
   }
}

Hier habe ich ein Beispiel für ACTION_BOOT_COMPLETED das vom System ausgelöst wird, sobald der Android-Startvorgang abgeschlossen ist.

Sie können einen Empfänger in einer Manifestdatei wie folgt registrieren:

<application
   android:icon="@drawable/ic_launcher"
   android:label="@string/app_name"
   android:theme="@style/AppTheme" >
   <receiver android:name="MyReceiver">
      <intent-filter>
         <action android:name="android.intent.action.BOOT_COMPLETED">
         </action>
      </intent-filter>
   </receiver>
</application>

Jetzt wird das Gerät gebootet, die onReceive() -Methode wird aufgerufen und Sie können Ihre Arbeit erledigen (z. B. einen Dienst starten, einen Alarm starten).

BroadcastReceiver-Grundlagen

BroadcastReceiver werden verwendet, um Broadcast- Intents zu empfangen, die vom Android-Betriebssystem, anderen Apps oder innerhalb derselben App gesendet werden.

Jeder Intent wird mit einem Intent-Filter erstellt , der eine String- Aktion erfordert. Zusätzliche Informationen können im Intent konfiguriert werden.

Ebenso registrieren sich BroadcastReceivers, um Intents mit einem bestimmten Intent-Filter zu empfangen. Sie können programmgesteuert registriert werden:

mContext.registerReceiver(new BroadcastReceiver() {
    @Override
   public void onReceive(Context context, Intent intent) {
      //Your implementation goes here.
   }
}, new IntentFilter("Some Action"));

oder in der Datei AndroidManifest.xml :

<receiver android:name=".MyBroadcastReceiver">
    <intent-filter>
        <action android:name="Some Action"/>
    </intent-filter>
</receiver>

Um die Absicht zu erhalten, setzen Sie die Aktion auf eine von Android OS, einer anderen App oder API oder in Ihrer eigenen Anwendung dokumentierte Aktion mit sendBroadcast

mContext.sendBroadcast(new Intent("Some Action"));

Darüber hinaus kann der Intent Informationen wie Strings, Primitives und Parcelables enthalten , die in onReceive angezeigt werden können.

LocalBroadcastManager verwenden

LocalBroadcastManager wird verwendet, um Broadcast Intents innerhalb einer Anwendung zu senden, ohne sie unerwünschten Listenern auszusetzen.

Die Verwendung von LocalBroadcastManager ist effizienter und sicherer als die context.sendBroadcast() Verwendung von context.sendBroadcast() , da Sie sich keine Sorgen um Broadcasts machen müssen, die von anderen Anwendungen gefälscht werden, was ein Sicherheitsrisiko darstellt.

Hier ist ein einfaches Beispiel für das Senden und Empfangen von lokalen Sendungen:

BroadcastReceiver receiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent.getAction().equals("Some Action")) {
            //Do something
        }
    }
});

LocalBroadcastManager manager = LocalBroadcastManager.getInstance(mContext);
manager.registerReceiver(receiver, new IntentFilter("Some Action"));

// onReceive() will be called as a result of this call:
manager.sendBroadcast(new Intent("Some Action"));//See also sendBroadcastSync

//Remember to unregister the receiver when you are done with it:
manager.unregisterReceiver(receiver);

Bluetooth-Rundfunkempfänger

Fügen Sie der Manifestdatei die Berechtigung hinzu

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

In deinem Fragment (oder in deiner Aktivität)

• Fügen Sie die Empfängermethode hinzu

private BroadcastReceiver mBluetoothStatusChangedReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        final Bundle extras = intent.getExtras();
        final int bluetoothState = extras.getInt(Constants.BUNDLE_BLUETOOTH_STATE);
        switch(bluetoothState) {
            case BluetoothAdapter.STATE_OFF:
                // Bluetooth OFF
                break;
            case BluetoothAdapter.STATE_TURNING_OFF:
                // Turning OFF
                break;
            case BluetoothAdapter.STATE_ON:
                // Bluetooth ON
                break;
            case BluetoothAdapter.STATE_TURNING_ON:
                // Turning ON
                break;
    }
};

Sendung registrieren

• Aufruf dieser Methode bei onResume ()

private void registerBroadcastManager(){
    final LocalBroadcastManager manager = LocalBroadcastManager.getInstance(getActivity());
    manager.registerReceiver(mBluetoothStatusChangedReceiver, new IntentFilter(Constants.BROADCAST_BLUETOOTH_STATE));
}

Broadcast abmelden

• Aufruf dieser Methode bei onPause ()

private void unregisterBroadcastManager(){
    final LocalBroadcastManager manager = LocalBroadcastManager.getInstance(getActivity());
    // Beacon機能用
    manager.unregisterReceiver(mBluetoothStatusChangedReceiver);
}

Programmgesteuertes Aktivieren und Deaktivieren eines Broadcast-Empfängers

Um einen BroadcastReceiver zu aktivieren oder zu deaktivieren, benötigen wir einen Verweis auf den PackageManager und benötigen ein ComponentName Objekt, das die Klasse des Empfängers enthält, den wir aktivieren / deaktivieren möchten:

ComponentName componentName = new ComponentName(context, MyBroadcastReceiver.class);
PackageManager packageManager = context.getPackageManager();

Jetzt können wir die folgende Methode aufrufen, um den BroadcastReceiver zu aktivieren:

packageManager.setComponentEnabledSetting(
    componentName,
    PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
    PackageManager.DONT_KILL_APP);

Oder Sie können stattdessen COMPONENT_ENABLED_STATE_DISABLED , um den Empfänger zu deaktivieren:

packageManager.setComponentEnabledSetting(
    componentName,
    PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
    PackageManager.DONT_KILL_APP);

BroadcastReceiver zur Behandlung von BOOT_COMPLETED-Ereignissen

Das folgende Beispiel zeigt, wie ein BroadcastReceiver wird, der BOOT_COMPLETED Ereignisse empfangen BOOT_COMPLETED . Auf diese Weise können Sie einen Service starten oder eine Activity starten, sobald das Gerät hochgefahren wurde.

Sie können auch BOOT_COMPLETED Ereignisse verwenden, um Ihre Alarme wiederherzustellen, da sie beim Ausschalten des Geräts zerstört werden.

HINWEIS: Der Benutzer muss die Anwendung mindestens einmal gestartet haben, bevor Sie die Aktion BOOT_COMPLETED empfangen BOOT_COMPLETED .

AndroidManifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.test.example" >
    ...
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />

    ...

    <application>
        ...

        <receiver android:name="com.test.example.MyCustomBroadcastReceiver">
        <intent-filter>
                <!-- REGISTER TO RECEIVE BOOT_COMPLETED EVENTS -->
                <action android:name="android.intent.action.BOOT_COMPLETED" />
            </intent-filter>
        </receiver>
    </application>
</manifest>

MyCustomBroadcastReceiver.java

public class MyCustomBroadcastReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();

        if(action != null) {
            if (action.equals(Intent.ACTION_BOOT_COMPLETED) ) {
                // TO-DO: Code to handle BOOT COMPLETED EVENT
                // TO-DO: I can start an service.. display a notification... start an activity
            } 
        }
    }
}

Beispiel für einen LocalBroadcastManager

Ein BroadcastReceiver ist im Wesentlichen ein Mechanismus, um Intents durch das Betriebssystem zu leiten, um bestimmte Aktionen auszuführen. Ein klassisches Definitionswesen

"Ein Broadcast-Empfänger ist eine Android-Komponente, mit der Sie sich für System- oder Anwendungsereignisse registrieren können."

LocalBroadcastManager ist eine Möglichkeit, Broadcasts innerhalb eines Anwendungsprozesses zu senden oder zu empfangen. Dieser Mechanismus hat viele Vorteile

1. Da die Daten im Anwendungsprozess verbleiben, können die Daten nicht durchgesickert werden.
2. LocalBroadcasts werden schneller aufgelöst, da die Auflösung einer normalen Übertragung zur Laufzeit im gesamten Betriebssystem erfolgt.

Ein einfaches Beispiel für einen LocalBroastManager ist:

SenderActivity

  Intent intent = new Intent("anEvent");
  intent.putExtra("key", "This is an event");
  LocalBroadcastManager.getInstance(this).sendBroadcast(intent);

ReceiverActivity

1. Einen Empfänger registrieren

LocalBroadcastManager.getInstance(this).registerReceiver(aLBReceiver,
              new IntentFilter("anEvent"));

2. Ein konkretes Objekt zum Durchführen einer Aktion, wenn der Empfänger aufgerufen wird

private BroadcastReceiver aLBReceiver = new BroadcastReceiver() {
    @Override 
    public void onReceive(Context context, Intent intent) {
        // perform action here.
    } 
};

3. Registrierung aufheben, wenn die Ansicht nicht mehr sichtbar ist.

@Override 
protected void onPause() { 
    // Unregister since the activity is about to be closed. 
    LocalBroadcastManager.getInstance(this).unregisterReceiver(aLBReceiver);
    super.onDestroy(); 
}

Kommunizieren Sie zwei Aktivitäten über einen benutzerdefinierten Broadcast-Empfänger

Sie können zwei Aktivitäten kommunizieren, sodass Aktivität A über ein Ereignis in Aktivität B benachrichtigt werden kann.

Tätigkeit A

final String eventName = "your.package.goes.here.EVENT";

@Override
protected void onCreate(Bundle savedInstanceState) {
    registerEventReceiver();
    super.onCreate(savedInstanceState);
}

@Override
protected void onDestroy() {
    unregisterEventReceiver(eventReceiver);
    super.onDestroy();
}

private void registerEventReceiver() {
    IntentFilter eventFilter = new IntentFilter();
    eventFilter.addAction(eventName);
    registerReceiver(eventReceiver, eventFilter);
}

private BroadcastReceiver eventReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
         //This code will be executed when the broadcast in activity B is launched
    }
};

Tätigkeit B

final String eventName = "your.package.goes.here.EVENT";

private void launchEvent() {
    Intent eventIntent = new Intent(eventName);
    this.sendBroadcast(eventIntent);
}

Natürlich können Sie der Sendung weitere Informationen hinzufügen und der Absicht, die zwischen den Aktivitäten übertragen wird, weitere Extras hinzufügen. Nicht hinzugefügt, um das Beispiel so einfach wie möglich zu halten.

Sticky Broadcast

Wenn wir die Methode sendStickyBroadcast (intent) verwenden, ist die entsprechende Absicht klebrig, dh die von Ihnen gesendete Absicht bleibt nach Abschluss der Übertragung erhalten. Ein StickyBroadcast ist, wie der Name schon sagt, ein Mechanismus zum Lesen der Daten aus einer Sendung, nachdem die Sendung abgeschlossen ist. Dies kann in einem Szenario verwendet werden, in dem Sie den Wert eines Schlüssels in der Absicht vor dem Start der Activity's onCreate() einer Activity's onCreate() überprüfen möchten.

Intent intent = new Intent("com.org.action");
intent.putExtra("anIntegerKey", 0);
sendStickyBroadcast(intent);

Geordnete Sendungen verwenden

Bestellte Broadcasts werden verwendet, wenn Sie eine Priorität für Broadcast-Listener festlegen müssen.

In diesem Beispiel firstReceiver Broadcast immer vor einem secondReceiver :

final int highPriority = 2;
final int lowPriority = 1;
final String action = "action";

// intent filter for first receiver with high priority
final IntentFilter firstFilter = new IntentFilter(action);
first Filter.setPriority(highPriority);
final BroadcastReceiver firstReceiver = new MyReceiver();

// intent filter for second receiver with low priority
final IntentFilter secondFilter = new IntentFilter(action);
secondFilter.setPriority(lowPriority);
final BroadcastReceiver secondReceiver = new MyReceiver();

// register our receivers
context.registerReceiver(firstReceiver, firstFilter);
context.registerReceiver(secondReceiver, secondFilter);

// send ordered broadcast
context.sendOrderedBroadcast(new Intent(action), null);

Außerdem kann der Rundfunkempfänger die bestellte Sendung abbrechen:

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

In diesem Fall erhalten alle Empfänger mit niedrigerer Priorität keine Broadcast-Nachricht.

Android-Status angehalten

Ab Android 3.1 werden alle Anwendungen nach der Installation in den Stoppzustand versetzt. Im gestoppten Zustand wird die Anwendung aus keinem Grund ausgeführt, außer durch manuelles Starten einer Aktivität oder durch eine explizite Absicht, die eine Aktivität, einen Dienst oder einen Broadcast anspricht.

Bitte beachten Sie beim Schreiben einer System-App, die APKs direkt installiert, dass die neu installierte APP keine Broadcasts empfängt, bis sie in einen nicht angehaltenen Status versetzt wird.

Eine einfache Möglichkeit, eine App zu aktivieren, ist das Senden einer expliziten Übertragung an diese App. INSTALL_REFERRER meisten Apps INSTALL_REFERRER implementieren, können wir es als Verbindungspunkt verwenden

Scannen Sie das Manifest der installierten App und senden Sie eine explizite Übertragung an jeden Empfänger:

Intent intent = new Intent();
intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
intent.setComponent(new ComponentName(packageName, fullClassName));
sendBroadcast(intent);