Activity与Android库之间通信的选项（IPC）

Question

Activity与Android库之间通信的选项（IPC）

androidipcandroid-library

4

假设我有一个SDK，以Android Library (aar)的形式提供基本的媒体处理功能（它有自己的UI作为单个活动）。目前，任何客户端Android应用程序在调用我的SDK时，通过Bundle发送所需的数据。

现在，由于各种原因，在调用我的SDK后可能需要发送被发送数据的一些额外信息，因此我需要与调用方应用程序进行双向通信。

简而言之，在SDK内部，我需要能够检查客户端应用程序是否实现了某些接口，以便SDK可以使用它与客户端应用程序进行通信（客户端可能选择不提供实现，在这种情况下，SDK将回退到内部默认实现...）。

无论如何，我最初的做法是这样的：

在SDK中，我已经公开了数据提供程序接口：

public interface ISDKDataProvider {

    void getMeSomething(Params param, Callback callback);

    SomeData getMeSomethingBlocking(Params param);
}

一个本地绑定器接口，应该返回一个已实现接口的实例：

public interface LocalBinder {
   ISDKDataProvider getService();
}

然后，在客户端，使用SDK的应用程序必须提供一个执行任务并实现这些接口的服务：

public class SDKDataProviderService extends Service implements ISDKDataProvider {
    private final IBinder mBinder = new MyBinder();

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

    @Override
    public void getMeSomething(Params param, Callback callback) {
        // ... do something on another thread
        // once done, invoke callback and return result to the SDK
    }

    @Override
    public SomeData getMeSomethingBlocking(Params param);{
        // do something..
        // return SomeData
    }

    public class MyBinder extends Binder implements LocalBinder {
        @Override
        public ISDKDataProvider getService() {
            return ISDKDataProvider.this;
        }
    }
}

此外，在调用SDK时，客户端应用程序通过bundle选项传递ComponentName：

sdkInvokationOptions.put("DATA_PROVIDER_EXTRAS", new ComponentName(getPackageName(), SDKDataProviderService.class.getName()));

从SDK中，我会检查服务是否存在以及是否可以绑定到它：

final ComponentName componentName = // get passed componentname "DATA_PROVIDER_EXTRAS"

if (componentName != null) {

    final Intent serviceIntent = new Intent(componentName.getClassName());
    serviceIntent.setComponent(componentName);
    bindService(serviceIntent, mConnection, Context.BIND_AUTO_CREATE);

}

其中mConnection是:

private boolean mBound;
private ISDKDataProvider mService;
private ServiceConnection mConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
       final LocalBinder binder = (LocalBinder) service;
       mService = binder.getService();
       mBound = true;
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
      mBound = false;
    }
};

这似乎可以正常工作，而且看起来很简洁，但我的问题是是否有更好的方法/实践来实现同样类型的通信？

- sinek

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Asaf Pinhassi · Accepted Answer

你的API应该简单易懂，例如一个静态类/单例：

MyAPI.start()
MyAPI.stop()
MyAPI.sendMessgage(mgs,callback)
MyAPI.setCallback(callback)

关于这项服务，我认为您应该决定谁负责它。

如果是用户-让他实现，只需提供API即可。

如果您始终希望将API作为服务运行，请自己实现并在单例中处理消息传递（例如，您可以使用意图来实现）。

我也将此架构用于图像处理服务 :)

我的API封装类如下:

public class MyAPI {
    public static final String TAG = "MyAPI";

    public MyAPI() {
    }

    public static MyAPI.Result startMyAPI(ScanParams scanParams) {
        try {
            Log.d("MyAPI", "in startMyAPI");
            if (scanParams.ctx == null || scanParams.appID == null || scanParams.api_key == null) {
                Log.d("MyAPI", "missing parameters");
                return MyAPI.Result.FAILED;
            }

            if (scanParams.userID == null) {
                scanParams.userID = "no_user";
            }

            if (scanParams.minBatteryThreshold == null) {
                scanParams.minBatteryThreshold = Consts.DEFAULT_BATTERY_THRESHOLD;
            }

            if (scanParams.minCpuThreshold == null) {
                scanParams.minCpuThreshold = Consts.DEFAULT_CPU_THRESHOLD;
            }

            if (!DeviceUtils.checkBatteryLevel(scanParams.ctx, (float)scanParams.minBatteryThreshold)) {
                ReportUtils.error("low battery");
                return MyAPI.Result.FAILED;
            }

            if (MyAPIUtils.isRunning(scanParams.ctx)) {
                return MyAPI.Result.FAILED;
            }

            Intent intent = new Intent(scanParams.ctx, MyAPIService.class);
            ServiceParams serviceParams = new ServiceParams(scanParams.appID, scanParams.api_key, scanParams.userID, scanParams.minBatteryThreshold, scanParams.minCpuThreshold);
            intent.putExtra("SERVICE_PARAMS", serviceParams);
            scanParams.ctx.startService(intent);
        } catch (Exception var3) {
            var3.printStackTrace();
        }

        return MyAPI.Result.SUCCESS;
    }

    public static void getBestCampaignPrediction(Context ctx, String apiKey, String appID, String creativeID, AppInterface appInterface) {
        try {
            String deviceID = DeviceUtils.getDeviceID(ctx);
            GetBestCampaignTask getBestCampaignTask = new GetBestCampaignTask(ctx, apiKey, deviceID, appID, creativeID, appInterface);
            getBestCampaignTask.execute(new Void[0]);
        } catch (Exception var7) {
            var7.printStackTrace();
        }

    }

    public static boolean sendAdEvent(Context ctx, String apiKey, Event event) {
        boolean res = false;

        try {
            boolean isValid = Utils.getIsValid(ctx);
            if (isValid) {
                Long timeStamp = System.currentTimeMillis();
                event.setTimeStamp(BigDecimal.valueOf(timeStamp));
                event.setDeviceID(DeviceUtils.getDeviceID(ctx));
                (new SendEventTask(ctx, apiKey, event)).execute(new Void[0]);
            }
        } catch (Exception var6) {
            var6.printStackTrace();
        }

        return res;
    }

    public static enum PredictionLevel {
        MAIN_CATEGORY,
        SUB_CATEGORY,
        ATTRIBUTE;

        private PredictionLevel() {
        }
    }

    public static enum Result {
        SUCCESS,
        FAILED,
        LOW_BATTERY,
        LOW_CPU,
        NOT_AUTHENTICATED;

        private Result() {
        }
    }
}

你可以看到，startMyAPI实际上启动了一个服务，而getBestCampaignPrediction运行了一个异步任务，与幕后的服务进行通信，并将其结果返回给appInterface回调。这样用户就获得了一个非常简单的API。