Enregistrer par programmation d'un récepteur de radiodiffusion

Un point important que les gens oublient de mentionner, c'est la durée de vie de la Broadcast Receiver. La différence de par programme l'enregistrement de s'inscrire dans AndroidManifest.xml est que. Dans le fichier de manifeste, il ne dépend pas demande temps de la vie. Alors que lors de l'enregistrement par programmation il ne dépend pas de la demande temps de la vie. Cela signifie que si vous vous inscrivez dans AndroidManifest.xml, vous pouvez prendre l'diffusé intentions, même si votre application n'est pas en cours d'exécution.

Edit: mentionnés en note n'est plus vrai que de Android 3.1, le système Android exclut tous les récepteur de recevoir les intentions par défaut si l'application correspondante n'a jamais été lancé par l'utilisateur ou si le consentement explicite de l'utilisateur arrêté à l'application via le menu Android (dans Gérer → Application). https://developer.android.com/about/versions/android-3.1.html

C'est une caractéristique de sécurité supplémentaire, que l'utilisateur peut être sûr que les demandes qu'il a commencé recevrez diffusion intentions.

De sorte qu'il peut être compris comme des récepteurs par programme enregistré dans l'Application onCreate() aurait le même effet avec ceux déclarés dans AndroidManifest.xml à partir d'Android 3.1 ci-dessus.

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

Il est de bonne pratique de toujours fournir l'autorisation lors de l'enregistrement du récepteur, sinon, vous recevrez pour toute application qui envoie un correspondant de l'intention. Cela peut permettre à des applications malveillantes pour la diffusion de votre récepteur.

Deux choix

1) Si vous voulez lire de Diffusion seulement lorsque l'Activité est visible
ensuite,

registerReceiver(...) dans onStart() et unregisterReceiver(...) dans onStop()

2) Si vous voulez lire de Diffusion, même si l'Activité est en arrière-plan
ensuite,

registerReceiver(...) dans onCreate(...) et unregisterReceiver(...) dans onDestroy()

Bonus:

Si vous êtes paresseux

Si vous ne voulez pas écrire du code réutilisable pour l'enregistrement et l'annulation de l'enregistrement d'un BroadcastReceiver encore et encore chaque Activité, puis,

1. Créer un résumé de l'Activité
2. Écrire du code réutilisable en Activité
3. Laisser la mise en œuvre que les méthodes abstraites

Voici l'extrait de code:

Résumé De L'Activité

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

}

En utilisant cette approche, vous pouvez écrire plus de code réutilisable comme
l'écriture commune, des animations, de la liaison à un service, etc.

Voir le code complet:

ICI