Android
Uitzending ontvanger

Invoering

Inleiding tot de ontvanger van de uitzending

Een uitzendontvanger is een Android-component waarmee u zich kunt registreren voor systeem- of toepassingsgebeurtenissen.

Een ontvanger kan worden geregistreerd via het bestand AndroidManifest.xml of dynamisch via de methode Context.registerReceiver() .

public class MyReceiver extends BroadcastReceiver {
   @Override
   public void onReceive(Context context, Intent intent) {
      //Your implementation goes here.
   }
}

Hier heb ik een voorbeeld genomen van ACTION_BOOT_COMPLETED die door het systeem wordt ACTION_BOOT_COMPLETED zodra Android het opstartproces heeft voltooid.

U kunt een ontvanger in manifest-bestand als volgt registreren:

<application
   android:icon="@drawable/ic_launcher"
   android:label="@string/app_name"
   android:theme="@style/AppTheme" >
   <receiver android:name="MyReceiver">
      <intent-filter>
         <action android:name="android.intent.action.BOOT_COMPLETED">
         </action>
      </intent-filter>
   </receiver>
</application>

Nu wordt het apparaat opgestart, onReceive() methode onReceive() aangeroepen en kunt u uw werk doen (bijvoorbeeld een service starten, een alarm starten).

Uitzending Basisprincipes

BroadcastReceivers worden gebruikt om de uitzending te ontvangen Intents dat door de Android OS, andere apps, of binnen dezelfde app worden verzonden.

Elke Intent is gemaakt met een Intent filter, dat een String actie vereist. Aanvullende informatie kan worden geconfigureerd in de intentie.

Evenzo registreren BroadcastReceivers zich om Intents te ontvangen met een bepaald Intent-filter. Ze kunnen programmatisch worden geregistreerd:

mContext.registerReceiver(new BroadcastReceiver() {
    @Override
   public void onReceive(Context context, Intent intent) {
      //Your implementation goes here.
   }
}, new IntentFilter("Some Action"));

of in het bestand AndroidManifest.xml :

<receiver android:name=".MyBroadcastReceiver">
    <intent-filter>
        <action android:name="Some Action"/>
    </intent-filter>
</receiver>

Om de intentie te ontvangen, stelt u de actie in op iets gedocumenteerd door Android OS, door een andere app of API, of binnen uw eigen applicatie, met behulp van sendBroadcast :

mContext.sendBroadcast(new Intent("Some Action"));

Bovendien kan de intentie informatie bevatten, zoals tekenreeksen, primitieven en pakketonderdelen , die kunnen worden bekeken in onReceive .

LocalBroadcastManager gebruiken

LocalBroadcastManager wordt gebruikt om Broadcast Intents binnen een toepassing te verzenden, zonder deze bloot te stellen aan ongewenste luisteraars.

Het gebruik van LocalBroadcastManager is efficiënter en veiliger dan het direct gebruiken van context.sendBroadcast() , omdat u zich geen zorgen hoeft te maken over uitzendingen die zijn vervalst door andere toepassingen, die een beveiligingsrisico kunnen vormen.

Hier is een eenvoudig voorbeeld van het verzenden en ontvangen van lokale uitzendingen:

BroadcastReceiver receiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent.getAction().equals("Some Action")) {
            //Do something
        }
    }
});

LocalBroadcastManager manager = LocalBroadcastManager.getInstance(mContext);
manager.registerReceiver(receiver, new IntentFilter("Some Action"));

// onReceive() will be called as a result of this call:
manager.sendBroadcast(new Intent("Some Action"));//See also sendBroadcastSync

//Remember to unregister the receiver when you are done with it:
manager.unregisterReceiver(receiver);

Bluetooth uitzending ontvanger

toestemming toevoegen in uw manifestbestand

<uses-permission android:name="android.permission.BLUETOOTH" />

In uw fragment (of activiteit)

• Voeg de ontvangermethode toe

private BroadcastReceiver mBluetoothStatusChangedReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        final Bundle extras = intent.getExtras();
        final int bluetoothState = extras.getInt(Constants.BUNDLE_BLUETOOTH_STATE);
        switch(bluetoothState) {
            case BluetoothAdapter.STATE_OFF:
                // Bluetooth OFF
                break;
            case BluetoothAdapter.STATE_TURNING_OFF:
                // Turning OFF
                break;
            case BluetoothAdapter.STATE_ON:
                // Bluetooth ON
                break;
            case BluetoothAdapter.STATE_TURNING_ON:
                // Turning ON
                break;
    }
};

