在 Android 的 IntentService 中等待异步回调

Question

我有一个 IntentService 在另一个类中启动异步任务，然后应该等待结果。

问题是IntentService 会在onHandleIntent(...) 方法运行完毕后立即结束，对吧？

也就是说，正常情况下IntentService会在启动异步任务后立即关闭，不再在那里接收结果。

public class MyIntentService extends IntentService implements MyCallback {

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

    @Override
    protected final void onHandleIntent(Intent intent) {
        MyOtherClass.runAsynchronousTask(this);
    }

}

public interface MyCallback {

    public void onReceiveResults(Object object);

}

public class MyOtherClass {

    public void runAsynchronousTask(MyCallback callback) {
        new Thread() {
            public void run() {
                // do some long-running work
                callback.onReceiveResults(...);
            }
        }.start();
    }

}

我怎样才能使上面的 sn-p 工作？我已经尝试在开始任务后将Thread.sleep(15000)（任意持续时间）放入onHandleIntent(...)。它似乎工作。

但这绝对不是一个干净的解决方案。甚至可能存在一些严重的问题。

有更好的解决方案吗？

Answer 1

使用标准的Service 类而不是IntentService，从onStartCommand() 回调启动异步任务，并在收到完成回调时销毁Service。

这样做的问题是正确处理Service 的破坏，因为Service 在它已经运行的同时又被重新启动了。如果您需要处理这种情况，那么您可能需要设置一个正在运行的计数器或一组回调，并仅在它们全部完成后销毁Service。

Answer 2

我同意 corsair992 的观点，通常您不必从 IntentService 进行异步调用，因为 IntentService 已经在工作线程上完成了它的工作。但是，如果您必须这样做，您可以使用CountDownLatch。

public class MyIntentService extends IntentService implements MyCallback {
    private CountDownLatch doneSignal = new CountDownLatch(1);

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

    @Override
    protected final void onHandleIntent(Intent intent) {
        MyOtherClass.runAsynchronousTask(this);
        doneSignal.await();
    }

}

@Override
public void onReceiveResults(Object object) {
    doneSignal.countDown();
}

public interface MyCallback {

    public void onReceiveResults(Object object);

}

public class MyOtherClass {

    public void runAsynchronousTask(MyCallback callback) {
        new Thread() {
            public void run() {
                // do some long-running work
                callback.onReceiveResults(...);
            }
        }.start();
    }

}

Answer 3

如果你还在寻找使用 Intent Service 进行异步回调的方法，你可以在线程上等待并通知如下，

private Object object = new Object();

@Override
protected void onHandleIntent(Intent intent) {
    // Make API which return async calback.

    // Acquire wait so that the intent service thread will wait for some one to release lock.
    synchronized (object) {
        try {
            object.wait(30000); // If you want a timed wait or else you can just use object.wait()
        } catch (InterruptedException e) {
            Log.e("Message", "Interrupted Exception while getting lock" + e.getMessage());
        }
    }
}

// Let say this is the callback being invoked
private class Callback {
    public void complete() {
        // Do whatever operation you want

        // Releases the lock so that intent service thread is unblocked.
        synchronized (object) {
            object.notifyAll();
        }   
    }
}

Answer 4

我最喜欢的选项是公开两个类似的方法，例如：

public List<Dog> getDogsSync();
public void getDogsAsync(DogCallback dogCallback);

那么实现可以如下：

public List<Dog> getDogsSync() {
    return database.getDogs();
}

public void getDogsAsync(DogCallback dogCallback) {
    new AsyncTask<Void, Void, List<Dog>>() {
        @Override
        protected List<Dog> doInBackground(Void... params) {
            return getDogsSync();
        }

        @Override
        protected void onPostExecute(List<Dog> dogs) {
            dogCallback.success(dogs);
        }
    }.execute();
}

然后在您的IntentService 中，您可以调用getDogsSync()，因为它已经在后台线程上。

Answer 5

不改MyOtherClass你就注定了。

更改该类后，您有两个选择：

1. 进行同步调用。 IntentService 已经为你生成了一个背景 Thread。
2. 在runAsynchronousTask()中返回新创建的Thread并调用join()就可以了。

Answer 6

我同意，直接使用Service 可能比IntentService 更有意义，但是如果您使用Guava，您可以实现一个AbstractFuture 作为您的回调处理程序，这样您就可以方便地忽略同步细节：

public class CallbackFuture extends AbstractFuture<Object> implements MyCallback {
    @Override
    public void onReceiveResults(Object object) {
        set(object);
    }

    // AbstractFuture also defines `setException` which you can use in your error 
    // handler if your callback interface supports it
    @Override
    public void onError(Throwable e) {
        setException(e);
    }
}

AbstractFuture 定义 get() 在调用 set() 或 setException() 方法之前阻塞，并分别返回值或引发异常。

那么你的onHandleIntent 变成：

    @Override
    protected final void onHandleIntent(Intent intent) {
        CallbackFuture future = new CallbackFuture();
        MyOtherClass.runAsynchronousTask(future);
        try {
            Object result = future.get();
            // handle result
        } catch (Throwable t) {
            // handle error
        }
    }