Comment vérifier si le récepteur est enregistré dans Android?

Je dois vérifier si mon récepteur enregistré est toujours enregistré sinon comment puis-je vérifier toutes les méthodes?

214
demandé sur Nikita G. 2010-04-21 14:25:33

16 réponses

Je ne suis pas sûr que L'API fournit directement une API, si vous considérez Ce thread :

Je me demandais la même chose.
Dans mon cas, j'ai une implémentation BroadcastReceiver qui appelle Context#unregisterReceiver(BroadcastReceiver) se passant comme l'arg après avoir manipulé l'intention qu'il reçoit.
Il y a une petite chance que la méthode onReceive(Context, Intent) du récepteur soit appelée plus d'une fois, puisqu'il est enregistré avec plusieurs IntentFilters, créant le potentiel d'un IllegalArgumentException étant lancé à partir de Context#unregisterReceiver(BroadcastReceiver).

Dans mon cas, je peux stocker un membre synchronisé privé à vérifier avant d'appeler Context#unregisterReceiver(BroadcastReceiver), mais ce serait beaucoup plus propre si L'API a fourni une méthode de vérification.

57
répondu VonC 2010-04-21 10:50:59

Il n'y a pas de fonction API pour vérifier si un récepteur est enregistré. La solution consiste à placer votre code dans un bloc try {...} catch(IllegalArgumentException e) {...}.

270
répondu Daniel Velkov 2010-08-25 18:05:46

Solution la plus simple

Dans le récepteur:

public class MyReceiver extends BroadcastReceiver {   
    public boolean isRegistered;

    /**
    * register receiver
    * @param context - Context
    * @param filter - Intent Filter
    * @return see Context.registerReceiver(BroadcastReceiver,IntentFilter)
    */
    public Intent register(Context context, IntentFilter filter) {
        try {
              // ceph3us note:
              // here I propose to create 
              // a isRegistered(Contex) method 
              // as you can register receiver on different context  
              // so you need to match against the same one :) 
              // example  by storing a list of weak references  
              // see LoadedApk.class - receiver dispatcher 
              // its and ArrayMap there for example 
              return !isRegistered 
                     ? context.registerReceiver(this, filter) 
                     : null;
            } finally {
               isRegistered = true;
            }
    }

    /**
     * unregister received
     * @param context - context
     * @return true if was registered else false
     */
     public boolean unregister(Context context) {
         // additional work match on context before unregister
         // eg store weak ref in register then compare in unregister 
         // if match same instance
         return isRegistered 
                    && unregisterInternal(context);
     }

     private boolean unregisterInternal(Context context) {
         context.unregisterReceiver(this); 
         isRegistered = false;
         return true;
     }

    // rest implementation  here 
    // or make this an abstract class as template :)
    ...
}

Dans le code:

MyReceiver myReceiver = new MyReceiver();
myReceiver.registerReceiver(Conext, IntentFilter); // register 
myReceiver.unregister(Context); // unregister 

Modifier I

-- en réponse à

ce n'est vraiment pas élégant parce que vous devez vous rappeler de définir le isRegistered drapeau après vous inscrire. - Rabbin Furtif

--" more ellegant way " méthode ajoutée dans le récepteur pour enregistrer et définir l'indicateur

27
répondu ceph3us 2017-08-09 12:56:27

J'utilise cette solution

public class ReceiverManager {

    private static List<BroadcastReceiver> receivers = new ArrayList<BroadcastReceiver>();  
    private static ReceiverManager ref;
    private Context context;

    private ReceiverManager(Context context){
        this.context = context;
    }

    public static synchronized ReceiverManager init(Context context) {      
        if (ref == null) ref = new ReceiverManager(context);
        return ref;
    }

    public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter intentFilter){
        receivers.add(receiver);
        Intent intent = context.registerReceiver(receiver, intentFilter);
        Log.i(getClass().getSimpleName(), "registered receiver: "+receiver+"  with filter: "+intentFilter);
        Log.i(getClass().getSimpleName(), "receiver Intent: "+intent);
        return intent;
    }

    public boolean isReceiverRegistered(BroadcastReceiver receiver){
        boolean registered = receivers.contains(receiver);
        Log.i(getClass().getSimpleName(), "is receiver "+receiver+" registered? "+registered);
        return registered;
    }

    public void unregisterReceiver(BroadcastReceiver receiver){
        if (isReceiverRegistered(receiver)){
            receivers.remove(receiver);
            context.unregisterReceiver(receiver);
            Log.i(getClass().getSimpleName(), "unregistered receiver: "+receiver);
        }
    }
}
26
répondu slinden77 2016-10-18 13:08:40

, Vous avez plusieurs options

  1. Vous pouvez mettre un drapeau dans votre classe ou de l'activité. Mettez une variable booléenne dans votre classe et regardez cet indicateur pour savoir si vous avez le récepteur enregistré.

  2. Créez une classe qui étend le récepteur et là vous pouvez utiliser:

    1. Le modèle Singleton n'a qu'une seule instance de cette classe dans votre projet.

    2. Implémentez les méthodes pour savoir si le récepteur est inscrire.

