盐析白兔

这个屌丝很懒，什么也没留下！

热门标签

Android 统一打包框架（附源码下载）_android 游戏sdk网页自动打包

作者：盐析白兔 | 2024-05-15 16:27:44

踩

android 游戏sdk网页自动打包

唠叨：
把手给我，我带你去吃云浮吃石磨肠粉、云吞面，木瓜渣。
那里的肠粉和广州的不一样，皮很薄很滑，肉馅没广州的那么花里胡哨，只有肉碎和香葱。但吃起来就很香滑，再配上它的甜辣酱。那味道好极了。
云吞面的面是手打的竹升面，就是手动用个大竹子，一下下压打那面团做出来的。入口很爽脆，而且即使泡久了，面也不会糊。但最喜欢的还是它那里的自制辣椒酱，不是很辣，但是很香。
…醒醒，醒醒，工作啦。
哦，天亮了？
来，把手给我，我带你码统一打包框架。

序言：

统一打包框架有什么用？
现在市面上大大小小的渠道加起来不下百家。虽然很多渠道SDK的接入方法都大同小异，正常接入耗时并不会很久。但如果你每一个游戏都一遍遍手动接入，每修改一个需求就又全部手动接入一遍，你可能得天天欣赏凌晨的广州了。所以统一打包框架就是为了可以让游戏便捷的接入SDK。

概述：

目的：通过配置文件完成SDK的接入并且出包。
主要就是三个部分：
一、SDK接入框架
二、各SDK的接入实现
三、打包工具

一、SDK接入框架

1、结构：

YMSDK - 业务层访问SDK的唯一入口

PluginFactory - 实例化插件的工厂，通过读取assets目录下的sdk_config.xml文件，配置对应的插件信息，在需要实例化插件时，读取这些配置信息，构造对应的SDK实例。

IUser等 - 对应的插件接口，定义此插件所拥有的功能。

YMUser等 - 对应插件的代理，代理通过实例化插件的工厂构造插件的实例对象。业务层与代理交互，代理就调用对应插件接口的实例对象方法。

2、具体代码：

1）、IUse 和 IPay，IEvent。

一般的联运SDK都包含 login登录，exit退出，部分也含有pay支付方法。广告SDK一般只需要在游戏的特定场景展示/隐藏广告，即showAD和hideAD方法。
把它们拆分开来定义三类接口。
用户登录插件接口：

public interface IUser extends IPlugin{
                public static final int PLUGIN_TYPE = Constants.PLUGIN_TYPE_USER;
                    /***
                     * 登录
                     */
                    public void login();
    
                    / ***
                     * SDK的退出方法
                     */
                    public void exit();
                }
1
2
3
4
5
6
7
8
9
10
11
12

支付插件接口：

public interface IPay extends IPlugin{
                    public static final int PLUGIN_TYPE = Constants.PLUGIN_TYPE_PAY;
                    /***
                     * 调用支付界面
                     */
                    public void pay(String index);
                }
1
2
3
4
5
6
7

广告插件接口：

public interface IEvent extends IPlugin{
                    public static final int PLUGIN_TYPE = Constants.PLUGIN_TYPE_EVENT    ;
                    /***
                     * 游戏发送过来的事件
                     */
                    public void SendEvent(String type,String event, String value);

                    /***
                     * 统计等级相关的事件
                     */
                    public void CountlyLevel(String type,String level);
                 }
1
2
3
4
5
6
7
8
9
10
11
12

但并不是所有SDK都需要实现以上接口的，比如OPPOsdk就用不到广告插件接口。所以还需要判断是否支持某个接口。

                public interface IPlugin {
                    /**
                     * 是否支持某个接口
                     * @param methodName
                     * @return
                     */
                    public boolean isSupportMethod(String methodName);
                }
1
2
3
4
5
6
7
8

2）、YMUser和YMPay、YMEvent（以YMUser为例）

YMUser为用户插件的代理。在初始化中获取所有SDK的User插件，并把支持User插件的各个SDK都初始化，以及相应的类加载进来。然后login登陆等操作均选择第一个，然后在第一个里判断是否需要代理第二个的longin登陆操作。
YMUser主要示例代码：

