web-dev-qa-db-de.com

Programmgesteuert einen Rundfunkempfänger registrieren

Ich würde gerne wissen, wie ein Sender am besten programmgesteuert registriert wird. Ich möchte bestimmte Empfänger nach Wahl des Benutzers registrieren.

Da die Registrierung über die Manifestdatei erfolgt, frage ich mich, ob es eine geeignete Möglichkeit gibt, dies im Code zu erreichen.

137
CoolStraw

Es klingt so, als ob Sie steuern möchten, ob in Ihrem Manifest veröffentlichte Komponenten aktiv sind, und einen Empfänger nicht dynamisch registrieren (über Context.registerReceiver ()), während er ausgeführt wird.

In diesem Fall können Sie PackageManager.setComponentEnabledSetting () verwenden, um zu steuern, ob diese Komponenten aktiv sind:

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

Wenn Sie nur während der Ausführung eine Sendung empfangen möchten, sollten Sie registerReceiver () verwenden. Eine Empfängerkomponente ist vor allem dann nützlich, wenn Sie sicherstellen möchten, dass Ihre App bei jedem Broadcast-Versand gestartet wird.

63
hackbod

In Ihrer onCreate-Methode können Sie einen Empfänger wie folgt registrieren:

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

Denken Sie daran, dies in der onDestroy-Methode auszuführen:

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

Ein wichtiger Punkt, den die Menschen vergessen zu erwähnen, ist die Lebensdauer des Broadcast Receiver. Der Unterschied der programmgesteuerten Registrierung gegenüber der Registrierung in AndroidManifest.xml ist der Unterschied. In der Manifestdatei hängt es nicht von der Lebensdauer der Anwendung ab. Bei der programmgesteuerten Registrierung hängt es jedoch von der Lebensdauer der Anwendung ab. Das heißt, wenn Sie sich in AndroidManifest.xml registrieren, können Sie die übertragenen Absichten auch dann erfassen, wenn Ihre Anwendung nicht ausgeführt wird.

Edit: Der erwähnte Hinweis ist ab Android 3.1 nicht mehr gültig. Das Android-System schließt standardmäßig alle Empfänger vom Empfangen von Absichten aus, wenn die entsprechende Anwendung noch nie vom Benutzer gestartet wurde oder der Benutzer die Anwendung explizit über die Android-Menü (unter Verwalten → Anwendung). https://developer.Android.com/about/versions/Android-3.1.html

Dies ist eine zusätzliche Sicherheitsfunktion, da der Benutzer sicher sein kann, dass nur die von ihm gestarteten Anwendungen Broadcast-Intents erhalten.

Es kann also verstanden werden, dass Empfänger, die programmatisch in der Anwendung onCreate() registriert sind, die gleiche Wirkung haben wie Empfänger, die in AndroidManifest.xml von Android 3.1 oben deklariert wurden.

66
Krypton

Definieren Sie einen Broadcast-Empfänger an einer beliebigen Stelle in Aktivität/Fragment wie folgt:

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

Definiere IntentFilter in onCreate ()

mIntentFilter=new IntentFilter("action_name");

Registrieren Sie jetzt den BroadcastReciever in onResume () und die Registrierung in onPause [ da Broadcast nicht verwendet wird, wenn die Aktivität angehalten ist]. 

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



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

Für ein detailliertes Tutorial schauen Sie unter broadcast receiver-zwei Möglichkeiten, zu implementieren.

36
SohailAziz
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();
   }
}
4
Sunil Pandey

Es wird empfohlen, bei der Registrierung des Empfängers immer die Erlaubnis zu erteilen, andernfalls erhalten Sie für jede Anwendung, die eine entsprechende Absicht sendet. Dadurch können bösartige Apps auf Ihren Receiver übertragen werden. 

2
ChopperCharles

Entsprechend dem Abhören und Senden von globalen Nachrichten und dem Einstellen von Alarmen in Häufige Aufgaben und Vorgehensweisen in Android :

Wenn die empfangende Klasse nicht .__ ist. registriert mit seiner Manifest können Sie dynamisch einen Empfänger mit .__ registrieren und registrieren. Aufruf von Context.registerReceiver ().

Werfen Sie einen Blick auf registerReceiver (BroadcastReceiver-Empfänger, IntentFilter-Filter) für weitere Informationen.

2
McStretch

für LocalBroadcastManager  

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

und registrieren in onResume 

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

und die Registrierung aufheben onStop

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

und erhalte es ..

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

wo IntentFilter ist

 new IntentFilter("any.action.string")
1
Xar E Ahmer

Einen Rundfunkempfänger erstellen

[BroadcastReceiver (Enabled = true, Exported = false)]

public class BCReceiver : BroadcastReceiver
{

    BCReceiver receiver;

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

Füge aus deiner Aktivität folgenden Code hinzu:

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

Zwei Möglichkeiten

1) Wenn Sie Broadcast nur lesen möchten, wenn die Aktivität sichtbar ist,

registerReceiver(...) in onStart() und unregisterReceiver(...) in onStop()

2) Wenn Sie Broadcast lesen möchten, auch wenn sich die Aktivität im Hintergrund befindet,

registerReceiver(...) in onCreate(...) und unregisterReceiver(...) in onDestroy()

Bonus:

Wenn Sie faul sind

Wenn Sie keinen Code für die Registrierung und Aufhebung der Registrierung eines Broadcast-Empfängers in jeder Aktivität schreiben möchten, gehen Sie folgendermaßen vor:

  1. Erstellen Sie eine abstrakte Aktivität
  2. Schreiben Sie den Kesselschildcode in Aktivität
  3. Belassen Sie die Implementierung als abstrakte Methoden

Hier ist das Code-Snippet:

Abstrakte Aktivität

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

}

Mit diesem Ansatz können Sie mehr Code für Boilerplates schreiben, z. B. allgemeine Animationen schreiben, an einen Dienst binden usw.

Vollständigen Code anzeigen:

HIER

0
Rohit Singh