Android
Receptor de radiodifusión

Introducción

Introducción al receptor de radiodifusión

Un receptor de difusión es un componente de Android que le permite registrarse para eventos del sistema o de la aplicación.

Un receptor se puede registrar a través del archivo AndroidManifest.xml o dinámicamente a través del método Context.registerReceiver() .

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

Aquí he tomado un ejemplo de ACTION_BOOT_COMPLETED que es ACTION_BOOT_COMPLETED por el sistema una vez que Android ha completado el proceso de arranque.

Puede registrar un receptor en un archivo de manifiesto como este:

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

Ahora se onReceive() dispositivo, se onReceive() método onReceive() y luego podrá hacer su trabajo (por ejemplo, iniciar un servicio, iniciar una alarma).

Fundamentos de BroadcastReceiver

Los BroadcastReceivers se utilizan para recibir los Intentos de transmisión enviados por el sistema operativo Android, otras aplicaciones o dentro de la misma aplicación.

Cada intento se crea con un filtro de intento , que requiere una acción de cadena. Se puede configurar información adicional en la Intención.

Del mismo modo, BroadcastReceivers se registra para recibir Intents con un Intent Filter particular. Se pueden registrar programáticamente:

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

o en el archivo AndroidManifest.xml :

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

Para recibir la Intención, configure la Acción como algo documentado por el sistema operativo Android, por otra aplicación o API, o dentro de su propia aplicación, usando sendBroadcast :

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

Además, la intención puede contener información, como cadenas, primitivas y parcelables , que se pueden ver en onReceive .

Usando LocalBroadcastManager

LocalBroadcastManager se utiliza para enviar Intentos de difusión dentro de una aplicación, sin exponerlos a oyentes no deseados.

Usar LocalBroadcastManager es más eficiente y seguro que usar context.sendBroadcast() directamente, ya que no necesita preocuparse por las transmisiones falsificadas por otras Aplicaciones, que pueden representar un peligro para la seguridad.

Aquí hay un ejemplo simple de enviar y recibir transmisiones locales:

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

Receptor Bluetooth Broadcast

agrega permiso en tu archivo manifiesto

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

En tu Fragmento (o Actividad)

• Añade el método del receptor

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

Registrar transmisión

• Llame a este método en onResume ()

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

Anular el registro de transmisión

• Llame a este método en onPause ()

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

Habilitar y deshabilitar un receptor de difusión programáticamente

Para habilitar o deshabilitar un BroadcastReceiver , necesitamos obtener una referencia al PackageManager y necesitamos un objeto ComponentName que contenga la clase del receptor que deseamos habilitar / deshabilitar:

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

Ahora podemos llamar al siguiente método para habilitar BroadcastReceiver :

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

O podemos usar COMPONENT_ENABLED_STATE_DISABLED para desactivar el receptor:

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

BroadcastReceiver para manejar eventos BOOT_COMPLETED

El siguiente ejemplo muestra cómo crear un BroadcastReceiver que puede recibir eventos BOOT_COMPLETED . De esta manera, puede iniciar un Service o iniciar una Activity tan pronto como se encendió el dispositivo.

Además, puede usar eventos BOOT_COMPLETED para restaurar sus alarmas, ya que se destruyen cuando se apaga el dispositivo.

NOTA: El usuario debe haber iniciado la aplicación al menos una vez antes de poder recibir la acción 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
            } 
        }
    }
}

Ejemplo de un LocalBroadcastManager

Un BroadcastReceiver es básicamente un mecanismo para transmitir intenciones a través del sistema operativo para realizar acciones específicas. Una definición clásica siendo

"Un receptor de difusión es un componente de Android que le permite registrarse para eventos del sistema o de la aplicación".

LocalBroadcastManager es una forma de enviar o recibir transmisiones dentro de un proceso de solicitud. Este mecanismo tiene muchas ventajas.

1. ya que los datos permanecen dentro del proceso de la aplicación, los datos no se pueden filtrar.
2. Las transmisiones locales se resuelven más rápido, ya que la resolución de una transmisión normal ocurre en el tiempo de ejecución en todo el sistema operativo.

Un ejemplo simple de un LocalBroastManager es:

SenderActivity

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

ReceiverActivity

1. Registrar un receptor

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

2. Un objeto concreto para realizar una acción cuando se llama al receptor.

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

3. anular el registro cuando la vista ya no es visible.

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

Comunicar dos actividades a través del receptor Broadcast personalizado.

Puede comunicar dos actividades para que la Actividad A pueda ser notificada de un evento que ocurra en la Actividad B.

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

Actividad B

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

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

Por supuesto, puede agregar más información a la transmisión, agregando extras a la Intención que se pasa entre las actividades. No añadido para mantener el ejemplo lo más simple posible.

Transmisión pegajosa

Si estamos usando el método sendStickyBroadcast (intento), el intento correspondiente es fijo, lo que significa que el intento que está enviando permanece después de que se completa la transmisión. Un StickyBroadcast como su nombre indica es un mecanismo para leer los datos de una transmisión, una vez que se completa la transmisión. Esto se puede usar en un escenario en el que es posible que desee verificar, por ejemplo, en Activity's onCreate() una Activity's onCreate() el valor de una clave en la intención antes de que se lanzara esa Actividad.

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

Usando transmisiones ordenadas

Las transmisiones ordenadas se utilizan cuando necesita especificar una prioridad para los oyentes de transmisión.

En este ejemplo, firstReceiver recibirá una transmisión siempre antes que un 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);

Además, el receptor de difusión puede abortar la emisión ordenada:

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

en este caso, todos los receptores con prioridad más baja no recibirán un mensaje de difusión.

Android detuvo el estado

A partir de Android 3.1, todas las aplicaciones, después de la instalación, se colocan en un estado detenido. Mientras se encuentre en estado detenido, la aplicación no se ejecutará por ningún motivo, excepto mediante el lanzamiento manual de una actividad o una intención explícita que aborde una actividad, servicio o difusión.

Al escribir la aplicación del sistema que instala los APK directamente, tenga en cuenta que la aplicación recién instalada no recibirá ninguna transmisión hasta que se mueva a un estado no detenido.

Una forma fácil de activar una aplicación es enviar una transmisión explícita a esta aplicación. Como la mayoría de las aplicaciones implementan INSTALL_REFERRER , podemos usarlo como un punto de INSTALL_REFERRER .

Escanee el manifiesto de la aplicación instalada y envíe una transmisión explícita a cada receptor:

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