¿Cómo usar / localizar LocalBroadcastManagercomo se describe en Google Docs y Service Broadcast Doc ?

Intenté buscarlo en Google, pero ¿no hay un código disponible para comenzar?

Los documentos dicen que debería usarlo si quiero hacer una transmisión interna en el proceso de mi aplicación, pero no sé dónde buscar esto.

¿Alguna ayuda / comentario?

Actualización : sé cómo usar transmisiones pero no sé cómo estar LocalBroadcastManagerdisponible en mi proyecto.

Contestaré esto de todos modos. Por si acaso alguien lo necesita.

ReceiverActivity.java

Una actividad que busca notificaciones para el evento nombrado "custom-event-name".

@Override
public void onCreate(Bundle savedInstanceState) {

  ...

  // Register to receive messages.
  // We are registering an observer (mMessageReceiver) to receive Intents
  // with actions named "custom-event-name".
  LocalBroadcastManager.getInstance(this).registerReceiver(mMessageReceiver,
      new IntentFilter("custom-event-name"));
}

// Our handler for received Intents. This will be called whenever an Intent
// with an action named "custom-event-name" is broadcasted.
private BroadcastReceiver mMessageReceiver = new BroadcastReceiver() {
  @Override
  public void onReceive(Context context, Intent intent) {
    // Get extra data included in the Intent
    String message = intent.getStringExtra("message");
    Log.d("receiver", "Got message: " + message);
  }
};

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

SenderActivity.java

La segunda actividad que envía / difunde notificaciones.

@Override
public void onCreate(Bundle savedInstanceState) {

  ...

  // Every time a button is clicked, we want to broadcast a notification.
  findViewById(R.id.button_send).setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      sendMessage();
    }
  });
}

// Send an Intent with an action named "custom-event-name". The Intent sent should 
// be received by the ReceiverActivity.
private void sendMessage() {
  Log.d("sender", "Broadcasting message");
  Intent intent = new Intent("custom-event-name");
  // You can also include some extra data.
  intent.putExtra("message", "This is my message!");
  LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
}

Con el código anterior, cada vez que R.id.button_sendse hace clic en el botón , se transmite una Intención y se recibe mMessageReceiveren ReceiverActivity.

La salida de depuración debería verse así:

01-16 10:35:42.413: D/sender(356): Broadcasting message
01-16 10:35:42.421: D/receiver(356): Got message: This is my message! 

Prefiero responder de manera integral.

1. LocalbroadcastManager incluido en Android 3.0 y superior, por lo que debe usar la biblioteca de soporte v4 para las versiones anteriores ver instrucciones aquí

2. Crear un receptor de difusión:

   private BroadcastReceiver onNotice= new BroadcastReceiver() {
   
       @Override
       public void onReceive(Context context, Intent intent) {
           // intent can contain anydata
           Log.d("sohail","onReceive called");
           tv.setText("Broadcast received !");
   
       }
   };

3. Registre su receptor en onResume de actividad como:

   protected void onResume() {
           super.onResume();
   
           IntentFilter iff= new IntentFilter(MyIntentService.ACTION);
           LocalBroadcastManager.getInstance(this).registerReceiver(onNotice, iff);
       }
   
   //MyIntentService.ACTION is just a public static string defined in MyIntentService.

4. cancelar el registro del receptor en onPause:

   protected void onPause() {
     super.onPause();
     LocalBroadcastManager.getInstance(this).unregisterReceiver(onNotice);
   }

5. Ahora, cada vez que se envía una transmisión local desde la actividad o el servicio de las aplicaciones, se llamará a onReceive of onNotice :).

Editar: puede leer el tutorial completo aquí LocalBroadcastManager: pasar el mensaje de la aplicación Intra

En el extremo receptor:

• Primero registre LocalBroadcast Receiver

• Luego maneje los datos de intención entrantes en onReceive.

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
  
        LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(this);
        lbm.registerReceiver(receiver, new IntentFilter("filter_string"));
    }
  
    public BroadcastReceiver receiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent != null) {
                String str = intent.getStringExtra("key");
                // get all your data from intent and do what you want 
            }
        }
    };

Al finalizar el envío:

   Intent intent = new Intent("filter_string");
   intent.putExtra("key", "My Data");
   // put your all data using put extra 

   LocalBroadcastManager.getInstance(this).sendBroadcast(intent);

En Eclipse, eventualmente tuve que agregar la Biblioteca de compatibilidad / soporte haciendo clic derecho en mi proyecto y seleccionando:

Android Tools -> Add Support Library

Una vez que se agregó, pude usar LocalBroadcastManagerclass en mi código.

Cómo cambiar su transmisión global a LocalBroadcast

1) Crear instancia

LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(this);

2) Para registrar BroadcastReceiver

Reemplazar

registerReceiver(new YourReceiver(),new IntentFilter("YourAction"));

Con

localBroadcastManager.registerReceiver(new YourReceiver(),new IntentFilter("YourAction"));

3) Para enviar mensajes de difusión

Reemplazar

sendBroadcast(intent);

Con

localBroadcastManager.sendBroadcast(intent);

4) Para cancelar el registro del mensaje de difusión

Reemplazar

unregisterReceiver(mybroadcast);

Con

localBroadcastManager.unregisterReceiver(mybroadcast);

