教你快速高效接入SDK——SDK接入抽象层的设计

时间：2014-12-29 23:05:44 阅读：369 评论：0 收藏：0 [点我收藏+]

题记：很多做游戏开发的人，估计都或多或少地接过渠道SDK，什么UC，当乐，91，小米，360......据统计国内市场当前不下于100家渠道，还包括一些没有SDK的小渠道。每个渠道SDK接入的方法呢，多是大同小异。但是，正是这些小异，又让SDK的接入，产生了无穷无尽的变数。所以，接入SDK之前，如果你没有经验，或者没有被SDK坑过，那么当你看到这系列文章的时候，你很幸运，你可以避免这一切了。如果你之前被坑过，而且还在继续被坑着，那么现在，就是你解脱的时刻。

上一篇文章，我们总体地分析并设计了一套高效的SDK接入方案，也罗列出这套方案，我们需要完成的工作。这里再罗列并回顾下：

1、统一抽象的SDK接入框架

2、各个SDK接入实现

3、一键打包工具

4、统一的登陆认证中心和支付中心

5、对多个平台的支持，比如Unity3D,Cocos2D等

那么接下来这篇文章，我们就开始第一部分：抽象的SDK接入框架的实现。在实现之前，我们再深入地想一下，抽象层需要提供哪些接口。因为，对于每个游戏来说，都只需要接入这个抽象层，而所有SDK的接入就是实现这个抽象层。所以，这个抽象层设计的好坏，不仅影响到游戏的接入，同时也影响到各个渠道SDK的实现。

没有好的思路，我们可以看下AnySDK，或者棱镜SDK他们的宣传资料和文档，我们发现他们支持的组件有这些：

技术分享

渠道SDK就不用说了，除了渠道SDK，他把部分支付SDK，广告SDK，分享SDK，统计SDK，消息推送SDK等都放到了这套统一SDK接入框架中来了。那么，作为我们这套抽象框架，我们也需要考虑以后可能会加入这些其他非渠道的SDK。所以，我们总体的设计思想是：

1、游戏各个渠道有一个主渠道SDK，比如UC，当乐，91等SDK。这个各个渠道只能同时有一个。不可能同时为UC也是91SDK

2、非渠道的功能性SDK，包括广告，分享，统计，推送等。这些东西，我们作为插件集成到这套抽象框架来。

3、所有SDK的实现可以很方便，而且结构比较统一

4、所有的渠道SDK也好，还是功能性SDK也好，SDK抽象层都抽象出对应的接口。方便游戏层的调用，也方便具体插件的实现。

那么，接下来，我们就根据前一篇我们画的那个登陆和支付流程图，和上面提到的总体设计思路来实现这个抽象层。上篇文章说道，我们这套东西暂且命名为u8 sdk，那么我们这个抽象层就叫U8 SDK。为了可以将各个功能作为插件式开发，我们抽象接口的时候，也将各个功能分开。

首先，我们定义两个接口，一个是登陆接口，一个是支付接口：

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#333333;">package com.u8.sdk;


public interface IUser {

	public void login();
	
}</span>

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#333333;">package com.u8.sdk;

public interface IPay {

	public void pay(PayParams data);
}
</span>

这两个接口定义好了，我们简单说下。一般SDK的登陆成功之后，都会拿到sid对吧，那这个登陆login方法并没有返回值，而是后面，我们会定义一个总的SDK监听器，通过监听器来实现。支付需要游戏层传入一些支付参数。但是，有童鞋可能要问了，各个渠道需要的支付参数好像不太一样吧？是的亲，但是对于游戏来说，我能提供的支付数据也就那么些。我全传给你，各个渠道sdk各自按需索取就可以了。那么，我们简单看下，我们这个PayParams类，有哪些属性呢？

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#333333;">package com.u8.sdk;

public class PayParams{
	
	private String productId;
	private String productName;
	private int price;
	private int buyNum;
	private int coinNum;
	private String serverId;
	private String roleId;
	private String roleName;
	private int roleLevel;
	private String extension;	
	
