Mi piacerebbe sapere qual è la migliore pratica / il modo di registrare programmaticamente un ricevitore di trasmissione. Voglio registrare ricevitori specifici in base alla scelta dell'utente.

Mentre la registrazione viene effettuata tramite il file manifest, mi chiedo se esiste un modo corretto per ottenere ciò nel codice.

Sembra che tu voglia controllare se i componenti pubblicati nel tuo manifest sono attivi, non registrare dinamicamente un ricevitore (tramite Context.registerReceiver ()) durante l'esecuzione.

In tal caso, è possibile utilizzare PackageManager.setComponentEnabledSetting () per controllare se questi componenti sono attivi:

http://developer.android.com/reference/android/content/pm/PackageManager.html#setComponentEnabledSetting(android.content.ComponentName, int, int)

Nota se sei interessato a ricevere una trasmissione solo mentre sei in esecuzione, è meglio usare registerReceiver (). Un componente ricevitore è utile soprattutto quando è necessario assicurarsi che l'app venga avviata ogni volta che viene inviata la trasmissione.

Nel tuo onCreatemetodo puoi registrare un ricevitore in questo modo:

private BroadcastReceiver receiver;

@Override
public void onCreate(Bundle savedInstanceState){

  // your oncreate code should be

  IntentFilter filter = new IntentFilter();
  filter.addAction("SOME_ACTION");
  filter.addAction("SOME_OTHER_ACTION");

  receiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
      //do something based on the intent's action
    }
  };
     registerReceiver(receiver, filter);
}

Ricordati di eseguirlo nel onDestroymetodo:

 @Override
 protected void onDestroy() {
  if (receiver != null) {
   unregisterReceiver(receiver);
   receiver = null;
  }
  super.onDestroy();
 }

Un punto importante che le persone dimenticano di menzionare è il tempo di vita di Broadcast Receiver. La differenza della registrazione programmatica dalla registrazione in AndroidManifest.xml è quella. Nel file manifest, non dipende dalla durata dell'applicazione. Mentre la registrazione a livello di codice dipende dalla durata dell'applicazione. Ciò significa che se ti registri in AndroidManifest.xml , puoi catturare gli intenti trasmessi anche quando l'applicazione non è in esecuzione.

Modifica: la nota menzionata non è più vera a partire da Android 3.1, il sistema Android esclude tutti i ricevitori dalla ricezione degli intenti di default se l'applicazione corrispondente non è mai stata avviata dall'utente o se l'utente ha interrotto esplicitamente l'applicazione tramite il menu Android (in Gestisci → Applicazione). https://developer.android.com/about/versions/android-3.1.html

Questa è una funzione di sicurezza aggiuntiva in quanto l'utente può essere sicuro che solo le applicazioni che ha avviato riceveranno intenti di trasmissione.

Quindi si può capire che i ricevitori registrati a livello di codice nell'applicazione onCreate()avrebbero lo stesso effetto con quelli dichiarati in AndroidManifest.xml da Android 3.1 sopra.

Definisci un ricevitore di trasmissione ovunque in Attività / Frammento in questo modo:

mReceiver = new BroadcastReceiver() {
 @Override
 public void onReceive(Context context, Intent intent) {
     Log.d(TAG," onRecieve"); //do something with intent
   }
 };

Definisci IntentFilter in onCreate()

mIntentFilter=new IntentFilter("action_name");

Ora registra BroadcastReciever onResume()e Annulla la registrazione in onPause()[perché non è possibile utilizzare la trasmissione se l'attività è in pausa].

@Override
protected void onResume() {
     super.onResume();
     registerReceiver(mReceiver, mIntentFilter);
}

@Override
protected void onPause() {
    if(mReceiver != null) {
            unregisterReceiver(mReceiver);
            mReceiver = null;
    }
    super.onPause();
}

Per un'esercitazione dettagliata, dai un'occhiata al ricevitore di trasmissione in due modi per implementarlo .

package com.example.broadcastreceiver;


import android.app.Activity;
import android.content.IntentFilter;
import android.os.Bundle;
import android.view.Menu;
import android.view.View;
import android.widget.Toast;

public class MainActivity extends Activity {

   UserDefinedBroadcastReceiver broadCastReceiver = new UserDefinedBroadcastReceiver();

   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);
   }

   @Override
   public boolean onCreateOptionsMenu(Menu menu) {
      getMenuInflater().inflate(R.menu.main, menu);
      return true;
   }

   /**
    * This method enables the Broadcast receiver for
    * "android.intent.action.TIME_TICK" intent. This intent get
    * broadcasted every minute.
    *
    * @param view
    */
   public void registerBroadcastReceiver(View view) {

      this.registerReceiver(broadCastReceiver, new IntentFilter(
            "android.intent.action.TIME_TICK"));
      Toast.makeText(this, "Registered broadcast receiver", Toast.LENGTH_SHORT)
            .show();
   }

   /**
    * This method disables the Broadcast receiver
    *
    * @param view
    */
   public void unregisterBroadcastReceiver(View view) {

      this.unregisterReceiver(broadCastReceiver);

      Toast.makeText(this, "unregistered broadcst receiver", Toast.LENGTH_SHORT)
            .show();
   }
}

