void u_biz_vm_ability_ex_set_base(const UAbilityExBase* pAbility);

…
u_biz_vm_ability_ex_set_base(base_ability);
…

void u_biz_vm_ability_ex_set_vm_mgr(const UAbilityExVmMgr* pAbility);

…
u_biz_vm_ability_ex_set_vm_mgr(vm_mgr_ability);
…

void u_biz_vm_ability_ex_set_driver_mgr(const UAbilityExDriverMgr* pAbility);

…
u_biz_vm_ability_ex_set_driver_mgr(driver_mgr_ability);
…

void u_biz_vm_ability_ex_set_auth(const UAbilityExAuth* pAbility);

u_biz_vm_ability_ex_set_auth(auth_ability);

bool_t u_biz_vm_ability_init(int* pErrCode);

…
int pErrCode = -1;
ok = u_biz_vm_ability_init(&pErrCode);
if (!ok || pErrCode != U_BIZ_ERR_SUCCESS) { printf("虚拟机能力初始化失败"); }
…

void_u_biz_vm_ability_deinit(void);

…
bool ok = u_biz_vm_ability_deinit();
if(!ok) printf("虚拟机反初始化失败")
…

typedef enum _UDataType{
	U_DATA_TYPE_VOID = 0x20, //void

	U_DATA_TYPE_INT8 = 0x21, //int8	 
	U_DATA_TYPE_INT16 = 0x22, //int16
	U_DATA_TYPE_INT32 = 0x23, //int32	 
	U_DATA_TYPE_INT64 = 0x24, //int64     
	U_DATA_TYPE_FLOAT = 0x25, //float
	U_DATA_TYPE_DOUBLE = 0x26, //double
	U_DATA_TYPE_BOOL = 0x27, //bool
	U_DATA_TYPE_STRING = 0x28, //string	

	U_DATA_TYPE_NIL = 0xFF //无效类型
}UDataType;//数据类型

UObject* u_object_new_int8 (int8_t data);

…
int8_t a = 10;
UObject* object =  u_object_new_int8(a);
if(object != NULL) printf("转换成功")
…

UObject* u_object_new_int16 (int16_t data);

…
int16_t a = 10;
UObject* object =  u_object_new_int16(a);
if(object != NULL) printf("转换成功")
…

UObject* u_object_new_int32 (int32_t data);

…
int32_t a = 10;
UObject* object =  u_object_new_int32(a);
if(object != NULL) printf("转换成功")
…

UObject* u_object_new_int64(int64_t data);

…
int64_t a = 10;
UObject* object =  u_object_new_int64(a);
if(object != NULL) printf("转换成功")
…

UObject* u_object_new_float (float data);

…
float a = 6.66;
UObject* object =  u_object_new_float(a);
if(object != NULL) printf("转换成功")
…

UObject* u_object_new_double (double data);

…
double a = 8.888888;
UObject* object =  u_object_new_double(a);
if(object != NULL) printf("转换成功")
…

UObject* u_object_new_bool(bool data);

…
bool a = true;
UObject* object =  u_object_new_bool(a);
if(object != NULL) printf("转换成功")
…

UObject* u_object_new_string (const char* data);

…
char a[16] = "helloworld"
UObject* object =  u_object_new_bool(a);
if(object != NULL) printf("转换成功")
…

UObject* u_object_new_null (UDataType type);

…
UObject* object =  u_object_new_null(U_DATA_TYPE_INT8);
if(object != NULL) printf("转换成功")
…

UDataType u_object_get_type(const UObject* data);

…
int8_t a =10
UObject* object =  u_object_new_int8(a);
UDataType type = u_object_get_type(object)
…

int8_t u_object_to_int8(const UObject* data, bool* ok);

…
int8_t a =10
bool ok = false;
UObject* object =  u_object_new_int8(a);
int8_t ret=  u_object_to_int8(object, &ok);
if(ok) printf("转换成功");
…

int16_t u_object_to_int16(const UObject* data, bool* ok);

…
int16_t a =10
bool ok = false;
UObject* object =  u_object_new_int16(a);
int16_t ret=  u_object_to_int16(object, &ok);
if(ok) printf("转换成功");
…

int32_t u_object_to_int32(const UObject* data, bool* ok);

…
int32_t a =10
bool ok = false;
UObject* object =  u_object_new_int32(a);
int32_t ret=  u_object_to_int32(object, &ok);
if(ok) printf("转换成功");
…

int64_t u_object_to_int64(const UObject* data, bool* ok);

