Komunikacja między działalnością a służbą

Aktualizacja: Lipiec 10 2016

IMO myślę, że używanie BroadcastReceiver dla niestandardowych wydarzeń jest lepszym sposobem jak Wspomniali posłańcy nie obsługują aktywności na urządzeniu rotacja, jak również możliwe wycieki pamięci.

Możesz utworzyć własny Odbiornik transmisji dla zdarzeń w aktywności, a następnie możesz również korzystać z komunikatorów.

1. W Twoim Activity

   Utwórz klasę MessageHandler jako

   public static class MessageHandler extends Handler {
       @Override
       public void handleMessage(Message message) {
           int state = message.arg1;
           switch (state) {
           case HIDE:
               progressBar.setVisibility(View.GONE);
               break;
           case SHOW:
               progressBar.setVisibility(View.VISIBLE);
               break;
           }
       }
   }
   

   Teraz możesz mieć jest to instancja

   public static Handler messageHandler = new MessageHandler();
   

   Rozpocznij {[6] } z tym obiektem obsługi jako dodatkowymi danymi jako

   Intent startService = new Intent(context, SERVICE.class)
   startService.putExtra("MESSENGER", new Messenger(messageHandler));
   context.startService(startService);
   

2. W Twoim Service otrzymujesz ten obiekt od intent i inicjalizujesz zmienną Messenger w usłudze jako

   private Messenger messageHandler;
   Bundle extras = intent.getExtras();
   messageHandler = (Messenger) extras.get("MESSENGER");
   sendMessage(ProgressBarState.SHOW);
   

   A następnie napisz metodę sendMessage, aby wysyłać wiadomości do aktywności.

   public void sendMessage(ProgressBarState state) {
   Message message = Message.obtain();
   switch (state) {
       case SHOW :
           message.arg1 = Home.SHOW;
           break;
       case HIDE :
           message.arg1 = Home.HIDE;
           break;
   }
   try {
       messageHandler.send(message);
   } catch (RemoteException e) {
       e.printStackTrace();
   }
   }
   

Powyższy przykładowy kod pokazuje i ukrywa pasek postępu w aktywności, gdy wiadomości są odbierane z usługi.

Intencje są dobrym rozwiązaniem do komunikacji między aktywnością a Obsługą.

Szybkim rozwiązaniem dla odbioru intentów w Twojej usłudze jest podklasowanie IntentService klasy. Obsługuje asynchroniczne żądania wyrażone jako intencje za pomocą kolejki i wątku roboczego.

Do komunikacji z usługi do aktywności możesz nadawać intencję, ale zamiast używać zwykłej sendbroadcast () z kontekstu, bardziej efektywnym sposobem jest użycie LocalBroadcastManager z obsługi biblioteka.

Przykładowa usługa.

public class MyIntentService extends IntentService {
    private static final String ACTION_FOO = "com.myapp.action.FOO";
    private static final String EXTRA_PARAM_A = "com.myapp.extra.PARAM_A";

    public static final String BROADCAST_ACTION_BAZ = "com.myapp.broadcast_action.FOO";
    public static final String EXTRA_PARAM_B = "com.myapp.extra.PARAM_B";

    // called by activity to communicate to service
    public static void startActionFoo(Context context, String param1) {
        Intent intent = new Intent(context, MyIntentService.class);
        intent.setAction(ACTION_FOO);
        intent.putExtra(EXTRA_PARAM1, param1);
        context.startService(intent);
    }

    public MyIntentService() {
        super("MyIntentService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        if (intent != null) {
            final String action = intent.getAction();
            if (ACTION_FOO.equals(action)) {
                final String param1 = intent.getStringExtra(EXTRA_PARAM_A);
                // do something
            }
        }
    }

    // called to send data to Activity
    public static void broadcastActionBaz(String param) {
        Intent intent = new Intent(BROADCAST_ACTION_BAZ);
        intent.putExtra(EXTRA_PARAM_B, param);
        LocalBroadcastManager bm = LocalBroadcastManager.getInstance(this);
        bm.sendBroadcast(intent);
    }
}

Przykładowa Aktywność

public class MainActivity extends ActionBarActivity {

    // handler for received data from service
    private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent.getAction().equals(MyIntentService.BROADCAST_ACTION_BAZ)) {
                final String param = intent.getStringExtra(EXTRA_PARAM_B);
                // do something
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        IntentFilter filter = new IntentFilter();
        filter.addAction(MyIntentService.BROADCAST_ACTION_BAZ);
        LocalBroadcastManager bm = LocalBroadcastManager.getInstance(this);
        bm.registerReceiver(mBroadcastReceiver, filter);
    }

    @Override
    protected void onDestroy() {
        LocalBroadcastManager bm = LocalBroadcastManager.getInstance(this);
        bm.unregisterReceiver(mBroadcastReceiver);
        super.onDestroy();
    }

    // send data to MyService
    protected void communicateToService(String parameter) {
        MyIntentService.startActionFoo(this, parameter);
    }
}

Myślę, że jest problem z prawidłową odpowiedzią. Nie mam wystarczającej reputacji, by to skomentować.

Right in the answer: Wywołanie Activity bindService (), aby uzyskać wskaźnik do usługi, jest ok. Ponieważ kontekst usługi jest utrzymywany podczas utrzymywania połączenia.

