start - ¿Cómo comprobar si Receiver está registrado en Android?

sendbroadcast android example

Question

Necesito verificar si mi receptor registrado todavía está registrado, de lo contrario, ¿cómo puedo verificarlo por algún método?

Answer 1

la solución más simple

en el receptor:

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 :)
    ...
}

en codigo:

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

editar yo

-- en respuesta a

Esto realmente no es tan elegante porque debe recordar establecer la marca isRegistered después de registrarse. - rabino sigiloso

- Se agregó un método "de manera más inteligente" en el receptor para registrar y establecer la bandera.

Answer 2

Así es como lo he hecho, es una versión modificada de la respuesta dada por ceph3us y editada por slinden77 (entre otras cosas, he eliminado los valores de retorno de los métodos que no necesitaba):

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

Luego en una clase de actividad:

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

Answer 3

Esto es lo que hice para comprobar si la emisora ​​ya está registrada, incluso si cierra la aplicación (finalizar ())

La primera vez que ejecute su aplicación, envíe primero una transmisión; devolverá verdadero / falso dependiendo de si su emisora ​​sigue funcionando o no.

Mi locutor

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

Mi actividad principal

// 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"));
}

Answer 4

Estoy usando esta solución

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

Answer 5

No estoy seguro de que la API proporcione directamente una API, si considera este hilo :

Me preguntaba lo mismo.
En mi caso, tengo una implementación de BroadcastReceiver que llama a Context#unregisterReceiver(BroadcastReceiver) pasa a sí misma como argumento después de manejar la intención que recibe.
Existe una pequeña posibilidad de que el onReceive(Context, Intent) del receptor se llame más de una vez, ya que se registra con varios IntentFilters , creando el potencial para que se IllegalArgumentException una IllegalArgumentException desde Context#unregisterReceiver(BroadcastReceiver) .

En mi caso, puedo almacenar un miembro sincronizado privado para verificar antes de llamar a Context#unregisterReceiver(BroadcastReceiver) , pero sería mucho más limpio si la API proporcionara un método de verificación.

Answer 6

No hay una función API para verificar si un receptor está registrado. La solución es poner su código en un bloque try {...} catch(IllegalArgumentException e) {...} .

Answer 7

Personalmente, uso el método de llamar a unregisterReceiver y tragar la excepción si se lanza. Estoy de acuerdo en que esto es feo, pero el mejor método actualmente proporcionado.

He generado una solicitud de función para obtener un método booleano para verificar si un receptor está registrado y agregado a la API de Android. Pruébelo aquí si desea verlo agregado: code.google.com/p/android/issues/detail?id=73718

Answer 8

Pongo este código en mi actividad principal

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

Answer 9

Puedes hacerlo fácil ...

1) crear una variable booleana ...

private boolean bolBroacastRegistred;

2) Cuando registre su Broadcast Receiver, ajústelo a TRUE

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

3) En el onPause () hazlo ...

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

Solo eso, y ahora, no recibirá más mensajes de error de excepción en onPause ().

Consejo1: siempre use unregisterReceiver () en onPause () no en onDestroy () Consejo2: No olvide configurar la variable bolBroadcastRegistred en FALSE cuando ejecute el unregisterReceive ()

¡Éxito!

Answer 10

Si pones esto en el método onDestroy o onStop. Creo que cuando la actividad se ha creado de nuevo, el MessageReciver no se estaba creando.

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

}

Answer 11

Simplemente compruebe NullPointerException. Si el receptor no existe, entonces ...

try{
    Intent i = new Intent();
    i.setAction("ir.sss.smsREC");
    context.sendBroadcast(i);
    Log.i("...","broadcast sent");
}
catch (NullPointerException e)
{
    e.getMessage();
}

Answer 12

Tengo su problema, me enfrenté al mismo problema en mi aplicación. Estaba llamando a registerReceiver () varias veces dentro de la aplicación.

Una solución simple para este problema es llamar a registerReceiver () en su clase de aplicación personalizada. Esto asegurará que su receptor de Broadcast sea llamado solo uno en todo su ciclo de vida de la Aplicación.

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

    }
}

Answer 13

Tienes que usar try / catch:

try {
    if (receiver!=null) {
        Activity.this.unregisterReceiver(receiver);
    }
} catch (IllegalArgumentException e) {
    e.printStackTrace();
}

Answer 14

Tienes varias opciones

1. Puedes poner una bandera en tu clase o actividad. Coloque una variable booleana en su clase y mire esta bandera para saber si tiene el Receptor registrado.

2. Cree una clase que extienda el Receptor y allí puede usar:

   1. El patrón Singleton solo tiene una instancia de esta clase en su proyecto.

   2. Implementar los métodos para saber si el Receptor está registrado.

Answer 15

Utilicé Intención para informar a Broadcast Receiver sobre la instancia de Handler del hilo de actividad principal y utilicé Message para pasar un mensaje a main activity

He utilizado dicho mecanismo para comprobar si Broadcast Receiver ya está registrado o no. A veces es necesario cuando registra dinámicamente su Broadcast Receiver y no quiere hacerlo dos veces o se lo presenta al usuario si Broadcast Receiver se está ejecutando.

Actividad principal:

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

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

Receptor de radiodifusión:

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

}

}

Answer 16

if( receiver.isOrderedBroadcast() ){
     // receiver object is registered
}
else{
     // receiver object is not registered
}