…
int64_t a =10
bool ok = false;
UObject* object =  u_object_new_int64(a);
int64_t ret=  u_object_to_int64(object, &ok);
if(ok) printf("转换成功");
…

float u_object_to_float(const UObject* data, bool* ok);

…
float a =6.66
bool ok = false;
UObject* object =  u_object_new_float(a);
float ret=  u_object_to_float(object, &ok);
if(ok) printf("转换成功");
…

double u_object_to_double(const UObject* data, bool* ok);

…
double a =8.888888
bool ok = false;
UObject* object =  u_object_new_double(a);
double ret=  u_object_to_double(object, &ok);
if(ok) printf("转换成功");
…

bool u_object_to_bool(const UObject* data, bool* ok);

…
bool a = true
bool ok = false;
UObject* object =  u_object_new_bool(a);
bool ret=  u_object_to_bool(object, &ok);
if(ok) printf("转换成功");
…

const char* u_object_to_string(const UObject* data, bool* ok);

…
char* a[16] = "helloworld"
bool ok = false;
UObject* object =  u_object_new_string(a);
char* ret=  u_object_to_bool(object, &ok);
if(ok) printf("转换成功");
…

bool u_object_is_null (UObject* data);

…
UObject* object = u_object_new_null(U_DATA_TYPE_INT8);
if(u_object_is_null(object)) printf("该UObject数据为null")
…

UObject* u_object_clone (const UObject * data);

…
UObject* object = u_object_new_null(U_DATA_TYPE_INT8);
UObject* new_object = u_object_clone (object);
…

void u_object_free (UObject** ppObj);

…
UObject* object = u_object_new_null(U_DATA_TYPE_INT8);
u_object_free (object);
…

typedef struct _UAbilityExBase {
	UAbilityExBaseLogout logout; // 日志
	UAbilityExBaseReadULC read_ulc; // ulc文件读取
	UAbilityExBaseLineNumberChange line_number_change; // 通知语句行号变化
	/***************** 所有内部模块都需要的回调 *****************/
	 /***************** 并提供给所有外部能力共用 *****************/
	USysdepMalloc malloc; // 动态申请内存
	USysdepFree free;     // 释放内存
	USysdepMutexInit mutex_new;      //创建互斥锁
	USysdepMutexLock mutex_lock;     //加锁互斥锁
	USysdepMutexUnlock mutex_unlock; //解锁互斥锁
	USysdepMutexDeinit mutex_free;   //释放互斥锁
	// 睡眠指定的毫秒数
	USysdepSleep sleep;
	UAbilityExBaseInit init; // 基本外部能力初始化
	UAbilityExBaseDeinit deinit; // 基本外部能力反初始化
}UAbilityExBase;

typedef struct _UAbilityExAuth {
	UAbilityExAuthAuthorize authorize;   //鉴权
	UAbilityExAuthCallbackSetCoreEx set_access_core_ex_cb;  // 设置接入层扩展功能回调
	UAbilityExAuthInit init;      // 虚拟机管理外部能力初始化
	UAbilityExAuthDeinit deinit;  // 虚拟机管理外部能力反初始化
} UAbilityExAuth;

typedef struct _UAbilityExDriverMgr {
	UAbilityExDriverMgrAppFun appfun; // 应用函数入口
	UAbilityExDriverMgrGetVar getvar; // 获取变量值
	UAbilityExDriverMgrSetVar setvar; // 设置变量值
	UAbilityExDriverMgrVarGetKey var_get_key; // 依据变量id获取变量key
	UAbilityExDriverMgrVarGetId var_get_id;   // 依据变量key获取变量id
	UAbilityExDriverMgrFunGetKey fun_get_key; // 依据函数id获取函数key
	UAbilityExDriverMgrFunGetId fun_get_id;   // 依据函数key获取函数id
	UAbilityExDriverMgrCallbackSetCoreEx set_access_core_ex_cb;// 设置接入层核心扩展功能回调
	UAbilityExDriverMgrInit init;     // 驱动管理器外部能力初始化
	UAbilityExDriverMgrDeinit deinit; // 驱动管理器外部能力反初始化
}UAbilityExDriverMgr;

