devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 应用提供SDK Jar包给第三方使用 (设计思路 以及实现步骤)_android 开发sdk怎么根据key开放接口给第三方使用

作者：小丑西瓜9 | 2024-03-18 19:09:28

赞

踩

android 开发sdk怎么根据key开放接口给第三方使用

最近想总结一下关于应用如何封装自己的SDK给第三方应用使用,提供jar包给第三方使用是现在比较常见的方式,方式有很多种,但是具体的大体思路都是一样的,今天写了一个SDK封装的大体框架Demo,方便后期查查阅:

工具基于AndroidStudio 3.6.3版本

AndroidSDKDemo

大体的设计思路分为三个步骤

第一: 服务端 作为服务端 我们需要建立自己的aidl 以及实现类 方便第三方调用的时候 将服务端代理的句柄传给SDK

第二: SDK作为服务端和客户端的中间代理,可以直接拿到服务代理对象进行操作,并暴露给客户端可见的实用类和接口回调类

第三: 客户端只能使用SDK暴露出来的接口进行操作,不持有服务端代理.

具体的逻辑可以下图:

下面是对Demo的详解,个人建议 直接将Demo下载下来阅读即可,后面文章过于繁琐,时间充足的话建议阅读.

 

如图本项目分为三个 :

第一个是 客户端 app是个应用.

第二个是 SDK mylibrary是个lib库.

第三个是 clienapp 是个应用.

 

整体的架构设计如下图：

 

 第一步先编写SDK(mylibrary)  

 

mylibrary是一个lib项目不是可运行项目 

首先需要确定的是需要AIDL做什么, 只有确定了具体需要做的功能才能确定mylibrary项目中新建aidl文件之中的方法,本案例的设计一个是数据传递 一个是 数据回调.

在 MyRemoteCtrl.aidl中做了如下操作

  1. package com.example.mylibrary;
  2.  
  3. import com.example.mylibrary.MySDKStatusCallBack;
  4.  
  5. interface MyRemoteCtrl {
  6.           //传递数据
  7.         void sendMessage(String msg);
  8.         //建立死亡链接
  9.         void linkToDeath(IBinder binder);
  10.         //断开死亡链接
  11.         void unlinkToDeath(IBinder binder);
  12.         //注册callback
  13.         void registerMySDKStatusCallBack(MySDKStatusCallBack mySDKStatusCallBack);
  14.  
  15.         void unregisterMySDKStatusCallBack(MySDKStatusCallBack mySDKStatusCallBack);
  16. }

MySDKStatusCallBack.aidl中做了三个回调函数

  1. // MySDKStatusCallBack.aidl
  2. package com.example.mylibrary;
  3.  
  4. // Declare any non-default types here with import statements
  5.  
  6. interface MySDKStatusCallBack {
  7.  
  8.       void statusCallBackVisible();
  9.  
  10.       void statusCallBackInvisible();
  11.  
  12.       void sendMessage(String message);
  13. }

创建和aidl用户具体的交互基类Controller.java基本 确定SDK的基本功能 因为需要和 service进行绑定所以继承于 ServiceConnection 实现 ServiceConnection的方法.

  1. public interface Controller extends ServiceConnection {
  2.     /**
  3.      * init sdk
  4.      *
  5.      * @param context context
  6.      * @return result
  7.      */
  8.     int init(Context context);
  9.  
  10.     /**
  11.      * setStateCallback
  12.      *
  13.      * @param remoteSDKStatusCallBack
  14.      */
  15.  
  16.     void setStateCallback(RemoteSDKStatusCallBack remoteSDKStatusCallBack);
  17.  
  18.  
  19.     void setMessage(String msg);
  20.  
  21.     /***
  22.      * release sdk
  23.      */
  24.     void release();
  25.  
  26. }

