Уведомлять службу Android, когда связанный клиент отключается

У меня есть служба android в удаленном процессе, который может иметь несколько привязок от разных клиентов. Мой вопрос заключается в том, как служба может получать уведомление, когда конкретный связанный клиент неожиданно отключается (т.е. Клиент разбился)? Я не могу использовать onUnbind(), потому что он вызывается только после того, как клиенты all были отключены.

public class MyService extends Service {

    final Messenger mServiceMessenger = new Messenger(new IncomingHandler());

    @Override
    public IBinder onBind(Intent intent) {
        return mServiceMessenger.getBinder();
    }

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return Service.START_STICKY;
    }

    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
        // Handling messages logic...
        }
    }
}

Ответ 1

вы можете использовать обработчик IncomingHandler, который у вас есть, и отправить сообщение от клиента, что оно будет незакреплено перед вызовом unbindService (serviceConnection), сохраняя arraylist Messengers (клиентов) и добавляя/удаляя при получении сообщения.

вы также можете попытаться отправить фиктивные сообщения, и если вы получите RemoteException, значит, что удаленный клиент мертв.

проверьте этот пример http://developer.android.com/reference/android/app/Service.html

экстракт:

class IncomingHandler extends Handler {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case MSG_REGISTER_CLIENT:
                mClients.add(msg.replyTo);
                break;
            case MSG_UNREGISTER_CLIENT:
                mClients.remove(msg.replyTo);
                break;
            case MSG_SET_VALUE:
                mValue = msg.arg1;
                for (int i=mClients.size()-1; i>=0; i--) {
                    try {
                        mClients.get(i).send(Message.obtain(null,
                                MSG_SET_VALUE, mValue, 0));
                    } catch (RemoteException e) {
                        // The client is dead.  Remove it from the list;
                        // we are going through the list from back to front
                        // so this is safe to do inside the loop.
                        mClients.remove(i);
                    }
                }
                break;
            default:
                super.handleMessage(msg);
        }
    }
}

Ответ 2

Это можно сделать с помощью механизма Binder.linkToDeath(). Вам нужно будет попросить каждого клиента отправить объект new Binder(), который они инициировали, а затем связать с смертью своих (ваших клиентов). Я объясню, как преформировать это, используя AIDL файлы.

(Вы можете выбрать любой механизм IPC для Android, пока вы можете пройти Связывает объекты с вашим клиентом на ваш сервис)

Пример кода -

Внутри вашего файла .AIDL. Создайте метод для передачи объекта IBinder от клиента к службе

void registerProcessDeath(in IBinder clientDeathListener, String packageName);

На стороне клиента. Инициализируйте новый объект и передайте его в свою службу через интерфейс AIDL.

public void onServiceConnected(ComponentName className, IBinder service) {
    mIMyAidlInterface = IMyAidlInterface.Stub.asInterface(service);
    //Call the registerProcessDeath method from the AIDL file and pass 
    //the new Binder object and the client package name
    mIMyAidlInterface.registerProcessDeath(new Binder(),getPackageName());
}

На стороне обслуживания -

1. Получите клиента Binder и зарегистрируйтесь на его linkToDeath().
2. Используйте вспомогательный класс для обработки всех клиентов с помощью android IBinder.DeathRecipient class

public class MyService extends Service {
    //Helper class to handle all client deaths.
    private volatile ClientsDeathWatcher mClientsList;

    @Override
    public IBinder onBind(Intent intent) {
        mClientsList = new ClientsDeathWatcher();
        return mStub;
    }

    private final IMyAidlInterface.Stub mStub = new IMyAidlInterface.Stub() {

        @Override
        public void registerProcessDeath(IBinder cb, String packageName){

            boolean isRegistered = mClientsList.register(cb , packageName);
        }
    };
}
//This is thread-safe helper class to handle all 
//the client death related tasks.

//All you care abut is the clientDeath() method. 
public class ClientsDeathWatcher {

    private ArrayMap<String, DeathCallBack> mCallbacks = new ArrayMap<>();

    private final class DeathCallBack implements IBinder.DeathRecipient {
        private String pn;
        private IBinder mBinder;

        DeathCallBack(String packageName,IBinder binder) {
            pn = packageName;
            mBinder = binder;
        }

        public void binderDied() {
            synchronized (mCallbacks) {
                mBinder.unlinkToDeath(this,0);
                clientDeath(pn);
            }
        }
    }

    //To be called only from thread-safe functions
    private void clientDeath(String packageName) {
        mCallbacks.remove(packageName);
        //Do your stuff here.
        //$$$$$$$$$
    }

    public boolean register(IBinder token, String packageName) {
        synchronized (mCallbacks) {
            try {
                if (!mCallbacks.containsKey(packageName)) {
                    DeathCallBack mDeathCallBack = new DeathCallBack(packageName,token);
                    mCallbacks.put(packageName, mDeathCallBack);
                    //This is where the magic happens
                    token.linkToDeath(mDeathCallBack, 0);
                }
                return true;
            } catch (RemoteException e) {
                e.printStackTrace();
                return false;
            }
        }
    }
}