title: Android: IntentService: How to: pass callback into IntentService from Activity?
body: <p>I would like to pass callback to IntentService. Here are my current codes:</p>
  
  <p>My callback interface</p>
  
  <pre><code>import android.os.Message;
  
  public interface SampleCallback {
  
      public void doSomethingFromCurrentThread();
  
      public void doSomethingFromUIThread(final Message msg);
  }
  </code></pre>
  
  <p>My IntentService</p>
  
  <pre><code>import android.app.IntentService;
  import android.content.Intent;
  import android.os.Handler;
  import android.os.Message;
  import android.util.Log;
  
  public class SampleCallbackIntentService extends IntentService {
      private final String LOG_LOGCAT_TAG = "SampleCallbackIntentService";
      private final SampleCallback _callback;
      private Handler _handler;
  
      public SampleCallbackIntentService(String name, SampleCallback callback) {
          super(name);
          _callback = callback;
      }
  
      @Override
      public void onCreate() {
          super.onCreate();
  
          // initialize variables for pause &amp; resume thread
          _mPauseLock = new Object();
          _mPaused = false;
          _mFinished = false;
  
          // initialize handler to switch to UI/Main thread
           _handler = new Handler()
              {
                  @Override
                  public void handleMessage(final Message msg)
                  {
                      _callback.doSomethingFromUIThread(msg);
                  }
              };
      }
  
      private final int CALLBACK_MESSAGE = 1;
      @Override
      protected void onHandleIntent(Intent arg0) {
          Log.i(LOG_LOGCAT_TAG, "loop started");
          while (!_mFinished) {
              // do stuff here
              _callback.doSomethingFromCurrentThread();
  
              // process and create the result to pass
              String someResult = "some result here";
              _handler.sendMessage(_handler.obtainMessage(CALLBACK_MESSAGE, someResult));
  
              synchronized (_mPauseLock) {
                  while (_mPaused) {
                      try {
                          Log.i(LOG_LOGCAT_TAG, "loop paused");
                          _mPauseLock.wait();
                          Log.i(LOG_LOGCAT_TAG, "loop resumed");
                      } catch (InterruptedException e) {
                          Log.e(LOG_LOGCAT_TAG, "error occured on pause", e);
                      }
                  }
              }
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  Log.e(LOG_LOGCAT_TAG, "error occured on sleep", e);
              }
          }
          Log.i(LOG_LOGCAT_TAG, "loop ended");
      }
  
      private Object _mPauseLock;
      private boolean _mPaused;
      private boolean _mFinished;
  
      /**
       * Call this on pause.
       */
      public void pause() {
          Log.i(LOG_LOGCAT_TAG, "pause() called");
          synchronized (_mPauseLock) {
              _mPaused = true;
          }
      }
  
      /**
       * Call this on resume.
       */
      public void resume() {
          Log.i(LOG_LOGCAT_TAG, "resume() called");
          synchronized (_mPauseLock) {
              _mPaused = false;
              _mPauseLock.notifyAll();
          }
      }
  }
  </code></pre>
  
  <p>Any guidance on how to pass my callback is appreciated.</p>