22
répondu chemalarrea 2012-02-14 20:14:41

, Vous devez utiliser try/catch:

try {
    if (receiver!=null) {
        Activity.this.unregisterReceiver(receiver);
    }
} catch (IllegalArgumentException e) {
    e.printStackTrace();
}
7
répondu Mohsen mokhtari 2017-06-07 07:00:25

Si vous mettez ceci sur la méthode onDestroy ou onStop. Je pense que lorsque l'activité a été créée à nouveau, le MessageReciver n'était pas créé.

@Override 
public void onDestroy (){
    super.onDestroy();
LocalBroadcastManager.getInstance(context).unregisterReceiver(mMessageReceiver);

}
5
répondu eloirobe 2013-06-06 18:28:58

, Vous pouvez le faire facilement....

1) crée une variable booléenne ...

private boolean bolBroacastRegistred;

2) lorsque vous enregistrez votre récepteur de diffusion, réglez-le sur TRUE

...
bolBroacastRegistred = true;
this.registerReceiver(mReceiver, new IntentFilter(BluetoothDevice.ACTION_FOUND));
....

3) dans onPause() faites-le...

if (bolBroacastRegistred) {
    this.unregisterReceiver(mReceiver);
    bolBroacastRegistred = false
}

Juste, et maintenant, vous ne recevrez plus de message d'erreur d'exception sur onPause ().

Tip1: toujours utiliser le unregisterReceiver () dans onPause () pas dans onDestroy() Tip2: N'oubliez pas de définir la variable bolBroadcastRegistred sur FALSE lors de l'exécution du unregisterReceive ()

Succès!

5
répondu Biruel Rick 2014-11-16 13:56:58

J'ai utilisé Intent pour informer Broadcast Receiver de L'instance du Gestionnaire du thread d'activité principale et utilisé Message pour transmettre un message à l'activité principale

J'ai utilisé un tel mécanisme pour vérifier si Broadcast Receiver est déjà enregistré ou non. Parfois, il est nécessaire lorsque vous enregistrez votre récepteur de diffusion dynamiquement et ne veulent pas le faire deux fois ou vous présentez à l'utilisateur si le récepteur de diffusion est en cours d'exécution.

Activité Principale:

public class Example extends Activity {

private BroadCastReceiver_example br_exemple;

final Messenger mMessenger = new Messenger(new IncomingHandler());

private boolean running = false;

static class IncomingHandler extends Handler {
    @Override
    public void handleMessage(Message msg) {
        running = false;    
        switch (msg.what) {
        case BroadCastReceiver_example.ALIVE:
    running = true;
            ....
            break;
        default:

            super.handleMessage(msg);
        }

    }
    }

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

    IntentFilter filter = new IntentFilter();
        filter.addAction("pl.example.CHECK_RECEIVER");

        br_exemple = new BroadCastReceiver_example();
        getApplicationContext().registerReceiver(br_exemple , filter); //register the Receiver
    }

// call it whenever you want to check if Broadcast Receiver is running.

private void check_broadcastRunning() {    
        /**
        * checkBroadcastHandler - the handler will start runnable which will check if Broadcast Receiver is running
        */
        Handler checkBroadcastHandler = null;

        /**
        * checkBroadcastRunnable - the runnable which will check if Broadcast Receiver is running
        */
        Runnable checkBroadcastRunnable = null;

        Intent checkBroadCastState = new Intent();
        checkBroadCastState .setAction("pl.example.CHECK_RECEIVER");
        checkBroadCastState .putExtra("mainView", mMessenger);
        this.sendBroadcast(checkBroadCastState );
        Log.d(TAG,"check if broadcast is running");

        checkBroadcastHandler = new Handler();
        checkBroadcastRunnable = new Runnable(){    

            public void run(){
                if (running == true) {
                    Log.d(TAG,"broadcast is running");
                }
                else {
                    Log.d(TAG,"broadcast is not running");
                }
            }
        };
        checkBroadcastHandler.postDelayed(checkBroadcastRunnable,100);
        return;
    }

.............
}

Récepteur De Diffusion:

public class BroadCastReceiver_example extends BroadcastReceiver {


public static final int ALIVE = 1;
@Override
public void onReceive(Context context, Intent intent) {
    // TODO Auto-generated method stub
    Bundle extras = intent.getExtras();
    String action = intent.getAction();
    if (action.equals("pl.example.CHECK_RECEIVER")) {
        Log.d(TAG, "Received broadcast live checker");
        Messenger mainAppMessanger = (Messenger) extras.get("mainView");
        try {
            mainAppMessanger.send(Message.obtain(null, ALIVE));
        } catch (RemoteException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    .........

}

}
3
répondu jarek 2013-10-13 18:49:35

Personnellement, j'utilise la méthode d'appeler unregisterReceiver et d'avaler l'exception si elle est levée. Je suis d'accord que c'est moche mais la meilleure méthode actuellement fournie.

J'ai soulevé une demande de fonctionnalité pour obtenir une méthode booléenne pour vérifier si un récepteur est enregistré ajouté à L'API Android. Veuillez le soutenir ici si vous voulez le voir ajouté: https://code.google.com/p/android/issues/detail?id=73718

2
répondu ojf 2014-07-17 13:35:41

Je mets ce code dans mon activité parente

Liste registeredReceivers = new ArrayList();

@Override
public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
    registeredReceivers.add(System.identityHashCode(receiver));
    return super.registerReceiver(receiver, filter);
}

@Override
public void unregisterReceiver(BroadcastReceiver receiver) {
    if(registeredReceivers.contains(System.identityHashCode(receiver)))
    super.unregisterReceiver(receiver);
}
1
répondu darkwater84 2017-08-31 00:54:07

Voici ce que j'ai fait pour vérifier si le diffuseur est déjà enregistré, même si vous fermez votre application (finish ())

Firstime exécutant votre application, envoyez d'abord une diffusion, il retournera true/false dépend si votre diffuseur fonctionne toujours ou non.

Mon Diffuseur

public class NotificationReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        if(intent.getExtras() != null && intent.getStringExtra("test") != null){
            Log.d("onReceive","test");
            return;
        }
    }
}

MA MainActivity

// init Broadcaster
private NotificationReceiver nr = new NotificationReceiver();


Intent msgrcv = new Intent("Msg");
msgrcv.putExtra("test", "testing");
boolean isRegistered = LocalBroadcastManager.getInstance(this).sendBroadcast(msgrcv);

if(!isRegistered){
    Toast.makeText(this,"Starting Notification Receiver...",Toast.LENGTH_LONG).show();
    LocalBroadcastManager.getInstance(this).registerReceiver(nr,new IntentFilter("Msg"));
}
0
répondu user6558470 2016-07-07 00:24:31

C'est comme ça que je l'ai fait, c'est une version modifiée de la réponse donnée par ceph3us et éditée par slinden77 (entre autres choses j'ai supprimé les valeurs de retour des méthodes dont je n'avais pas besoin):

public class MyBroadcastReceiver extends BroadcastReceiver{
    private boolean isRegistered; 

    public void register(final Context context) {
        if (!isRegistered){
            Log.d(this.toString(), " going to register this broadcast receiver");
            context.registerReceiver(this, new IntentFilter("MY_ACTION"));
            isRegistered = true;
        }
    }
    public void unregister(final Context context) {
        if (isRegistered) {            
            Log.d(this.toString(), " going to unregister this broadcast receiver");
            context.unregisterReceiver(this);
            isRegistered = false;
        }
    }
    @Override
    public void onReceive(final Context context, final Intent intent) {        
        switch (getResultCode()){
        //DO STUFF
        }        
    }        
}

Puis sur une classe D'activité:

public class MyFragmentActivity extends SingleFragmentActivity{
    MyBroadcastReceiver myBroadcastReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        registerBroacastReceiver();       
    }

    @Override
    protected Fragment createFragment(){
        return new MyFragment();
    }

    //This method is called by the fragment which is started by this activity, 
    //when the Fragment is done, we also register the receiver here (if required)
    @Override
    public void receiveDataFromFragment(MyData data) {
        registerBroacastReceiver();
        //Do some stuff                
    }

    @Override
    protected void onStop(){        
        unregisterBroacastReceiver();
        super.onStop();
    }

    void registerBroacastReceiver(){
        if (myBroadcastReceiver == null)
            myBroadcastReceiver = new MyBroadcastReceiver();
        myBroadcastReceiver.register(this.getApplicationContext());
    }

    void unregisterReceiver(){
        if (MyBroadcastReceiver != null)
            myBroadcastReceiver.unregister(this.getApplicationContext());
    }
}
0
répondu Víctor Gil 2016-12-18 14:23:36

Je reçois votre problème, j'ai fait face au même problème dans mon Application. J'appelais registerReceiver () plusieurs fois dans l'application.

Une solution simple à ce problème consiste à appeler registerReceiver() dans votre classe D'Application personnalisée. Cela garantira que votre récepteur de diffusion ne sera appelé qu'un seul dans l'ensemble du cycle de vie de votre Application.

public class YourApplication extends Application
{
    @Override
    public void onCreate()
    {
        super.onCreate();

        //register your Broadcast receiver here
        IntentFilter intentFilter = new IntentFilter("MANUAL_BROADCAST_RECIEVER");
        registerReceiver(new BroadcastReciever(), intentFilter);

    }
}
0
répondu Sameer Ranjan 2018-03-21 05:00:23
if( receiver.isOrderedBroadcast() ){
     // receiver object is registered
}
else{
     // receiver object is not registered
}
-3
répondu Kamta Sahu 2017-06-01 07:52:06

Vérifiez simplement NullPointerException. Si le récepteur n'existe pas, alors...

try{
    Intent i = new Intent();
    i.setAction("ir.sss.smsREC");
    context.sendBroadcast(i);
    Log.i("...","broadcast sent");
}
catch (NullPointerException e)
{
    e.getMessage();
}
-7
répondu Kasra 2014-06-25 07:59:40