	public String getProductId() {
		return productId;
	}
	public void setProductId(String productId) {
		this.productId = productId;
	}
	public String getProductName() {
		return productName;
	}
	public void setProductName(String productName) {
		this.productName = productName;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	public int getBuyNum() {
		return buyNum;
	}
	public void setBuyNum(int buyNum) {
		this.buyNum = buyNum;
	}
	public int getCoinNum() {
		return coinNum;
	}
	public void setCoinNum(int coinNum) {
		this.coinNum = coinNum;
	}
	public String getServerId() {
		return serverId;
	}
	public void setServerId(String serverId) {
		this.serverId = serverId;
	}
	public String getRoleId() {
		return roleId;
	}
	public void setRoleId(String roleId) {
		this.roleId = roleId;
	}
	public String getRoleName() {
		return roleName;
	}
	public void setRoleName(String roleName) {
		this.roleName = roleName;
	}
	public int getRoleLevel() {
		return roleLevel;
	}
	public void setRoleLevel(int roleLevel) {
		this.roleLevel = roleLevel;
	}
	public String getExtension() {
		return extension;
	}
	public void setExtension(String extension) {
		this.extension = extension;
	}

	
}
</span>

大家要问这里参数怎么抽象出来的，那么我告诉你，不是我拍脑袋想出来的，是参考AnySDK文档中提供的充值参数信息来的。（小贱一把）

两个接口有了，紧接着，上层游戏需要登录和支付的地方，怎么调用呢？对于游戏来说，这个接口需要new一个哪个实现？是UC还是当乐还是91呢？

所以，我们对每个插件定义一个单例的包装类。简单地说，就是怎么方便，怎么搞。这样就是方便上层游戏层得调用。那么，我们实现两个包装类：

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#333333;">package com.u8.sdk.components;

import com.u8.sdk.IUser;
import com.u8.sdk.ComponentFactory;
import com.u8.sdk.U8SDK;

/**
 * 用户插件
 *
 */
public class U8User{
	private static U8User instance;
	
	private IUser userComponent;
	
	private U8User(){
		
	}
	
	public void init(){
		this.userComponent = (IUser)ComponentFactory.getInstance().initComponent(U8SDK.TYPE_LOGIN);
	}
	
	public static U8User getInstance(){
		if(instance == null){
			instance = new U8User();
		}
		
		return instance;
	}
	
	public void login(){
		if(userComponent==null){
			return;
		}
		
		userComponent.login();
	}
}
</span>

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#333333;">package com.u8.sdk.components;


import com.u8.sdk.IPay;
import com.u8.sdk.PayParams;
import com.u8.sdk.ComponentFactory;
import com.u8.sdk.U8SDK;


/***
 * 支付插件
 *
 */
public class U8Pay{
	
	private static U8Pay instance;
	
	private IPay payComponent;
	
	private U8Pay(){
		
	}
	
	public static U8Pay getInstance(){
		if(instance == null){
			instance = new U8Pay();
		}
		return instance;
	}
	
	public void init(){
		this.payComponent = (IPay)ComponentFactory.getInstance().initComponent(U8SDK.TYPE_PAY);
	}
	
	public void pay(PayParams data){
		if(this.payComponent == null){
			return;
		}
		this.payComponent.pay(data);
	}
}
</span>

关于这两个包装类，大家可以看到，有一个初始化init方法，然后就是所有的插件对应的方法，他把插件接口作为一个私有属性，在init方法里面，将对应的插件接口赋值了。然后在插件对应的方法里面，间接地调用插件对应的接口。那么，这里的关键就是ComponentFactory这个类。刚刚说了，我们这个后面可能有多个插件，所以，我们需要一个插件管理类。ComponentFactory就是我们的插件管理类：

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#333333;">package com.u8.sdk;

import java.io.IOException;
import java.io.StringReader;
import java.util.HashMap;
import java.util.Map;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import com.u8.sdk.utils.SDKTools;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.util.Log;
import android.util.Xml;

@SuppressLint("UseSparseArrays")
public class ComponentFactory {

	private static ComponentFactory instance;
	
	private Map<Integer, String> supportedComponents;
	
	private ComponentFactory(){
		supportedComponents = new HashMap<Integer, String>();
	}
	
	public static ComponentFactory getInstance(){
		if(instance == null){
			instance = new ComponentFactory();
		}
		
		return instance;
	}	
	