typedef struct _UAbilityExVmMgr {
	UAbilityExVmMgrPostEvent post_event; //发送事件
	UAbilityExVmMgrGetVmId get_vm_id;    //获取虚拟机id
	UAbilityExVmMgrCallbackSetCore set_access_core_cb;       // 设置接入层核心功能回调
	UAbilityExVmMgrCallbackSetCoreEx set_access_core_ex_cb;  // 设置接入层扩展功能回调
        UAbilityExVmMgrInit init;      // 虚拟机管理外部能力初始化
	UAbilityExVmMgrDeinit deinit;  // 虚拟机管理外部能力反初始化
} UAbilityExVmMgr;

typedef struct _UAbilityExBase {
	UAbilityExBaseLogout logout; // 日志
	UAbilityExBaseReadULC read_ulc; // ulc文件读取
	UAbilityExBaseLineNumberChange line_number_change; // 通知语句行号变化
	/***************** 所有内部模块都需要的回调 *****************/
	 /***************** 并提供给所有外部能力共用 *****************/
	USysdepMalloc malloc; // 动态申请内存
	USysdepFree free;     // 释放内存
	USysdepMutexInit mutex_new;      //创建互斥锁
	USysdepMutexLock mutex_lock;     //加锁互斥锁
	USysdepMutexUnlock mutex_unlock; //解锁互斥锁
	USysdepMutexDeinit mutex_free;   //释放互斥锁
	// 睡眠指定的毫秒数
	USysdepSleep sleep;
	UAbilityExBaseInit init; // 基本外部能力初始化
	UAbilityExBaseDeinit deinit; // 基本外部能力反初始化
}UAbilityExBase;

typedef void(*UAbilityExBaseLogout)(const char* pTag, const char* pStr, ULogLevel iLevel);

typedef enum _ULogLevel
{
	U_LOG_LEVEL_DEBUG = 0,  //  自动测试的等级
	U_LOG_LEVEL_INFO = 1,   // 
	U_LOG_LEVEL_WARN = 2,   //  警告的优先级
	U_LOG_LEVEL_ERROR = 3   //  错误的优先级
}ULogLevel;

///日志代理
void UAbilityExBaseLogout_impl(const char* pTag, const char* pStr, ULogLevel iLevel)
{
     printf("[%d][%s]:%s\n", iLevel, pTag, pStr);
}

typedef bool(*UAbilityExBaseReadULC)(const char* pCtxId, uint32_t iOffset, uint32_t iLen, char* pRetStr);

bool UAbilityExBaseReadULC_impl(const char* pCtxId, uint32_t iOffset, uint32_t iLen, char* pRetStr)
{
  //TODO
  return true
}

typedef void(*UAbilityExBaseLineNumberChange)(uint32_t iVmId, uint32_t iLineNO);

void UAbilityExBaseLineNumberChange_impl(uint32_t iVmId, uint32_t iLineNO);
{
   printf("%d,%d", iVmld, iLineNo);
   return;
}

typedef void*(*USysdepMalloc)(size_t iSize);

void* USysdepMalloc_impl(size_t iSize)
{
  return malloc(iSize);
}

typedef void(*USysdepFree)(void* pMemory);

void USysdepFree_impl(void* pMemory)
{
  if(pMemory == NULL)
    return;
  free(pMemory);
}

typedef bool(*USysdepMutexInit)(void** ppMutex);

//Demo
bool USysdepMutexInit_impl(void** ppMutex)
{
  pthread_mutex_t* pMutex = (pthread_mutex_t*)calloc(1, sizeof(pthread_mutex_t));//申请内存
  int ret = pthread_mutex_init(pMutex , NULL);
  if(ret != 0)
  {
    free(pMutex); //释放内存
    return false;
  }
  *ppMutext = pMutex;
  return true;
}

typedef bool(*USysdepMutexLock)(void* pMutex);

bool USysdepMutexLock_impl(void* pMutex)
{
  if(pMutex == NULL)
    return false;
  pthread_mutex_t* mutex = (pthread_mutex_t*)pMutex;  
  return 0 == pthread_mutex_lock(mutex); 
}

typedef bool(*USysdepMutexUnlock)(void* pMutex);

bool USysdepMutexUnlock_impl(void* pMutex)
{
  if(!pMutex)
    return false;
  pthread_mutex_t* mutex = (pthread_mutex_t*)pMutex;
  return 0 == pthread_mutex_unlock(mutex);
}

typedef bool(*USysdepMutexDeinit)(void** ppMutex);

bool USysdepMutexDeinit_impl(void** ppMutex)
{
  if(!ppMutex || !*ppMutex)
    return false;
  pMutex = (pthread_mutex_t*)*ppMutex;
  if(0 == pthread_mutex_destroy(pMutex))
  {
    free(pMutex)
    *ppMutex = NULL
    return true;
  }
  return false;
}

