netease
/
PV1_MakeProject
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
PV1_MakeProject/Framework/libuvEngine/libuv_dbus.c

2309 lines
65 KiB
C
Raw Blame History

#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <linux/input.h>
#include <sys/shm.h>
#include <sys/msg.h>
#include <sys/sendfile.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/vfs.h>
#include <uthash/utlist.h>
#include "log.h"
#include "libuv_dbus.h"
#include "json_struct.h"
#include "inet_api.h"
#include "crypto.h"
#include "server_addr.h"
#ifdef ENABLE_COUNT_DEBUG
#include "monitor.h"
#endif
#ifdef ENABLE_COUNT_DEBUG
#define MON_MSG_PROC_STAT ("Message Process")
#define MON_MSG_BST_PROC_STAT ("Boardcast Message Process")
#define MON_USER_MSG_PROC_STAT ("User Message Process")
#define MON_USER_MSG_BST_PROC_STAT ("User Boardcast Message Process")
#endif
typedef void (*OnDBusSendError)(int, void*);
static void uvOpenKeyEventCb(uv_fs_t* puvFs);
typedef struct LOOP_TASK_ARRAY
{
uv_loop_t* pLoop;
int isRunning;
struct LOOP_TASK_ARRAY *next, *prev;
} *PLOOP_TASK_ARRAY;
typedef struct
{
key_t shmKey;
// uint32_t tarMask;
// uint32_t tmSend;
uint32_t msgSize;
UT_hash_handle hh; ///< UT Hash handle
} UV_SHM_ITEM, *PUV_SHM_ITEM;
typedef struct
{
long int msgMask;
unsigned char pMsgContext[0];
} DBUS_MSG_DATA, *PDBUS_MSG_DATA;
typedef struct
{
DBusConnection* pBus;
const char* pBusName;
uint32_t busCmd;
JSON_ENGINE_TYPE type;
void* pStruct;
int iSize;
OnDBusAsyncSendTo cbSendTo;
int enBase64;
} DBUS_ASYNC_PARAMS, *PDBUS_ASYNC_PARAMS;
static LIBUV_DBUS_PARAMS g_LibuvDBusParam;
static uv_idle_t g_uvIdleHandle;
static uv_timer_t g_uvTimerPing;
static uv_fs_t g_uvKeyEvent;
static WORKDAY_INFO g_workDayArray;
static WIFI_STATUS g_WifiConnStatus = WIFI_CONNECTED;
static PDBUS_MSG_PROC g_pMsgProcList = NULL;
static uv_rwlock_t g_uvLoopRwLock;
static PLOOP_TASK_ARRAY g_LoopArray = NULL;
static unsigned int g_EnHBLExit = TRUE;
static uv_rwlock_t g_uvMsgProcRwLock;
#if USED_SHM_TO_DBUS
static uv_rwlock_t g_uvShmHashRwLock;
static PUV_SHM_ITEM g_pShmTbl = NULL;
static void __addShmIdToTable(key_t shmKey, uint32_t tmSend, uint32_t tarMask, uint32_t msgSize)
{
PUV_SHM_ITEM pItem = NULL;
uv_rwlock_rdlock(&g_uvShmHashRwLock);
HASH_FIND_INT(g_pShmTbl, &shmKey, pItem);
uv_rwlock_rdunlock(&g_uvShmHashRwLock);
if(pItem == NULL)
{
pItem = (PUV_SHM_ITEM)malloc(sizeof(UV_SHM_ITEM));
memset(pItem, 0, sizeof(UV_SHM_ITEM));
pItem->shmKey = shmKey;
uv_rwlock_wrlock(&g_uvShmHashRwLock);
HASH_ADD_INT(g_pShmTbl, shmKey, pItem);
uv_rwlock_wrunlock(&g_uvShmHashRwLock);
}
pItem->tmSend = tmSend;
pItem->tarMask = tarMask;
pItem->msgSize = msgSize;
}
static void __removeReqIdFromTable(key_t shmKey)
{
PUV_SHM_ITEM pItem = NULL;
uv_rwlock_rdlock(&g_uvShmHashRwLock);
HASH_FIND_INT(g_pShmTbl, &shmKey, pItem);
uv_rwlock_rdunlock(&g_uvShmHashRwLock);
if(pItem != NULL)
{
uv_rwlock_wrlock(&g_uvShmHashRwLock);
HASH_DEL(g_pShmTbl, pItem);
uv_rwlock_wrunlock(&g_uvShmHashRwLock);
free(pItem);
}
}
static void __uvShmTblTaskThreadCb(void *pParam)
{
struct timeval tv;
PUV_SHM_ITEM pItem = NULL, pTmpItem = NULL;
while(TRUE)
{
gettimeofday(&tv, NULL);
HASH_ITER(hh, g_pShmTbl, pItem, pTmpItem)
{
int msgId;
if(tv.tv_sec - pItem->tmSend <= 60)
{
continue;
}
msgId = shmget((key_t)pItem->shmKey, pItem->msgSize, 0666 | IPC_CREAT);
if(msgId == -1)
{
continue;
}
// Not Boardcast Message
if((pItem->tarMask & 0xFFFF0000) != 0xFFFF0000)
{
PDBUS_MSG_DATA pData = (PDBUS_MSG_DATA)shmat(msgId, NULL, 0);
if(pData == (void*)-1)
{
continue;
}
// Nevery Recevied By Anyone
if(pData->msgMask == pItem->tarMask)
{
continue;
}
shmdt(pData);
shmctl(msgId, IPC_RMID, 0);
__removeReqIdFromTable((key_t)pItem->shmKey);
}
}
sleep(1);
}
pthread_detach(pthread_self());
}
#endif
PLIBUV_DBUS_PARAMS DBusLibuvGetRuntime(void)
{
if(g_LibuvDBusParam.pBus == NULL || g_LibuvDBusParam.pLoop == NULL)
{
return NULL;
}
return &g_LibuvDBusParam;
}
MODULE_NAME DBusLibGetModName(void)
{
return g_LibuvDBusParam.modName;
}
uv_loop_t* GetDBusDefaultLoop(void)
{
if(g_LibuvDBusParam.pBus == NULL || g_LibuvDBusParam.pLoop == NULL)
{
return uv_default_loop();
}
return g_LibuvDBusParam.pLoop;
}
static void uvAsyncCb(uv_async_t* pAsync)
{
DBusConnection* pConn = (DBusConnection*)pAsync->data;
dbus_connection_read_write(pConn, 0);
while(dbus_connection_dispatch(pConn) == DBUS_DISPATCH_DATA_REMAINS);
}
static void uvTimeoutCb(uv_timer_t* pTimer)
{
DBusTimeout* timeout = (DBusTimeout*)pTimer->data;
dbus_timeout_handle(timeout);
}
static void uvPollCb(uv_poll_t* pPoll, int status, int events)
{
DBusWatch* watch = (DBusWatch*)pPoll->data;
unsigned int uvFlags = 0;
if(events & UV_READABLE)
{
uvFlags |= DBUS_WATCH_READABLE;
}
if(events & UV_WRITABLE)
{
uvFlags |= DBUS_WATCH_WRITABLE;
}
dbus_watch_handle(watch, uvFlags);
}
static void uvIdleCb(uv_idle_t* phuvIdle)
{
usleep(1000);
}
static void uvFsAccessCb(uv_fs_t* puvFs)
{
if(puvFs->result != 0)
{
IHW_EnableLogLevel((LOG_LEVEL)(LOG_Fatal | LOG_Error | LOG_Warn | LOG_Debug | LOG_Info), 1);
}
uv_fs_req_cleanup(puvFs);
free(puvFs);
}
static void uvReadKeyEventCb(uv_fs_t* puvFs)
{
if(puvFs->result < 0)
{
uv_fs_req_cleanup(puvFs);
return;
}
else if(puvFs->result == 0)
{
uv_fs_t uvClose;
uv_fs_close(g_LibuvDBusParam.pLoop, &uvClose, g_uvKeyEvent.result, NULL);
}
else
{
uv_buf_t* puvIov = (uv_buf_t*)puvFs->data;
if(puvIov->len == sizeof(struct input_event))
{
struct input_event* pKeyEvt = (struct input_event*)puvIov->base;
if(g_LibuvDBusParam.onKeyCb)
{
// LOG_EX(LOG_Info, "type = %u, code = %u, value = %u\n", pKeyEvt->type, pKeyEvt->code, pKeyEvt->value);
g_LibuvDBusParam.onKeyCb(pKeyEvt->type, pKeyEvt->code, pKeyEvt->value);
}
}
}
uv_fs_req_cleanup(puvFs);
usleep(1000);
uv_fs_open(g_LibuvDBusParam.pLoop, &g_uvKeyEvent, R16_TINA_KEY_EVENT_PATH, O_RDONLY, 0, uvOpenKeyEventCb);
}
static void uvOpenKeyEventCb(uv_fs_t* puvFs)
{
static uv_buf_t uvIoV;
static struct input_event keyEvent;
if(puvFs->result < 0)
{
LOG_EX(LOG_Error, "Open Key Event File[%s] Error: %d\n", R16_TINA_KEY_EVENT_PATH, puvFs->result);
uv_fs_req_cleanup(puvFs);
return;
}
uvIoV = uv_buf_init((void*)&keyEvent, sizeof(struct input_event));
puvFs->data = (void*)&uvIoV;
uv_fs_read(g_LibuvDBusParam.pLoop, &g_uvKeyEvent, puvFs->result, &uvIoV, 1, -1, uvReadKeyEventCb);
uv_fs_req_cleanup(puvFs);
return;
}
static void DBusAsyncFreeCb(void* pData)
{
uv_async_t* pAsync = (uv_async_t*)pData;
if(pAsync)
{
pAsync->data = NULL;
uv_close((uv_handle_t*)pAsync, (uv_close_cb)free);
}
}
static void DBusPollFreeCb(void* pData)
{
uv_poll_t* pPoll = (uv_poll_t*)pData;
if(pPoll)
{
pPoll->data = NULL;
uv_ref((uv_handle_t*)pPoll);
uv_poll_stop(pPoll);
uv_close((uv_handle_t*)pPoll, (uv_close_cb)free);
}
}
static dbus_bool_t DBusAddWatchCb(DBusWatch* pWatch, void* pData)
{
static int isCreate = 0;
int fdDBus, uvPollFlags = 0;
unsigned int dBusWatchFlags;
uv_poll_t* pPoll = NULL;
uv_loop_t* pLoop = (uv_loop_t*)pData;
if(!dbus_watch_get_enabled(pWatch)
|| dbus_watch_get_data(pWatch) != NULL
|| isCreate != 0)
{
return TRUE;
}
fdDBus = dbus_watch_get_unix_fd(pWatch);
dBusWatchFlags = dbus_watch_get_flags(pWatch);
if(dBusWatchFlags & DBUS_WATCH_READABLE)
{
uvPollFlags |= UV_READABLE;
}
if(dBusWatchFlags & DBUS_WATCH_WRITABLE)
{
uvPollFlags |= UV_WRITABLE;
}
pPoll = (uv_poll_t*)malloc(sizeof(uv_poll_t));
pPoll->data = (void*)pWatch;
uv_poll_init(pLoop, pPoll, fdDBus);
uv_poll_start(pPoll, uvPollFlags, uvPollCb);
LOG_EX(LOG_Debug, "Create POOL by FD: %d\n", fdDBus);
uv_unref((uv_handle_t*)pPoll);
dbus_watch_set_data(pWatch, (void*)pPoll, DBusPollFreeCb);
isCreate = 1;
return TRUE;
}
static void DBusRemoveWatchCb(DBusWatch* pWatch, void* pData)
{
uv_poll_t* pPoll = (uv_poll_t*)dbus_watch_get_data(pWatch);
if(pPoll)
{
dbus_watch_set_data(pWatch, NULL, NULL);
}
}
static void DBusNotifyWatchCb(DBusWatch* pWatch, void* pData)
{
if(dbus_watch_get_enabled(pWatch))
{
DBusAddWatchCb(pWatch, pData);
}
else
{
DBusRemoveWatchCb(pWatch, pData);
}
}
static void DBusTimeoutFreeCb(void* pData)
{
uv_timer_t* pTimer = (uv_timer_t*)pData;
if(pTimer == NULL)
{
return;
}
pTimer->data = NULL;
uv_timer_stop(pTimer);
uv_unref((uv_handle_t*)pTimer);
uv_close((uv_handle_t*)pTimer, (uv_close_cb)free);
}
static dbus_bool_t DBusAddTimeoutCb(DBusTimeout* pTimeout, void* pData)
{
uv_timer_t* pTimer = NULL;
uv_loop_t* pLoop = (uv_loop_t*)pData;
if(!dbus_timeout_get_enabled(pTimeout)
|| dbus_timeout_get_data(pTimeout) != NULL)
{
return TRUE;
}
pTimer = (uv_timer_t*)malloc(sizeof(uv_timer_t));
pTimer->data = pTimeout;
uv_timer_init(pLoop, pTimer);
uv_timer_start(pTimer, uvTimeoutCb, dbus_timeout_get_interval(pTimeout), 0);
dbus_timeout_set_data(pTimeout, (void*)pTimer, DBusTimeoutFreeCb);
return TRUE;
}
static void DBusRemoveTimeoutCb(DBusTimeout* pTimeout, void* pData)
{
uv_timer_t* pTimer = (uv_timer_t*)dbus_timeout_get_data(pTimeout);
if(pTimer)
{
dbus_timeout_set_data(pTimeout, NULL, NULL);
}
}
static void DBusNotifyTimeoutCb(DBusTimeout* pTimeout, void* pData)
{
if(dbus_timeout_get_enabled(pTimeout))
{
DBusAddTimeoutCb(pTimeout, pData);
}
else
{
DBusRemoveTimeoutCb(pTimeout, pData);
}
}
static void DBusWakeupMainLoopCb(void* pData)
{
uv_async_t* pAsync = (uv_async_t*)pData;
uv_async_send(pAsync);
}
static void FreeDBusOnMsgCb(uv_work_t* pWork, int status)
{
PDBUS_MSG_PACK pMsg = (PDBUS_MSG_PACK)pWork->data;
if(pMsg)
{
free(pMsg);
}
free(pWork);
}
#if 0
static void DBusOnBoardcastMsgWorkCb(uv_work_t* pWork)
#else
static int DBusOnBoardcastMsgWorkCb(PDBUS_MSG_PACK pMsg)
#endif
{
pMsg->isBstMsg = TRUE;
// Message context on dbus message pad
if(pMsg->msgSize < DBUS_MSG_MAX_PAD_SIZE)
{
if(pMsg->busCmd == CMD_WIFI_STATE_NTF)
{
int err = 0;
PWIFI_STATUS_PRO pWifiInfo = (PWIFI_STATUS_PRO)Json2Struct((const char *)pMsg->pMsg,
JSON_WIFI_STATUS_NOTIFY, FALSE, &err);
//LOG_EX(LOG_Debug, "pWifiInfo: %s\n", pMsg->pMsg);
if(pWifiInfo && err == 0)
{
if(pWifiInfo->wifi_evt == 0)
{
g_WifiConnStatus = WIFI_CONNECTED;
}
else
{
g_WifiConnStatus = WIFI_DISCONNECTED;
}
}
if(pWifiInfo)
{
free(pWifiInfo);
}
}
else if(pMsg->busCmd == CMD_CFG_UPG_NOTIFY)
{
}
else if(pMsg->busCmd == CMD_LOG_CONFIG)
{
int err = 0;
PLOG_CFG_PROTOCOL pCfgInfo = (PLOG_CFG_PROTOCOL)Json2Struct((const char *)pMsg->pMsg,
JSON_ENGINE_LOG_CFG_CMD, FALSE, &err);
//LOG_EX(LOG_Debug, "pCfgInfo: %s\n", pMsg->pMsg);
if(pCfgInfo && err == 0)
{
UpgradLogConfigure(pCfgInfo);
}
if(pCfgInfo)
{
free(pCfgInfo);
}
}
else if(pMsg->busCmd != CMD_MISC_PING)
{
pMsg->msgDests = 0xFFFFFFFF;
if(g_LibuvDBusParam.onMsgCb)
{
g_LibuvDBusParam.onMsgCb(g_LibuvDBusParam.pLoop, g_LibuvDBusParam.pBus, pMsg);
}
return 1;
}
}
return 0;
}
#if 0
static void DBusOnMsgWorkAPICb(uv_work_t* pWork)
#else
static int DBusOnMsgWorkAPICb(PDBUS_MSG_PACK pMsg)
#endif
{
int err = 0;
pMsg->isBstMsg = FALSE;
// Message context on dbus message pad
if(pMsg->msgSize < DBUS_MSG_MAX_PAD_SIZE)
{
if(pMsg->busCmd >= CMD_CFG_ADD_REQ && pMsg->busCmd < CMD_CFG_UPG_NOTIFY)
{
OnCfgMsgProcess(pMsg->msgSrc, pMsg->busCmd, pMsg->pMsg);
}
else if(pMsg->busCmd == CMD_LOG_CONFIG)
{
PLOG_CFG_PROTOCOL pCfgInfo = (PLOG_CFG_PROTOCOL)Json2Struct((const char *)pMsg->pMsg,
JSON_ENGINE_LOG_CFG_CMD, FALSE, &err);
//LOG_EX(LOG_Debug, "pCfgInfo: %s\n", pMsg->pMsg);
if(pCfgInfo && err == 0)
{
UpgradLogConfigure(pCfgInfo);
}
if(pCfgInfo)
{
free(pCfgInfo);
}
}
else if(pMsg->busCmd == CMD_WORKDAY_DB_RSP)
{
PWORKDAY_INFO pWorkDayInfo = (PWORKDAY_INFO)Json2Struct((const char *)pMsg->pMsg,
JSON_ENGINE_WORKDAY_REQ, FALSE, &err);
//LOG_EX(LOG_Debug, "WorkDay: %s\n", pMsg->pMsg);
if(pWorkDayInfo && err == 0)
{
memcpy(&g_workDayArray, pWorkDayInfo, sizeof(WORKDAY_INFO));
}
//LOG_EX2(LOG_Debug, "Database: %s\n", pMsg->pMsg);
if(pWorkDayInfo)
{
free(pWorkDayInfo);
}
}
else if(pMsg->busCmd != CMD_MISC_PING)
{
if(g_LibuvDBusParam.onMsgCb)
{
g_LibuvDBusParam.onMsgCb(g_LibuvDBusParam.pLoop, g_LibuvDBusParam.pBus, pMsg);
}
return 1;
}
}
else // More than 4K size used Share Memory
{
LOG_EX(LOG_Error, "Receive Message Error Size: %d\n", pMsg->msgSize);
#if 0
PDBUS_MSG_DATA pData = NULL;
int key = strtol(pMsg->pMsg, NULL, 10);
int msgId = shmget((key_t)key, pMsg->msgSize, 0666 | IPC_CREAT);
if(msgId == -1)
{
return;
}
pData = (PDBUS_MSG_DATA)shmat(msgId, NULL, 0);
if(pData == (void*)-1)
{
return;
}
//print_hex_dump_bytes("send_", 2, pData, pMsg->msgSize);
pMsg->pMsg = pData->pMsgContext;
pMsg->msgSize -= sizeof(long int);
if(pMsg->busCmd != CMD_MISC_PING)
{
g_LibuvDBusParam.onMsgCb(g_LibuvDBusParam.pLoop, g_LibuvDBusParam.pBus, pMsg);
}
pData->msgMask &= ~(1 << g_LibuvDBusParam.modName);
// Cleanup Share Memory
if(pData->msgMask == 0)
{
shmctl(msgId, IPC_RMID, 0);
#if USED_SHM_TO_DBUS
__removeReqIdFromTable((key_t)key);
#endif
}
shmdt(pData);
#endif
}
return 0;
}
static DBusHandlerResult DBusOnMsgCb(DBusConnection* pConn, DBusMessage* pMsg, void* user_data)
{
#if 0
struct timeval tmBegin, tmEnd;
long long diffTm;
#endif
DBusError error;
PDBUS_MSG_PROC pMsgProc = NULL;
PDBUS_MSG_PACK pMsgPack = (PDBUS_MSG_PACK)malloc(sizeof(DBUS_MSG_PACK));
if(pMsgPack == NULL)
{
LOG_EX(LOG_Error, "Receive Message: No Memory\n");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
memset(pMsgPack, 0, sizeof(DBUS_MSG_PACK));
dbus_error_init(&error);
if(dbus_message_is_signal(pMsg, DBUS_MESSAGE_INTERFACE_NAME, "Notify"))
{
if(dbus_message_get_args(pMsg, &error,
DBUS_TYPE_UINT32, &pMsgPack->msgSrc, // from
DBUS_TYPE_UINT32, &pMsgPack->msgDests, // to -1 means all except it's self
#if USED_SHM_TO_DBUS
DBUS_TYPE_UINT32, &pMsgPack->tmTickMSec, // timestamp for msecond
#endif
DBUS_TYPE_UINT32, &pMsgPack->busCmd, // command type
DBUS_TYPE_STRING, &pMsgPack->pMsg, // message context if had
DBUS_TYPE_INVALID))
{
pMsgPack->msgSize = strlen((char*)pMsgPack->pMsg);
// reset timeout timer
if(g_LibuvDBusParam.onHblCb && pMsgPack->msgSrc != g_LibuvDBusParam.modName)
{
HeartDaemonUpgrade(pMsgPack->msgSrc);
}
// Dispatch message except from it's self
if(pMsgPack->msgSrc != g_LibuvDBusParam.modName
&& pMsgPack->msgDests & (1 << g_LibuvDBusParam.modName))
{
if(g_LibuvDBusParam.onMsgCb == NULL)
{
pMsgProc = (PDBUS_MSG_PROC)malloc(sizeof(struct DBUS_MSG_PROC));
if(pMsgProc == NULL)
{
LOG_EX(LOG_Error, "Receive Message: No Memory\n");
free(pMsgPack);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
memset(pMsgProc, 0, sizeof(struct DBUS_MSG_PROC));
memcpy(&pMsgProc->msgContent, pMsgPack, sizeof(DBUS_MSG_PACK));
pMsgProc->msgContent.pMsg = strdup(pMsgPack->pMsg);
pMsgProc->msgFrom = 0;
uv_rwlock_wrlock(&g_uvMsgProcRwLock);
DL_APPEND(g_pMsgProcList, pMsgProc);
uv_rwlock_wrunlock(&g_uvMsgProcRwLock);
}
else
{
DBusOnBoardcastMsgWorkCb(pMsgPack);
}
}
}
else
{
LOG_EX(LOG_Error, "Receive Notify Message Error: %s\n", error.message);
dbus_error_free(&error);
}
free(pMsgPack);
return DBUS_HANDLER_RESULT_HANDLED;
}
else if(dbus_message_is_method_call(pMsg, DBUS_MESSAGE_INTERFACE_NAME, "API"))
{
if(dbus_message_get_args(pMsg, &error,
DBUS_TYPE_UINT32, &pMsgPack->msgSrc, // from
DBUS_TYPE_UINT32, &pMsgPack->msgDests, // to -1 means all except it's self
#if USED_SHM_TO_DBUS
DBUS_TYPE_UINT32, &pMsgPack->tmTickMSec, // timestamp for msecond
#endif
DBUS_TYPE_UINT32, &pMsgPack->busCmd, // command type
DBUS_TYPE_UINT32, &pMsgPack->msgSize, // message size(in bytes)
DBUS_TYPE_STRING, &pMsgPack->pMsg, // message context if had
DBUS_TYPE_INVALID))
{
// reset timeout timer
if(g_LibuvDBusParam.onHblCb && pMsgPack->msgSrc != g_LibuvDBusParam.modName)
{
HeartDaemonUpgrade(pMsgPack->msgSrc);
}
// Dispatch message except from it's self
if(pMsgPack->msgSrc != g_LibuvDBusParam.modName
&& pMsgPack->msgDests == (1 << g_LibuvDBusParam.modName))
{
if(g_LibuvDBusParam.onMsgCb == NULL)
{
pMsgProc = (PDBUS_MSG_PROC)malloc(sizeof(struct DBUS_MSG_PROC));
if(pMsgProc == NULL)
{
LOG_EX(LOG_Error, "Receive Message: No Memory\n");
free(pMsgPack);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
memset(pMsgProc, 0, sizeof(struct DBUS_MSG_PROC));
memcpy(&pMsgProc->msgContent, pMsgPack, sizeof(DBUS_MSG_PACK));
pMsgProc->msgContent.pMsg = strdup(pMsgPack->pMsg);
pMsgProc->msgFrom = 1;
uv_rwlock_wrlock(&g_uvMsgProcRwLock);
DL_APPEND(g_pMsgProcList, pMsgProc);
uv_rwlock_wrunlock(&g_uvMsgProcRwLock);
}
else
{
DBusOnMsgWorkAPICb(pMsgPack);
}
}
}
else
{
LOG_EX(LOG_Error, "Receive API Message Error: %s\n", error.message);
dbus_error_free(&error);
}
free(pMsgPack);
return DBUS_HANDLER_RESULT_HANDLED;
}
free(pMsgPack);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static void freeSHMResource(int shmId, void* pData)
{
// Cleanup Share Memory
if(pData)
{
shmdt(pData);
}
shmctl(shmId, IPC_RMID, 0);
}
static void FreeDBusSendToAsyncCb(uv_work_t* pWork, int status)
{
PDBUS_ASYNC_PARAMS pParam = (PDBUS_ASYNC_PARAMS)pWork->data;
free(pParam->pStruct);
free(pParam);
free(pWork);
}
static void DBusSendToAsyncCb(uv_work_t* pWork)
{
int err = 0;
PDBUS_ASYNC_PARAMS pParam = (PDBUS_ASYNC_PARAMS)pWork->data;
const char *pJsonStr = Struct2Json(pParam->pStruct, pParam->type, pParam->enBase64, &err);
if(pJsonStr == NULL || err != 0)
{
pParam->cbSendTo(err);
return;
}
err = DBusSendToCommand(pParam->pBus, pParam->pBusName, pParam->busCmd, pJsonStr);
free((void*)pJsonStr);
pParam->cbSendTo(err);
}
int DBusJsonSendToCommandAsync(DBusConnection* pBus,
const char* pBusName,
uint32_t busCmd,
JSON_ENGINE_TYPE type,
void* pStruct,
int iSize,
OnDBusAsyncSendTo cbSendTo,
int enBase64)
{
PDBUS_ASYNC_PARAMS pParam = NULL;
uv_work_t* puvWork = NULL;
if(cbSendTo == NULL)
{
return 0;
}
pParam = (PDBUS_ASYNC_PARAMS)malloc(sizeof(DBUS_ASYNC_PARAMS));
puvWork = (uv_work_t*)malloc(sizeof(uv_work_t));
pParam->pBus = pBus;
pParam->pBusName = pBusName;
pParam->busCmd = busCmd;
pParam->type = type;
pParam->iSize = iSize;
pParam->pStruct = malloc(iSize);
pParam->cbSendTo = cbSendTo;
pParam->enBase64 = enBase64;
memcpy(pParam->pStruct, pStruct, iSize);
puvWork->data = (void*)pParam;
uv_queue_work(g_LibuvDBusParam.pLoop, puvWork, DBusSendToAsyncCb, FreeDBusSendToAsyncCb);
return 0;
}
int DBusJsonSendToCommand(DBusConnection* pBus,
const char* pBusName,
uint32_t busCmd,
JSON_ENGINE_TYPE type,
void* pStruct,
int enBase64)
{
int ret, err = 0;
const char* pJsonStr = Struct2Json(pStruct, type, enBase64, &err);
if(pJsonStr == NULL || err != 0)
{
return err;
}
ret = DBusSendToCommand(pBus, pBusName, busCmd, pJsonStr);
free((void*)pJsonStr);
return ret;
}
int DBusJsonBoardcastCommand(DBusConnection* pBus,
uint32_t msgToMask,
uint32_t busCmd,
JSON_ENGINE_TYPE type,
void* pStruct,
int enBase64)
{
int ret, err = 0;
const char* pJsonStr = Struct2Json(pStruct, type, enBase64, &err);
if(pJsonStr == NULL || err != 0)
{
return err;
}
ret = DBusBoardcastCommand(pBus, msgToMask, busCmd, pJsonStr);
free((void*)pJsonStr);
return ret;
}
static unsigned int __getShmReqId(void)
{
static unsigned int g_shmReqId = 1;
unsigned int iReqId;
if(g_shmReqId >= 0xFFFF - 1)
{
g_shmReqId = 1;
}
iReqId = __sync_fetch_and_add(&g_shmReqId, 1);
return (iReqId & 0xFFFF) | (g_LibuvDBusParam.modName << 16);
}
int DBusSendToCommand(DBusConnection* pBus,
const char* pBusName,
uint32_t busCmd,
const char* pContext)
{
#if USED_SHM_TO_DBUS
struct timeval tv;
#endif
int i;
int msgId;
//char msgContext[DBUS_MSG_MAX_PAD_SIZE];
DBusMessage* pMsg = NULL;
uint32_t msgLen = 0;
uint32_t msgToMask = 0;
OnDBusSendError pErrorCb = NULL;
uint8_t* pMsgInfo = NULL;
PDBUS_MSG_DATA pShmData = NULL;
const char* pPath = NULL;
char* pMsgContent = NULL;
#if 0
if(pContext == NULL || (msgLen = strlen(pContext)) <= 0)
{
return (-ERR_INPUT_PARAMS);
}
#else
if(pContext == NULL)
{
pContext = "";
msgLen = 0;
}
else
{
msgLen = strlen(pContext);
}
#endif
pMsgContent = (char*)malloc(msgLen + 1);
if(pMsgContent == NULL)
{
LOG_EX(LOG_Error, "Malloc memory %d error\n", msgLen + 1);
return -ERR_MALLOC_MEMORY;
}
pMsgInfo = (uint8_t*)pMsgContent;
memset(pMsgContent, 0, msgLen + 1);
if(pBus == NULL)
{
pBus = g_LibuvDBusParam.pBus;
}
for(i = 0; (i < sizeof(g_pModInfoTable) / sizeof(g_pModInfoTable[0])); i++)
{
// Skip match it'self
if(strcmp(g_pModInfoTable[i].modAliase, pBusName) == 0)
{
msgToMask = 1 << i;
pPath = g_pModInfoTable[i].modPath;
break;
}
}
pMsg = dbus_message_new_method_call(pBusName,
pPath,
DBUS_MESSAGE_INTERFACE_NAME,
"API");
if(pMsg == NULL)
{
free(pMsgContent);
LOG_EX(LOG_Error, "DBus Create Message Error\n");
return -ERR_DBUS_CREATE_MSG;
}
dbus_message_set_no_reply(pMsg, TRUE);
#if USED_SHM_TO_DBUS
gettimeofday(&tv, NULL);
#endif
if(msgLen < DBUS_MSG_MAX_PAD_SIZE)
{
strcpy(pMsgContent, pContext);
}
else
{
#if 0
int msgKey = __getShmReqId();
msgLen += sizeof(long int);
// Make message with Memory Share
msgId = shmget((key_t)msgKey, msgLen, 0666 | IPC_CREAT);
if(msgId == -1)
{
perror("shmget_");
return (-ERR_CREATE_SHM);
}
else
{
pShmData = (PDBUS_MSG_DATA)shmat(msgId, NULL, 0);
if(pShmData == (void*)-1)
{
return -ERR_MAP_SHM;
}
pShmData->msgMask = msgToMask;
memcpy(pShmData->pMsgContext, pContext, msgLen);
sprintf(pMsgInfo, "%d", msgKey);
shmdt(pShmData);
//print_hex_dump_bytes("send_", 2, pShmData, msgLen);
//strcpy(pMsgInfo, (void*)&msgKey, sizeof(key_t));
#if USED_SHM_TO_DBUS
__addShmIdToTable((key_t)msgKey, tv.tv_sec, msgToMask, msgLen);
#endif
pErrorCb = freeSHMResource;
}
//#else
#endif
free(pMsgContent);
LOG_EX(LOG_Error, "Send Message size %d more than DBUS_MSG_MAX_PAD_SIZE, busCmd = %u, pBusName = %s\n",
msgLen, busCmd, pBusName);
return -ERR_INPUT_PARAMS;
}
dbus_message_append_args(pMsg,
DBUS_TYPE_UINT32, &g_LibuvDBusParam.modName, // from
DBUS_TYPE_UINT32, &msgToMask, // to -1 means all except it's self
#if USED_SHM_TO_DBUS
DBUS_TYPE_UINT32, &tv.tv_sec, // timestamp for msecond
#endif
DBUS_TYPE_UINT32, &busCmd, // command type
DBUS_TYPE_UINT32, &msgLen, // message size(in bytes)
DBUS_TYPE_STRING, &pMsgInfo,
// msgLen[0, 512): pad to message; msgLen[512, ~): memory map key,
//DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &pMsgInfo, (msgLen < DBUS_MSG_MAX_PAD_SIZE) ? msgLen : sizeof(key_t),
DBUS_TYPE_INVALID);
free(pMsgContent);
if(!dbus_connection_send(pBus, pMsg, NULL))
{
LOG_EX(LOG_Error, "Send Message Error\n");
if(pErrorCb)
{
pErrorCb(msgId, pShmData);
}
return -ERR_BUS_SEND_MSG;
}
//dbus_connection_flush(pBus);
dbus_message_unref(pMsg);
usleep(100);
return 0;
}
int DBusBoardcastCommand(DBusConnection* pBus,
uint32_t msgToMask,
uint32_t busCmd,
const char* pContext)
{
#if USED_SHM_TO_DBUS
struct timeval tv;
#endif
DBusMessage* pMsg = NULL;
if(pContext == NULL)
{
pContext = "";
}
if(strlen(pContext) >= DBUS_MSG_MAX_PAD_SIZE)
{
LOG_EX(LOG_Error, "Msg size = %u more than DBUS_MSG_MAX_PAD_SIZE\n", strlen(pContext));
return -ERR_DBUS_MSG_TO_LARGE;
}
if(pBus == NULL)
{
pBus = g_LibuvDBusParam.pBus;
}
pMsg = dbus_message_new_signal(g_LibuvDBusParam.pBusPath, DBUS_MESSAGE_INTERFACE_NAME, "Notify");
if(pMsg == NULL)
{
return -ERR_DBUS_CREATE_MSG;
}
dbus_message_set_no_reply(pMsg, TRUE);
#if USED_SHM_TO_DBUS
gettimeofday(&tv, NULL);
#endif
dbus_message_append_args(pMsg,
DBUS_TYPE_UINT32, &g_LibuvDBusParam.modName, // from
DBUS_TYPE_UINT32, &msgToMask, // to -1 means all except it's self
#if USED_SHM_TO_DBUS
DBUS_TYPE_UINT32, &tv.tv_sec, // timestamp for msecond
#endif
DBUS_TYPE_UINT32, &busCmd, // command type
DBUS_TYPE_STRING, &pContext,
DBUS_TYPE_INVALID);
if(!dbus_connection_send(pBus, pMsg, NULL))
{
return -ERR_BUS_SEND_MSG;
}
//dbus_connection_flush(pBus);
dbus_message_unref(pMsg);
usleep(100);
return 0;
}
static void __addNewLoopTask(uv_loop_t* pLoop)
{
PLOOP_TASK_ARRAY pItem = NULL;
PLOOP_TASK_ARRAY pTask = NULL;
if(pLoop == NULL)
{
return;
}
uv_rwlock_wrlock(&g_uvLoopRwLock);
LL_FOREACH(g_LoopArray, pItem)
{
if(pItem->pLoop == pLoop)
{
LOG_EX(LOG_Warn, "Loop %p is added\n", pLoop);
uv_rwlock_wrunlock(&g_uvLoopRwLock);
return;
}
}
pTask = (PLOOP_TASK_ARRAY)malloc(sizeof(struct LOOP_TASK_ARRAY));
if(pTask == NULL)
{
LOG_EX(LOG_Error, "Malloc Memory Error\n");
return;
}
memset(pTask, 0, sizeof(struct LOOP_TASK_ARRAY));
pTask->pLoop = pLoop;
pTask->isRunning = FALSE;
LL_APPEND(g_LoopArray, pTask);
uv_rwlock_wrunlock(&g_uvLoopRwLock);
}
static void __uvLoopRuntime(void *pParam)
{
uv_loop_t* pLoop = (uv_loop_t*)pParam;
if(pLoop)
{
while(TRUE)
{
uv_run(pLoop, UV_RUN_DEFAULT);
usleep(1000);
}
}
pthread_detach(pthread_self());
}
static void __runUVLoopTask(uv_loop_t* pLoop, void* pCallback)
{
uv_thread_t uvThread;
if(pLoop == NULL)
{
return;
}
uv_thread_create(&uvThread, __uvLoopRuntime, pLoop);
}
void RunUVLoop(uv_loop_t *pLoop)
{
#if 1
int more;
while(TRUE)
{
more = uv_run(g_LibuvDBusParam.pLoop, UV_RUN_ONCE);
if(more == FALSE)
{
more = uv_loop_alive(g_LibuvDBusParam.pLoop);
if(uv_run(g_LibuvDBusParam.pLoop, UV_RUN_NOWAIT) != 0)
{
more = TRUE;
}
}
}
#else
int more;
do
{
if(pLoop && pLoop != g_LibuvDBusParam.pUserLoop)
{
more = uv_run(pLoop, UV_RUN_ONCE);
if(more == FALSE)
{
more = uv_loop_alive(pLoop);
if(uv_run(pLoop, UV_RUN_NOWAIT) != 0)
{
more = TRUE;
}
}
}
if(g_LibuvDBusParam.pUserLoop)
{
more = uv_run(g_LibuvDBusParam.pUserLoop, UV_RUN_ONCE);
if(more == FALSE)
{
more = uv_loop_alive(g_LibuvDBusParam.pUserLoop);
if(uv_run(g_LibuvDBusParam.pUserLoop, UV_RUN_NOWAIT) != 0)
{
more = TRUE;
}
}
}
if(g_LibuvDBusParam.pLoop)
{
more = uv_run(g_LibuvDBusParam.pLoop, UV_RUN_ONCE);
if(more == FALSE)
{
more = uv_loop_alive(g_LibuvDBusParam.pLoop);
if(uv_run(g_LibuvDBusParam.pLoop, UV_RUN_NOWAIT) != 0)
{
more = TRUE;
}
}
}
}
while(TRUE);
//#else
//__runUVLoopTask(pLoop, NULL);
//__addNewLoopTask(pLoop);
#endif
}
static void __uvDBusRecvProc(void *pParams)
{
while(TRUE)
{
DBusMessage* pMsg = NULL;
dbus_connection_read_write(g_LibuvDBusParam.pBus, 0);
pMsg = dbus_connection_pop_message(g_LibuvDBusParam.pBus);
if(pMsg != NULL)
{
DBusOnMsgCb(g_LibuvDBusParam.pBus, pMsg, NULL);
}
usleep(100);
}
}
void DBusMsgCleanup(PDBUS_MSG_PACK pMsg)
{
if(pMsg)
{
if(pMsg->pMsg)
{
free(pMsg->pMsg);
}
free(pMsg);
}
}
PDBUS_MSG_PACK DBusGetMessage(void)
{
int iCount, ret = 0;
PDBUS_MSG_PACK pMsg = NULL;
PDBUS_MSG_PROC pItem = NULL, pTmp = NULL;
if(g_LibuvDBusParam.onMsgCb)
{
return NULL;
}
DL_COUNT(g_pMsgProcList, pItem, iCount);
if(iCount == 0)
{
return pMsg;
}
pItem = NULL;
uv_rwlock_wrlock(&g_uvMsgProcRwLock);
DL_FOREACH_SAFE(g_pMsgProcList, pItem, pTmp)
{
if(pItem->msgFrom == 0)
{
ret = DBusOnBoardcastMsgWorkCb(&pItem->msgContent);
}
else
{
ret = DBusOnMsgWorkAPICb(&pItem->msgContent);
}
if(ret != 0)
{
pMsg = (PDBUS_MSG_PACK)malloc(sizeof(DBUS_MSG_PACK));
if(pMsg)
{
memset(pMsg, 0, sizeof(DBUS_MSG_PACK));
memcpy(pMsg, &pItem->msgContent, sizeof(DBUS_MSG_PACK));
pMsg->pMsg = strdup(pItem->msgContent.pMsg);
}
}
DL_DELETE(g_pMsgProcList, pItem);
free(pItem->msgContent.pMsg);
free(pItem);
break;
}
uv_rwlock_wrunlock(&g_uvMsgProcRwLock);
return pMsg;
}
#if 0
static void __uvMsgProc(void *pParams)
{
#ifdef ENABLE_COUNT_DEBUG
struct timeval tmBegin, tmEnd;
long long diffTm;
#endif
while(TRUE)
{
int iMaxProcMsg = 100;
PDBUS_MSG_PROC pItem = NULL, pTmp = NULL;
uv_rwlock_wrlock(&g_uvMsgProcRwLock);
DL_FOREACH_SAFE(g_pMsgProcList, pItem, pTmp)
{
if(--iMaxProcMsg == 0)
{
break;
}
#ifdef ENABLE_COUNT_DEBUG
gettimeofday(&tmBegin, NULL);
#endif
if(pItem->msgFrom == 0)
{
DBusOnBoardcastMsgWorkCb(&pItem->msgContent);
#ifdef ENABLE_COUNT_DEBUG
gettimeofday(&tmEnd, NULL);
diffTm = (tmEnd.tv_sec * 1000000 + tmEnd.tv_usec) - (tmBegin.tv_sec * 1000000 + tmBegin.tv_usec);
MonUpgradeStatistical(MON_MSG_BST_PROC_STAT, diffTm);
#endif
}
else
{
DBusOnMsgWorkAPICb(&pItem->msgContent);
#ifdef ENABLE_COUNT_DEBUG
gettimeofday(&tmEnd, NULL);
diffTm = (tmEnd.tv_sec * 1000000 + tmEnd.tv_usec) - (tmBegin.tv_sec * 1000000 + tmBegin.tv_usec);
MonUpgradeStatistical(MON_MSG_PROC_STAT, diffTm);
#endif
}
if(pItem->msgContent.pMsg)
{
free(pItem->msgContent.pMsg);
}
DL_DELETE(g_pMsgProcList, pItem);
free(pItem);
}
uv_rwlock_wrunlock(&g_uvMsgProcRwLock);
usleep(1000);
}
pthread_detach(pthread_self());
}
#endif
void SetHBLAutoExit(int flag)
{
g_EnHBLExit = flag ? TRUE : FALSE;
}
static void __dBusDeameonCb(MODULE_NAME modName, int status)
{
LOG_EX(status == 0 ? LOG_Info : LOG_Error,
"Daemon %s(%d) Msg: [%s]\n", ModuleNameToString(modName), modName,
status == 0 ? "Connect" : "Disconnect");
if(status != 0 && modName == MODULE_CONTROLLER && g_EnHBLExit)
{
sleep(1);
//exit(0);
}
}
static void __waitUDISKMount(void)
{
#ifdef PLATFORM_R16
const char* pDoneStat = "done";
const char* pBootStatFile = "/tmp/booting_state";
char buf[5];
FILE* pFile;
// wait system create setup status file
LOG_EX(LOG_Debug, "Wait boot status file create ......\n");
while(access(pBootStatFile, F_OK) != 0)
{
usleep(10000);
}
pFile = fopen(pBootStatFile, "rb");
if(pFile == NULL)
{
LOG_EX(LOG_Error, "Open boot status file error\n");
return;
}
LOG_EX(LOG_Debug, "Wait boot status done ......\n");
// when UDISK mount, file /tmp/booting_state content is "done"
do
{
fseek(pFile, 0, SEEK_SET);
memset(buf, 0, 5);
fread(buf, 1, 4, pFile); // read 4 bytes status tags
usleep(10000);
}
while(strncmp(buf, pDoneStat, strlen(pDoneStat)) != 0);
fclose(pFile);
LOG_EX(LOG_Debug, "Boot status done ......\n");
#endif
}
DBusConnection* DBusWithLibuvInit(uv_loop_t* pUserLoop,
const char* pBusName,
OnDBusMessage cbOnMsg,
OnDaemonMsg cbOnHbl,
OnKeyEvent cbOnKey,
int* pErrno)
{
int i, ret = 0;
DBusError error;
SERVER_MODULE_TYPE svrMode;
uv_async_t* pAsync = NULL;
DBusConnection* pBus = NULL;
uv_fs_t* puvFsReq;
//uv_thread_t uvMsgProcThread;
//uv_thread_t uvMsgRecvThread;
//uv_thread_t uvLoopThread;
char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH - 1];
#if USED_SHM_TO_DBUS
uv_thread_t uvSyncThread;
#endif
//uv_loop_t *pLoop = uv_loop_new();
uv_loop_t *pLoop = pUserLoop;
memset(&g_LibuvDBusParam, 0, sizeof(LIBUV_DBUS_PARAMS));
for(i = 0; (i < sizeof(g_pModInfoTable) / sizeof(g_pModInfoTable[0])); i++)
{
// Skip match it'self
if(strcmp(g_pModInfoTable[i].modAliase, pBusName) == 0)
{
g_LibuvDBusParam.modName = g_pModInfoTable[i].modName;
g_LibuvDBusParam.pBusName = g_pModInfoTable[i].modAliase;
g_LibuvDBusParam.pBusPath = g_pModInfoTable[i].modPath;
break;
}
}
memset(&g_workDayArray, 0, sizeof(WORKDAY_INFO));
srand(time(NULL));
if(pLoop == NULL || pBusName == NULL || pErrno == NULL)
{
if(pErrno)
{
*pErrno = -ERR_INPUT_PARAMS;
}
LOG_EX(LOG_Error, "Input params error: pLoop = %p, pBusName = %p, pErrno = %p\n",
pLoop, pBusName, pErrno);
return NULL;
}
puvFsReq = (uv_fs_t*)malloc(sizeof(uv_fs_t));
CfgFileInit();
IHW_InitLOG(strrchr(pBusName, '.') + 1, NULL, TRUE);
IHW_EnableLogLevel(LOG_Fatal | LOG_Error | LOG_Warn | LOG_Debug | LOG_Info, 1);
APP_BUILD_INFO(strrchr(pBusName, '.') + 1, GetCurrentVersion());
// wait UDISK mount, configure file save in UDISK partition
__waitUDISKMount();
svrMode = CfgGetIntValue("Global.ServerMode", PUBLISH_MODE);
SetCurrentServerMode(svrMode);
DumpCurServerAddr("Default");
#if USED_SHM_TO_DBUS
uv_rwlock_init(&g_uvShmHashRwLock);
#endif
uv_rwlock_init(&g_uvMsgProcRwLock);
uv_rwlock_init(&g_uvLoopRwLock);
uv_fs_access(pLoop, puvFsReq, "/mnt/UDISK/debug.dbg", F_OK, uvFsAccessCb);
memset(rule, 0, DBUS_MAXIMUM_MATCH_RULE_LENGTH - 1);
srand(time(NULL));
//setenv("UV_THREADPOOL_SIZE", "128", 1);
dbus_error_init(&error);
pBus = dbus_bus_get(DBUS_BUS_SESSION, &error);
if (dbus_error_is_set(&error))
{
LOG_EX(LOG_Error, "dbus: Could not acquire the session bus\n");
dbus_error_free(&error);
*pErrno = -ERR_GET_BUS;
return NULL;
}
ret = dbus_bus_request_name(pBus, pBusName, DBUS_NAME_FLAG_REPLACE_EXISTING, &error);
if(dbus_error_is_set(&error))
{
LOG_EX(LOG_Error, "dbus: Could not request dbus name\n");
dbus_error_free(&error);
*pErrno = -ERR_REQUEST_BUS_NAME;
return NULL;
}
if(ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
{
LOG_EX(LOG_Error, "dbus: Could not request dbus name\n");
dbus_error_free(&error);
*pErrno = -ERR_REQUEST_BUS_NAME;
return NULL;
}
#if 1
if(!dbus_connection_set_watch_functions(pBus,
DBusAddWatchCb,
DBusRemoveWatchCb,
DBusNotifyWatchCb,
(void*)pLoop, NULL))
{
LOG_EX(LOG_Error, "dbus: Could not set watch function\n");
*pErrno = -ERR_SET_WATCH_FUNCTION;
return NULL;
}
if(!dbus_connection_set_timeout_functions(pBus,
DBusAddTimeoutCb,
DBusRemoveTimeoutCb,
DBusNotifyTimeoutCb,
(void*)pLoop, NULL))
{
LOG_EX(LOG_Error, "dbus: Could not set watch function\n");
*pErrno = -ERR_SET_TIMEOUT_FUNCTION;
return NULL;
}
#endif
pAsync = malloc(sizeof(uv_async_t));
pAsync->data = (void*)pBus;
uv_async_init(pLoop, pAsync, uvAsyncCb);
uv_unref((uv_handle_t*)pAsync);
#if 1
dbus_connection_set_wakeup_main_function(pBus,
DBusWakeupMainLoopCb,
(void*)pAsync, DBusAsyncFreeCb);
#endif
sprintf(rule, "type='signal', interface='%s'", DBUS_MESSAGE_INTERFACE_NAME);
dbus_bus_add_match(pBus, rule, &error);
if(dbus_error_is_set(&error))
{
LOG_EX(LOG_Error, "dbus_bus_add_match [%s] error: %s\n", DBUS_MESSAGE_INTERFACE_NAME, error.message);
dbus_error_free(&error);
*pErrno = -ERR_BUS_MATCH;
return NULL;
}
#if 1
if(!dbus_connection_add_filter(pBus, DBusOnMsgCb, pLoop, NULL))
{
LOG_EX(LOG_Error, "dbus_connection_add_filter error\n");
*pErrno = -ERR_BUS_SET_MSG_CB;
return NULL;
}
#endif
uv_idle_init(pLoop, &g_uvIdleHandle);
g_uvIdleHandle.data = pBus;
uv_idle_start(&g_uvIdleHandle, uvIdleCb);
if(cbOnKey)
{
uv_fs_open(pLoop, &g_uvKeyEvent, R16_TINA_KEY_EVENT_PATH, O_RDONLY, 0, uvOpenKeyEventCb);
g_LibuvDBusParam.onKeyCb = cbOnKey;
}
g_LibuvDBusParam.pLoop = pLoop;
g_LibuvDBusParam.pUserLoop = pUserLoop;
g_LibuvDBusParam.pBus = pBus;
g_LibuvDBusParam.onMsgCb = cbOnMsg;
#if 0
if(cbOnHbl)
{
g_LibuvDBusParam.onHblCb = cbOnHbl;
HeartDaemonInit(g_LibuvDBusParam.modName, HEART_LOST_DELAY, cbOnHbl);
}
#else
g_LibuvDBusParam.onHblCb = __dBusDeameonCb;
HeartDaemonInit(g_LibuvDBusParam.modName, HEART_LOST_DELAY, __dBusDeameonCb);
#endif
#if USED_SHM_TO_DBUS
uv_thread_create(&uvSyncThread, __uvShmTblTaskThreadCb, NULL);
#endif
#ifdef ENABLE_COUNT_DEBUG
MonitorInit();
MonAddNewItem(MON_MSG_PROC_STAT, 100000);
MonAddNewItem(MON_MSG_BST_PROC_STAT, 100000);
MonAddNewItem(MON_USER_MSG_PROC_STAT, 100000);
MonAddNewItem(MON_USER_MSG_BST_PROC_STAT, 100000);
#endif
InetInit();
EvpSystemInit();
#if 0
if(g_LibuvDBusParam.onMsgCb)
{
uv_thread_create(&uvMsgProcThread, __uvMsgProc, NULL);
}
#endif
IHW_RunLogService();
return pBus;
}
int DBusWithLibuvCfgInit(OnCfgMsg cbOnCfgMsg)
{
CfgGlobalEnvInit();
if(cbOnCfgMsg == NULL)
{
return (-ERR_INPUT_PARAMS);
}
g_LibuvDBusParam.onCfgCb = cbOnCfgMsg;
return (0);
}
int GetShellExecResult(const char *pCmd, char **pResult)
{
FILE *pFile = NULL;
unsigned int uRdSize = 0;
char *pCmdOut;
*pResult = NULL;
if(pCmd == NULL || strlen(pCmd) == 0)
{
return (-ERR_INPUT_PARAMS);
}
pFile = popen(pCmd, "r");
if(pFile == NULL)
{
return (-ERR_OPEN_FILE);
}
*pResult = (char *)malloc(4096);
pCmdOut = *pResult;
uRdSize = fread(pCmdOut, sizeof(char), 4096, pFile);
pCmdOut[uRdSize] = 0;
if(pCmdOut[strlen(pCmdOut) - 1] == '\n')
{
pCmdOut[strlen(pCmdOut) - 1] = 0;
}
pclose(pFile);
//fprintf(stdout, "%s --> [%s](%u)\n", pCmd, pCmdOut, uRdSize);
return (0);
}
void SystemSafeReboot(void)
{
int ret, reTry = 0;
#if 0
ret = system("sync");
ret = system("ubus call system watchdog \'{\"stop\" : true}\'");
reTry = 3;
do
{
sleep(1);
} while(reTry--);
reTry = 0;
LOG_EX(LOG_Debug, "Reboot System By Power Control Chips\n");
sleep(1);
ret = system("echo 3140 > /sys/bus/platform/devices/axp22_board/axp22_reg");
sleep(10);
#endif
while(TRUE)
{
LOG_EX(LOG_Debug, "Reboot System: %d times\n", reTry++);
sleep(1);
ret = system("reboot -f");
sleep(3);
}
}
char* GetCpuChipId(void)
{
char* pRet = NULL;
#ifdef PLATFORM_R16
char* pChipId = NULL;
GetShellExecResult("cat /proc/cpuinfo | grep Chipid | awk '{print $3}'", &pChipId);
if(pChipId == NULL)
{
return strdup("");
}
pRet = strdup(pChipId);
free(pChipId);
return pRet;
#else
return strdup("Unknown CPU Chip ID");
#endif
}
char* GetCpuSerial(void)
{
char* pRet = NULL;
#ifdef PLATFORM_R16
char* pSerial = NULL;
GetShellExecResult("cat /proc/cpuinfo | grep Serial | awk '{print $3}'", &pSerial);
if(pSerial == NULL)
{
return strdup("");
}
pRet = strdup(pSerial);
free(pSerial);
return pRet;
#else
return strdup("Unknown CPU Serial");
#endif
}
int CopyFile(const char *pSrc, const char *pDest)
{
int fdSrc, fdDest;
struct stat st;
ssize_t sz;
if(stat(pSrc, &st) != 0)
{
LOG_EX(LOG_Error, "Get File %s Size Error\n", pSrc);
return (-ERR_GET_FILE_SIZE);
}
fdSrc = open(pSrc, O_RDONLY);
if(fdSrc < 0)
{
LOG_EX(LOG_Error, "Open File %s Error\n", pSrc);
return (-ERR_OPEN_FILE);
}
fdDest = open(pDest, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
if(fdDest < 0)
{
close(fdSrc);
LOG_EX(LOG_Error, "Open File %s Error\n", pDest);
return (-ERR_OPEN_FILE);
}
sz = sendfile(fdDest, fdSrc, NULL, st.st_size);
if(sz != st.st_size)
{
LOG_EX(LOG_Error, "Copy File Size Error: %d, %d\n", sz, st.st_size);
close(fdSrc);
close(fdDest);
return (-ERR_COPY_FILE);
}
fsync(fdDest);
close(fdSrc);
close(fdDest);
return (0);
}
int CopyFileWithSize(const char *pSrc, const char *pDest, int iSize)
{
int fdSrc, fdDest;
struct stat st;
ssize_t sz;
size_t cpSize = iSize;
if(iSize <= 0)
{
if(stat(pSrc, &st) != 0)
{
LOG_EX(LOG_Error, "Get File %s Size Error\n", pSrc);
return (-ERR_GET_FILE_SIZE);
}
cpSize = st.st_size;
}
fdSrc = open(pSrc, O_RDONLY);
if(fdSrc < 0)
{
LOG_EX(LOG_Error, "Open File %s Error\n", pSrc);
return (-ERR_OPEN_FILE);
}
fdDest = open(pDest, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH |S_IWOTH);
if(fdDest < 0)
{
close(fdSrc);
LOG_EX(LOG_Error, "Open File %s Error\n", pDest);
return (-ERR_OPEN_FILE);
}
sz = sendfile(fdDest, fdSrc, NULL, cpSize);
if(sz != cpSize)
{
LOG_EX(LOG_Error, "Copy File Size Error: %d, %d\n", sz, cpSize);
close(fdSrc);
close(fdDest);
return (-ERR_COPY_FILE);
}
close(fdSrc);
close(fdDest);
return (0);
}
int ReadFileToBuf(const char *pSrc, unsigned char *pBuf, int iSize)
{
int fdSrc;
struct stat st;
ssize_t sz;
size_t cpSize = iSize;
if(iSize < 0)
{
if(stat(pSrc, &st) != 0)
{
LOG_EX(LOG_Error, "Get File %s Size Error\n", pSrc);
return (-ERR_GET_FILE_SIZE);
}
cpSize = st.st_size;
}
fdSrc = open(pSrc, O_RDONLY);
if(fdSrc < 0)
{
LOG_EX(LOG_Error, "Open File %s Error\n", pSrc);
return (-ERR_OPEN_FILE);
}
sz = read(fdSrc, pBuf, cpSize);
if(sz != cpSize)
{
LOG_EX(LOG_Error, "Copy File Size Error: %d, %d\n", sz, cpSize);
close(fdSrc);
return (-ERR_COPY_FILE);
}
close(fdSrc);
return (sz);
}
static int __reqWorkDayInfo(int year)
{
int ret = 0;
WORKDAY_INFO reqInfo;
memset(&reqInfo, 0, sizeof(WORKDAY_INFO));
if(year <= 0)
{
struct tm localTime;
time_t tmStamp = time((time_t*)NULL);
localtime_r(&tmStamp, &localTime);
reqInfo.year = localTime.tm_year;
}
else
{
reqInfo.year = year;
}
ret = DBusJsonSendToCommand(NULL,
g_pModInfoTable[MODULE_CONTROLLER].modAliase,
CMD_WORKDAY_DB_REQ,
JSON_ENGINE_WORKDAY_REQ,
&reqInfo, FALSE);
return (ret);
}
int CurrentIsWorkDay(int year, int day)
{
// LOG_EX(LOG_Debug, "CurrentIsWorkDay: year = %d, day = %d\n", year, day);
if(day > 365)
{
LOG_EX(LOG_Error, "Error Input Params: day = %d\n", day);
return (-ERR_INPUT_PARAMS);
}
if(g_workDayArray.year <= 0)
{
__reqWorkDayInfo(year);
LOG_EX(LOG_Error, "Unsync Database: year = %d\n", year);
return (-ERR_UNINIT_ITEM);
}
if(day < 0 || year <= 0)
{
struct tm localTime;
time_t tmStamp = time((time_t*)NULL);
localtime_r(&tmStamp, &localTime);
if(day < 0)
{
day = localTime.tm_yday;
}
if(year <= 0)
{
year = localTime.tm_year;
}
}
if(year != g_workDayArray.year - 1900)
{
__reqWorkDayInfo(year);
LOG_EX(LOG_Error, "Have No Current Year Database: year = %d, g_workDayArray.year = %d\n",
year, g_workDayArray.year);
return (-ERR_NO_ITEMS);
}
// 0 work day, 1 holiday
return (g_workDayArray.days[day] == 0);
}
unsigned long long GetPartitionFreeSize(const char *pPartPath)
{
struct statfs myStatfs;
unsigned long long freeSize;
if(statfs(pPartPath, &myStatfs) == -1)
{
return 0;
}
freeSize = myStatfs.f_bsize * myStatfs.f_bfree;
//fprintf(stdout, "%s free = %llu bytes\n", pPartPath, freeSize);
return freeSize;
}
#ifdef CURRENT_VERSION
char* GetCurrentVersion(void)
{
return CURRENT_VERSION;
}
#else
char* GetCurrentVersion(void)
{
return "0.0.1";
}
#endif
WIFI_STATUS GetCurrWIFIConnStatus(void)
{
return g_WifiConnStatus;
}
const char* ErrcodeToString(int errCode)
{
switch(errCode)
{
case ERR_INPUT_PARAMS: return "ERR_INPUT_PARAMS";
case ERR_NO_ITEMS: return "ERR_NO_ITEMS";
case ERR_GET_BUS: return "ERR_GET_BUS";
case ERR_DBUS_CONNECTION: return "ERR_DBUS_CONNECTION";
case ERR_REQUEST_BUS_NAME: return "ERR_REQUEST_BUS_NAME";
case ERR_SET_WATCH_FUNCTION: return "ERR_SET_WATCH_FUNCTION";
case ERR_SET_TIMEOUT_FUNCTION: return "ERR_SET_TIMEOUT_FUNCTION";
case ERR_BUS_MATCH: return "ERR_BUS_MATCH";
case ERR_BUS_SET_MSG_CB: return "ERR_BUS_SET_MSG_CB";
case ERR_DBUS_CREATE_MSG: return "ERR_DBUS_CREATE_MSG";
case ERR_BUS_SEND_MSG: return "ERR_BUS_SEND_MSG";
case ERR_DBUS_MSG_TO_LARGE: return "ERR_DBUS_MSG_TO_LARGE";
case ERR_BUS_RCV_MSG: return "ERR_BUS_RCV_MSG";
case ERR_ADD_TASK: return "ERR_ADD_TASK";
case ERR_UNSUP_EVP_TYPE: return "ERR_UNSUP_EVP_TYPE";
case ERR_CREATE_MQ: return "ERR_CREATE_MQ";
case ERR_MQ_SENDMSG: return "ERR_MQ_SENDMSG";
case ERR_CREATE_SHM: return "ERR_CREATE_SHM";
case ERR_MAP_SHM: return "ERR_MAP_SHM";
case ERR_MALLOC_MEMORY: return "ERR_MALLOC_MEMORY";
case ERR_EVP_INIT_KEY: return "ERR_EVP_INIT_KEY";
case ERR_EVP_UPDATE: return "ERR_EVP_UPDATE";
case ERR_EVP_FINALE: return "ERR_EVP_FINALE";
case ERR_EVP_KEY_SIZE: return "ERR_EVP_KEY_SIZE";
case ERR_OPEN_FILE: return "ERR_OPEN_FILE";
case ERR_READ_FILE: return "ERR_READ_FILE";
case ERR_WRITE_FILE: return "ERR_WRITE_FILE";
case ERR_COPY_FILE: return "ERR_COPY_FILE";
case ERR_FILE_NOT_EXISTS: return "ERR_FILE_NOT_EXISTS";
case ERR_GET_FILE_SIZE: return "ERR_GET_FILE_SIZE";
case ERR_UNINIT_ITEM: return "ERR_UNINIT_ITEM";
case ERR_FILE_EMPTY: return "ERR_FILE_EMPTY";
case ERR_SEND_MAIL: return "ERR_SEND_MAIL";
case ERR_NETWORK_SEND: return "ERR_NETWORK_SEND";
case ERR_NETWORK_NOT_CONNECTED: return "ERR_NETWORK_NOT_CONNECTED";
case ERR_UNSUPPORT: return "ERR_UNSUPPORT";
case ERR_NO_INIT_IPL3: return "ERR_NO_INIT_IPL3";
case ERR_BAD_IPL3: return "ERR_BAD_IPL3";
case ERR_BAD_FILE_SIZE: return "ERR_BAD_FILE_SIZE";
case ERR_MD5_FILE: return "ERR_MD5_FILE";
case ERR_MD5_CHECK_SUM: return "ERR_MD5_CHECK_SUM";
case ERR_OTA_WRITE_BOOT: return "ERR_OTA_WRITE_BOOT";
case ERR_OTA_WRITE_ROOTFS: return "ERR_OTA_WRITE_ROOTFS";
case ERR_OTA_WRITE_IPL3: return "ERR_OTA_WRITE_IPL3";
case ERR_OTA_WRITE_PARAMS: return "ERR_OTA_WRITE_PARAMS";
case ERR_OTA_DOWNLOAD_FILE: return "ERR_OTA_DOWNLOAD_FILE";
case ERR_VERIFY_PARTITION_MD5: return "ERR_VERIFY_PARTITION_MD5";
case ERR_OTA_PRE_STATR: return "ERR_OTA_PRE_STATR";
case ERR_OTA_YET_CUR_VER: return "ERR_OTA_YET_CUR_VER";
case ERR_OTA_NOT_READY: return "ERR_OTA_NOT_READY";
case ERR_CREATE_CFG_FILE: return "ERR_CREATE_CFG_FILE";
case ERR_CREATE_SQLITE3_DB: return "ERR_CREATE_SQLITE3_DB";
case ERR_OPEN_SQLITE3_DB: return "ERR_OPEN_SQLITE3_DB";
case ERR_SQLITE3_CREATE_TABLE: return "ERR_SQLITE3_CREATE_TABLE";
case ERR_SYNC_DATABASE: return "ERR_SYNC_DATABASE";
case ERR_SQL_QUERY: return "ERR_SQL_QUERY";
case ERR_SQL_DELETE: return "ERR_SQL_DELETE";
case ERR_UNKNOWN_TYPE: return "ERR_UNKNOWN_TYPE";
case ERR_PERMISSION_DENIED: return "ERR_PERMISSION_DENIED";
case ERR_CFG_NOITEM: return "ERR_CFG_NOITEM";
case ERR_CFG_ITEM_EXIST: return "ERR_CFG_ITEM_EXIST";
case ERR_CFG_WAIT_RSP: return "ERR_CFG_WAIT_RSP";
case ERR_CFG_BUSY: return "ERR_CFG_BUSY";
case ERR_STR_CONVERT: return "ERR_STR_CONVERT";
case ERR_SQL_REG_MODULE: return "ERR_SQL_REG_MODULE";
default: return "Unknown Error";
}
}
const char* DBusCmdToString(DBUS_CMD cmd)
{
switch(cmd)
{
case CMD_MISC_PING: return "CMD_MISC_PING";
case CMD_MISC_OTA: return "CMD_MISC_OTA";
case CMD_MISC_WEATHER: return "CMD_MISC_WEATHER";
case CMD_MISC_NOWTIME: return "CMD_MISC_NOWTIME";
case CMD_MISC_UPGRADE: return "CMD_MISC_UPGRADE";
case CMD_SYSTEM_STANDBY: return "CMD_SYSTEM_STANDBY";
case CMD_MISC_QUERY_OTA_STATUS: return "CMD_MISC_QUERY_OTA_STATUS";
case CMD_MISC_QUERY_DL_STATUS: return "CMD_MISC_QUERY_DL_STATUS";
case CMD_CALL_DIAL: return "CMD_CALL_DIAL";
case CMD_CALL_ACCEPI: return "CMD_CALL_ACCEPI";
case CMD_CALL_HANGUP: return "CMD_CALL_HANGUP";
case CMD_CALL_MESSAGE: return "CMD_CALL_MESSAGE";
case CMD_PLAY_MODECHANGE: return "CMD_PLAY_MODECHANGE";
case CMD_PLAY_PLAY: return "CMD_PLAY_PLAY";
case CMD_PLAY_PAUSE: return "CMD_PLAY_PAUSE";
case CMD_PLAY_STOP: return "CMD_PLAY_STOP";
case CMD_PLAY_SEEKTO: return "CMD_PLAY_SEEKTO";
case CMD_PLAY_SHOWMODE: return "CMD_PLAY_SHOWMODE";
case CMD_PLAY_NEXT: return "CMD_PLAY_NEXT";
case CMD_PLAY_PRE: return "CMD_PLAY_PRE";
case CMD_PLAY_SHOWLIST: return "CMD_PLAY_SHOWLIST";
case CMD_PLAY_UPDATELIST: return "CMD_PLAY_UPDATELIST";
case CMD_PLAY_PREPARE_NEXT: return "CMD_PLAY_PREPARE_NEXT";
case CMD_PLAY_ADDTOLIST: return "CMD_PLAY_ADDTOLIST";
case CMD_PLAY_DELETEFROMLIST: return "CMD_PLAY_DELETEFROMLIST";
case CMD_PLAY_RESETLIST: return "CMD_PLAY_RESETLIST";
case CMD_PLAY_AUDIO_STOP: return "CMD_PLAY_AUDIO_STOP";
case CMD_PLAY_AUDIO_PLAY: return "CMD_PLAY_AUDIO_PLAY";
case CMD_SE_PLAY: return "CMD_SE_PLAY";
case CMD_PLAY_RET_STATUS: return "CMD_PLAY_RET_STATUS";
case CMD_CFG_ADD_REQ: return "CMD_CFG_ADD_REQ";
case CMD_CFG_ADD_RSP: return "CMD_CFG_ADD_RSP";
case CMD_CFG_CHANGE_REQ: return "CMD_CFG_CHANGE_REQ";
case CMD_CFG_CHANGE_RSP: return "CMD_CFG_CHANGE_RSP";
case CMD_CFG_GET_REQ: return "CMD_CFG_GET_REQ";
case CMD_CFG_GET_RSP: return "CMD_CFG_GET_RSP";
case CMD_CFG_UPG_NOTIFY: return "CMD_CFG_UPG_NOTIFY";
case CMD_MSC_MSG_CONTROLLER_RECOG_SUCCESS: return "CMD_MSC_MSG_CONTROLLER_RECOG_SUCCESS";
case CMD_MSC_MSG_CONTROLLER_RECOG_ERROR: return "CMD_MSC_MSG_CONTROLLER_RECOG_ERROR";
case CMD_MSC_MSG_CONTROLLER_WAKEUP: return "CMD_MSC_MSG_CONTROLLER_WAKEUP";
case CMD_MSC_MSG_CONTROLLER_RECOGING: return "CMD_MSC_MSG_CONTROLLER_RECOGING";
case CMD_CONTROLLER_REQMSG_INITARGS: return "CMD_CONTROLLER_REQMSG_INITARGS";
case CMD_CONTROLLER_RSPMSG_INITARGS: return "CMD_CONTROLLER_RSPMSG_INITARGS";
case CMD_CONTROLLER_REQMSG_PLAYERSTATUS: return "CMD_CONTROLLER_REQMSG_PLAYERSTATUS";
case CMD_CONTROLLER_RSPMSG_PLAYERSTATUS: return "CMD_CONTROLLER_RSPMSG_PLAYERSTATUS";
case CMD_MSC_REQMSG_MIC_CONTROL: return "CMD_MSC_REQMSG_MIC_CONTROL";
case CMD_MSC_RSPMSG_MIC_CONTROL: return "CMD_MSC_RSPMSG_MIC_CONTROL";
case CMD_YUNXIN_RECVMSG: return "CMD_YUNXIN_RECVMSG";
case CMD_YUNXIN_SENDMSG: return "CMD_YUNXIN_SENDMSG";
case CMD_YUNXIN_SENDMSG_BYPASS: return "CMD_YUNXIN_SENDMSG_BYPASS";
case CMD_YUNXIN_SENDMSGCB: return "CMD_YUNXIN_SENDMSGCB";
case CMD_CONTROLLER_MSG_YUNXIN: return "CMD_CONTROLLER_MSG_YUNXIN";
case CMD_YUNXIN_STATUS: return "CMD_YUNXIN_STATUS";
case CMD_YUNXIN_SYSMSG: return "CMD_YUNXIN_SYSMSG";
case CMD_WIFI_CONF: return "CMD_WIFI_CONF";
case CMD_WIFI_CONF_RESP: return "CMD_WIFI_CONF_RESP";
case CMD_WIFI_AUTO_CONN: return "CMD_WIFI_AUTO_CONN";
case CMD_WIFI_AUTO_CONN_RESP: return "CMD_WIFI_AUTO_CONN_RESP";
case CMD_WIFI_STATE_REQ: return "CMD_WIFI_STATE_REQ";
case CMD_WIFI_STATE_RESP: return "CMD_WIFI_STATE_RESP";
case CMD_WIFI_STATE_NTF: return "CMD_WIFI_STATE_NTF";
case CMD_BT_NAME_GET_REQ: return "CMD_BT_NAME_GET_REQ";
case CMD_BT_NAME_GET_RESP: return "CMD_BT_NAME_GET_RESP";
case CMD_BT_EVT_NTF: return "CMD_BT_EVT_NTF";
case CMD_KPLAYER_START: return "CMD_KPLAYER_START";
case CMD_KPLAYER_STOP: return "CMD_KPLAYER_STOP";
case CMD_KPLAYER_NOTIF_DUR: return "CMD_KPLAYER_NOTIF_DUR";
case CMD_KPLAYER_HOST_ACTION: return "CMD_KPLAYER_HOST_ACTION";
case CMD_KPLAYER_CTR_NTF_BASE: return "CMD_KPLAYER_CTR_NTF_BASE";
case CMD_KPLAYER_CTR_CREATED: return "CMD_KPLAYER_CTR_CREATED";
case CMD_KPLAYER_CTR_DELED: return "CMD_KPLAYER_CTR_DELED";
case CMD_KPLAYER_CTR_PLAY: return "CMD_KPLAYER_CTR_PLAY";
case CMD_KPLAYER_CTR_STOP: return "CMD_KPLAYER_CTR_STOP";
case CMD_KPLAYER_CTR_PAUSE: return "CMD_KPLAYER_CTR_PAUSE";
case CMD_KPLAYER_CTR_SEEK: return "CMD_KPLAYER_CTR_SEEK";
case CMD_KPLAYER_CTR_SET_URL: return "CMD_KPLAYER_CTR_SET_URL";
case CMD_KPLAYER_CTR_SET_VOLUME: return "CMD_KPLAYER_CTR_SET_VOLUME";
case CMD_KPLAYER_CTR_SET_MUTE: return "CMD_KPLAYER_CTR_SET_MUTE";
case CMD_KPLAYER_CTR_SET_NXT_URL: return "CMD_KPLAYER_CTR_SET_NXT_URL";
case CMD_KPLAYER_CTR_SET_NEXT: return "CMD_KPLAYER_CTR_SET_NEXT";
case CMD_KPLAYER_CTR_SET_PREV: return "CMD_KPLAYER_CTR_SET_PREV";
case CMD_ALARM_SYNC_REQ: return "CMD_ALARM_SYNC_REQ";
case CMD_ALARM_SYNC_RSP: return "CMD_ALARM_SYNC_RSP";
case CMD_ALARM_ADD: return "CMD_ALARM_ADD";
case CMD_ALARM_REMOVE: return "CMD_ALARM_REMOVE";
case CMD_ALARM_REMOVEALL: return "CMD_ALARM_REMOVEALL";
case CMD_REMAIND_SYNC_REQ: return "CMD_REMAIND_SYNC_REQ";
case CMD_REMAIND_SYNC_RSP: return "CMD_REMAIND_SYNC_RSP";
case CMD_REMAIND_ADD: return "CMD_REMAIND_ADD";
case CMD_REMAIND_REMOVE: return "CMD_REMAIND_REMOVE";
case CMD_REMAIND_REMOVEALL: return "CMD_REMAIND_REMOVEALL";
case CMD_ASSISTANT_STATUS: return "CMD_ASSISTANT_STATUS";
case CMD_ASSISTANT_RUNNING: return "CMD_ASSISTANT_RUNNING";
case CMD_ASSISTANT_NOTIFY: return "CMD_ASSISTANT_NOTIFY";
case CMD_SESSION_ALARM_SYNC: return "CMD_SESSION_ALARM_SYNC";
case CMD_WORKDAY_DB_REQ: return "CMD_WORKDAY_DB_REQ";
case CMD_WORKDAY_DB_RSP: return "CMD_WORKDAY_DB_RSP";
case CMD_OTA_NOTIFY: return "CMD_OTA_NOTIFY";
case CMD_OTA_STATUS: return "CMD_OTA_STATUS";
case CMD_OTA_RUNNOW: return "CMD_OTA_RUNNOW";
case CMD_LOG_CONFIG: return "CMD_LOG_CONFIG";
default: return "Unknown CMD";
}
}
const char* ModuleNameToString(MODULE_NAME modName)
{
switch(modName)
{
case MODULE_CONTROLLER: return "MODULE_CONTROLLER";
case MODULE_ALARM: return "MODULE_ALARM";
case MODULE_CALL: return "MODULE_CALL";
case MODULE_VOICEENGINE: return "MODULE_VOICEENGINE";
case MODULE_PLAYER: return "MODULE_PLAYER";
case MODULE_CONFIGURE: return "MODULE_CONFIGURE";
case MODULE_OTA: return "MODULE_OTA";
case MODULE_WIFI: return "MODULE_WIFI";
case MODULE_BT: return "MODULE_BT";
case MODULE_KPLAYER: return "MODULE_KPLAYER";
case MODULE_KPLAYER_TEST: return "MODULE_KPLAYER_TEST";
case MODULE_SPLAYER: return "MODULE_SPLAYER";
case MODULE_SPLAYER_TEST: return "MODULE_SPLAYER_TEST";
case MODULE_LIGHT_MCU: return "MODULE_LIGHT_MCU";
case MODULE_BLUEKC: return "MODULE_BLUEKC";
case MODULE_BLUEKC_TEST: return "MODULE_BLUEKC_TEST";
case MODULE_MANUFACTURE: return "MODULE_MANUFACTURE";
case MODULE_BT_DEMO: return "MODULE_BT_DEMO";
case MODULE_LOG_CTRL: return "MODULE_LOG_CTRL";
}
return "Unknown Module Name";
}
Reference in New Issue View Git Blame Copy Permalink