Android 如何使用AIDL远程服务处理不同的客户端'；并发请求？

我正在编写一个插件，它定义了一个远程服务，并为第三方开发人员提供了一个AIDL接口

如何使用此远程服务处理不同客户端的并发请求

---

服务apk的活动可以为每个客户端保持状态，当它们在彼此之间切换时，如何做到这一点？

与编写多线程服务器没有太大区别。您为每个客户机保持线程的本地状态，并可能为他们提供某种会话ID，以便您知道您在与谁交谈

这可以通过使用带有活套的HandlerThread来实现，该活套可以维护和服务所有请求，无论从100个应用程序收到什么请求

对于此AIDL，还需要添加回调接口，因为请求将通过这些回调提供

服务器应用程序

IAidlService.aidl

iaidl.aidl

股份有限公司

Stock.java

---

希望能有所帮助：）

我正在尝试实现类似的目标，但有点困惑。Stock.java和Stock.aidl放在哪里？我想所有的AIDL都应该在android studio中的main>aidl>package目录。对吗？您的Stock.aidl是可包裹的，但min是Enum。这有什么不同吗？@sam_0829-请参阅我在。。。您将在sdk模块下找到aidl和相应java文件的位置。我认为当服务与客户端进程处于不同的进程时，它将不起作用。@passerwhu将aidl作为服务的全部意义在于客户端是从不同的进程服务的：）

interface IAidlService {
    void getStockInfo(IAidlCallback callback);
}

oneway interface IAidlCallback {
    void handleStockInfo(in Stock stockinfo);
}

parcelable Stock;

public class Stock implements Parcelable {

String stockName;

public String getStockName() {
    return stockName;
}

public void setStockName(String stockName) {
    this.stockName = stockName;
}

@Override
public int describeContents() {
    return 0;
}

@Override
public void writeToParcel(Parcel dest, int flags) {
    dest.writeString(stockName);
}

public static final Creator<Stock> CREATOR = new Parcelable.Creator<Stock>() {
    @Override
    public Stock createFromParcel(Parcel in) {
        return new Stock(in);
    }

    @Override
    public Stock[] newArray(int size) {
        return new Stock[size];
    }
};

public Stock(Parcel in) {
    this.stockName = in.readString();
}

public Stock() {}
}

public class AidlService extends Service {

private static final int MSG_STOCK_INFO = 53;

private ArrayList<IAidlCallback> mRemoteCallbacks;

private ServiceHandler mHandler = null;

HandlerThread mHandlerThread = new HandlerThread("AidlServiceThread");

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

    mRemoteCallbacks = new ArrayList<>();
}

@Override
public IBinder onBind(Intent intent) {

    // Handler Thread handling all call back methods
    mHandlerThread.start();
    mHandler = new ServiceHandler(mHandlerThread.getLooper());

    return mBinder;
}

/**
 * Stub implementation for Remote service
 */
IAidlService.Stub mBinder = new IAidlService.Stub() {

    @Override
    public void getStockInfo(IAidlCallback callback) throws RemoteException {

        sendMsgToHandler(callback, MSG_STOCK_INFO);
    }
};

/**
 * Create handler message to be sent
 *
 * @param callback
 * @param flag
 */
void sendMsgToHandler(IAidlCallback callback, int flag) {

    mRemoteCallbacks.add(callback);

    Message message = mHandler.obtainMessage();
    message.arg1 = mRemoteCallbacks.size() - 1;

    message.what = flag;
    mHandler.sendMessage(message);
}

/**
 * Handler class sending result in callback to respective
 * application
 */
private class ServiceHandler extends Handler {
    int callbackIndex = 0;

    ServiceHandler(Looper looper) {
        super(looper);
    }

    @Override
    public void handleMessage(Message msg) {
        callbackIndex = msg.arg1;

        switch (msg.what) {

            case MSG_STOCK_INFO:

                Stock stock = new Stock();
                stock.setStockName("Apple Inc");

                try {
                    mRemoteCallbacks.get(callbackIndex).handleStockInfo(stock);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
        }
    }
}
}

IAidlCallback.Stub callback = new IAidlCallback.Stub() {
    @Override
    public void handleStockInfo(Stock stockinfo) throws RemoteException {

        // do what ever you want with stock info :)
    }
};