Android od podstaw: omówienie powiadomień w Android

() translation by (you can also view the original English article)

Większość z nas jest zaznajomiona z komunikatami w miejscach publicznych. To doniosłe wiadomości, które mają na celu poinformować dużą grupę ludzi o czymś ważnym. Aplikacje na Androida również mają do czynienia z ogłoszeniami—generowanymi przez inne aplikacje lub system operacyjny Android. Takie komunikaty noszą nazwę powiadomień i są postrzegane jako ważna forma asynchronicznej komunikacji międzyprocesowej na platformie Android.

W tym poradniku, pokażę ci jak tworzyć, przesyłać i odbierać lokalne i systemowe powiadomienia. Wyjaśnię również jak skorzystać z biblioteki firm trzecich o nazwie EvenBus, która służy jako alternatywa dla lokalnych powiadomień.

1. Tworzenie powiadomień

Powiadomienia Android są przesyłane w formie obiektów Intent. W związku z tym, przed stworzeniem powiadomienia, musisz dodać obiekt Intent. Ta seria ma szczegółowy poradnik o intencjach. Jeśli jeszcze go nie przeczytałeś, najwyższa pora, aby to zrobić.

Każda intencja przesyłana jako powiadomieni musi posiadać nazwę działania. Chociaż może być ona dowolnym ciągiem, zalecam zawsze dodać prefiks z nazwą pakietu twojej aplikacji, aby uniknąć konfliktów z powiadomieniami innych aplikacji.

Poniższy fragment kodu pokazuje jak stworzyć nową intencję o nazwie działania com.tutsplus.my.first.broadcast:

1	Intent myIntent = new Intent("com.tutsplus.my.first.broadcast");

Aby przesłać intencję jako powiadomienie, wystarczy wywołać metodę sendBroadcast() i przekazać jej obiekt Intent jako argument.

1	sendBroadcast(myIntent);

Zwróć uwagę, że metoda sendBroadcast() tworzy globalne powiadomienie, które może być odebrane nie tylko przez twoją aplikację, ale również przez każdą zainstalowaną na urządzeniu użytkownika.

2. Odbieranie powiadomień

Aby móc odbierać powiadomienia, twoja aplikacja musi posiadać odpowiednio skonfigurowany odbiornik powiadomień. Możesz go stworzyć rozszerzając abstrakcyjną klasę BroadcastReceiver i nadpisując jej metodę onReceive(). Na przykład, oto jak dodać odbiornik, który drukuje wiadomości za każdym razem, gdy otrzymuje powiadomienie.

public class MyBroadcastReceiver extends BroadcastReceiver {
    public void onReceive(Context context, Intent intent) {
        Log.d("MYAPP", "I received a broadcast");
    }
}

Odbiornik powiadomień działa tylko po rejestracji. W tym celu, należy dodać go do pliku manifestu projektu za pomocą tagu receiver.

Dodatkowo, wewnątrz deklaracji odbiornika, musisz dołączyć tagi intent-filter określające nazwy działań, którymi odbiornik powiadomień jest zainteresowany.

Poniższy fragment kodu rejestruje MyBroadcastReceiver i konfiguruje go do odpowiadania na działanie o nazwie com.tutsplus.my.first.broadcast:

<receiver android:name=".MyBroadcastReceiver">
    <intent-filter>
        <action android:name="com.tutsplus.my.first.broadcast" />
    </intent-filter>
</receiver>

3. Odbieranie powiadomień systemowych

System Android obsługuje kilka globalnych powiadomień. Większość z nich zawiera cenne informacje na temat zmian w stanie urządzenia Android. Na przykład, za każdym razem, gdy użytkownik dzwoni, pojawia się powiadomienie android.intent.action.NEW_OUTGOING_CALL. Podobnie, za każdym razem, gdy użytkownik włącza tryb samolotowy, pojawia się powiadomienie android.intent.action.AIRPLANE_MODE.

Odbieranie powiadomień systemowych działa jak odbieranie tych zwyczajnych. Jednakże większość intencji powiadomień systemowych zawiera dodatkowe informacje. Możesz pobrać wszystkie te dodatki jako obiekt Bundle wywołując metodę getExtras(). Dla przykładu, intencja powiadomienia android.intent.action.AIRPLANE_MODE zawsze zawiera obiekt o nazwie state jako wartość logiczna określająca czy tryb samolotowy jest włączony czy wyłączony.

Poniższy fragment kodu pokazuje jak zarejestrować wartość obiektu state:

// Check if you have the right broadcast intent
if (intent.getAction().equals("android.intent.action.AIRPLANE_MODE")) {
    // Get all extras
    Bundle extras = intent.getExtras();

    // Fetch the boolean extra using getBoolean()
    boolean state = extras.getBoolean("state");

    // Log the value of the extra
    Log.d("MYAPP", "AIRPLANE MODE: " + state);
}

Zwróć uwagę, że powyższy kod będzie działał tylko wtedy, gdy odbiornik został zarejestrowany z poniższym filtrem intencji.

1	<intent-filter>
2	<action android:name="android.intent.action.AIRPLANE_MODE" />
3	</intent-filter>

4. Praca z lokalnymi powiadomieniami

Z oczywistych powodów globalne powiadomienia nie mogą nigdy zawierać poufnych informacji. Jednakże, istnieje możliwość nadawania takich informacji lokalnie za pomocą klasy LocalBroadcastManager, która jest częścią biblioteki wsparcia Android.

