प्रोग्रामेटिक रूप से एक प्रसारण रिसीवर पंजीकृत करें

Question

मैं यह जानना चाहूंगा कि प्रोग्राम रिसीवर को प्रोग्रामेटिक रूप से पंजीकृत करने का सबसे अच्छा अभ्यास / तरीका क्या है। मैं उपयोगकर्ता की पसंद के अनुसार विशिष्ट रिसीवर पंजीकृत करना चाहता हूं।

जैसा कि पंजीकरण मैनिफ़ेस्ट फ़ाइल के माध्यम से किया जाता है, मैं सोच रहा था कि क्या कोड में इसे प्राप्त करने का एक उचित तरीका है।

Comments

कोडरज़ैपियन ब्रॉडकास्ट रिसीवर अब तक का सबसे अच्छा विस्तृत ट्यूटोरियल

— karanatwal.github.io

कृपया इस लिंक को देखें stackoverflow.com/questions/15698790/…

Answer 1

ऐसा लगता है कि आप नियंत्रित करना चाहते हैं कि क्या आपके प्रकटन में प्रकाशित घटक सक्रिय हैं, न कि गतिशील रूप से एक रिसीवर पंजीकृत करें (चलते समय Context.registerReceiver ())।

यदि ऐसा है, तो आप इन घटकों के सक्रिय होने के नियंत्रण के लिए PackageManager.setComponentEnabledSetting () का उपयोग कर सकते हैं:

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

ध्यान दें कि यदि आप दौड़ते समय केवल एक प्रसारण प्राप्त करने में रुचि रखते हैं, तो रजिस्टरराइवर () का उपयोग करना बेहतर है। एक रिसीवर घटक मुख्य रूप से तब उपयोगी होता है जब आपको यह सुनिश्चित करने की आवश्यकता होती है कि प्रसारण भेजे जाने के बाद आपका ऐप हर बार लॉन्च हो।

Comments

चतुर ! आपने मुझे सीधा कर दिया। बहुत बहुत धन्यवाद

— CoolStraw

एक अच्छा - आपको पता नहीं था कि आप ऐसा कर सकते हैं :)

— क्रिस नोल्डस

यह इसी तरह के stackoverflow.com/questions/24140894/…

— अंकित श्रीवास्तव

@hackbod कस्टम रिसीवर में मेटा-डेटा टैग कैसे जोड़ सकता है? आपकों कुछ इल्म है !! मुझे मेटा-डेटा टैग जोड़ने की आवश्यकता है जिसका उपयोग हम androidmanifest.xml में करते हैं।

— ज़ला जनकसिंह

अब तक का सर्वश्रेष्ठ ट्यूटोरियल कोडरज़पासियन.com/implement - broadcastreceiver - android और सरल भाषा में

— जगजीत सिंह

Answer 2

अपनी onCreateविधि में आप इस तरह से एक रिसीवर पंजीकृत कर सकते हैं:

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

इसे onDestroyविधि में चलाने के लिए याद रखें :

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

Comments

धन्यवाद, यह बहुत अच्छा काम किया। प्रसारण भेजने के लिए मैंने कोड इरादे i = नए इरादे ("SOME_ACTION") का उपयोग किया; sendBroadcast (i);

— बेन क्लेटन

फिर से शुरू और शुरू में क्यों नहीं?

— सैयद रज़ा मेंहदी

यदि मैं प्रसारण रिसीवर को अनरजिस्टर्ड नहीं करता तो क्या होता? क्या यह रिबूट के बाद भी पंजीकृत रिसीवर को छोड़ देगा?

— जयदेव

इसकी गारंटी नहीं है कि onDestroy()इसे कहा जाएगा, इस प्रकार एक संभावित मेमोरी लीक हो सकती है। यह रजिस्टर करने के लिए / अपंजीकृत में बेहतर है onStart()/ onStop()।

— नेरिया नाचम

क्या इसका यह मतलब है कि मुझे ब्रॉडकास्ट रिसीवर क्लास नहीं बनाना है? मैं बस अपने सभी onReceive () कोड यहां डाल सकता हूं और यह काम करेगा?

— तसलीम ओसेनी

Answer 3