Secondo l'ascolto e la trasmissione di messaggi globali e l'impostazione di allarmi in attività comuni e come eseguirli in Android :

Se la classe ricevente non è registrata usando nel suo manifest, è possibile creare un'istanza e registrare dinamicamente un ricevitore chiamando Context.registerReceiver () .

Dai un'occhiata a registerReceiver (ricevitore BroadcastReceiver, filtro IntentFilter) per maggiori informazioni.

È consigliabile fornire sempre l'autorizzazione quando si registra il destinatario, altrimenti si riceverà per qualsiasi applicazione che invia un intento corrispondente. Ciò può consentire alle app dannose di trasmettere al tuo ricevitore.

per LocalBroadcastManager

   Intent intent = new Intent("any.action.string");
   LocalBroadcastManager.getInstance(context).
                                sendBroadcast(intent);

e registrati onResume

LocalBroadcastManager.getInstance(
                    ActivityName.this).registerReceiver(chatCountBroadcastReceiver, filter);

e Annulla la registrazione onStop

LocalBroadcastManager.getInstance(
                ActivityName.this).unregisterReceiver(chatCountBroadcastReceiver);

e riceverlo ..

mBroadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.e("mBroadcastReceiver", "onReceive");
        }
    };

dove si trova IntentFilter

 new IntentFilter("any.action.string")

Due scelte

1) Se desideri leggere la trasmissione solo quando l'attività è visibile,

registerReceiver(...) in onStart()e unregisterReceiver(...)inonStop()

2) Se desideri leggere la trasmissione anche se l'attività è in background,

registerReceiver(...)dentro onCreate(...)e unregisterReceiver(...)dentroonDestroy()

Bonus:

Se sei pigro

Se non si desidera scrivere il codice boilerplate per la registrazione e l'annullamento della registrazione di un BroadcastReceiver ancora e ancora in ciascuna attività,

1. Crea un'attività astratta
2. Scrivi il codice del boilerplate in Activity
3. Lasciare l'implementazione come metodi astratti

Ecco il frammento di codice:

Attività astratta

public abstract class BasicActivity extends AppCompatActivity {

    private BroadcastReceiver broadcastReceiver;
    private IntentFilter filter;
    private static final String TAG = "BasicActivity";

    /**********************************************************************
    *                   Boilerplate code
    **********************************************************************/

    @Override
    public void onCreate(Bundle sis){
        super.onCreate(sis);
        broadcastReceiver = getBroadcastReceiver();
        filter = getFilter();
    }

    @Override
    public void onStart(){
        super.onStart();
        register();
    }

    @Override
    public void onStop(){
        super.onStop();
        unregister();
    }

    private void register(){
        registerReceiver(broadcastReceiver,filter);
    }

    private void unregister(){
        unregisterReceiver(broadcastReceiver);
    }

    /**********************************************************************
    *                   Abstract methods
    **********************************************************************/

    public abstract BroadcastReceiver getBroadcastReceiver();

    public abstract IntentFilter getFilter();

}

Usando questo approccio è possibile scrivere più codice boilerplate come scrivere animazioni comuni, associare a un servizio, ecc.

Vedi il codice completo:

QUI

Crea un ricevitore broadcast

[BroadcastReceiver (Enabled = true, Exported = false)]

public class BCReceiver : BroadcastReceiver
{

    BCReceiver receiver;

    public override void OnReceive(Context context, Intent intent)
    {
        //Do something here
    }
}

Dalla tua attività aggiungi questo codice:

LocalBroadcastManager.getInstance(ApplicationContext)
    .registerReceiver(receiver, filter);