Prioritize intents in IntentService

Question

Here is what I do now:

1. I have a service that runs in the background and reads user location. Each time a valid location is read (there are some parameters like distance and time) an IntentService is started to send that location to a web server

2. The app, that uses the tracking service, also has some web calls, depending on what options the user presses. Right now, the app simply calls the web service in a asynctask.

Some code: The location service fires the IntentService, each time a good location is received, like this:

Intent intentService = new Intent(LocationLoggerService.this, LocationManagerIntentService.class);
intentService.putExtra(Constants.MESSAGE_LOCATION, readLocation);
startService(intentService);

The intentservice processes the intent:

@Override
protected void onHandleIntent(Intent intent) {
     LocationInfo location = intent.getExtras().getParcelable(Constants.MESSAGE_LOCATION);
   .... //Do the web call and broadcast result to app
}

Here are the changes I need to make:

1. The IntentService and the app must not call web server in the same time. As the implementation is made now, this is not possible, as they act independent. I was thinking of passing all the web calls from the app, to the IntentService by creating intents for all of them. Would this work? In case that there was a location web sending, a new intent from an app call would be put in queue and executed right after current call?

2. If there are multiple location sending in queue because of low network speed, the app call, needs to be put in front of queue and not wait for all existing intents to finish, just for the current one. Is there a way to put an intent on top of queue?

Thank you.

Later edit:

Here are the changes I've made.

1. Created a custom intent service

public abstract class PriorityIntentService extends Service {
      private final AtomicInteger     intentsCount    = new AtomicInteger();

  protected void intentFinished() {
      intentsCount.decrementAndGet();
  }

  private final class ServiceHandler extends Handler {
      public ServiceHandler(Looper looper) {
          super(looper);
      }

      public final boolean sendPriorityMessage(Message msg) {

          intentsCount.incrementAndGet();

          int priority = msg.arg2;

          if (priority == 0) {
              return sendMessageAtFrontOfQueue(msg);
          } else {
              return sendMessage(msg);
          }

      }

      @Override
      public void handleMessage(Message msg) {
          onHandleIntent((Intent) msg.obj);

          if (intentsCount.get() == 0) {
              // stopSelf(msg.arg1);
              stopSelf();
          }
      }
  }


  @Override
  public void onStart(Intent intent, int startId) {

      Message msg = mServiceHandler.obtainMessage();
      msg.arg1 = startId;
      msg.obj = intent;

      if (intent.getExtras().getInt(Constants.MESSAGE_PRIORITY) == 0) {
          msg.arg2 = 0;
      } else {
          msg.arg2 = 1;
      }

      mServiceHandler.sendPriorityMessage(msg);
      // mServiceHandler.sendMessage(msg);
  }
}

2. And the other service:

public class LocationManagerIntentService extends PriorityIntentService {

    @Override
      protected void onHandleIntent(Intent intent) {

      intentFinished();
      }
}

Answer 1

What you want to do is not possible because of the way IntentService is built, but, IntentService is a very simple code and is open source, so you can just create your own version of it with a few modifications.

The original code is here.

In the onCreate() method you can see where Service creates a HandlerThread and a Handler that dispatch all the onHandleIntent calls.

So all you have to do is:

• Create a Singleton HandlerThread and Handler for your whole application to use. Every network call or CustomIntentService should call this single Handler. That's part 1. You just forced all the network calls to never happen concurrently.

• Now that you have all the calls through the same Thread and Handler, it's just a matter of calling Handler.postAtFrontOfQueue to prioritize certain executions.

Happy coding.

Edit:

• HandlerThread: a thread that doesn't finish. It has a "looper" that keeps the thread alive. https://developer.android.com/reference/android/os/HandlerThread.html

• Handler: a "handle" to a thread that contains a "looper". Through this handle any thread can send messages or runnables to this handle thread. The messages will be executed on the handle handleMessage(Message) callback and Runnables will have the run() method executed.https://developer.android.com/reference/android/os/Handler.html

• All this Handler stuff gets funneled to the MessageQueue which is unique for each looper/thread. https://developer.android.com/reference/android/os/MessageQueue.html

New edit:

The reason it's not executing is here:

stopSelf(msg.arg1);

This stops the service once all the messages being executed, check the docs:

Stop the service if the most recent time it was started was startId. This is the same as calling stopService(Intent) for this particular service but allows you to safely avoid stopping if there is a start request from a client that you haven't yet seen in onStart(Intent, int).

Be careful about ordering of your calls to this function. If you call this function with the most-recently received ID before you have called it for previously received IDs, the service will be immediately stopped anyway. If you may end up processing IDs out of order (such as by dispatching them on separate threads), then you are responsible for stopping them in the same order you received them.

So you'll have to find a different way of checking if all the messages have been executed before finishing. Maybe an AtomicInt counting the number of messages in the queue, or a map to hold the startId.