Android：根据服务中后台线程中对象的值更新UI

Question

I am currently developing an Android app which contains the following activities:

• MainActivity;
• UpdateActivity.

Besides that it also contains a completely separate package in which exists the following classes:

• SyncService: which is, as the name already indicates, a service. To be more specific a bound service;
• SyncServiceManager: a singleton object which binds to the service.
• SyncTask: only containing the logic that the service needs to do. So the service is the only object that interact with it;
• A couple of interfaces to make it possible for my manager to interact with the service. And 2 interfaces just to use the Observer Pattern for my app. The Service is the subject which is supposed to notify the manager, the syncTask and the updateActivity to do something.

The problem I am facing is that I want to modify the UI of my updateActivity depending on an enum that changes as the service needs to do his job. Which is notifying the syncTask to do the requested job (Configuring, Resetting or Syncing the application database with the data of a webservice).

However since I want to make the service do his thing in the background I'm using a new thread object in which it can do thing I want it to do. This is all kind of working the way it should, except for the fact that I can modify the UI in the update activity because the UI can only be edited from the UI Thread. I've already found a very promising link on the forum, but I just can't figure out if it really is the thing I need and/or how to implement it. android: update UI from another thread in another class

This is my code. The Service:

public enum ServiceState {
    RESETTING,
    CONFIGURING,
    SYNCHRONIZING,
    IDLE
}

private Vector<IObserver> observers = new Vector<IObserver>();
private IBinder syncBinder = new SyncServiceBinder();
private ServiceState serviceState;

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

private final IBinder syncServiceBinder = new SyncServiceBinder();

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

    Thread th = new Thread(new Runnable() {
        @Override
        public void run() {
            //Modifying the service state and starting the sync depending on the state.
            startSync();
        }
    });

    th.start();

    return START_REDELIVER_INTENT;
}

private void startSync() {
    notifyObservers(serviceState);
}

@Override
public void registerObserver(IObserver iObserver) {
    observers.add(iObserver);
}

@Override
public void unregisterObserver(IObserver iObserver) {
    observers.remove(iObserver);
}

@Override
public void notifyObservers(SyncService.ServiceState serviceState) {
    for (IObserver observer : observers) {
        observer.update();
    }
}

The update activity:

public class UpdateActivity extends Activity implements IObserver {

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

@Override
public void update() {
    //Modify UI from here depeding on the serviceState
}

}

I've also thought of using the runOnUiThread function which comes with the activity class, but it just gets fired way too late. The same thing with creating a new handler within the updateactivity and create a runnable which should allow me to send a message to the handler.

You guys have any thoughts/suggestions?

Thanks in Advance,

Michael

Answer 1

Broadcast Listener would be best in this case and also recommended. Just create Broadcast listener in activity which will update the UI, register it in onStart and unregister in onStop.

Answer 2

I think you really overcomplicated your logic. There is no necessecity for all that mess. You only need the main activity class and the service, and you got more than enought. You dont even need to bind the service.

As the Activity and the service run in the same process, a good way to share state between them are static variables. So make service state static and set up a getter so the activity can access the state of the service.

When the UI needs to be updated you can send a broadcast to the activity, registering in onStart and onregistering in onStop ( onPause and onResume could also work, depending on your needs).

Though i think a much easier approach than a Broadcast its just using a event bus, like otto. Just create a singleton class providing the bus, get in the service and post the event to the bus (see examples on how to post to main thread from backgroun, its pretty easy). In the activity register and unregister the same way as i said before, and set up a @susbribe event.

Some code samples:

Posting the update from service:

EventBusProvider.getInstance().postToMainThread(new SomeEventOrAnyClassObject());

Registering and unregistering the activity to listen to the bus:

  @Override
public void onStart(){
    super.onStart();
    EventBusProvider.getInstance().register(this);

 @Override
public void onStop(){
    super.onStop();
    EventBusProvider.getInstance().unregister(this);
}

Subscribing to receive the update

 @Subscribe
public void loginResponse(Data someinstance){
 //Here you could read the update directly from the someinstance
//or check the service static variable
 SyncService.getStatus()
}

It's really that easy. hope its helps