Jak usługa Android komunikować się z aktywnością

Asker prawdopodobnie już dawno o tym zapomniał, ale na wypadek, gdyby ktoś inny tego szukał...

Dodaj BroadcastReceiver do swojej aktywności. Zarejestruj go, aby otrzymać niestandardowe intencje w onResume i Wyrejestruj go w onPause. Następnie wyślij tę intencję z usługi, gdy chcesz wysłać aktualizacje statusu lub co masz.

Upewnij się, że nie będziesz niezadowolony, jeśli jakaś inna aplikacja słuchał swoich intencji (czy ktoś może zrobić coś złośliwego?), ale poza tym powinno być w porządku.

Poproszono o próbkę kodu:

W mojej służbie mam:

// Do stuff that alters the content of my local SQLite Database
sendBroadcast(new Intent(RefreshTask.REFRESH_DATA_INTENT));

(refresh.REFRESH_DATA_INTENT jest tylko ciągiem ciągłym.)

W mojej aktywności odsłuchowej definiuję mój BroadcastReceiver:

private class DataUpdateReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent.getAction().equals(RefreshTask.REFRESH_DATA_INTENT)) {
          // Do stuff - maybe update my view based on the changed DB contents
        }
    }
}

Ogłaszam mojego odbiorcę na szczycie klasy:

private DataUpdateReceiver dataUpdateReceiver;

Nadpisuję onResume aby dodać:

if (dataUpdateReceiver == null) dataUpdateReceiver = new DataUpdateReceiver();
IntentFilter intentFilter = new IntentFilter(RefreshTask.REFRESH_DATA_INTENT);
registerReceiver(dataUpdateReceiver, intentFilter);

I nadpisuję onPause, aby dodać:

if (dataUpdateReceiver != null) unregisterReceiver(dataUpdateReceiver);

Teraz moja aktywność polega na słuchaniu mojego serwisu, aby powiedzieć " Hej, idź się zaktualizować."Mogłem przekazać dane w intencji zamiast aktualizować tabele bazy danych, a następnie wrócić, aby znaleźć zmiany w mojej aktywności, ale ponieważ chcę, aby zmiany i tak się utrzymywały, sensowne jest przekazywanie danych przez db.

Użyj LocalBroadcastManager aby zarejestrować odbiornik do słuchania transmisji wysyłanej z localservice wewnątrz aplikacji, odniesienie idzie tutaj:

Http://developer.android.com/reference/android/support/v4/content/LocalBroadcastManager.html

Dziwię się, że nikt nie podał odwołania do Otto event Bus library

Http://square.github.io/otto/

Używam tego w moich aplikacjach na Androida i działa bezproblemowo.

[2]}Używanie komunikatora to kolejny prosty sposób komunikowania się między usługą a działalnością.

W ćwiczeniu Utwórz funkcję obsługi z odpowiednim komunikatorem. Będzie to obsługiwać wiadomości z twojego serwisu.

class ResponseHandler extends Handler {
    @Override public void handleMessage(Message message) {
            Toast.makeText(this, "message from service",
                    Toast.LENGTH_SHORT).show();
    }
}
Messenger messenger = new Messenger(new ResponseHandler());

Posłaniec może być przekazany do służby, dołączając go do wiadomości:

Message message = Message.obtain(null, MyService.ADD_RESPONSE_HANDLER);
message.replyTo = messenger;
try {
    myService.send(message);
catch (RemoteException e) {
    e.printStackTrace();
}

Pełny przykład można znaleźć w demach API: MessengerService i MessengerServiceActivity . Zapoznaj się z pełnym przykładem działania MyService.

Inną metodą, o której nie wspomniano w innych komentarzach, jest powiązanie z usługą z aktywności za pomocą bindService() i uzyskanie instancji usługi w wywołaniu zwrotnym ServiceConnection. Jak opisano tutaj http://developer.android.com/guide/components/bound-services.html

Innym sposobem może być użycie obserwatorów z fałszywą klasą modelu poprzez działanie i samą usługę, implementując wariację wzorca MVC. Nie wiem, czy to najlepszy sposób, aby to osiągnąć, ale to sposób, który pracował dla mnie. Jeśli potrzebujesz jakiegoś przykładu, poproś o to, a ja coś wpiszę.

Aby kontynuować odpowiedź @ MrSnowflake z przykładem kodu. to jest klasa Xabber teraz open source Application . Klasa Application jest centralizująca i koordynująca Listeners oraz ManagerInterfaces i wiele innych. Wszelkiego rodzaju Menedżery są ładowane dynamicznie. Activity´s rozpoczęte w Xabberze będą raportować, jakiego typu są Listener. A kiedy Service uruchamia raport do Application klasy jako rozpoczętej. Teraz, aby wysłać wiadomość do Activity wystarczy, że Twoja Activity stanie się listener jakiego typu potrzebujesz. W OnStart() OnPause() Zarejestruj się / unreg. {[5] } może poprosić klasę Application o to, że listener musi z nią porozmawiać, a jeśli tam jest, aktywność jest gotowa do odbioru.

Przechodząc przez klasę Application zobaczysz, że jest więcej łupów niż to.

Jak wspomniał Madhur, możesz używać autobusu do komunikacji.

W przypadku korzystania z magistrali masz kilka opcji:

Http://square.github.io/otto/

Green Robot ' s EventBus

Http://greenrobot.org/eventbus/

NYBus (RxBus, zaimplementowany przy użyciu RxJava. bardzo podobny do EventBus)

Https://github.com/MindorksOpenSource/NYBus

Poza LocalBroadcastManager , Event Bus i Messenger już odpowiedziały na to pytanie,Możemy użyć Pending Intent do komunikacji z serwisu.

Jak wspomniano tutaj w moim wpisie na blogu

Komunikacja pomiędzy usługą a aktywnością może odbywać się za pomocą PendingIntent.Do tego możemy użyć createPendingResult ().createPendingResult () tworzy nowy PendingIntent obiekt, który możesz przekazać do serwisu w celu użycia i wysłania wynik dane do Twojej aktywności w onActivityResult (int, int, Intent).Ponieważ PendingIntent jest Parcelowalny i może dlatego należy umieścić w intencji extra, Twoja aktywność może przekazać to / Align = "left" / Serwis z kolei może zadzwonić wyślij() metoda na PendingIntent powiadamiania o aktywności poprzez na skutek działania zdarzenia.

Aktywność

public class PendingIntentActivity extends AppCompatActivity
{
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

PendingIntent pendingResult = createPendingResult(
100, new Intent(), 0);
Intent intent = new Intent(getApplicationContext(), PendingIntentService.class);
intent.putExtra("pendingIntent", pendingResult);
startService(intent);

}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == 100 && resultCode==200) {
Toast.makeText(this,data.getStringExtra("name"),Toast.LENGTH_LONG).show();
}
super.onActivityResult(requestCode, resultCode, data);
}
}

Serwis

public class PendingIntentService extends Service {

    private static final String[] items= { "lorem", "ipsum", "dolor",
            "sit", "amet", "consectetuer", "adipiscing", "elit", "morbi",
            "vel", "ligula", "vitae", "arcu", "aliquet", "mollis", "etiam",
            "vel", "erat", "placerat", "ante", "porttitor", "sodales",
            "pellentesque", "augue", "purus" };
    private PendingIntent data;

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {

        data = intent.getParcelableExtra("pendingIntent");

        new LoadWordsThread().start();
        return START_NOT_STICKY;
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }

    class LoadWordsThread extends Thread {
        @Override
        public void run() {
            for (String item : items) {
                if (!isInterrupted()) {

                    Intent result = new Intent();
                    result.putExtra("name", item);
                    try {
                        data.send(PendingIntentService.this,200,result);
                    } catch (PendingIntent.CanceledException e) {

                        e.printStackTrace();
                    }
                    SystemClock.sleep(400);

                }
            }
        }
    }
}