localbroadcastmanager está en desuso, utilice implementaciones del patrón observable en su lugar.

androidx.localbroadcastmanager está en desuso en la versión 1.1.0

Razón

LocalBroadcastManageres un bus de eventos para toda la aplicación y abarca las infracciones de capa en su aplicación; cualquier componente puede escuchar eventos de cualquier otro componente. Hereda limitaciones innecesarias de casos de uso del sistema BroadcastManager; los desarrolladores tienen que usar Intent aunque los objetos vivan en un solo proceso y nunca lo abandonen. Por esta misma razón, no sigue a BroadcastManager en cuanto a funciones.

Estos se suman a una experiencia confusa del desarrollador.

Reemplazo

Puede reemplazar el uso de LocalBroadcastManagercon otras implementaciones del patrón observable. Dependiendo de su caso de uso, las opciones adecuadas pueden ser LiveDatao flujos reactivos.

Ventaja de LiveData

Puede extender un LiveDataobjeto usando el patrón singleton para ajustar los servicios del sistema para que puedan compartirse en su aplicación. El LiveDataobjeto se conecta al servicio del sistema una vez, y luego cualquier observador que necesite el recurso puede simplemente observar el LiveDataobjeto.

 public class MyFragment extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        LiveData<BigDecimal> myPriceListener = ...;
        myPriceListener.observe(this, price -> {
            // Update the UI.
        });
    }
}

El observe()método pasa el fragmento, que es una instancia de LifecycleOwner, como primer argumento. Hacerlo indica que este observador está vinculado al Lifecycleobjeto asociado con el propietario, lo que significa:

• Si el objeto del ciclo de vida no está en un estado activo, no se llama al observador incluso si el valor cambia.

• Después de que se destruye el objeto del ciclo de vida, el observador se elimina automáticamente

El hecho de que los LiveDataobjetos sean conscientes del ciclo de vida significa que puede compartirlos entre múltiples actividades, fragmentos y servicios.

Cuando juegues lo suficiente con LocalBroadcastReceiver, te sugiero que pruebes el EventBus de Green Robot: definitivamente te darás cuenta de la diferencia y la utilidad de este en comparación con LBR. Menos código, personalizable sobre el hilo del receptor (UI / Bg), verificando la disponibilidad de los receptores, eventos fijos, eventos podrían usarse como entrega de datos, etc.

Un ejemplo de una Actividad y un Servicio que implementa un LocalBroadcastManager se puede encontrar en los documentos del desarrollador . Personalmente lo encontré muy útil.

EDITAR: desde entonces, el enlace se ha eliminado del sitio, pero los datos son los siguientes: https://github.com/carrot-garden/android_maven-android-plugin-samples/blob/master/support4demos/src/com/ ejemplo / android / supportv4 / content / LocalServiceBroadcaster.java

enter code here if (createSuccses){
                        val userDataChange=Intent(BRODCAST_USER_DATA_CHANGE)
                        LocalBroadcastManager.getInstance(this).sendBroadcast(
                            userDataChange
                        )
                        enableSpinner(false)
                        finish()

Al declarar uno en su archivo AndroidManifest.xml con la etiqueta (también llamada estática)

<receiver android:name=".YourBrodcastReceiverClass"  android:exported="true">
<intent-filter>
    <!-- The actions you wish to listen to, below is an example -->
    <action android:name="android.intent.action.BOOT_COMPLETED"/>
</intent-filter>

Notará que el receptor de difusión declarado anteriormente tiene una propiedad de exported = "true". Este atributo le dice al receptor que puede recibir transmisiones desde fuera del alcance de la aplicación.
2. O dinámicamente registrando una instancia con registerReceiver (lo que se conoce como contexto registrado)

public abstract Intent registerReceiver (BroadcastReceiver receiver, 
            IntentFilter filter);

public void onReceive(Context context, Intent intent) {
//Implement your logic here
}

Hay tres formas de enviar transmisiones:
El método sendOrderedBroadcast se asegura de enviar transmisiones a un solo receptor a la vez. A su vez, cada transmisión puede transmitir datos a la siguiente o detener la propagación de la transmisión a los receptores que siguen.
SendBroadcast es similar al método mencionado anteriormente, con una diferencia. Todos los receptores de difusión reciben el mensaje y no dependen unos de otros.
El método LocalBroadcastManager.sendBroadcast solo envía transmisiones a receptores definidos dentro de su aplicación y no excede el alcance de su aplicación.

También podemos usar la interfaz para broadcastManger aquí. Estoy compartiendo el código probado para broadcastManager pero por interfaz.

primero crea una interfaz como:

public interface MyInterface {
     void GetName(String name);
}

2-esta es la primera clase que necesita implementación

public class First implements MyInterface{

    MyInterface interfc;    
    public static void main(String[] args) {
      First f=new First();      
      Second s=new Second();
      f.initIterface(s);
      f.GetName("Paddy");
  }
  private void initIterface(MyInterface interfc){
    this.interfc=interfc;
  }
  public void GetName(String name) {
    System.out.println("first "+name);
    interfc.GetName(name);  
  }
}

3-aquí está la segunda clase que implementa la misma interfaz cuyo método llama automáticamente

public class Second implements MyInterface{
   public void GetName(String name) {
     System.out.println("Second"+name);
   }
}

por este enfoque podemos usar la interfaz que funciona igual que broadcastManager.