Registreer uitzending

• Roep deze methode aan op onResume ()

private void registerBroadcastManager(){
    final LocalBroadcastManager manager = LocalBroadcastManager.getInstance(getActivity());
    manager.registerReceiver(mBluetoothStatusChangedReceiver, new IntentFilter(Constants.BROADCAST_BLUETOOTH_STATE));
}

Uitzending afmelden

• Roep deze methode aan op onPause ()

private void unregisterBroadcastManager(){
    final LocalBroadcastManager manager = LocalBroadcastManager.getInstance(getActivity());
    // Beacon機能用
    manager.unregisterReceiver(mBluetoothStatusChangedReceiver);
}

Een uitzendontvanger programmatisch in- en uitschakelen

Om een BroadcastReceiver of uit te schakelen, hebben we een verwijzing naar de PackageManager en hebben we een ComponentName object nodig met de klasse van de ontvanger die we willen inschakelen / uitschakelen:

ComponentName componentName = new ComponentName(context, MyBroadcastReceiver.class);
PackageManager packageManager = context.getPackageManager();

Nu kunnen we de volgende methode aanroepen om de BroadcastReceiver te schakelen:

packageManager.setComponentEnabledSetting(
    componentName,
    PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
    PackageManager.DONT_KILL_APP);

Of we kunnen in plaats daarvan COMPONENT_ENABLED_STATE_DISABLED gebruiken om de ontvanger uit te schakelen:

packageManager.setComponentEnabledSetting(
    componentName,
    PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
    PackageManager.DONT_KILL_APP);

BroadcastReceiver om BOOT_COMPLETED-gebeurtenissen af te handelen

Het onderstaande voorbeeld laat zien hoe u een BroadcastReceiver die BOOT_COMPLETED evenementen kan ontvangen. Op deze manier kunt u een Service of een Activity starten zodra het apparaat is opgestart.

U kunt ook BOOT_COMPLETED gebeurtenissen gebruiken om uw alarmen te herstellen, omdat ze worden vernietigd wanneer het apparaat wordt uitgeschakeld.

OPMERKING: de gebruiker moet de toepassing minimaal eenmaal hebben gestart voordat u de actie BOOT_COMPLETED kunt ontvangen.

AndroidManifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.test.example" >
    ...
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />

    ...

    <application>
        ...

        <receiver android:name="com.test.example.MyCustomBroadcastReceiver">
        <intent-filter>
                <!-- REGISTER TO RECEIVE BOOT_COMPLETED EVENTS -->
                <action android:name="android.intent.action.BOOT_COMPLETED" />
            </intent-filter>
        </receiver>
    </application>
</manifest>

MyCustomBroadcastReceiver.java

public class MyCustomBroadcastReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();

        if(action != null) {
            if (action.equals(Intent.ACTION_BOOT_COMPLETED) ) {
                // TO-DO: Code to handle BOOT COMPLETED EVENT
                // TO-DO: I can start an service.. display a notification... start an activity
            } 
        }
    }
}

Voorbeeld van een LocalBroadcastManager

Een BroadcastReceiver is in feite een mechanisme om Intents door het besturingssysteem te sturen om specifieke acties uit te voeren. Een klassieke definitie die is

"Een uitzendontvanger is een Android-component waarmee u zich kunt registreren voor systeem- of toepassingsgebeurtenissen."

LocalBroadcastManager is een manier om uitzendingen te verzenden of te ontvangen binnen een applicatieproces. Dit mechanisme heeft veel voordelen

1. aangezien de gegevens binnen het aanvraagproces blijven, kunnen de gegevens niet worden gelekt.
2. LocalBroadcasts worden sneller opgelost, omdat de resolutie van een normale uitzending tijdens runtime gebeurt in het hele besturingssysteem.

Een eenvoudig voorbeeld van een LocalBroastManager is:

SenderActivity

  Intent intent = new Intent("anEvent");
  intent.putExtra("key", "This is an event");
  LocalBroadcastManager.getInstance(this).sendBroadcast(intent);

ReceiverActivity

1. Registreer een ontvanger

LocalBroadcastManager.getInstance(this).registerReceiver(aLBReceiver,
              new IntentFilter("anEvent"));

2. Een concreet object om actie uit te voeren wanneer de ontvanger wordt opgeroepen

private BroadcastReceiver aLBReceiver = new BroadcastReceiver() {
    @Override 
    public void onReceive(Context context, Intent intent) {
        // perform action here.
    } 
};

