Como usar / localizar, LocalBroadcastManagerconforme descrito no Google Docs e no Documento de transmissão de serviço ?

Tentei pesquisar no Google, mas não há código disponível para começar?

Os documentos dizem que eu devo usá-lo se quiser transmitir internamente no processo do meu aplicativo, mas não sei onde procurar isso.

Alguma ajuda / comentário?

Atualização : Eu sei como usar transmissões, mas não sei como ficar LocalBroadcastManagerdisponível no meu projeto.

Eu vou responder isso de qualquer maneira. Apenas no caso de alguém precisar.

ReceiverActivity.java

Uma atividade que procura notificações para o evento nomeado "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

A segunda atividade que envia / transmite notificações.

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

Com o código acima, toda vez que o botão R.id.button_sendé clicado, um Intent é transmitido e recebido por mMessageReceiverin ReceiverActivity.

A saída de depuração deve ficar assim:

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! 

Eu gostaria de responder de forma abrangente.

1. LocalbroadcastManager incluído no Android 3.0 e superior, para que você tenha que usar a biblioteca de suporte v4 para versões anteriores. veja as instruções aqui

2. Crie um receptor de transmissão:

   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 seu receptor em um currículo de atividade 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. cancele o registro do receptor no onPause:

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

5. Agora, sempre que um broadcast local for enviado da atividade ou serviço dos aplicativos, onReceive of onNotice será chamado :).

Edit: Você pode ler o tutorial completo aqui LocalBroadcastManager: Passagem de mensagens dentro do aplicativo

No final de recebimento:

• Primeiro registro LocalBroadcast Receiver

• Em seguida, manipule os dados de intenção de entrada no 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 
            }
        }
    };

No final do envio:

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

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

No Eclipse, finalmente tive que adicionar a Biblioteca de Compatibilidade / Suporte clicando com o botão direito do mouse no meu projeto e selecionando:

Android Tools -> Add Support Library

Depois de adicionado, pude usar a LocalBroadcastManagerclasse no meu código.

Como mudar sua transmissão global para LocalBroadcast

1) Criar instância

LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(this);

2) Para registrar o BroadcastReceiver

Substituir

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

Com

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

3) Para enviar mensagem de difusão

Substituir

sendBroadcast(intent);

Com

localBroadcastManager.sendBroadcast(intent);

4) Para cancelar o registro da mensagem de difusão

Substituir

unregisterReceiver(mybroadcast);

Com

localBroadcastManager.unregisterReceiver(mybroadcast);

localbroadcastmanager foi descontinuado, use implementações do padrão observável.

androidx.localbroadcastmanager está sendo reprovado na versão 1.1.0

Razão

LocalBroadcastManageré um barramento de eventos para todo o aplicativo e abrange violações de camada no seu aplicativo; qualquer componente pode ouvir eventos de qualquer outro componente. Ele herda limitações desnecessárias de casos de uso do BroadcastManager do sistema; os desenvolvedores precisam usar o Intent, mesmo que os objetos vivam em apenas um processo e nunca o abandonem. Por esse mesmo motivo, ele não segue o BroadcastManager.

Isso resulta em uma experiência confusa para o desenvolvedor.

Substituição

Você pode substituir o uso LocalBroadcastManagerpor outras implementações do padrão observável. Dependendo do seu caso de uso, as opções adequadas podem ser LiveDataou fluxos reativos.

Vantagem do LiveData

Você pode estender um LiveDataobjeto usando o padrão singleton para agrupar os serviços do sistema para que eles possam ser compartilhados no seu aplicativo. O LiveDataobjeto se conecta ao serviço do sistema uma vez e, em seguida, qualquer observador que precise do recurso pode apenas observar o 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.
        });
    }
}

O observe()método passa o fragmento, que é uma instância de LifecycleOwner, como o primeiro argumento. Fazer isso indica que esse observador está vinculado ao Lifecycleobjeto associado ao proprietário, o que significa:

• Se o objeto Ciclo de Vida não estiver em um estado ativo, o observador não será chamado, mesmo que o valor seja alterado.

• Após a destruição do objeto Ciclo de Vida, o observador é removido automaticamente

O fato de os LiveDataobjetos reconhecerem o ciclo de vida significa que você pode compartilhá-los entre várias atividades, fragmentos e serviços.

Quando você jogar o suficiente com LocalBroadcastReceiver, sugiro que você experimente o EventBus da Green Robot - você definitivamente perceberá a diferença e a utilidade dele em comparação com o LBR. Menos código personalizável sobre o encadeamento do receptor (UI / Bg), verificação da disponibilidade do receptor, eventos persistentes, eventos podem ser usados ​​como entrega de dados, etc.

Um exemplo de uma Atividade e um Serviço implementando um LocalBroadcastManager pode ser encontrado nos documentos do desenvolvedor . Eu pessoalmente achei muito útil.

EDIT: O link foi removido desde então do site, mas os dados são os seguintes: https://github.com/carrot-garden/android_maven-android-plugin-samples/blob/master/support4demos/src/com/ exemplo / 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()

Ao declarar um no seu arquivo AndroidManifest.xml com a tag (também chamada 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>

Você notará que o receptor de transmissão declarado acima possui uma propriedade exported = ”true”. Este atributo informa ao receptor que ele pode receber transmissões de fora do escopo do aplicativo.
2. Ou dinamicamente, registrando uma instância com registerReceiver (o que é conhecido como contexto registrado)

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

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

Há três maneiras de enviar transmissões:
O método sendOrderedBroadcast, garante a transmissão de transmissões para apenas um receptor por vez. Cada transmissão, por sua vez, pode repassar dados para quem segue ou interromper a propagação da transmissão para os receptores a seguir.
O sendBroadcast é semelhante ao método mencionado acima, com uma diferença. Todos os receptores de transmissão recebem a mensagem e não dependem um do outro.
O método LocalBroadcastManager.sendBroadcast envia apenas transmissões para receptores definidos dentro do seu aplicativo e não excede o escopo do seu aplicativo.

Também podemos usar a interface para o mesmo que o broadcastManger. Aqui, estou compartilhando o código testd do broadcastManager, mas pela interface.

primeiro faça uma interface como:

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

2 - esta é a primeira classe que precisa de implementação

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-aqui é a segunda classe que implementa a mesma interface cuja chamada de método automaticamente

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

portanto, com essa abordagem, podemos usar a interface funcionando da mesma forma que o broadcastManager.