typedef void (*USysdepSleep)(uint64_t iMillSecond);

void USysdepSleep_impl(uint64_t iMillSecond)
{
  Sleep(iMillSecond);
}

typedef bool(*UAbilityExBaseInit)(int* pErrCode);

bool UAbilityExBaseInit_impl(int* pErrCode)
{
  //TODO INIT
  return true;
}

 typedef void(*UAbilityExBaseDeinit)(void);

void UAbilityExBaseDeinit_impl()
{
  //TODO
}

const UAbilityExAuth* u_auth_get_ability(void);

typedef struct _UAbilityExAuth {
	UAbilityExAuthAuthorize authorize;   //鉴权
	UAbilityExAuthCallbackSetCoreEx set_access_core_ex_cb;  // 设置接入层扩展功能回调
	UAbilityExAuthInit init;      // 虚拟机管理外部能力初始化
	UAbilityExAuthDeinit deinit;  // 虚拟机管理外部能力反初始化
} UAbilityExAuth;

...
const UAbilityExAuth* pAbilityExAuth = u_auth_get_ability();
u_biz_vm_ability_ex_set_auth(pAbilityExAuth);//商用虚拟机提供的接口，设置鉴权外部能力
...

typedef bool(*UAbilityExAuthAuthorize)(const char* pSecret,
	const char* pRandomKey, char** ppExecuteCode, size_t* pCodeSize, int* pErrCode);

typedef void(*UAbilityExAuthCallbackSetCoreEx)(const UVmAccessCoreEx * pAccessCoreEx);

typedef struct _UVmAccessCoreEx {
	/************ 由基础外部能力注入 ************/
	UAbilityExLogout logout; // 日志
	USysdepMalloc malloc; // 动态申请内存
	USysdepFree free;     // 释放内存
	USysdepMutexInit mutex_new;       //创建互斥锁
	USysdepMutexLock mutex_lock;     //加锁互斥锁
	USysdepMutexUnlock mutex_unlock; //解锁互斥锁
	USysdepMutexDeinit mutex_free;   //释放互斥锁
	USysdepSleep sleep;              // 休眠（毫秒）
	/************* 由虚拟机管理外部能力注入 *************/
	UAbilityExPostEvent post_event_ex;
	/************* 由驱动管理外部能力注入(如果为NULL（允许）,说明应用没有实现该功能) *************/
	UAbilityExVarGetKey var_get_key_ex; // 依据变量id获取变量key
	UAbilityExVarGetId var_get_id_ex;   // 依据变量key获取变量id
	UAbilityExFunGetKey fun_get_key_ex; // 依据函数id获取函数key
	UAbilityExFunGetId fun_get_id_ex;   // 依据函数key获取函数id
}UVmAccessCoreEx;

typedef bool(*UAbilityExAuthInit)(int* pErrCode);

typedef void(*UAbilityExAuthDeinit)(void);

bool u_driver_mgr_set_ability_executor(UAbilityExDriverMgrAppFun appfun, 
	UAbilityExDriverMgrGetVar getvar, UAbilityExDriverMgrSetVar setvar);
``

bool UAbilityExDriverMgrAppFun_impl(uint32_t iVmId, const char* pFunKey, const UObject** ppParams, int32_t iParamsNum, UObject** ppRetData)
{
  //函数实现见4.2.2.1
}

bool UAbilityExDriverMgrGetVar_impl(uint32_t iVmId, const char* pVarKey, UObject** ppVal)
{
  //函数实现见4.2.2.2
}

bool UAbilityExDriverMgrSetVar_impl(uint32_t iVmId, const char* pVarKey, const UObject* pVal)
{
  //函数实现见4.2.2.3
}

{
...
u_driver_mgr_set_ability_executor(UAbilityExDriverMgrAppFun_impl, UAbilityExDriverMgrGetVar_impl, UAbilityExDriverMgrSetVar_impl);
const UAbilityExDriverMgr* pAbilityExDriverMgr = u_driver_mgr_get_ability();
u_biz_vm_ability_ex_set_driver_mgr(pAbilityExDriverMgr);
...
}

bool u_driver_mgr_set_ability_idkey(
	UAbilityExDriverMgrVarGetKey var_get_key, UAbilityExDriverMgrVarGetId var_get_id,
	UAbilityExDriverMgrFunGetKey fun_get_key, UAbilityExDriverMgrFunGetId fun_get_id);

const char* UAbilityExDriverMgrVarGetKey_impl(uint32_t iVmId, int32_t id)
{
  //具体实现见4.2.2.4
}


int32_t UAbilityExDriverMgrVarGetId_impl(uint32_t iVmId, const char* key)
{
  //具体实现见4.2.2.5
}

const char* UAbilityExDriverMgrFunGetKey_impl(uint32_t iVmId, int32_t id)
{
  //具体实现见4.2.2.6
}

int32_t UAbilityExDriverMgrFunGetId_impl(uint32_t iVmId, const char* key)
{
  //具体实现见4.2.2.7
}

{
...
u_driver_mgr_set_ability_idkey(UAbilityExDriverMgrVarGetKey_impl, UAbilityExDriverMgrVarGetId_impl, UAbilityExDriverMgrFunGetKey_impl, UAbilityExDriverMgrFunGetId_impl);
//获取驱动管理外部能力
const UAbilityExDriverMgr* pAbilityExDriverMgr = u_driver_mgr_get_ability();
//设置驱动管理外部能力
u_biz_vm_ability_ex_set_driver_mgr(pAbilityExDriverMgr);
...
}

const UAbilityExDriverMgr* u_driver_mgr_get_ability(void);

typedef struct _UAbilityExDriverMgr {
	UAbilityExDriverMgrAppFun appfun; // 应用函数入口
	UAbilityExDriverMgrGetVar getvar; // 获取变量值
	UAbilityExDriverMgrSetVar setvar; // 设置变量值
	UAbilityExDriverMgrVarGetKey var_get_key; // 依据变量id获取变量key
	UAbilityExDriverMgrVarGetId var_get_id;   // 依据变量key获取变量id
	UAbilityExDriverMgrFunGetKey fun_get_key; // 依据函数id获取函数key
	UAbilityExDriverMgrFunGetId fun_get_id;   // 依据函数key获取函数id
	UAbilityExDriverMgrCallbackSetCoreEx set_access_core_ex_cb;// 设置接入层核心扩展功能回调
	UAbilityExDriverMgrInit init;     // 驱动管理器外部能力初始化
	UAbilityExDriverMgrDeinit deinit; // 驱动管理器外部能力反初始化
}UAbilityExDriverMgr;

...
//获取驱动管理外部能力
const UAbilityExDriverMgr* pAbilityExDriverMgr = u_driver_mgr_get_ability();
//设置驱动管理外部能力
u_biz_vm_ability_ex_set_driver_mgr(pAbilityExDriverMgr);
...

bool u_driver_mgr_post_event(uint32_t iVmId, const char** ppVarKeys, 
const UObject** ppVarValues, size_t iVarSize, int* pErrCode);

...
int iErrCode = 0;
bool bRet = false;
// 构造事件数据
char** ppVarKeys = calloc(2, sizeof(void*));
UObject** ppVarValues = calloc(2, sizeof(void*));
ppVarKeys[0] = "varInt8Key";
ppVarValues[0] = u_object_new_int8(1);
ppVarKeys[1] = "varStringKey";
ppVarValues[1] = u_object_new_string("1");
// 发送事件
bRet = u_driver_mgr_post_event(iVmId, ppVarKeys, ppVarValues, 2, false, &iErrCode);
assert_true(bRet == bExpectRet);
...

typedef struct _UAbilityExDriverMgr {
	UAbilityExDriverMgrAppFun appfun; // 应用函数入口
	UAbilityExDriverMgrGetVar getvar; // 获取变量值
	UAbilityExDriverMgrSetVar setvar; // 设置变量值
	UAbilityExDriverMgrVarGetKey var_get_key; // 依据变量id获取变量key
	UAbilityExDriverMgrVarGetId var_get_id;   // 依据变量key获取变量id
	UAbilityExDriverMgrFunGetKey fun_get_key; // 依据函数id获取函数key
	UAbilityExDriverMgrFunGetId fun_get_id;   // 依据函数key获取函数id
	UAbilityExDriverMgrCallbackSetCoreEx set_access_core_ex_cb;// 设置接入层核心扩展功能回调
	UAbilityExDriverMgrInit init;     // 驱动管理器外部能力初始化
	UAbilityExDriverMgrDeinit deinit; // 驱动管理器外部能力反初始化
}UAbilityExDriverMgr;

typedef bool(*UAbilityExDriverMgrAppFun)(uint32_t iVmId, const char* pFunKey, 
const UObject** ppParams, int32_t iParamsNum, UObject** ppRetData);