एक महत्वपूर्ण बिंदु जो लोग उल्लेख करना भूल जाते हैं वह है जीवन का समय Broadcast Receiver। AndroidManifest.xml में रजिस्टर करने से प्रोग्रामेटिक रूप से इसे रजिस्टर करने का अंतर यह है। मैनिफ़ेस्ट फ़ाइल में, यह अनुप्रयोग जीवन समय पर निर्भर नहीं करता है। जबकि प्रोग्रामेटिक रूप से इसे रजिस्टर करते समय यह एप्लीकेशन लाइफ टाइम पर निर्भर करता है। इसका मतलब यह है कि यदि आप AndroidManifest.xml में पंजीकरण करते हैं, तो आप प्रसारण इंटेंट को तब भी पकड़ सकते हैं, जब आपका आवेदन नहीं चल रहा हो।

संपादित करें: उल्लिखित नोट अब एंड्रॉइड 3.1 के रूप में सही नहीं है, एंड्रॉइड सिस्टम डिफ़ॉल्ट रूप से उपयोगकर्ता द्वारा कभी भी आवेदन शुरू नहीं किया गया है या अगर उपयोगकर्ता ने एंड्रॉइड मेनू के माध्यम से एप्लिकेशन को स्पष्ट रूप से रोक दिया है, तो डिफ़ॉल्ट रूप से सभी रिसीवर को डिफ़ॉल्ट रूप से प्राप्त करने से बाहर रखा गया है। प्रबंधित → आवेदन)। https://developer.android.com/about/versions/android-3.1.html

यह एक अतिरिक्त सुरक्षा सुविधा है क्योंकि उपयोगकर्ता यह सुनिश्चित कर सकता है कि केवल उसके द्वारा शुरू किए गए एप्लिकेशन प्रसारण प्रसारण प्राप्त करेंगे।

इसलिए इसे एप्लिकेशन में प्रोग्रामेटिक रूप से पंजीकृत रिसीवर्स के रूप में समझा जा सकता है और ऊपर दिए गए एंड्रॉइड 3.1 से AndroidManifest.xmlonCreate() में घोषित किए गए लोगों के साथ समान प्रभाव होगा ।

Comments

यह एक अच्छा नोट है। मैं वास्तव में एक ऐसी किताब देख रहा हूं जिसे मैं एंड्रॉइड के बारे में पढ़ रहा हूं और सोच रहा हूं कि प्रसारण को लागू करने के दोनों तरीके क्यों किए गए हैं। यह मुझे लगता है कि यह पिछड़ेपन के अनुकूलता के लिए है। लेकिन मुझे यकीन नहीं है।

— नियॉन वारगे

ठीक है, क्या तुम सच में बात है कि संपादित सच है? मेरा मतलब आखिरी वाक्य है। एंड्रॉइड आपके एप्लिकेशन को किसी भी समय मारने की संभावना है, जिसके परिणामस्वरूप आपके प्रोग्राम पंजीकृत रिसीवर अब और काम नहीं करेंगे, लेकिन पंजीकृत मेनिफ़ेस्ट अभी भी काम करेगा।

— जैकसोफ़ 1

Answer 4

गतिविधि / खंड में कहीं भी एक प्रसारण रिसीवर को परिभाषित करें:

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

में IntentFilter को परिभाषित करें onCreate()

mIntentFilter=new IntentFilter("action_name");

अब ब्रॉडकास्टइवर को इसमें पंजीकृत करें onResume()और इसे अनरजिस्टर्ड करें onPause()[क्योंकि गतिविधि रुकी हुई है तो प्रसारण का कोई उपयोग नहीं है]।

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

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

डिटेल ट्यूटोरियल के लिए, ब्रॉडकास्ट रिसीवर के दो तरीकों पर नजर डालिए ।

Comments

अब तक का सबसे अच्छा उदाहरण! धन्यवाद!

— आयुष गोयल

@SohailAziz लिंक एक अच्छा जवाब प्रदान करता है। क्या आप अपने उत्तर में लिंक का संदर्भ रख सकते हैं, ताकि यदि लिंक नीचे जाए, तो आपका उत्तर प्रासंगिक बना रहे?

— रात्रि

मेरे व्यक्तिगत विचारों में, प्रसारण को पहले और onPause में पंजीकृत किया जाना चाहिए जैसा कि आपने सुझाव दिया था, लेकिन कुछ लोगों का कहना है कि यह ऑनक्रिएट और ऑनडेस्ट्रॉय पर होना चाहिए, क्या आप दोनों के लिए पेशेवरों और विपक्षों को समझा सकते हैं?