	public void init(Activity context){
		loadComponentInfo();
		
	}

	private boolean isSupportComponent(int type){
		
		return supportedComponents.containsKey(type);
	}
	
	private String getComponentName(int type){
		if(supportedComponents.containsKey(type)){
			return supportedComponents.get(type);
		}
		return null;
	}
	
	public SDKConfigData getSDKConfigData(){
		Map<String, String> configs = SDKTools.getAssetPropConfig(U8SDK.getInstance().getContext(), "developer_config.properties");
		return new SDKConfigData(configs);		
	}
	
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public Object initComponent(int type){
		Class localClass = null;
		
		try {
			
			if(!isSupportComponent(type)){
				
				Log.e("U8SDK", "The config of the U8SDK is not support plugin type:"+type);
				return null;
			}
			
			String name = getComponentName(type);
			
			localClass = Class.forName(name);
			
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		}
		
		try {
			return localClass.getDeclaredConstructor(new Class[]{Activity.class}).newInstance(new Object[]{U8SDK.getInstance().getContext()});
		} catch (Exception e) {

			e.printStackTrace();
		}
		return null;
	}
	
	
	private void loadComponentInfo(){
		String xmlStr = SDKTools.getAssetConfigs(U8SDK.getInstance().getContext(), "plugin_config.xml");
		
		Log.e("The plugin Str:", xmlStr);
		
		XmlPullParser parser = Xml.newPullParser();

		try {
			parser.setInput(new StringReader(xmlStr));
			
			int eventType = parser.getEventType();
			while(eventType != XmlPullParser.END_DOCUMENT){
				
				switch(eventType){
				case XmlPullParser.START_TAG:
					String tag = parser.getName();
					if("plugin".equals(tag)){
						String name = parser.getAttributeValue(0);
						int type = Integer.parseInt(parser.getAttributeValue(1));
						this.supportedComponents.put(type, name);
						Log.e("u8_plugin", "Curr Supported Plugin: "+type+"; name:"+name);
					}
				}
				eventType = parser.next();
			}
			
		} catch (XmlPullParserException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
</span>

大家可以看到initComponent方法里面，就是判断当前插件是否支持，如果支持，则从supportedComponents 里面根据当前插件类型取到对应插件实现类的完整类名。通过Class.forName().newInstance()进行初始化。那么，我们怎么知道支持哪些插件呢？怎么得到当前支持的各个插件的实现类呢？大家也许已经看到了，这个管理类中，也有一个初始化init方法。在init方法中，调用了loadComponentInfo方法来加载当前支持的插件信息。大家可以看到它是从assets目录下的plugin_config.xml配置来读取的。关于这个plugin_config.xml怎么生成的，我们后面说打包工具的时候，会详细讲到。这个文件不是我们手动写的，而是打包工具在生成各个渠道包的时候动态生成的。

为了在SDK抽象层和SDK实现层传递数据，我们定义一个监听器：

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#333333;">package com.u8.sdk;

public interface IU8SDKListener {

	public void onResult(int code, String msg);
	
	public void onLoginResult(LoginResult result);
}
</span>

这个监听器，我们定义了两个接口，一个是onResult，是SDK实现层传递的状态信息，比如SDK初始化成功，SDK初始化失败，SDK登陆成功，登陆失败等信息。而onLoginResult()这个接口，就是之前说到的，登陆成功之后，SDK实现层需要调用该接口，将封装好的登陆结果，返回给SDK抽象层。这个LoginResult里面，就包含sid信息。

为了能够将我们刚刚说的这些插件，插件包装类，插件管理类，和事件监听接口整合到一起，我们最后定义一个总的单例类，也是我们整个抽象层的核心纽带：

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#333333;">package com.u8.sdk;

import com.u8.sdk.components.U8Pay;
import com.u8.sdk.components.U8User;

import android.app.Activity;
import android.content.Intent;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;

public class U8SDK{

	public static final int TYPE_LOGIN = 1;
	public static final int TYPE_PAY = 2;
	
	private static U8SDK instance;
	
	private Activity context;
	private Handler mainThreadHandler;	
	
	private SDKConfigData developInfo;
	
	private IU8SDKListener listener;
	private IActivityListener activityCallback;
	
	private U8SDK(){
		mainThreadHandler = new Handler(Looper.getMainLooper());
	}
	
	public static U8SDK getInstance(){
		if(instance == null){
			instance = new U8SDK();
		}
		return instance;
	}
	
	public SDKConfigData getSDKParams(){
		return developInfo;
	}
	
	public int getCurrChannel(){
		if(this.developInfo == null || !this.developInfo.contains("U8_Channel")){
			return 0;
		}
		
		return this.developInfo.getInt("U8_Channel");
	}
	
	public void setSDKListener(IU8SDKListener listener){
		this.listener = listener;
	}
	
	public void setActivityCallback(IActivityListener callback){
		this.activityCallback = callback;
	}
	
	public void init(Activity context){
		this.context = context;
		ComponentFactory.getInstance().init(context);
		developInfo = ComponentFactory.getInstance().getSDKConfigData();	
		
		U8User.getInstance().init();
		U8Pay.getInstance().init();
	}
	
	public void runOnMainThread(Runnable runnable){
		if(mainThreadHandler != null){
			mainThreadHandler.post(runnable);
			return;
		}
		
		if(context != null){
			context.runOnUiThread(runnable);
		}
	}	
	
	public Activity getContext(){
		return this.context;
	}
	
	public void onResult(int code, String msg){
		Log.e("U8SDK Action Result:", "code:"+code+";msg:"+msg);
		if(listener != null){
			listener.onResult(code, msg);
		}
	}
	
	public void onLoginResult(LoginResult result){
		if(listener != null){
			listener.onLoginResult(result);
		}
	}

	public void onActivityResult(int requestCode, int resultCode, Intent data) {
		if(this.activityCallback != null){
			this.activityCallback.onActivityResult(requestCode, resultCode, data);
		}
	}
	
	public void onBackPressed(){
		if(this.activityCallback != null){
			this.activityCallback.onBackPressed();
		}
	}


	public void onPause() {
		if(this.activityCallback != null){
			this.activityCallback.onPause();
		}
	}


	public void onResume() {
		
		if(this.activityCallback != null){
			this.activityCallback.onResume();
		}
		
	}


	public void onNewIntent(Intent newIntent) {
		if(this.activityCallback != null){
			this.activityCallback.onNewIntent(newIntent);
		}
		
	}


	public void onStop() {
		if(this.activityCallback != null){
			this.activityCallback.onStop();
		}
		
	}


	public void onDestroy() {
		if(this.activityCallback != null){
			this.activityCallback.onDestroy();
		}
		
	}


	public void onRestart() {
		if(this.activityCallback != null){
			this.activityCallback.onRestart();
		}
		
	}
	
	
}
</span>

大家可以看到，我们这里，通过U8SDK这个单例，将所有的东西进行了连接和整合。在init方法里面，我们init插件管理类，也init所有的插件包装类。然后，对事件监听器也进行一个简单的包装。使得SDK实现层的调用简单方便，游戏层的调用也简单方便。

最后，因为有的SDK，需要在Activity的系统事件中做一些处理操作，而Activity是在游戏接入我们这个抽象层时，传递进来的，所以，我们在抽象层定义了一个Activity事件监听器：

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#333333;">package com.u8.sdk;

import android.content.Intent;

public interface IActivityListener {

	public void onPause();
	public void onResume();
	public void onRestart();
	public void onBackPressed();	
	public void onNewIntent(Intent newIntent);
	public void onStop();
	public void onDestroy();
	public void onActivityResult(int requestCode, int resultCode, Intent data);
}
</span>

这样，整个SDK接入的抽象层就差不多了。还有一些细节，我们可以后面边开发，边迭代，边完善。后面我们将用实例来看看，游戏层怎么调用这个抽象层SDK，以及具体的SDK接入怎么来实现这个抽象层。

本文作者：小黑

上一篇：教你快速高效接入SDK——总体思路和架构

教你快速高效接入SDK——SDK接入抽象层的设计

标签：sdk接入游戏开发 anysdk原理棱镜sdk原理 android开发

原文地址：http://blog.csdn.net/chenjie19891104/article/details/42243321

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行