/**
以下面的函数表为例

<<函数表>>
函数名称      | 参数列表        | 返回值类型    | 唯一标识            | 参数值描述
funInt8      | int8           | int8         | funInt8Key          |
funString    | string         | string       | funStringKey        |
**/
int g_iVarInt8
bool UAbilityExDriverMgrAppFun_impl(uint32_t iVmId, const char* pFunKey, const UObject** ppParams, int32_t iParamsNum, UObject** ppRetData)
{
        //根据函数唯一标识，返回对应的值
 	if (0 == strcmp(pFunKey, "funInt8Key"))
	{
		*ppRetData = u_object_new_int8(1);;//生成对应类型数据
	}
	else if (0 == strcmp(pFunKey, "funStringKey"))
	{
		*ppRetData = u_object_new_string("1");
	}
	else
	{
		return false;
	}
	return true;
}

typedef bool(*UAbilityExDriverMgrGetVar)(uint32_t iVmId, const char* pVarKey, UObject** ppVal);

/**
以下面的变量表为例

<<变量表>>
变量名称       | 数据类型   | 唯一标识            |  值描述
varInt8       | int8      | varInt8Key          |
varString     | string    | varStringKey        |
varInt8_2     | int8      | varInt8Key_2        |
**/
bool UAbilityExDriverMgrGetVar_impl(uint32_t iVmId, const char* pVarKey, UObject** ppVal)
{
        //根据不同的唯一标识，设置不同的值，
	if (0 == strcmp(pVarKey, "varInt8Key"))
	{
		*ppVal = u_object_new_int8(1);
	}
	else if (0 == strcmp(pVarKey, "varStringKey"))
	{
		*ppVal = u_object_new_string("1");
	}
	else if (0 == strcmp(pVarKey, "varInt8Key_2"))
	{
		*ppVal = u_object_new_int8(1);
	}
	else
	{
		*ppVal = 0;
		return false;
	}
	return true;
}

typedef bool(*UAbilityExDriverMgrSetVar)(uint32_t iVmId, const char* pVarKey, const UObject* pVal);

/**
以下面的函数表为例

<<函数表>>
函数名称      | 参数列表        | 返回值类型    | 唯一标识            | 参数值描述
funInt8      | int8           | int8         | funInt8Key          |
funString    | string         | string       | funStringKey        |
**/
int g_iVarInt8SetVarCount = 0;
int g_iVarStringSetVarCount = 0;
bool UAbilityExDriverMgrSetVar_impl(uint32_t iVmId, const char* pVarKey, const UObject* pVal)
{
        //根据唯一标识判断对应类型变量被执行（回调）的次数
	if (0 == strcmp(pVarKey, "varInt8Key"))
	{
		++g_iVarInt8SetVarCount;
	}
	else if (0 == strcmp(pVarKey, "varStringKey"))
	{
		++g_iVarStringSetVarCount;
	}

	return true;
}

typedef const char*(*UAbilityExDriverMgrVarGetKey)(uint32_t iVmId, int32_t id);

/**
以下面的变量表为例

<<变量表>>
变量名称       | 数据类型   | 唯一标识            |  值描述
varInt8       | int8      | varInt8Key          |
varString     | string    | varStringKey        |
varInt8_2     | int8      | varInt8Key_2        |
**/
const char* UAbilityExDriverMgrVarGetKey_impl(uint32_t iVmId, int32_t id)
{
	if (id == 0)
	{
		return "varInt8Key";
	}
	else if (id == 1)
	{
		return "varStringKey";
	}
	else if (id == 2)
	{
		return "varInt8Key_2";
	}
	else
	{
		return NULL;
	}
}

typedef int32_t(*UAbilityExDriverMgrVarGetId)(uint32_t iVmId, const char* key);

/**
以下面的变量表为例

<<变量表>>
变量名称       | 数据类型   | 唯一标识            |  值描述
varInt8       | int8      | varInt8Key          |
varString     | string    | varStringKey        |
varInt8_2     | int8      | varInt8Key_2        |
**/
int32_t UAbilityExDriverMgrVarGetId_impl(uint32_t iVmId, const char* key)
{
	if (0 == strcmp(key, "varInt8Key"))
	{
		return 0;
	}
	else if (0 == strcmp(key, "varStringKey"))
	{
		return 1;
	}
	else if (0 == strcmp(key, "varInt8Key_2"))
	{
		return 2;
	}
	else
	{
		return -1;
	}
}

typedef const char*(*UAbilityExDriverMgrFunGetKey)(uint32_t iVmId, int32_t id);

