Question

让我们假设我们有一个简单的Android应用程序，它通过IPC连接到远程服务，安排一个相对较长的任务，然后继续工作，同时等待回调一些结果。 AIDL接口：

IRemoteService.aidl

package com.var.testservice;
import com.var.testservice.IServCallback;

interface IRemoteService {

    void scheduleHeavyTask(IServCallback callback);

}

IRemoteService.aidl

package com.var.testservice;

interface IServCallback {

    void onResult(int result);

}

活动代码：

package com.var.testclient;

import com.var.testservice.IServCallback;
import com.var.testservice.IRemoteService;

import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;

public class MainActivity extends Activity {

    private static final String TAG = "TestClientActivity"; 

    private IServCallback.Stub servCallbackListener = new IServCallback.Stub(){
        @Override
        public void onResult(int result) throws RemoteException {
            Log.d(TAG, "Got value: " + result);
        }

};

private ServiceConnection servConnection = new ServiceConnection(){

    @Override
    public void onServiceConnected(ComponentName name, IBinder binder) {
        service = IRemoteService.Stub.asInterface(binder);          
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
        service = null;         
    }

    };

    private IRemoteService service;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        if(!bindService(new Intent(IRemoteService.class.getName()), servConnection, Context.BIND_AUTO_CREATE)){
            Log.d(TAG, "Service binding failed");
        } else {
            Log.d(TAG, "Service binding successful");
        }
    }

    @Override
    protected void onDestroy() {
        if(service != null) {
            unbindService(servConnection);
        }
        super.onDestroy();
    }

    public void onButtonClick(View view){
        Log.d(TAG, "Button click");
        if(service != null){
            try {
                service.scheduleHeavyTask(servCallbackListener);
            } catch (RemoteException e) {
                Log.d(TAG, "Oops! Can't schedule task!");
                e.printStackTrace();
            }
        }
    }

}

服务守则：

package com.var.testservice;

import android.app.Service;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.RemoteException;
import android.util.Log;

public class TestService extends Service {

    private static final String TAG = "TestService";

    class TestServiceStub extends IRemoteService.Stub {

        private IServCallback servCallback;
        //These 2 fields will be used a bit later
        private Handler handler;
        private int result;

        //The simpliest implementation. In next snippets I will replace it with
        //other version
        @Override
        public void scheduleHeavyTask(IServCallback callback)
                    throws RemoteException {
            servCallback = callback;
            result = doSomethingLong();
            callback.onResult(result);
        }

        private int doSomethingLong(){
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                return 42;
            }
        }

    }

    @Override
    public IBinder onBind(Intent intent) {
        return new TestServiceStub();
    }

}

这个版本虽然非常愚蠢（它使应用程序的UI线程挂起5秒，导致ANR），但它成功地通过IPC执行所有调用，将结果传递给活动。如果我尝试将计算放入单独的线程中，问题就会出现：

@Override
public void scheduleHeavyTask(IServCallback callback)
        throws RemoteException {
    servCallback = callback;
    Runnable task = new Runnable(){

        @Override
        public void run() {
            result = doSomethingLong();
            try {
                Log.d(TAG, "Sending result!");
                servCallback.onResult(result);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

    };
    new Thread(task).start();
}

在这种情况下，回调不会传递给活动：服务成功调用servCallback.onResult(result);，但在活动中没有调用任何内容。没有例外，没有线索，没有幸存者：完美的谋杀谋杀。我找不到任何关于这种行为的可能原因的信息，所以如果有人能澄清这里发生的事情，我将不胜感激。我的建议是，有某种安全机制，跟踪哪些确切的线程被绑定，并忽略来自其他线程的“不安全”调用（当我们尝试从非UI线程中弄乱UI元素时会发生类似情况），但我不能一定不会。

最明显的解决方案是将回调调用发布到绑定线程，所以我做了这个：

@Override
public void scheduleHeavyTask(IServCallback callback)
        throws RemoteException {
    Log.d(TAG, "Schedule request received.");
    servCallback = callback;
    if(Looper.myLooper() == null) {
        Looper.prepare();
    }

    handler = new Handler();
    Runnable task = new Runnable(){

        @Override
        public void run() {
            result = doSomethingLong();
            Log.d(TAG, "Posting result sender");
            handler.post(new Runnable(){

                @Override
                public void run() {
                    try {
                        Log.d(TAG, "Sending result!");
                        servCallback.onResult(result);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    Looper.myLooper().quit();
                    Log.d(TAG, "Looper stopped");
                }

            });
        }

    };
    new Thread(task).start();
    Looper.loop();
}

我在这里遇到了两个问题：

我不得不调用Looper.loop()来启用回调runnables的处理，但是它阻止了IPC，所以我得到了与开头相同的结果 - 没有实际的多线程;

第二次注册回调（在第一个周期完成并返回值之后）导致异常：

java.lang.RuntimeException: Handler (android.os.Handler) sending message to a Handler on a dead thread
at android.os.MessageQueue.enqueueMessage
at android.os.Handler.sendMessageAtTime
at android.os.Handler.sendMessageDelayed
at android.os.Handler.post
at com.var.testservice.TestService$TestServiceStub$1.run
at java.lang.Thread.run

这让我感到很困惑：我从实际的Looper创建一个新的实例，它怎么能指向死线？

服务能够排队完成任务并在完成后回调的整个想法对我来说听起来并不疯狂，所以我希望有经验的人能够解释我：

为什么我不能从不同的线程实际进行IPC调用？
我的Handler？
我应该使用哪些工具/架构来建立一个干净，正确的队列机制，这样它就可以在正确的线程上调用IPC方法而不必经常调用Looper.loop() / Looper.quit()？

谢谢。

Answer 1

我无法解释为什么你的程序无效。但涉及线程和异步回调的版本：

@Override
public void scheduleHeavyTask(IServCallback callback)
        throws RemoteException {
    servCallback = callback;
    Runnable task = new Runnable(){

        @Override
        public void run() {
            result = doSomethingLong();
            try {
                Log.d(TAG, "Sending result!");
                servCallback.onResult(result);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

    };
    new Thread(task).start();
}

应该可以正常工作。

以下是Android如何为AIDL和其他类型的Binder交易安排线程。

如果调用者和被调用者处于同一进程中，则它将成为一个简单的方法调用。所以，你应该在与scheduleHeavyTask完全相同的线程中调用onButtonClick。同样，你应该从运行任务的线程中调用onResult应该是一个简单的方法调用。
如果调用者和被调用者处于不同的进程中，Android将从被调用者进程中的一个线程池中运行Binder事务（它们被称为Binder＃1等）即使在这里它也非常聪明 - 所以如果{{1} } onButtonClick调用scheduleHeavyTask从同一个帖子调用onResult，然后onButtonClick会直接显示在调用者进程中调用onResult。

绝对没有机制可以避免来自“不安全”或“未绑定”线程的调用 - 所以这个发布的简单方法应该工作。正如你所说，这是一种常见的模式，我已经使用了很多次。因此，我建议继续这样做，而不是摆弄额外的操纵者和处理者。

以下是一些想法：

在调试器中运行它。假设您的服务和活动处于同一过程中，您应该能够设置断点并查看合理的方法调用。
即使您不能，也可以从命令行启动ddms，或在Eclipse中显示设备和线程视图。这将为您提供每个线程正在做什么的视图 - 您可以获得一个callstack。即使在全面调试器不方便的情况下，通常也可以使用它。
你在任何地方都有synchronized这个词吗？可能发生的事情是onResult希望继续运行，但它在某些监视器上被阻止。一旦它被解锁，它就可以运行。

在远程服务中使用处理程序

1 个答案: