Android
Odbiornik transmisji

Wprowadzenie

Wprowadzenie do odbiornika rozgłoszeniowego

Odbiornik rozgłoszeniowy to komponent systemu Android, który umożliwia rejestrację zdarzeń systemowych lub aplikacji.

Odbiornik można zarejestrować za pomocą pliku AndroidManifest.xml lub dynamicznie za pomocą metody Context.registerReceiver() .

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

Tutaj wziąłem przykład ACTION_BOOT_COMPLETED który jest uruchamiany przez system po zakończeniu rozruchu systemu Android.

Możesz zarejestrować odbiornik w pliku manifestu w następujący sposób:

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

Teraz urządzenie zostanie uruchomione, zostanie onReceive() metoda onReceive() a następnie będziesz mógł wykonać swoją pracę (np. Uruchomić usługę, uruchomić alarm).

Podstawy BroadcastReceiver

Odbiorniki transmisji są używane do odbierania zamiarów transmisji wysyłanych przez system operacyjny Android, inne aplikacje lub w ramach tej samej aplikacji.

Każda intencja jest tworzona za pomocą filtru intencji , który wymaga akcji ciągu . Dodatkowe informacje można skonfigurować w celu.

Podobnie, BroadcastReceivers rejestruje się, aby otrzymywać Intencje z określonym Filtrem Intencji. Można je zarejestrować programowo:

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

lub w pliku AndroidManifest.xml :

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

Aby otrzymać zamiar, ustaw akcję na coś udokumentowanego przez system operacyjny Android, inną aplikację lub interfejs API lub we własnej aplikacji, używając sendBroadcast :

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

Ponadto zamiar może zawierać informacje, takie jak ciągi, prymitywy i paczki , które można wyświetlać w onReceive .

Korzystanie z LocalBroadcastManager

LocalBroadcastManager służy do wysyłania Broadcast intencjami w aplikacji, bez narażania ich na niechcianych słuchaczy.

Korzystanie LocalBroadcastManager jest bardziej efektywne i bezpieczniejsze niż używanie context.sendBroadcast() bezpośrednio, ponieważ nie trzeba się martwić o jakiekolwiek transmisje sfałszowanych przez inne aplikacje, które mogą stanowić zagrożenie dla bezpieczeństwa.

Oto prosty przykład wysyłania i odbierania lokalnych transmisji:

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

Odbiornik transmisji Bluetooth

dodaj uprawnienia do pliku manifestu

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

W twoim fragmencie (lub aktywności)

• Dodaj metodę odbiornika

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

Zarejestruj transmisję

• Wywołaj tę metodę w onResume ()

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

Wyrejestruj transmisję

• Wywołaj tę metodę w onPause ()

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

Programowe włączanie i wyłączanie odbiornika rozgłoszeniowego

Aby włączyć lub wyłączyć BroadcastReceiver , musimy uzyskać odwołanie do PackageManager i potrzebujemy obiektu ComponentName zawierającego klasę odbiornika, którą chcemy włączyć / wyłączyć:

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

Teraz możemy wywołać następującą metodę, aby włączyć BroadcastReceiver :

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

Lub zamiast tego możemy użyć COMPONENT_ENABLED_STATE_DISABLED aby wyłączyć odbiornik:

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

BroadcastReceiver do obsługi zdarzeń BOOT_COMPLETED

Przykład poniżej pokazuje, jak utworzyć BroadcastReceiver który będzie w stanie odbierać zdarzenia BOOT_COMPLETED . W ten sposób możesz uruchomić Service lub Activity gdy tylko urządzenie zostanie włączone.

Możesz także użyć zdarzeń BOOT_COMPLETED , aby przywrócić alarmy, ponieważ są one niszczone po wyłączeniu urządzenia.

UWAGA: Użytkownik musi uruchomić aplikację przynajmniej raz, aby można było otrzymać akcję BOOT_COMPLETED .

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

Przykład LocalBroadcastManager

BroadcastReceiver to w zasadzie mechanizm przekazywania zamiarów przez system operacyjny w celu wykonywania określonych działań. Klasyczna definicja

„Odbiornik rozgłoszeniowy to komponent dla systemu Android, który umożliwia rejestrację zdarzeń systemowych lub aplikacji”.

LocalBroadcastManager to sposób na wysyłanie lub odbieranie transmisji w ramach procesu aplikacji. Ten mechanizm ma wiele zalet

1. ponieważ dane pozostają w procesie aplikacyjnym, nie można ich wyciec.
2. Transmisje lokalne są rozwiązywane szybciej, ponieważ rozdzielczość normalnej emisji odbywa się w czasie wykonywania w całym systemie operacyjnym.

Prostym przykładem LocalBroastManager jest:

SenderActivity

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

ReceiverActivity

1. Zarejestruj odbiornik

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

2. Konkretny obiekt do wykonywania akcji po wywołaniu odbiornika

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

3. wyrejestruj, gdy widok nie będzie już widoczny.

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

Komunikuj dwie czynności za pomocą niestandardowego odbiornika Broadcast

Możesz zakomunikować dwa działania, aby Działanie A było powiadamiane o zdarzeniu mającym miejsce w Działaniu B.

Działanie 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
    }
};

Działanie B

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

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

Oczywiście możesz dodać więcej informacji do transmisji, dodając dodatki do zamiaru przekazywanego między działaniami. Nie dodano, aby przykład był tak prosty, jak to możliwe.

Sticky Broadcast

Jeśli używamy metody sendStickyBroadcast (intent), odpowiednia intencja jest lepka, co oznacza, że intencja, którą wysyłasz, pozostaje w pobliżu po zakończeniu emisji. StickyBroadcast, jak sama nazwa wskazuje, to mechanizm odczytywania danych z transmisji po zakończeniu transmisji. Można tego użyć w scenariuszu, w którym możesz chcieć sprawdzić powiedz w Activity's onCreate() wartość klucza w zamiarze przed uruchomieniem tego działania.

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

Korzystanie z uporządkowanych transmisji

Uporządkowane transmisje są używane, gdy trzeba określić priorytet dla słuchaczy transmisji.

W tym przykładzie firstReceiver odbiera transmisję zawsze przed 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);

Ponadto odbiornik może anulować zamówioną transmisję:

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

w takim przypadku wszystkie odbiorniki o niższym priorytecie nie otrzymają wiadomości rozgłoszeniowej.

Android zatrzymał stan

Począwszy od Androida 3.1 wszystkie aplikacje po instalacji są zatrzymywane. W stanie zatrzymania aplikacja nie będzie działać z żadnego powodu, z wyjątkiem ręcznego uruchomienia działania lub wyraźnego zamiaru dotyczącego działania, usługi lub emisji.

Pisząc aplikację systemową, która bezpośrednio instaluje pliki APK, należy wziąć pod uwagę, że nowo zainstalowana aplikacja nie odbierze żadnych emisji, dopóki nie przejdzie w stan nieprzerwanego działania.

Prostym sposobem na aktywację aplikacji jest wysłanie jawnej transmisji do tej aplikacji. ponieważ większość aplikacji implementuje INSTALL_REFERRER , możemy użyć go jako punktu zaczepienia

Zeskanuj manifest zainstalowanej aplikacji i wyślij wyraźną transmisję do każdego odbiornika:

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