Android
BroadcastReceiver

introduzione

Introduzione al ricevitore Broadcast

Un ricevitore Broadcast è un componente Android che consente di registrarsi per eventi di sistema o applicazione.

Un ricevitore può essere registrato tramite il file AndroidManifest.xml o dinamicamente tramite il metodo Context.registerReceiver() .

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

Qui ho preso un esempio di ACTION_BOOT_COMPLETED che viene ACTION_BOOT_COMPLETED dal sistema una volta che Android ha completato il processo di avvio.

Puoi registrare un ricevitore nel file manifest come questo:

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

Ora il dispositivo viene avviato, viene chiamato il metodo onReceive() e quindi è possibile eseguire il proprio lavoro (ad esempio avviare un servizio, avviare un allarme).

Informazioni di base su BroadcastReceiver

BroadcastReceivers viene utilizzato per ricevere gli eventi di trasmissione inviati dal sistema operativo Android, da altre app o dalla stessa app.

Ogni intent viene creato con un filtro Intent , che richiede un'azione String. Ulteriori informazioni possono essere configurate nell'intento.

Allo stesso modo, BroadcastReceivers si registra per ricevere Intenti con un particolare Filtro Intento. Possono essere registrati a livello di codice:

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

o nel file AndroidManifest.xml :

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

Per ricevere l'intenzione, imposta l'azione su qualcosa documentato dal sistema operativo Android, da un'altra app o API o all'interno della tua applicazione, utilizzando sendBroadcast :

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

Inoltre, l'intento può contenere informazioni, come stringhe, primitive e Parcelables , che possono essere visualizzate in onReceive .

Utilizzando LocalBroadcastManager

LocalBroadcastManager viene utilizzato per inviare Broadcast Intents all'interno di un'applicazione, senza esporli agli ascoltatori indesiderati.

L'uso di LocalBroadcastManager è più efficiente e più sicuro dell'uso di context.sendBroadcast() , poiché non è necessario preoccuparsi di eventuali trasmissioni di programmi falsificati da altre applicazioni, il che può costituire un rischio per la sicurezza.

Ecco un semplice esempio di invio e ricezione di trasmissioni locali:

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

Ricevitore di trasmissione Bluetooth

aggiungi permesso nel file manifest

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

Nel tuo frammento (o attività)

• Aggiungi il metodo ricevitore

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

Registra trasmissione

• Chiama questo metodo su onResume ()

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

Annulla registrazione

• Chiama questo metodo su onPause ()

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

Abilitazione e disabilitazione di un ricevitore di trasmissione a livello di programmazione

Per abilitare o disabilitare un BroadcastReceiver , abbiamo bisogno di ottenere un riferimento al PackageManager e abbiamo bisogno di un oggetto ComponentName contenente la classe del ricevitore che vogliamo abilitare / disabilitare:

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

Ora possiamo chiamare il seguente metodo per abilitare BroadcastReceiver :

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

Oppure possiamo usare COMPONENT_ENABLED_STATE_DISABLED per disabilitare il ricevitore:

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

BroadcastReceiver per gestire eventi BOOT_COMPLETED

L'esempio seguente mostra come creare un BroadcastReceiver grado di ricevere eventi BOOT_COMPLETED . In questo modo, si è in grado di avviare un Service o avviare Activity nel più breve dispositivo è stato acceso.

Inoltre, puoi utilizzare BOOT_COMPLETED eventi BOOT_COMPLETED per ripristinare gli allarmi poiché vengono distrutti quando il dispositivo viene spento.

NOTA: l'utente deve aver avviato l'applicazione almeno una volta prima di poter ricevere l'azione 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
            } 
        }
    }
}

Esempio di un LocalBroadcastManager

Un BroadcastReceiver è fondamentalmente un meccanismo per inoltrare Intenti attraverso il sistema operativo per eseguire azioni specifiche. Un essere di definizione classica

"Un ricevitore Broadcast è un componente Android che ti consente di registrarti per eventi di sistema o applicazioni."

LocalBroadcastManager è un modo per inviare o ricevere trasmissioni all'interno di un processo di applicazione. Questo meccanismo ha molti vantaggi

1. poiché i dati rimangono all'interno del processo di applicazione, i dati non possono essere trapelati.
2. I LocalBroadcast sono risolti più velocemente, poiché la risoluzione di una normale trasmissione avviene in fase di esecuzione su tutto il sistema operativo.

Un semplice esempio di LocalBroastManager è:

SenderActivity

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

ReceiverActivity

1. Registra un ricevitore

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

2. Un oggetto concreto per eseguire azioni quando viene chiamato il ricevitore

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

3. annullare la registrazione quando la vista non è più visibile.

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

Comunicare due attività tramite ricevitore Broadcast personalizzato

È possibile comunicare due attività in modo che l'attività A possa essere notificata di un evento che si verifica nell'attività B.

Attività 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
    }
};

Attività B

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

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

Naturalmente è possibile aggiungere ulteriori informazioni alla trasmissione aggiungendo degli extra all'Intento che viene passato tra le attività. Non aggiunto per mantenere l'esempio il più semplice possibile.

Trasmissione appiccicosa

Se stiamo usando il metodo sendStickyBroadcast (intento), l'intento corrispondente è appiccicoso, il che significa che l'intento che stai inviando rimane in attesa dopo che la trasmissione è completa. Un StickyBroadcast come suggerisce il nome è un meccanismo per leggere i dati da una trasmissione, una volta completata la trasmissione. Questo può essere usato in uno scenario in cui si potrebbe voler dire di dire in un Activity's onCreate() il valore di una chiave nell'intento prima che quell'attività fosse lanciata.

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

Utilizzando le trasmissioni ordinate

Le trasmissioni ordinate vengono utilizzate quando è necessario specificare una priorità per i listener di trasmissione.

In questo esempio firstReceiver riceverà la trasmissione sempre prima di un secondo 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);

Inoltre, il destinatario della trasmissione può interrompere la trasmissione ordinata:

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

in questo caso tutti i ricevitori con priorità inferiore non riceveranno un messaggio broadcast.

Android ha smesso di funzionare

A partire da Android 3.1 tutte le applicazioni, al momento dell'installazione, vengono messe in stato di arresto. Quando è in stato di arresto, l'applicazione non verrà eseguita per nessun motivo, ad eccezione di un avvio manuale di un'attività o di un intento esplicito che indirizzi un'attività, un servizio o una trasmissione.

Quando scrivi un'app di sistema che installa gli APK direttamente, tieni presente che l'APP appena installata non riceverà alcuna trasmissione fino a quando non verrà spostata in uno stato non arrestato.

Un modo semplice per attivare un'app è inviare una trasmissione esplicita a questa app. poiché la maggior parte delle app implementa INSTALL_REFERRER , possiamo usarlo come punto di aggancio

Esegui la scansione del manifest dell'applicazione installata e invia una trasmissione esplicita a ciascun destinatario:

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