有了上面的AIDL文件之后开始确定 SDK的入口类MyLibSDK.java 这个类是需要暴露给第三方的使用的入口类,别人使用jar包的时候 只能通过 MyLibSDK.java类进行操作.

  1. package com.example.mylibrary;
  2.  
  3. import android.content.Context;
  4.  
  5. import com.example.mylibrary.base.Controller;
  6. import com.example.mylibrary.callback.RemoteSDKStatusCallBack;
  7. import com.example.mylibrary.imp.MyController;
  8.  
  9. public class MyLibSDK {
  10.     private volatile static MyLibSDK mInstance;
  11.     private Controller mController;
  12.  
  13.     private MyLibSDK() {
  14.     }
  15.  
  16.     public static MyLibSDK getInstance() {
  17.         if (mInstance == null) {
  18.             synchronized (MyLibSDK.class) {
  19.                 if (mInstance == null) {
  20.                     mInstance = new MyLibSDK();
  21.                 }
  22.             }
  23.         }
  24.         return mInstance;
  25.     }
  26.  
  27.     /**
  28.      * 初始化SDK
  29.      *
  30.      * @param context context
  31.      * @return result
  32.      */
  33.     public int init(Context context) {
  34.         mController = MyController.getInstance();
  35.         return mController.init(context);
  36.     }
  37.  
  38.     /***
  39.      * 发送消息
  40.      */
  41.     public void setMessage(String msg) {
  42.         if (mController != null) {
  43.             mController.setMessage(msg);
  44.         }
  45.  
  46.     }
  47.  
  48.     /***
  49.      * 释放SDK
  50.      */
  51.     public void release() {
  52.         if (mController != null) {
  53.             mController.release();
  54.         }
  55.     }
  56.  
  57.     /***
  58.      * 设置监听
  59.      */
  60.     public void setStateCallback(RemoteSDKStatusCallBack remoteSDKStatusCallBack) {
  61.         if (mController != null) {
  62.             mController.setStateCallback(remoteSDKStatusCallBack);
  63.         }
  64.     }
  65.  
  66. }

具体的业务实现类是 MyController.java 它持有 MySDKStatusCallBack和 MyRemoteCtrl 对象 ,MySDKStatusCallBack MyRemoteCtrl 是aidl的类系统对创建对应的java文件如果没有创建 就使用编译器clean 一下项目 然后再build一下 项目