const char* UAbilityExDriverMgrFunGetKey_impl(uint32_t iVmId, int32_t id)
{
	if (id == 0)
	{
		return "funInt8Key";
	}
	else if (id == 1)
	{
		return "funStringKey";
	}
	else
	{
		return NULL;
	}
}

typedef int32_t(*UAbilityExDriverMgrFunGetId)(uint32_t iVmId, const char* key);

/**
以下面的函数表为例：

<<函数表>>
函数名称     | 参数列表       | 返回值类型	 | 唯一标识            | 参数值描述
funInt8      | int8           | int8         | funInt8Key          |
funString    | string         | string       | funStringKey        |
**/
int32_t UAbilityExDriverMgrFunGetId_impl(uint32_t iVmId, const char* key)
{
        if (0 == strcmp(key, "funInt8Key"))
	{
		return 0;
	}
	else if (0 == strcmp(key, "funStringKey"))
	{
		return 1;
	}
	else
	{
		return -1;
	}
}

typedef void(*UAbilityExDriverMgrCallbackSetCoreEx)(const UVmAccessCoreEx * pAccessCoreEx);

typedef struct _UVmAccessCoreEx {
	/************ 由基础外部能力注入 ************/
	UAbilityExLogout logout; // 日志
	USysdepMalloc malloc; // 动态申请内存
	USysdepFree free;     // 释放内存
	USysdepMutexInit mutex_new;       //创建互斥锁
	USysdepMutexLock mutex_lock;     //加锁互斥锁
	USysdepMutexUnlock mutex_unlock; //解锁互斥锁
	USysdepMutexDeinit mutex_free;   //释放互斥锁
	USysdepSleep sleep;              // 休眠（毫秒）
	/************* 由虚拟机管理外部能力注入 *************/
	UAbilityExPostEvent post_event_ex;
	/************* 由驱动管理外部能力注入(如果为NULL（允许）,说明应用没有实现该功能) *************/
	UAbilityExVarGetKey var_get_key_ex; // 依据变量id获取变量key
	UAbilityExVarGetId var_get_id_ex;   // 依据变量key获取变量id
	UAbilityExFunGetKey fun_get_key_ex; // 依据函数id获取函数key
	UAbilityExFunGetId fun_get_id_ex;   // 依据函数key获取函数id
}UVmAccessCoreEx;

typedef bool(*UAbilityExDriverMgrInit)( int* pErrCode);

typedef void(*UAbilityExDriverMgrDeinit)(void);

const UAbilityExVmMgr* u_vm_mgr_get_ability(void);

const UAbilityExVmMgr* pAbilityExVmMgr = u_vm_mgr_get_ability();

uint32_t u_vm_mgr_create_vm(const char* pCtxId, const char* pSecret, int32_t pErrCode);

#define SECRET "abcafwefaffeweyu"
int iErrCode = 0;
uint32_t iVmId1 = u_vm_mgr_create_vm("1", SECRET, &iErrCode)

void u_vm_mgr_free_vm(uint32_t iVmId, int* pErrCode);

int errCode = 0;
void u_vm_mgr_free_vm(vmId, &errCode);

bool u_vm_mgr_pause_vm(uint32_t iVmId, int* pErrCode);

int errCode = 0;
u_vm_mgr_pause_vm(vmmId, errCode);

bool u_vm_mgr_resume_vm(uint32_t iVmId, int* pErrCode);

int errCode = 0;
u_vm_mgr_resume_vm(vmId, &errCode);

typedef struct _UAbilityExVmMgr {
	UAbilityExVmMgrPostEvent post_event; //发送事件
	UAbilityExVmMgrGetVmId get_vm_id;    //获取虚拟机id
	UAbilityExVmMgrCallbackSetCore set_access_core_cb;       // 设置接入层核心功能回调
	UAbilityExVmMgrCallbackSetCoreEx set_access_core_ex_cb;  // 设置接入层扩展功能回调
        UAbilityExVmMgrInit init;      // 虚拟机管理外部能力初始化
	UAbilityExVmMgrDeinit deinit;  // 虚拟机管理外部能力反初始化
} UAbilityExVmMgr;

typedef bool(*UAbilityExVmMgrPostEvent)(uint32_t iVmId, const char** ppVarKeys, const UObject** ppVarValues, size_t iVarSize,bool bTriggerInnerEvent, int* pErrCode);

typedef uint32_t (*UAbilityExVmMgrGetVmId)(const UVM* pVM, int* pErrCode);

