Comment utiliser / localiser LocalBroadcastManagercomme décrit dans google docs et Service broadcast doc ?

J'ai essayé de le chercher sur Google, mais il n'y a pas de code disponible pour commencer?

Les documents disent que je devrais l'utiliser si je veux faire de la diffusion en interne avec dans le processus de mon application, mais je ne sais pas où chercher.

Une aide / un commentaire?

Mise à jour : je sais comment utiliser les diffusions mais je ne sais pas comment être LocalBroadcastManagerdisponible dans mon projet.

J'y répondrai quand même. Juste au cas où quelqu'un en aurait besoin.

ReceiverActivity.java

Une activité qui surveille les notifications de l'événement nommé "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 deuxième activité qui envoie / diffuse des notifications.

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

Avec le code ci-dessus, chaque fois que le bouton R.id.button_sendest cliqué, une intention est diffusée et reçue par mMessageReceiverin ReceiverActivity.

La sortie de débogage devrait ressembler à ceci:

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! 

Je préfère répondre de manière globale.

1. LocalbroadcastManager inclus dans Android 3.0 et supérieur, vous devez donc utiliser la bibliothèque de support v4 pour les premières versions. voir les instructions ici

2. Créez un récepteur de diffusion:

   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. Enregistrez votre récepteur sur une reprise d'activité comme:

   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. désenregistrer le récepteur en onPause:

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

5. Désormais, chaque fois qu'une diffusion locale est envoyée à partir de l'activité ou du service des applications, onReceive de onNotice sera appelé :).

Edit: Vous pouvez lire le tutoriel complet ici LocalBroadcastManager: passage de message intra application

À la réception:

• Enregistrez d'abord LocalBroadcast Receiver

• Ensuite, gérez les données d'intention entrantes dans 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 
            }
        }
    };

À la fin de l'envoi:

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

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

Dans Eclipse, j'ai finalement dû ajouter la bibliothèque de compatibilité / support en cliquant avec le bouton droit sur mon projet et en sélectionnant:

Android Tools -> Add Support Library

Une fois qu'il a été ajouté, j'ai pu utiliser la LocalBroadcastManagerclasse dans mon code.

localbroadcastmanager est obsolète, utilisez plutôt des implémentations du modèle observable.

androidx.localbroadcastmanager est déconseillé dans la version 1.1.0

Raison

LocalBroadcastManagerest un bus d'événements à l'échelle de l'application et intègre les violations de couche dans votre application; tout composant peut écouter les événements de tout autre composant. Il hérite des limitations inutiles de cas d'utilisation du système BroadcastManager; les développeurs doivent utiliser Intent même si les objets vivent dans un seul processus et ne le quittent jamais. Pour cette même raison, il ne suit pas BroadcastManager en termes de fonctionnalités.

Ceux-ci s'ajoutent à une expérience de développeur déroutante.

Remplacement

Vous pouvez remplacer l'utilisation de LocalBroadcastManagerpar d'autres implémentations du modèle observable. Selon votre cas d'utilisation, des options appropriées peuvent être LiveDatades flux réactifs.

Avantage de LiveData

Vous pouvez étendre un LiveDataobjet à l'aide du modèle singleton pour envelopper les services système afin qu'ils puissent être partagés dans votre application. L' LiveDataobjet se connecte au service système une fois, puis tout observateur qui a besoin de la ressource peut simplement regarder l' LiveDataobjet.

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

La observe()méthode passe le fragment, qui est une instance de LifecycleOwner, comme premier argument. Cela signifie que cet observateur est lié à l' Lifecycleobjet associé au propriétaire, ce qui signifie:

• Si l'objet Cycle de vie n'est pas dans un état actif, l'observateur n'est pas appelé même si la valeur change.

• Une fois l'objet Cycle de vie détruit, l'observateur est automatiquement supprimé

Le fait que les LiveDataobjets soient sensibles au cycle de vie signifie que vous pouvez les partager entre plusieurs activités, fragments et services.

Comment changer votre diffusion mondiale en LocalBroadcast

1) Créer une instance

LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(this);

2) Pour enregistrer BroadcastReceiver

Remplacer

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

Avec

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

3) Pour l'envoi d'un message diffusé

Remplacer

sendBroadcast(intent);

Avec

localBroadcastManager.sendBroadcast(intent);

4) Pour désenregistrer un message diffusé

Remplacer

unregisterReceiver(mybroadcast);

Avec

localBroadcastManager.unregisterReceiver(mybroadcast);

Lorsque vous jouerez suffisamment avec LocalBroadcastReceiver, je vous suggérerai d' essayer l'EventBus de Green Robot - vous en comprendrez certainement la différence et l'utilité par rapport à LBR. Moins de code, personnalisable sur le thread du récepteur (UI / Bg), vérifiant la disponibilité des récepteurs, les événements collants, les événements peuvent être utilisés comme livraison de données, etc.

Un exemple d'activité et de service implémentant un LocalBroadcastManager peut être trouvé dans les documents du développeur . Je l'ai personnellement trouvé très utile.

EDIT: Le lien a depuis été supprimé du site, mais les données sont les suivantes: https://github.com/carrot-garden/android_maven-android-plugin-samples/blob/master/support4demos/src/com/ exemple / 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()

En en déclarant un dans votre fichier AndroidManifest.xml avec la balise (également appelée statique)

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

Vous remarquerez que le récepteur de diffusion déclaré ci-dessus a une propriété de exports = "true". Cet attribut indique au récepteur qu'il peut recevoir des émissions de l'extérieur de la portée de l'application.
2. Ou dynamiquement en enregistrant une instance avec registerReceiver (ce que l'on appelle le contexte enregistré)

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

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

Il existe trois façons d'envoyer des diffusions:
La méthode sendOrderedBroadcast garantit l'envoi des diffusions à un seul récepteur à la fois. Chaque diffusion peut à son tour, transmettre des données à celle qui la suit, ou arrêter la propagation de la diffusion aux récepteurs qui suivent.
Le sendBroadcast est similaire à la méthode mentionnée ci-dessus, avec une différence. Tous les récepteurs de diffusion reçoivent le message et ne dépendent pas les uns des autres.
La méthode LocalBroadcastManager.sendBroadcast envoie uniquement des diffusions aux récepteurs définis dans votre application et ne dépasse pas la portée de votre application.

nous pouvons également utiliser l'interface pour le même que broadcastManger ici, je partage le code testd pour broadcastManager mais par interface.

faire d'abord une interface comme:

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

2-c'est la première classe à implémenter

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-voici la deuxième classe qui implémente la même interface dont la méthode appelle automatiquement

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

donc par cette approche, nous pouvons utiliser l'interface fonctionnant de la même manière que broadcastManager.