其实MyController.java ;类中的的 MyRemoteCtrl 就是绑定服务端之后服务端返回的代理对象, MyController.java 持有代理对象进行和服务端的交互操作.

  1. package com.example.mylibrary.imp;
  2.  
  3. import android.app.Service;
  4. import android.content.ComponentName;
  5. import android.content.Context;
  6. import android.content.Intent;
  7. import android.os.IBinder;
  8. import android.os.RemoteException;
  9. import android.util.Log;
  10.  
  11. import com.example.mylibrary.MyRemoteCtrl;
  12. import com.example.mylibrary.MySDKStatusCallBack;
  13. import com.example.mylibrary.base.Controller;
  14. import com.example.mylibrary.callback.RemoteSDKStatusCallBack;
  15.  
  16. public class MyController implements Controller {
  17.  
  18.  
  19.     private MyRemoteCtrl mMyRemoteCtrl;
  20.     private RemoteSDKStatusCallBack mRemoteSDKStatusCallBack;
  21.     private boolean isbind;
  22.     private volatile static Controller mInstance;
  23.     protected Context mContext;
  24.  
  25.     //死亡链接
  26.     private MySDKStatusCallBack mMySDKStatusCallBack = new MySDKStatusCallBack.Stub() {
  27.  
  28.         @Override
  29.         public void statusCallBackVisible() throws RemoteException {
  30.             mRemoteSDKStatusCallBack.statusCallBackVisible();
  31.         }
  32.  
  33.         @Override
  34.         public void statusCallBackInvisible() throws RemoteException {
  35.             mRemoteSDKStatusCallBack.statusCallBackInvisible();
  36.         }
  37.  
  38.         @Override
  39.         public void sendMessage(String message) throws RemoteException {
  40.             mRemoteSDKStatusCallBack.sendMessage(message);
  41.         }
  42.  
  43.     };
  44.  
  45.  
  46.     private MyController() {
  47.     }
  48.  
  49.     @Override
  50.     public int init(Context context) {
  51.         //初始化服务
  52.         Log.d("mysdk", " sdk  初始化服务  ");
  53.         mContext = context;
  54.         return initService();
  55.     }
  56.  
  57.     @Override
  58.     public void setStateCallback(RemoteSDKStatusCallBack remoteSDKStatusCallBack) {
  59.         Log.d("mysdk", " sdk  setStateCallback  ");
  60.         this.mRemoteSDKStatusCallBack = remoteSDKStatusCallBack;
  61.     }
  62.  
  63.     private int initService() {
  64.         Log.d("mysdk", " sdk  initService  ");
  65.         Intent intent = new Intent("com.example.androidsdkdemo.service.MySDKService");
  66.         intent.setClassName("com.example.androidsdkdemo", "com.example.androidsdkdemo.service.MySDKService");
  67.         isbind = mContext.bindService(intent, this, Service.BIND_AUTO_CREATE);
  68.         return 0;
  69.     }
  70.  
  71.     @Override
  72.     public void setMessage(String msg) {
  73.         try {
  74.             Log.d("mysdk", " sdk  setMessage  ");
  75.             mMyRemoteCtrl.sendMessage(msg);
  76.         } catch (RemoteException e) {
  77.             e.printStackTrace();
  78.         }
  79.     }
  80.  
  81.     @Override
  82.     public void release() {
  83.         Log.d("mysdk", " sdk  release  ");
  84.         //SDK内部做释放操作
  85.  
  86.     }
  87.  
  88.     @Override
  89.     public void onServiceConnected(ComponentName name, IBinder service) {
  90.         Log.d("mysdk", " sdk  onServiceConnected  ");
  91.         if (service == null) {
  92.             if (mMyRemoteCtrl != null) {
  93.                 try {
  94.                     mMyRemoteCtrl.unlinkToDeath(mMySDKStatusCallBack.asBinder());
  95.                 } catch (RemoteException e) {
  96.                     e.printStackTrace();
  97.                 }
  98.             }
  99.             mMyRemoteCtrl = null;
  100.         } else {
  101.             mMyRemoteCtrl = MyRemoteCtrl.Stub.asInterface(service);
  102.             if (mMyRemoteCtrl != null) {
  103.                 try {
  104.                     mMyRemoteCtrl.linkToDeath(mMySDKStatusCallBack.asBinder());
  105.                 } catch (RemoteException e) {
  106.                     e.printStackTrace();
  107.                 }
  108.  
  109.                 try {
  110.                     mMyRemoteCtrl.registerMySDKStatusCallBack(mMySDKStatusCallBack);
  111.                 } catch (RemoteException e) {
  112.                     e.printStackTrace();
  113.                 }
  114.             }
  115.         }
  116.     }
  117.  
  118.     @Override
  119.     public void onServiceDisconnected(ComponentName name) {
  120.         Log.d("mysdk", " sdk  onServiceDisconnected  ");
  121.         if (mMyRemoteCtrl != null) {
  122.             try {
  123.                 mMyRemoteCtrl.unregisterMySDKStatusCallBack(mMySDKStatusCallBack);
  124.                 mMyRemoteCtrl.unlinkToDeath(mMySDKStatusCallBack.asBinder());
  125.             } catch (RemoteException e) {
  126.                 e.printStackTrace();
  127.             }
  128.         }
  129.         mMyRemoteCtrl = null;
  130.     }
  131.  
  132.     public static Controller getInstance() {
  133.         if (mInstance == null) {
  134.             synchronized (MyController.class) {
  135.                 if (mInstance == null) {
  136.                     mInstance = new MyController();
  137.                 }
  138.             }
  139.         }
  140.         return mInstance;
  141.     }
  142. }

MyController.java 里有一个 RemoteSDKStatusCallBack对象,这个对象是暴露给客户 让客户进行注册的类对象属于SDK自己的CallBack类,当客户端设置这个Callback之后 SDK中就持有了客户端实现的Callback对象实例, SDK在接收到 服务端的回调之后 可以通过RemoteSDKStatusCallBack 实例回调给客户.这样做有个好处,客户端不会持有服务端的代理对象和不会持有SDK中的AIDL的回调实例,SDK中实现的AIDL具体的Callback就对客户是不可见的,此处RemoteSDKStatusCallBack.java 内部的名字和MySDKStatusCallBack.aidl的相同,也可以根据自己的需求添加接口,或者修改名称.

  1. package com.example.mylibrary.callback;
  2.  
  3. public interface RemoteSDKStatusCallBack {
  4.     void statusCallBackVisible();
  5.  
  6.     void statusCallBackInvisible();
  7.  
  8.     void sendMessage(String message);
  9. }