typedef void(*UAbilityExVmMgrCallbackSetCore)(const UVmAccessCore* pAccessCore);

/******************* 存储接入层-核心相关能力的容器（商用虚拟机本身的能力） *******************/
typedef struct _UVmAccessCore {
	/******************* 虚拟机相关的能力  **************************/
	UVmAccessCoreVmCreate vm_create;            //创建虚拟机
	UVmAccessCoreVmGetUserdata vm_get_userdata; //获取用户数据
	UVmAccessCoreVmPause vm_pause;              //暂停虚拟机
	UVmAccessCoreVmResume vm_resume;            //恢复虚拟机
	UVmAccessCoreVmFree vm_free;                //释放虚拟机
	UVmAccessCoreVmCtxNew vm_ctx_new;           // 创建虚拟机执行上下文
	UVmAccessCoreVmCtxFree vm_ctx_free;         // 销毁虚拟机执行上下文
	UVmAccessCoreVarCacheNew vm_var_cache_new;  // 创建变量缓存，用于调用UVmAccessCoreVmEventPrepare后缓存的varKey、varId、var值、vm的关联关系，发送事件时使用。
	UVmAccessCoreVarCacheFree vm_var_cache_free;// 释放变量缓存
	UVmAccessCoreVmEventPrepare vm_event_prepare; //事件预处理，获取执行上下文
	UVmAccessCoreVmEventPost vm_event_post;       //向虚拟机发送事件
	UVmAccessCoreVmVarlistUpdate vm_varlist_update; //向应用更新变量
	/*********************** IKC相关的能力  ***********************/
	UVmAccessCoreVarGetKey vm_var_get_key;  // 依据变量id获取变量key
	UVmAccessCoreVarGetId vm_var_get_id;    // 依据变量key获取变量id
	UVmAccessCoreFunGetKey vm_fun_get_key;  // 依据函数id获取函数key
	UVmAccessCoreFunGetId vm_fun_get_id;    // 依据函数key获取函数id
	/*************** 虚拟机工具方法相关的能力  **********************/
	UVmAccessCoreVarlistNew varlist_new;   //创建变量列表
	UVmAccessCoreVarNew var_new;           //创建变量信息
	UVmAccessCoreVarlistAdd varlist_add;   //追加变量到变量列表, 变量内存由变量列表管理
	UVmAccessCoreVarlistFree varlist_free; //释放变量列表
	UVmAccessCoreVmEventInfoListNew vm_event_info_list_new; //创建一个事件信息列表
	UVmAccessCoreVmGetEventInfoList vm_get_event_info_list; //获取事件信息列表
	UVmAccessCoreVmEventInfoListSize vm_event_info_list_size; //获取事件信息列表长度
	UVmAccessCoreVmEventInfoListGetVarId vm_event_info_list_get_var_id; //获取事件信息列表中指定下表的变量id
	UVmAccessCoreVmEventInfoListFree vm_event_info_list_free; //释放事件信息列表
}UVmAccessCore;

UAbilityExVmMgrCallbackSetCoreEx

/******************* 存储接入层-核心扩展相关能力的容器 *******************/
typedef struct _UVmAccessCoreEx {
	/************ 由基础外部能力注入 ************/
	UAbilityExLogout logout; // 日志
	USysdepMalloc malloc; // 动态申请内存
	USysdepFree free;     // 释放内存
	USysdepMutexInit mutex_new;       //创建互斥锁
	USysdepMutexLock mutex_lock;     //加锁互斥锁
	USysdepMutexUnlock mutex_unlock; //解锁互斥锁
	USysdepMutexDeinit mutex_free;   //释放互斥锁
	USysdepSleep sleep;              // 休眠（毫秒）
	/************* 由虚拟机管理外部能力注入 *************/
	UAbilityExPostEvent post_event_ex;
	/************* 由驱动管理外部能力注入(如果为NULL（允许）,说明应用没有实现该功能) *************/
	UAbilityExVarGetKey var_get_key_ex; // 依据变量id获取变量key
	UAbilityExVarGetId var_get_id_ex;   // 依据变量key获取变量id
	UAbilityExFunGetKey fun_get_key_ex; // 依据函数id获取函数key
	UAbilityExFunGetId fun_get_id_ex;   // 依据函数key获取函数id
}UVmAccessCoreEx;

typedef bool(*UAbilityExVmMgrInit)(int* pErrCode);

typedef void(*UAbilityExVmMgrDeinit)(void);