如何检查接收器是否在Android中注册？ 我需要检查我的注册接收方是否仍然注册，如果不是我怎么检查它的任何方法？< p>我不确定API是否直接提供了一个API，如果你考虑：

我也在想同样的事情。
在我的例子中，我有一个调用

Context#unregisterReceiver（BroadcastReceiver）

在处理接收到的意图后将自身作为参数传递。
调用接收方的

onReceive（上下文、意图）

方法的可能性很小 不止一次，因为它已向多个

IntentFilters

注册，因此可能会从

上下文中抛出
IllegalArgumentException
#unregisterReceiver（BroadcastReceiver）

在我的例子中，我可以在调用

上下文#unregisterReceiver（BroadcastReceiver）

之前存储一个私有同步成员以进行检查，但它将是 如果API提供了一种检查方法，那么就更干净了

---

没有API函数来检查接收器是否已注册。解决方法是将代码放入

try catch块中，如下所示。

try {

 //Register or UnRegister your broadcast receiver here

} catch(IllegalArgumentException e) {

    e.printStackTrace();
}

---

你有几个选择

您可以在类或活动中添加标志。在类中放入一个布尔变量，并查看此标志，以了解是否已注册接收器

创建一个扩展接收器的类，您可以在其中使用：

的Singleton模式在项目中只有一个此类实例

实现了解接收器是否已注册的方法

---

我正在使用这个解决方案

公共类接收方管理器{
私人弱引用；
私有静态列表接收器=新的ArrayList（）；
私人静态接收人管理人参考；
私人破产管理人（上下文）{
引用=新的WeakReference（上下文）；
}
公共静态同步ReceiverManager初始化（上下文）{
如果（ref==null）ref=new ReceiverManager（上下文）；
返回ref；
}
公共意图寄存器接收器（广播接收器接收器、意图过滤器、意图过滤器）{
接收者。添加（接收者）；
Intent Intent=creefence.get（）.registerReceiver（接收方，intentFilter）；
Log.i（getClass（）.getSimpleName（），“注册接收者：”+receiver+”，带筛选器：“+intentFilter”）；
Log.i（getClass（）.getSimpleName（），“接收方意图：”+Intent）；
返回意图；
}
公共布尔值isReceiverRegistered（广播接收器）{
布尔注册=接收器。包含（接收器）；
Log.i（getClass（）.getSimpleName（），“是否为接收器”+接收器+“已注册？”+已注册）；
注册报税表；
}
公共无效注销接收器（广播接收器）{
if（isReceiverRegistered（接收方））{
接收器。移除（接收器）；
crereference.get（）.unregisterReceiver（接收器）；
Log.i（getClass（）.getSimpleName（），“未注册的接收方：”+接收方）；
}
}
}

如果将其置于onDestroy或onStop方法中。我认为当再次创建活动时，没有创建MessageReceiver

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

}

---

我使用意图让广播接收器知道主活动线程的处理程序实例，并使用消息将消息传递给主活动

我已经使用这种机制来检查广播接收器是否已经注册。有时，当您动态注册广播接收器且不想重复注册两次或在广播接收器正在运行时向用户演示时，需要使用该选项

主要活动：

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

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

广播接收机：

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

}

}

---

只需检查NullPointerException。如果接收器不存在，则

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

---

就我个人而言，我使用调用unregisterReceiver并在抛出异常时吞咽异常的方法。我同意这是丑陋的，但这是目前提供的最好的方法

我提出了一个功能请求，以获取一个布尔方法来检查是否已将接收器注册添加到Android API中。如果您希望看到它被添加，请在此支持它：

你可以很容易地做到

1） 创建一个布尔变量

private boolean bolBroacastRegistred;

2） 注册广播接收器时，将其设置为TRUE

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

3） 在onPause（）中，执行以下操作

现在，您将不会在onPause（）上收到更多异常错误消息

提示1：始终在onPause（）中使用unregisterReceiver（），而不是在onDestroy（）中使用 提示2：运行unregisterReceive（）时，不要忘记将BolBroadcastRegistered变量设置为FALSE

成功

最简单的解决方案 在接收器中： 代码： 广告1

--答复：

---

这真的不是很优雅，因为你必须记住设置 注册后的isRegistered标志秘密教士

--“更优雅的方式”在接收器中添加了注册和设置标志的方法

---

如果您重新启动设备或您的应用程序被 OS.-阿明6小时前

---

@amin-请参阅代码内（不是通过清单条目注册的系统）注册接收者的生存期：）

以下是我检查广播者是否已注册的步骤，即使您关闭了应用程序（finish（））

第一次运行应用程序时，首先发送广播。它将返回true/false，这取决于广播者是否仍在运行

我的播音员

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

我的主要活动

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

---

我就是这样做的，它是ceph3us给出的答案的修改版本，由slinden77编辑（除其他外，我删除了我不需要的方法的返回值）：

然后在活动课上：

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

---

您必须使用try/catch：

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

---

我将此代码放在我的父活动中

List registeredReceivers=new ArrayList（）

---

我明白你的问题，我在申请中也遇到了同样的问题。我在应用程序中多次调用registerReceiver（）

t的一个简单解法

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

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

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

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

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

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

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

    }
}

@Provides
@YourScope
fun providesReceiver(): NotificationReceiver{
    return NotificationReceiver()
}

if (receiver.isOrderedBroadcast()) {
   requireContext().unregisterReceiver(receiver);
}