之后进行进行生成jar包的配置,在mylibrary 的build.gradle 里面添加如下代码

注意 from('build/intermediates/aar_main_jar/debug/') 可能路径不同的版本不同需要搜索一下 classes.jar 路径 进行替换即可

  1. task makeJar(type:Copy){
  2.     //如果之前存在，则先删除
  3.     delete 'build/libs/mysdklib.jar'
  4.     //设置拷贝的文件
  5.     from('build/intermediates/aar_main_jar/debug/')
  6.     //生成jar包后的文件目录位置
  7.     into('build/libs/')
  8.     //include,exclude参数来设置过滤
  9.     include('classes.jar')
  10.     //重命名
  11.     rename('classes.jar','mysdklib.jar')
  12. }
  13. makeJar.dependsOn(build)

生成jar包的两种方式

  1,可以在根目录执行  ./gradlew makeJar

2.或者在右上角的 Gradle --> mylibrary-->Tasks --> other --> makeJar 双击makeJar 生成

到此 jar包的生成已经做完了.

 

第二步 : 写服务端的类 服务端app 

首先需要将 mylibrary 导入到app中,因为需要要到SDK中的aidl,在APP项目中的build.gradle 中的 dependencies 添加如下代码不然服务端使用不了mylibrary中的aidl文件.

implementation project(':mylibrary')

MySDKService.java 中的内部类 MyRemoteCtrlImpl 是服务的代理类 也是SDK端拿到的 MyRemoteCtrl代理对象类,服务中我们可以控制代理对象具体功能,那么也就间接的控制了第三方可以使用服务端app的那些功能,我们这里这里没有做具体的控制逻辑,只是将接收到的数据进行返回操作即可. 

  1. package com.example.androidsdkdemo.service;
  2.  
  3. import android.app.Service;
  4. import android.content.Intent;
  5. import android.os.IBinder;
  6. import android.os.RemoteException;
  7. import android.util.Log;
  8.  
  9. import androidx.annotation.Nullable;
  10.  
  11. import com.example.mylibrary.MySDKStatusCallBack;
  12. import com.example.mylibrary.MyRemoteCtrl;
  13.  
  14. public class MySDKService extends Service {
  15.  
  16.     private MyRemoteCtrlImpl mCarcorderRemoteCtrl = new MyRemoteCtrlImpl();
  17.     private MySDKStatusCallBack mMySDKStatusCallBack = null;
  18.     @Nullable
  19.     @Override
  20.     public IBinder onBind(Intent intent) {
  21.         //返回内部代理对象给调用端
  22.         return mCarcorderRemoteCtrl.asBinder();
  23.     }
  24.  
  25.  
  26.     public class MyRemoteCtrlImpl extends MyRemoteCtrl.Stub {
  27.         private IBinder mBinder = null;
  28.         private Object deathRecipient;
  29.  
  30.         @Override
  31.         public void sendMessage(String msg) throws RemoteException {
  32.            if (mMySDKStatusCallBack != null) {
  33.                mMySDKStatusCallBack.sendMessage("我已经接收到你的数据返回给你 =  " + msg);
  34.            }
  35.         }
  36.  
  37.         @Override
  38.         public void linkToDeath(IBinder binder) throws RemoteException {
  39.             Log.d("mysdk"," 服务端 建立死亡链接  ");
  40.             mBinder = binder;
  41.             binder.linkToDeath(mDeathRecipient, 0);
  42.         }
  43.  
  44.  
  45.         @Override
  46.         public void unlinkToDeath(IBinder binder) throws RemoteException {
  47.             Log.d("mysdk"," 服务端 断开客户端死亡链接  ");
  48.             binder.unlinkToDeath(mDeathRecipient, 0);
  49.             mBinder = null;
  50.         }
  51.  
  52.         @Override
  53.         public void registerMySDKStatusCallBack(MySDKStatusCallBack mySDKStatusCallBack) throws RemoteException {
  54.             Log.d("mysdk"," 服务端 接收到 registerMySDKStatusCallBack ");
  55.             mMySDKStatusCallBack = mySDKStatusCallBack;
  56.             // mMySDKStatusCallBack 为第三方通过SDK传递过来的 对象 调用 mySDKStatusCallBack.statusCallBackInvisible()
  57.             // 相当于持有  MySDKStatusCallBack mMySDKStatusCallBack
  58.  
  59.             //这里不做操作直接返回即可
  60.             if (mMySDKStatusCallBack != null) {
  61.                 mySDKStatusCallBack.statusCallBackInvisible();
  62.             }
  63.         }
  64.  
  65.         @Override
  66.         public void unregisterMySDKStatusCallBack(MySDKStatusCallBack mySDKStatusCallBack) throws RemoteException {
  67.             Log.d("mysdk"," 服务端 接收到 unregisterMySDKStatusCallBack ");
  68.             mMySDKStatusCallBack = null;
  69.         }
  70.     }
  71.  
  72.  
  73.  
  74.     IBinder.DeathRecipient mDeathRecipient =  new IBinder.DeathRecipient() {
  75.             @Override
  76.             public void binderDied() {
  77.               /*  if (mMySDKStatusCallBack != null) {
  78.                     try {
  79.                         mMySDKStatusCallBack.statusCallBackInvisible();
  80.                     } catch (RemoteException e) {
  81.                         e.printStackTrace();
  82.                     }
  83.                 }*/
  84.  
  85.                 //客户端可以执行释放操作
  86.                 Log.d("mysdk"," 调用端已经死亡");
  87.             }
  88.  
  89.         };
  90.  
  91. }