public class YMUser implements IUser{
                ......
                //获取所有的sdk user插件
                public void init(){
                    this.sdkusers = (List<IUser>) PluginFactory.getInstance().initPlugin(PLUGIN_TYPE_USER);
                }
    
                @Override
                public void login() {
                    if(this.sdkusers==null)
                         return ;
                    this.sdkusers.get(0).login();
                 }

                @Override
                public void exit() {
                    if(this.sdkusers==null)
                        return ;
                    this.sdkusers.get(0).exit();
                }
                ......
            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3）、PluginFactory实例化插件的工厂

PluginFactory主要有两个方法，一个是把支持该插件类型的各个sdk都初始化，以及相应的类加载进来的 initPlugin 方法。另一个是读取assets目录下sdk_config.xml文件以获取插件信息的loadPluginInfo方法。
initPlugin 方法示例代码：

public Object initPlugin(int type){
        try {
            if(!isSupportPlugin(type)){
                Log.e(Constants.TAG, "The config of the YMSDK is not support plugin type:"+type);
                return null;
            }
            List<String> pluginName = getPluginName(type);
            for(String lis: pluginName){
                if(type == TYPE_USER){
                    sdkt1s.add(Class.forName(lis));
                }
                if(type == TYPE_PAY){
                    sdkt2s.add(Class.forName(lis));
                }
                if(type == TYPE_EVENT){
                    sdkt3s.add(Class.forName(lis));
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
        try {
            if(type == TYPE_USER){
                for(Class lis : sdkt1s){
                    try {
                        sdkt1Objects.add(lis.getDeclaredConstructor(new Class[]{Activity.class}).newInstance(new Object[]{YMSDK.getInstance().getContext()}));
                    }catch (InvocationTargetException e){
                            Log.e(Constants.TAG, Log.getStackTraceString(e));
                    }
                }
            }
            if(type == TYPE_PAY){
                for(Class lis : sdkt2s){
                    sdkt2Objects.add(lis.getDeclaredConstructor(new Class[]{Activity.class}).newInstance(new Object[]{YMSDK.getInstance().getContext()}));
                }
            }
            if(type == TYPE_EVENT){
                for(Class lis : sdkt3s){
                    sdkt3Objects.add(lis.getDeclaredConstructor(new Class[]{Activity.class}).newInstance(new Object[]{YMSDK.getInstance().getContext()}));
                }
            }
            if(type == TYPE_USER){
                return sdkt1Objects;
            }
            if(type == TYPE_PAY){
                return sdkt2Objects;
            }
            if(type == TYPE_EVENT){
                return sdkt3Objects;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

loadPluginInfo方法示例代码：

public void loadPluginInfo(Context context){
        String xmlPlugins = SDKTools.getAssetConfigs(context, "sdk_config.xml");
        if (xmlPlugins == null){
            Log.e(Constants.TAG, "fail to load sdk_config.xml");
            return;
        }
        XmlPullParser parser = Xml.newPullParser();
        try {
            parser.setInput(new StringReader(xmlPlugins));
            int eventType = parser.getEventType();
            while(eventType != XmlPullParser.END_DOCUMENT){
                switch(eventType){
                case XmlPullParser.START_TAG:
                    String tag = parser.getName();
                    if("plugin".equals(tag)){
                        String names = parser.getAttributeValue(0);
                        String name[] = names.split(",");
                        pluginnamestmp.clear();
                        for(String entity : name){
                            if(!TextUtils.isEmpty(entity)){
                                Log.e(Constants.TAG, "add a new plugin: "+entity);
                                pluginnamestmp.add(entity);
                            }
                        }
                        int type = Integer.valueOf(parser.getAttributeValue(1));

                        if(type==TYPE_USER){
                            try {
                                userpluginnames = deepCopy(pluginnamestmp);
                            } catch (ClassNotFoundException e) {
                                e.printStackTrace();
                            }
                            this.supportedPlugins.put(type, userpluginnames);
                        }
                        if(type==TYPE_PAY){
                            try {
                                paypluginnames = deepCopy(pluginnamestmp);
                            } catch (ClassNotFoundException e) {
                                e.printStackTrace();
                            }
                            this.supportedPlugins.put(type, paypluginnames);
                        }
                        if(type==TYPE_EVENT){
                            try {
                                eventpluginnames = deepCopy(pluginnamestmp);
                            } catch (ClassNotFoundException e) {
                                e.printStackTrace();
                            }
                            this.supportedPlugins.put(type, eventpluginnames);
                        }
                    }
                }
                eventType = parser.next();
            }

        } catch (XmlPullParserException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

4）、定义监听器，用于在SDK抽象层与SDK实现层传递数据。

监听器主要分两类，一个是IYMSDKListener，另一个是Activity事件监听器，因为有些SDK需要在Activity的系统事件中做处理操作。
IYMSDKListener示例代码：

public interface IYMSDKListener {
    public void onResult(int code, String msg);
}
1
2
3

Activity事件监听示例代码：

public interface IActivityCallback {
    public void onCreate();
    public void onStart();
    public void onResume();
    public void onNewIntent(Intent newIntent);
    public void onPause();
    public void onStop();
    public void onRestart();
    public void onDestroy();
    public void onActivityResult(int reqCode, int resCode, Intent data);
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults);
    public void onBackPress();
}
1
2
3
4
5
6
7
8
9
10
11
12
13

5）、YMSDK 业务层访问SDK的唯一入口

将上述的类与监听接口整合到一起。将所有东西进行连接和整合，方便游戏层的调用，也方便SDK实现层的调用。

public class YMSDK {
    private static YMSDK instance;
    ......（省略）
    private YMSDK(){
        listeners = new ArrayList<IYMSDKListener>();
        activityCallbacks = new ArrayList<IActivityCallback>();
        applicationListeners = new ArrayList<IApplicationListener>();
        platformsettingListeners = new ArrayList<IPlatformSettingListener>();
        mainThreadHandler = new Handler(Looper.getMainLooper());
        ......
    }
    public static YMSDK getInstance(){
        if(instance == null){
            instance = new YMSDK();
        }
        return instance;
    }
    public void init(Activity actcontext){
        this.actcontext = actcontext;
        YMUser.getInstance().init();
        YMEvent.getInstance().init();
        YMPay.getInstance().init();
    }
    public void setListenerCallback(IYMSDKListener listener){
        if(!listeners.contains(listener) && listener != null){
            this.listeners.add(listener);
        }
    }
    public void setActivityCallback(IActivityCallback callback){
        if(!this.activityCallbacks.contains(callback) && callback != null){
            this.activityCallbacks.add(callback);
        }
    }
    public void onCreate(){
        if(this.activityCallbacks != null){
            for(IActivityCallback callback : this.activityCallbacks){
                callback.onCreate();
            }
        }
    }
    ......（省略）
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

二、SDK接入框架的使用

SDK接入框架基本完成了。剩下的只能在使用中不断完善了。那之后，来聊聊如何使用吧。
先说游戏层的调用，游戏层的调用其实很简单。
只需要在游戏的初始化init方法中调用 ymsdk的init方法和回调方法。
示例代码：

//初始化
private void initGame(){
    //ymsdk的回调与设置
    YMCallback();
    //ymsdk的初始化
    YMSDK.getInstance().init(activity);
     ......（省略）
}

//ymsdk的回调
    public void YMCallback() {
        YMSDK.getInstance().setListenerCallback(new IYMSDKListener() {
            @Override
            public void onResult(final int code, final String msg) {
                YMSDK.getInstance().runOnMainThread(new Runnable() {
                    @Override
                    public void run() {
                        switch (code) {
                            case Code.NO_NETWORK://没有网络
                                //你要处理的事件
                                break;
                            case Code.INIT_FAIL://初始化失败
                                break;
                            case Code.INTI_SUCCESS://初始化成功
                                break;
                            case Code.PAY_FAIL://支付失败
                                break;
                            case Code.PAY_SUCCESS://支付成功
                                break;
                            case Code.PAY_CANCEL://支付取消
                                break;
                            case Code.PAY_CALLBACK_CHECK://补单
                                break;
                            case Code.AD_FAIL://广告展示失败
                                break;
                            case Code.AD_SUCCESS://广告展示成功
                                break;
                            case Code.STATISTICS:  //程序跳转
                                break;
                            ......（省略）
                            default:
                                Toast.makeText(UnityPlayerActivity.this, msg, Toast.LENGTH_SHORT).show();
                        }
                    }
                });
            }
        });
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

在支付或者退出时，分别调用对应方法pay方法和exit方法。

YMPay.getInstance().pay(index);
YMUser.getInstance().exit();
1
2

其中支付和退出都可以使用指定的SDK，或者顺序执行。默认是顺序执行，前一个SDK可以决定执不执行下一个SDK的pay/exit方法。

YMPay.getInstance().getympayPluginlist().get(Middle.getPayerNum("Next")).pay(index+"");
YMPay.getInstance().getympayPluginlist().get(Middle.getPayerNum("OPPO")).pay(index+"");
1
2

最后在Activity的系统事件中添加监听，那游戏层的调用就完成了。

......（省略）
    @Override
    protected void onStart() {
        Log.v(TAG, "onStart");
        super.onStart();
        YMSDK.getInstance().onStart();
    }
......（省略）
1
2
3
4
5
6
7
8

之后接入SDK只需要修改config配置文件即可。

三、各SDK的接入实现

以OPPO为例，需要新建OPPOUser和OPPOPay分别继承IUser和IPay。（建议）新建OPPOSDK处理OPPO的逻辑（按照OPPO文档作相应的init、login、pay等的操作）
OPPOUser示例代码：

public class OPPOUser implements IUser {
    public OPPOUser(Activity act){
        OPPOSDK.getInstance().init(act);
    }
    private String[] supportedmethod = {"exit","login"}; //选择OPPOsdk支持的功能
    @Override
    public boolean isSupportMethod(String methodName) {
        return Arrays.contain(supportedmethod, methodName);
    }
    @Override
    public void login() {
         OPPOSDK.getInstance().login();  //OPPO的登录操作
    }

    @Override
    public void exit() {
        OPPOSDK.getInstance().exit();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

四、打包工具

打包工具的主要功能就是自动配置config文件和具体的SDK参数。工具这里使用的是Python编写。
首先需要一个可视化的界面。Python的界面可以使用PyQt或者Tkinter等等来进行编写。但这里的界面只是内部使用的，所以暂时使用 Tkinter 编写就好。
Tkinter的使用可以参考一下这篇博客
工具的示例界面：（Demo）
在这里插入图片描述

根据用户在界面中输入的信息，生成一个temp_choice.txt文件。然后再以temp_choice.txt文件中的游戏名，SDK名，方案名等作为ID，从数据库中获取详细的信息，生成一个完整的app_config.properties文件和sdk_config.xml配置文件。
之后再
1、copy已接入了YMSDK的Demo工程到出包目录下。
2、把unity导出的游戏资源转化为aar格式资源。
3、读取app_config.properties文件，修改Demo工程的build.gradle，让其导入对应的SDK Module。
4、把游戏的aar资源copy到Demo当中。
5、使用Android Studio的命令行执行打包指令生成apk。
6、把apk剪切到指定目录并按照一定格式重命名。
其中，3中的app_config.properties文件是不会编译到APK里面的，在build.gradle中就对其进行读取，并把需要的参数写入到AndroidManifest.xml中。
5中的使用Android Studio命令行执行打包，需要先安装并配置Gradle环境，
前面使用到的Python知识，可以参考 python操作文件、python操作SQL。

五、总结

使用流程：
1、接到新SDK后，先按照技术文档接入，完成SDK的接入实现，并把sdk参数，如id和key之类的上传数据库。如果不是新SDK则只上传数据即可。如果也不是新游，则完全可以忽略这一步。
2、按需在界面中选择需要接入的SDK，可以多选。如渠道SDK、广告SDK等。需要需要的方案，如广告方案、礼包弹出方案等。最后点击确定即可完成出包。

源码下载

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/573818