Błąd w odpowiedzi: wskaźnik usługi do klasy Activity, aby oddzwonić, to zły sposób. Instancja Activity może nie null podczas kontekstu Activity jest tutaj Release = > exception.

Rozwiązanie za złe w odpowiedzi: usługa wysyłania intencji do aktywności. i zamiar odbiornika aktywności przez BroadcastReceiver.

Uwaga: w takim przypadku usługa i aktywność w tym samym procesie należy użyć LocalBroadcastManager, aby wysłać intencję. Poprawia wydajność i bezpieczeństwo

Najlepszym sposobem w tym przypadku jest komunikowanie się poprzez nadawanie z usługi dla różnych działań i odbieranie go w swojej działalności. Możesz utworzyć niestandardową transmisję i wysłać kody określające konkretne wydarzenia, takie jak ukończenie, zmiana, przygotowanie itp...

Jest to prosty przykład komunikacji między aktywnością a usługą

Aktywność

MyReceiver myReceiver; //my global var receiver
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.layourAwesomexD);
    registerReceiver();
}

//When the activity resume, the receiver is going to register...
@Override
protected void onResume() {
    super.onResume();
    checkStatusService(); // verficarStatusServicio(); <- name change
    registerReceiver();
}
//when the activity stop, the receiver is going to unregister...
@Override
protected void onStop() {
    unregisterReceiver(myReceiver); //unregister my receiver...
    super.onStop();
}
//function to register receiver :3
private void registerReceiver(){
    //Register BroadcastReceiver
    //to receive event from our service
    myReceiver = new MyReceiver();
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(MyService.SENDMESAGGE);
    registerReceiver(myReceiver, intentFilter);
}

// class of receiver, the magic is here...
private class MyReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context arg0, Intent arg1) {
        //verify if the extra var exist
        System.out.println(arg1.hasExtra("message")); // true or false
        //another example...
        System.out.println(arg1.getExtras().containsKey("message")); // true or false
        //if var exist only print or do some stuff
        if (arg1.hasExtra("message")) {
            //do what you want to
            System.out.println(arg1.getStringExtra("message"));
        }    
    }
}

public void checkStatusService(){
    if(MyService.serviceStatus!=null){
        if(MyService.serviceStatus == true){
            //do something
            //textview.text("Service is running");
        }else{
            //do something
            //textview.text("Service is not running");
        }
    }
}

Serwis

public class MyService extends Service {

final static String SENDMESAGGE = "passMessage";

public static Boolean serviceStatus = false;

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

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

@Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        //you service etc...             
        passMessageToActivity("hello my friend this an example of send a string...");
        return START_STICKY;
    }

@Override
    public void onDestroy() {
        super.onDestroy();
        passMessageToActivity("The service is finished, This is going to be more cooler than the heart of your ex...");
        System.out.println("onDestroy");
        serviceStatus=false;
   }

private void passMessageToActivity(String message){
        Intent intent = new Intent();
        intent.setAction(SENDMESAGGE);
        intent.putExtra("message",message);
        sendBroadcast(intent);
    }
}

• Jeśli nie wyrejestrujemy BroadcastReceiver będziemy mieli błąd, musisz wyrejestrować się, gdy aktywność go onPause, onStop, onDestroy...
• Jeśli nie zarejestrujesz BroadcastReceiver po powrocie do aktywności, nie będzie słuchać niczego z usługi... usługa wyśle informacje do BroadcastReceiver, ale nie będzie otrzymuj cokolwiek, ponieważ nie jest zarejestrowane.
• gdy utworzysz więcej niż jedną usługę, następujące usługi zaczną się w onStartCommand.
• możesz przekazać informacje do serwisu z zamiarem i otrzymasz je w onStartCommand
• różnica o return w onStartCommand: różnica między START_STICKY i START_REDELIVER_INTENT? i sprawdź oficjalną stronę google: usługi

Zajrzyj do dokumentacji Androida

Http://developer.android.com/guide/components/bound-services.html#Binder

Bardzo łatwy, a zarazem potężny sposób użycia EventBus możesz dodać go do swojej kompilacji gradle i cieszyć się łatwym wzorem wydawcy / subskrybenta .

Najprostszym i najskuteczniejszym sposobem będzie użycie EventBus z Greenrobota.

Użyj prostych 3 kroków:

1 Define events

public static class MessageEvent { /* Additional fields if needed */ }

2 Przygotuj subskrybentów: Zadeklaruj i opisz swoją metodę subskrybowania, opcjonalnie określ tryb wątku:

@Subscribe(threadMode = ThreadMode.MAIN)  
public void onMessageEvent(MessageEvent event) {/* Do something */};

Zarejestruj i Wyrejestruj swojego Abonenta. Na przykład na Androidzie aktywności i fragmenty powinny zazwyczaj rejestrować się zgodnie z cyklem życia:

@Override
 public void onStart() {
     super.onStart();
     EventBus.getDefault().register(this);
 }

 @Override
 public void onStop() {
     super.onStop();
     EventBus.getDefault().unregister(this);
 }

3 Post wydarzenia:

EventBus.getDefault().post(new MessageEvent());