在AndroidManifest.xml中天机如下代码       android:enabled="true"   android:exported="true" 4.4 版本之后必须添加

  1.        <service
  2.             android:name="com.example.androidsdkdemo.service.MySDKService"
  3.             android:enabled="true"
  4.             android:exported="true">
  5.         </service>

到此处服务端添加完成,此时可以运行一下服务端,先安装到手机上方便后期直接调用.

 

第三步:客户端 clienapp实现 

将mysdklib.jar 拷贝到 AndroidSDKDemo/clienapp/libs 下面 并且在 clienapp 项目 中 build.gradle的dependencies中

添加如下:

implementation files('libs/mysdklib.jar')

在 MainActivity 使用我们的sdk jar包中的类 MyLibSDK 进行服务端交互

  1. package com.example.clienapp;
  2.  
  3. import androidx.appcompat.app.AppCompatActivity;
  4.  
  5. import android.os.Bundle;
  6. import android.util.Log;
  7. import android.view.View;
  8.  
  9. import com.example.mylibrary.MyLibSDK;
  10. import com.example.mylibrary.callback.RemoteSDKStatusCallBack;
  11.  
  12. public class MainActivity extends AppCompatActivity {
  13.  
  14.     @Override
  15.     protected void onCreate(Bundle savedInstanceState) {
  16.         super.onCreate(savedInstanceState);
  17.         setContentView(R.layout.activity_main);
  18.  
  19.         MyLibSDK.getInstance().init(this);
  20.         MyLibSDK.getInstance().setStateCallback(new RemoteSDKStatusCallBack() {
  21.             @Override
  22.             public void statusCallBackVisible() {
  23.                 Log.d("mysdk"," 客户端  statusCallBackVisible  ");
  24.             }
  25.  
  26.             @Override
  27.             public void statusCallBackInvisible() {
  28.                 Log.d("mysdk"," 客户端  statusCallBackInvisible  ");
  29.             }
  30.  
  31.             @Override
  32.             public void sendMessage(String s) {
  33.                 Log.d("mysdk"," 客户端  sendMessage   " + s);
  34.             }
  35.         });
  36.     }
  37.  
  38.  
  39.     public void  sedmessage(View view) {
  40.         Log.d("mysdk"," 客户端  sendMessage 我是客户端  " );
  41.         MyLibSDK.getInstance().setMessage("我是客户端");
  42.     }
  43.  
  44. }

注意先运服务端再运行客户端 


运行结果如下:

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/265182
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号