— सैयद रज़ा मेंहदी

@SyedRazaMehdi अगर प्रसारण को यूआई को अद्यतन करने के लिए उपयोग किया जाता है [जो कि ज्यादातर मामलों में है] आपको इसे onResume में पंजीकृत करना चाहिए और ऑनपिन में अपंजीकृत करना चाहिए क्योंकि प्रसारण अन्यथा बेकार हो जाएगा।

— सोहेलअज़ीज़

धन्यवाद। यह सबसे अच्छा जवाब है।

— Saeid Z

Answer 5

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

Comments

क्या आप ओपी को समझा सकते हैं कि यह सबसे अच्छा अभ्यास क्यों है?

— मार्टिन प्रिक्रील

वे समझाते नहीं हैं, "वे" हमेशा कोड पोस्ट करते हैं, क्योंकि इसके बारे में आप बेहतर जानते हैं। -सर्मास

— नियॉन

Answer 6

ग्लोबल मैसेजेस सुनने और प्रसारित करने के लिए, और सामान्य कार्यों में अलार्म सेट करना और एंड्रॉइड में उन्हें कैसे करना है :

यदि प्राप्त करने वाले वर्ग को इसके प्रकट होने का उपयोग करके पंजीकृत नहीं किया गया है, तो आप Context.registerReceiver () को कॉल करके एक रिसीवर को गतिशील रूप से तत्काल और पंजीकृत कर सकते हैं ।

अधिक जानकारी के लिए registerReceiver (ब्रॉडकास्टसीवर रिसीवर, इंटेंटफिल्टर फिल्टर) पर एक नज़र डालें ।

Comments

मैं बुला की कोशिश की context.registerReceiverलेकिन इसके आप इस प्रश्न पर नज़र कृपया कर सकते बुलाया हो रही नहीं stackoverflow.com/questions/13238600/...

— हंट

Answer 7

रिसीवर को पंजीकृत करते समय हमेशा अनुमति की आपूर्ति करना सबसे अच्छा अभ्यास है, अन्यथा आप किसी भी आवेदन के लिए प्राप्त करेंगे जो मेल खाने वाले इरादे को भेजता है। इससे दुर्भावनापूर्ण ऐप आपके रिसीवर को प्रसारित कर सकते हैं।

Answer 8

के लिए LocalBroadcastManager

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

और में रजिस्टर करें onResume

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

और इसे अनरजिस्टर्ड करें onStop

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

और इसे पुनः प्राप्त करें ..

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

जहां IntentFilter है

 new IntentFilter("any.action.string")

Answer 9

दो विकल्प

1) यदि आप केवल तभी पढ़ना चाहते हैं जब गतिविधि दिखाई दे, तब,

registerReceiver(...में) onStart()और unregisterReceiver(...)मेंonStop()

2) अगर आप बैकग्राउंड में एक्टिविटी है तो भी ब्रॉडकास्ट पढ़ना चाहते हैं,

registerReceiver(...)में onCreate(...)और unregisterReceiver(...)मेंonDestroy()

बक्शीश:

यदि आप आलसी हैं

यदि आप प्रत्येक गतिविधि में बार-बार ब्रॉडकास्टर को रजिस्टर करने और अपंजीकृत करने के लिए बॉयलरप्लेट कोड नहीं लिखना चाहते हैं, तो

1. एक अमूर्त गतिविधि बनाएँ
2. गतिविधि में बॉयलरप्लेट कोड लिखें
3. अमूर्त विधियों के रूप में कार्यान्वयन को छोड़ दें

यहाँ कोड स्निपेट है:

सार गतिविधि

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

}

इस दृष्टिकोण का उपयोग करके आप अधिक बॉयलरप्लेट कोड लिख सकते हैं जैसे सामान्य एनिमेशन लिखना, किसी सेवा के लिए बाध्य करना, आदि।

देखें पूरा कोड:

यहाँ

Answer 10

एक प्रसारण रिसीवर बनाएँ

[प्रसारणकर्ता (सक्षम = सत्य, निर्यातित = गलत)]

public class BCReceiver : BroadcastReceiver
{

    BCReceiver receiver;

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

अपनी गतिविधि से इस कोड को जोड़ें:

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