Jeśli korzystasz z najnowszej wersji Android Studio, nie musisz ręcznie dodawać zależności dla biblioteki wsparcia Android. Jednakże, jeśli chcesz zaimplementować lokalne audycje w starszym projekcie, dodaj poniższy wiersz w pliku build.gradle aplikacji:

1	compile 'com.android.support:support-v4:23.4.0'

Aby stworzyć nową instancję klasy LocalBroadcastManager, musisz wywołać jej metodę getInstance() i przekazać jej aktywność lub usługę jako kontekst. Dla przykładu, oto jak stworzyć instancję wewnątrz aktywności o nazwie MyActivity:

1	LocalBroadcastManager localBroadcastManager
2	= LocalBroadcastManager.getInstance(MyActivity.this);

Teraz możesz przesyłać lokalne powiadomienia za pomocą metody sendBroadcast() klasy LocalBroadcastManager. Poniższy fragment kodu tworzy nową intencję o nazwie działania my-local-broadcast przesyłając ją jako lokalne powiadomienie:

// Create intent with action
Intent myIntent = new Intent("my-local-broadcast");

// Send local broadcast
localBroadcastManager.sendBroadcast(myIntent);

Odbieranie lokalnych powiadomień jest nieco bardziej skomplikowane. Lokalny odbiornik nie może być zarejestrowany w pliku manifestu projektu. Musi być zarejestrowany dynamicznie za pomocą metody registerReceiver() klasy LocalBroadcastManager. Oprócz instancji odbiornika powiadomień, metoda registerReceiver() wymagana obiektu IntentFilter określającego nazwę działania, na którą odbiornik powinien odpowiedzieć.

Oto jak stworzyć i zarejestrować odbiornik powiadomień, który odpowiada na działanie my-local-broadcast:

// Create a broadcast receiver as usual
BroadcastReceiver myBroadcastReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
      Log.d("MYAPP", "Received a local broadcast");
    }
};

// Create intent filter for it
IntentFilter myFilter = new IntentFilter("my-local-broadcast");

// Register it
localBroadcastManager.registerReceiver(
            myBroadcastReceiver, myFilter);

Gdy dynamicznie zarejestrowane odbiorniki nie są już potrzebne, musisz jej wyrejestrować. Aby to zrobić skorzystaj z metody unregisterReceiver() klasy LocalBroadcastManager.

1	localBroadcastManager.unregisterReceiver(
2	myBroadcastReceiver);

5. Korzystanie z EventBus

Jeśli lokalne powiadomienia i intencje nie dają ci wystarczającej elastyczności, powinieneś skorzystać z EventBus, biblioteki, która umożliwia asynchroniczne przesyłanie danych z jednego komponentu aplikacji do drugiego. Moim zdaniem, EventBus API jest bardzo intuicyjny i zwięzły.

Aby uwzględnić EventBus w projekcie, dodaj poniższą zależność compile do pliku build.gradle aplikacji:

1	compile 'org.greenrobot:eventbus:3.0.0'

Oprócz obiektów Intent, EventBus pozwala na przesyłanie i odbieranie obiektów dowolnej klasy Java. Na przykład, w EventBus można z łatwością wykorzystać instancje poniższych klas:

public class MyMessage {
    String title;
    String text;

    public MyMessage(String title, String text) {
        this.title = title;
        this.text = text;
    }
}

EventBus implementuje model wydawca-subskrybent i tworzy centralną magistralę dostępną dla wszystkich komponentów twojej aplikacji. W związku z tym, komponent, który ma przesłać obiekty, musi opublikować je w magistrali. Komponent zainteresowany odebraniem tych obiektów musi zarejestrować się jako subskrybent magistrali.

Najszybszym sposobem na pobranie instancji centralnej magistrali jest użycie metody getDefault() klasy EventBus.

1	EventBus bus = EventBus.getDefault();

Aby opublikować obiekt, wystarczy wywołać metodę post() magistrali. Dla przykładu, oto jak opublikować instancję klasy MyMessage:

1	bus.post(new MyMessage("Hello", "My first EventBus message"));

Komponent aplikacji, taki jak aktywność lub usługa, może zarejestrować się jako subskrybent wywołując metodę register() magistrali. Poniższy fragment kodu rejestruje usługę o nazwie MyService:

1	bus.register(MyService.this);

Komponent działający jak subskrybent musi również posiadać metodę subskrybenta, która z kolei musi mieć adnotację @Subscribe. Metody subskrybenta zachowują się jak moduły obsługi zdarzeń i są automatycznie wywoływane za każdym razem, gdy nowe obiekty pojawią się w magistrali.

Poniższy fragment kodu pokazuje jak stworzyć bardzo prostą metodę subskrybenta, która jest automatycznie wywoływana za każdym razem, gdy nowa instancja klasy MyMessage pojawia się w magistrali:

1	@Subscribe
2	public void messageAvailable(MyMessage message) {
3	Log.d("MYAPP", message.title + " [" + message.text + "]");
4	}

Podsumowanie

W tym poradniku, dowiedziałeś się jak przesyłać informację z jednego komponentu aplikacji do drugiego korzystając z globalnych i lokalnych powiadomień. Nauczyłeś się również jak używać bardzo popularnej biblioteki EventBus do komunikacji w obrębie aplikacji. Ponieważ powiadomienia nie obciążają aplikacji, możesz je przesyłać tak często jak to konieczne. Tak naprawdę, system Android generuje nowe powiadomienie android.intent.action.TIME_TICK w każdej minucie.

Aby uzyskać więcej informacji o odbiornikach systemu Android i powiadomieniach, zapoznaj się z dokumentacją na temat klas BroadcastReceiver i Intent.