3. afmelden als de weergave niet meer zichtbaar is.

@Override 
protected void onPause() { 
    // Unregister since the activity is about to be closed. 
    LocalBroadcastManager.getInstance(this).unregisterReceiver(aLBReceiver);
    super.onDestroy(); 
}

Communiceer twee activiteiten via aangepaste uitzendontvanger

U kunt twee activiteiten communiceren zodat activiteit A op de hoogte kan worden gebracht van een gebeurtenis die plaatsvindt in activiteit B.

Activiteit A

final String eventName = "your.package.goes.here.EVENT";

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

@Override
protected void onDestroy() {
    unregisterEventReceiver(eventReceiver);
    super.onDestroy();
}

private void registerEventReceiver() {
    IntentFilter eventFilter = new IntentFilter();
    eventFilter.addAction(eventName);
    registerReceiver(eventReceiver, eventFilter);
}

private BroadcastReceiver eventReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
         //This code will be executed when the broadcast in activity B is launched
    }
};

Activiteit B

final String eventName = "your.package.goes.here.EVENT";

private void launchEvent() {
    Intent eventIntent = new Intent(eventName);
    this.sendBroadcast(eventIntent);
}

Natuurlijk kunt u meer informatie toevoegen aan de uitzending door extra's toe te voegen aan de intentie die wordt doorgegeven tussen de activiteiten. Niet toegevoegd om het voorbeeld zo eenvoudig mogelijk te houden.

Sticky uitzending

Als we de methode sendStickyBroadcast (intentie) gebruiken, is de bijbehorende intentie plakkerig, wat betekent dat de intentie die u verzendt blijft bestaan nadat de uitzending is voltooid. Een StickyBroadcast, zoals de naam al doet vermoeden, is een mechanisme om de gegevens van een uitzending te lezen, nadat de uitzending is voltooid. Dit kan worden gebruikt in een scenario waarin u bijvoorbeeld in de Activity's onCreate() een Activity's onCreate() de waarde van een sleutel in de intentie wilt controleren voordat die activiteit werd gestart.

Intent intent = new Intent("com.org.action");
intent.putExtra("anIntegerKey", 0);
sendStickyBroadcast(intent);

Bestelde uitzendingen gebruiken

Bestelde uitzendingen worden gebruikt wanneer u een prioriteit moet opgeven voor uitgezonden luisteraars.

In dit voorbeeld ontvangt firstReceiver altijd een uitzending eerder dan een secondReceiver :

final int highPriority = 2;
final int lowPriority = 1;
final String action = "action";

// intent filter for first receiver with high priority
final IntentFilter firstFilter = new IntentFilter(action);
first Filter.setPriority(highPriority);
final BroadcastReceiver firstReceiver = new MyReceiver();

// intent filter for second receiver with low priority
final IntentFilter secondFilter = new IntentFilter(action);
secondFilter.setPriority(lowPriority);
final BroadcastReceiver secondReceiver = new MyReceiver();

// register our receivers
context.registerReceiver(firstReceiver, firstFilter);
context.registerReceiver(secondReceiver, secondFilter);

// send ordered broadcast
context.sendOrderedBroadcast(new Intent(action), null);

Verder kan de ontvanger de bestelde uitzending afbreken:

@Override
public void onReceive(final Context context, final Intent intent) {
    abortBroadcast();
}

in dit geval ontvangen alle ontvangers met een lagere prioriteit geen uitzendbericht.

Android is gestopt

Vanaf Android 3.1 worden alle applicaties na installatie gestopt. In de stopstand wordt de toepassing om welke reden dan ook niet uitgevoerd, behalve door een handmatige start van een activiteit of een expliciete intentie die betrekking heeft op een activiteit, service of uitzending.

Wanneer u een systeem-app schrijft die APK's rechtstreeks installeert, moet u er rekening mee houden dat de nieuw geïnstalleerde APP geen uitzendingen ontvangt totdat deze in een niet-gestopt staat wordt verplaatst.

Een eenvoudige manier om een app te activeren, is door een expliciete uitzending naar deze app te verzenden. aangezien de meeste apps INSTALL_REFERRER implementeren, kunnen we het als een haakpunt gebruiken

Scan het manifest van de geïnstalleerde app en verzend een expliciete uitzending naar elke ontvanger:

Intent intent = new Intent();
intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
intent.setComponent(new ComponentName(packageName, fullClassName));
sendBroadcast(intent);