790 lines
17 KiB
C
790 lines
17 KiB
C
#include "system/includes.h"
|
||
#include "action.h"
|
||
#include "server/net_server.h"
|
||
|
||
|
||
#include "IOTCAPIs.h"
|
||
#include "AVAPIs.h"
|
||
#include "P2PCam/AVIOCTRLDEFs.h"
|
||
#include "P2PCam/AVFRAMEINFO.h"
|
||
#include "video_rt_tutk.h"
|
||
#include "mssdp/mssdp.h"
|
||
#include "app_config.h"
|
||
|
||
int pthread_mutex_init(int *mutex, const int *attr)
|
||
{
|
||
OS_MUTEX *pmutex;
|
||
|
||
pmutex = (OS_MUTEX *)malloc(sizeof(OS_MUTEX));
|
||
|
||
if (pmutex == NULL) {
|
||
*mutex = 0;
|
||
return -1;
|
||
}
|
||
|
||
os_mutex_create(pmutex);
|
||
|
||
*mutex = (int)pmutex;
|
||
|
||
return 0;
|
||
}
|
||
|
||
int pthread_mutex_destroy(int *mutex)
|
||
{
|
||
if (mutex != NULL && ((void *)*mutex != NULL)) {
|
||
os_mutex_del((OS_MUTEX *)(*mutex), OS_DEL_ALWAYS);
|
||
free((void *)(*mutex));
|
||
*mutex = 0;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int pthread_mutex_lock(int *mutex)
|
||
{
|
||
return os_mutex_pend((OS_MUTEX *)(*mutex), 0);
|
||
}
|
||
|
||
int pthread_mutex_unlock(int *mutex)
|
||
{
|
||
return os_mutex_post((OS_MUTEX *)(*mutex));
|
||
}
|
||
|
||
int usleep(unsigned int t)
|
||
{
|
||
os_time_dly(t / 10000);
|
||
return 0;
|
||
}
|
||
|
||
#if 1
|
||
/***最大客户端数量***/
|
||
#define MAX_CLIENT_NUMBER 3
|
||
#define CMD_CHANNEL 0x0
|
||
#define FILE_CHANNEL 0x1
|
||
|
||
|
||
struct tutk_info {
|
||
struct list_head head;
|
||
u8 cli_num;
|
||
OS_MUTEX mutex;//用于保护客户端链表
|
||
u8 kill_task;
|
||
int login_pid;
|
||
u32 inited;
|
||
|
||
|
||
char username[64];
|
||
char password[64];
|
||
|
||
};
|
||
|
||
#define TEST_UID "HH25H2GNP4DTECTK111A"
|
||
|
||
|
||
|
||
//外部引用
|
||
void __cmd_pro(void *cli, const char *content);
|
||
|
||
|
||
|
||
enum {
|
||
TUTK_CMD_TIMEOUT = 0x1,
|
||
TUTK_ERR = 0x2,
|
||
TUTK_KILL_TASK = 0xff,
|
||
|
||
|
||
};
|
||
|
||
|
||
|
||
|
||
u32 OSTimeGet()
|
||
{
|
||
return OSGetTime();
|
||
}
|
||
|
||
static struct tutk_info tinfo;
|
||
|
||
static void tutk_login_info_cb(unsigned int nLoginInfo)
|
||
{
|
||
if ((nLoginInfo & 0x04)) {
|
||
printf("I can be connected via Internet\n");
|
||
} else if ((nLoginInfo & 0x08)) {
|
||
printf("I am be banned by IOTC Server because UID multi-login\n");
|
||
}
|
||
|
||
printf("loginInfo:0x%x\n", nLoginInfo);
|
||
}
|
||
|
||
static void tutk_login_task(void *arg)
|
||
{
|
||
int cnt = 0;
|
||
int ret = 0;
|
||
puts("\n thread_Login \n");
|
||
while (1) {
|
||
if (tinfo.kill_task) {
|
||
break;
|
||
}
|
||
ret = IOTC_Device_Login(TEST_UID, "aaaa", "12345678");
|
||
if (ret == IOTC_ER_NoERROR) {
|
||
printf("tutk platform login success !@!!\n");
|
||
//os_time_dly(100);
|
||
} else if (ret == IOTC_ER_LOGIN_ALREADY_CALLED) {
|
||
/* printf("logined\n"); */
|
||
}
|
||
msleep(1000);
|
||
|
||
}
|
||
}
|
||
|
||
|
||
int Handle_IOCTRL_Cmd(struct tutk_client_info *cli, int type, char *content)
|
||
{
|
||
int ret = 0;
|
||
switch (type) {
|
||
case IOTYPE_USER_IPCAM_START:
|
||
break;
|
||
case IOTYPE_USER_IPCAM_STOP:
|
||
break;
|
||
case IOTYPE_USER_CTP_CMD_MSG:
|
||
__cmd_pro(cli, content);
|
||
|
||
break;
|
||
case IOTYPE_USER_CTP_CMD_KEEP_ALIVE:
|
||
puts("KKKKKK\n");
|
||
/* if ((ret = avSendIOCtrl(cli->cmdindex, IOTYPE_USER_CTP_CMD_KEEP_ALIVE, "CTP_KEEP_ALIVE", strlen("CTP_KEEP_ALIVE"))) < 0) { */
|
||
/* } */
|
||
break;
|
||
default:
|
||
printf("\ntype = %d content = %s\n", type, content);
|
||
break;
|
||
}
|
||
return 0;
|
||
exit:
|
||
return -1;
|
||
}
|
||
|
||
static int AuthCallBackFn(char *viewAcc, char *viewPwd)
|
||
{
|
||
if (strcmp(viewAcc, tinfo.username) == 0 && strcmp(viewPwd, tinfo.password) == 0) {
|
||
printf("\n %s suc\n", __func__);
|
||
return 1;
|
||
}
|
||
printf("\n tutk_srv.username = %s viewAcc = %s\n", tinfo.username, viewAcc);
|
||
printf("\n tutk_srv.password = %s viewPwd = %s \n", tinfo.password, viewPwd);
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
static void thread_ForCMDServerStart(void *arg)
|
||
{
|
||
int ret;
|
||
int nResend = -1;
|
||
unsigned int ioType;
|
||
struct st_SInfo Sinfo = {0};
|
||
|
||
|
||
struct tutk_client_info *cinfo = (struct tutk_client_info *)arg;
|
||
|
||
|
||
|
||
cinfo->cmdindex = avServStart3(cinfo->session_id
|
||
, AuthCallBackFn
|
||
, 20
|
||
, 0
|
||
, CMD_CHANNEL
|
||
, &nResend);
|
||
if (cinfo->cmdindex < 0) {
|
||
goto exit;
|
||
}
|
||
|
||
printf("\n [ERROR] %s -yuyu %d\n", __FUNCTION__, __LINE__);
|
||
char *ioCtrlBuf = malloc(1024);
|
||
printf("\n [ERROR] %s -yuyu %d\n", __FUNCTION__, __LINE__);
|
||
if (!ioCtrlBuf) {
|
||
goto exit2;
|
||
}
|
||
|
||
|
||
|
||
while (1) {
|
||
|
||
if (cinfo->task_kill) {
|
||
goto exit2;
|
||
}
|
||
/***接收IO命令，ioType为命令号，ioCtrlBuf为参数buf，1000表示1秒超时***/
|
||
ret = avRecvIOCtrl(cinfo->cmdindex, &ioType, (char *)ioCtrlBuf, 1024, 10 * 1000);
|
||
if (ret < 0) {
|
||
if (ret == AV_ER_TIMEOUT) {
|
||
|
||
printf("tutk recv timeout\n");
|
||
os_taskq_post("tutk_state_task", 2, TUTK_CMD_TIMEOUT, (u32)cinfo);
|
||
goto exit2;
|
||
} else {
|
||
os_taskq_post("tutk_state_task", 2, TUTK_ERR, (u32)cinfo);
|
||
printf("avRecvIOCtrl ret = %d", ret);
|
||
goto exit2;
|
||
|
||
}
|
||
}
|
||
|
||
log_d("cinfo->session_id=%d\n", cinfo->session_id);
|
||
Handle_IOCTRL_Cmd(cinfo, ioType, ioCtrlBuf);
|
||
|
||
}
|
||
|
||
|
||
exit2:
|
||
if (ioCtrlBuf != NULL) {
|
||
free(ioCtrlBuf);
|
||
}
|
||
avServStop(cinfo->cmdindex);
|
||
exit:
|
||
|
||
|
||
|
||
printf("\n thread_ForCMDServerStart exit\n");
|
||
}
|
||
|
||
|
||
#if 1
|
||
/* char tmpbuf[5*1024*1024]; */
|
||
#define PCM_TYPE_AUDIO 1
|
||
#define JPEG_TYPE_VIDEO 2
|
||
#define H264_TYPE_VIDEO 3
|
||
#define PREVIEW_TYPE 4
|
||
#define DATE_TIME_TYPE 5
|
||
#define MEDIA_INFO_TYPE 6
|
||
#define PLAY_OVER_TYPE 7
|
||
#define GPS_INFO_TYPE 8
|
||
#define NO_GPS_DATA_TYPE 9
|
||
#define G729_TYPE_AUDIO 10
|
||
#define META_DATA 11
|
||
|
||
|
||
struct frm_head {
|
||
u8 type;
|
||
u8 res;
|
||
#if 0
|
||
u8 sample_seq;
|
||
#endif
|
||
u16 payload_size;
|
||
u32 seq;
|
||
u32 frm_sz;
|
||
u32 offset;
|
||
u32 timestamp;
|
||
} __attribute__((packed));
|
||
|
||
|
||
static int do_file_server_event(int fileindex, FILE_t *file_info)
|
||
{
|
||
/* struct FILE_t * file_info = (struct FILE_t *)arg; */
|
||
/* printf("fileclient start\n"); */
|
||
printf("path:%s\n", file_info->path);
|
||
printf("offset:%d\n", file_info->offset);
|
||
printf("size:%d\n", file_info->size);
|
||
/* put_buf((void *)&file_info->size, 4); */
|
||
int ret = 0;
|
||
int ret1 = 0;
|
||
struct frm_head f_head = {0};
|
||
FILE *fp = fopen(file_info->path, "r");
|
||
if (!fp) {
|
||
printf("%s open fail\n", file_info->path);
|
||
return -1;
|
||
}
|
||
if (!file_info->size) {
|
||
fclose(fp);
|
||
return 0;
|
||
}
|
||
|
||
fseek(fp, file_info->offset, SEEK_SET);
|
||
|
||
printf("\n [ERROR] %s -yuyu %d\n", __FUNCTION__, __LINE__);
|
||
char *buf = malloc(file_info->size);//这内存看来申请吧,不够就小点做点处理
|
||
printf("\n [ERROR] %s -yuyu %d\n", __FUNCTION__, __LINE__);
|
||
if (!buf) {
|
||
printf("malloc fail\n");
|
||
fclose(fp);
|
||
return -1;
|
||
}
|
||
|
||
|
||
ret = fread(buf, file_info->size, 1, fp);
|
||
if (ret <= 0) {
|
||
printf("read all read all \n\n");
|
||
f_head.type = PLAY_OVER_TYPE;
|
||
do {
|
||
/* printf("fileindex=%d ret=%d\n", fileindex, ret); */
|
||
memset(buf, 0xff, 32);
|
||
ret1 = avSendFrameData(fileindex, buf, 32, &f_head, sizeof(f_head));
|
||
printf("ret1=%d\n", ret1);
|
||
if (ret1 < 0) {
|
||
if (ret1 == AV_ER_EXCEED_MAX_SIZE) {
|
||
putchar('K');
|
||
os_time_dly(1);
|
||
continue;
|
||
|
||
}
|
||
log_e("\n\n\n tutk_send err ret=%d\n", ret);
|
||
fclose(fp);
|
||
free(buf);
|
||
return ret;
|
||
|
||
}
|
||
|
||
} while (ret1 != AV_ER_NoERROR);
|
||
|
||
printf("read all read all end end\n\n");
|
||
|
||
|
||
fclose(fp);
|
||
free(buf);
|
||
return -1;
|
||
}
|
||
|
||
do {
|
||
f_head.type = META_DATA;
|
||
/* printf("fileindex=%d ret=%d\n", fileindex, ret); */
|
||
ret1 = avSendFrameData(fileindex, buf, ret, &f_head, sizeof(f_head));
|
||
/* printf("ret1=%d\n", ret1); */
|
||
if (ret1 < 0) {
|
||
if (ret1 == AV_ER_EXCEED_MAX_SIZE) {
|
||
putchar('K');
|
||
os_time_dly(1);
|
||
continue;
|
||
|
||
}
|
||
log_e("\n\n\n tutk_send err ret=%d\n", ret);
|
||
fclose(fp);
|
||
free(buf);
|
||
return ret;
|
||
|
||
}
|
||
|
||
} while (ret1 != AV_ER_NoERROR);
|
||
|
||
fclose(fp);
|
||
free(buf);
|
||
|
||
/* printf("file client send end\n"); */
|
||
return 0;
|
||
|
||
}
|
||
|
||
static void thread_ForFileServerStart(void *arg)
|
||
{
|
||
int ret;
|
||
int nResend = -1;
|
||
|
||
|
||
FILE_t file_info;
|
||
unsigned int frmNo;
|
||
int outBufSize = 0;
|
||
int outFrmSize = 0;
|
||
int outFrmInfoSize = 0;
|
||
int count = 0;
|
||
|
||
char file_info_buf[1024];
|
||
int ioType = 0;
|
||
|
||
|
||
|
||
struct tutk_client_info *cinfo = (struct tutk_client_info *)arg;
|
||
|
||
|
||
//start file server channel
|
||
cinfo->fileindex = avServStart3(cinfo->session_id
|
||
, AuthCallBackFn
|
||
, 5
|
||
, 0
|
||
, FILE_CHANNEL
|
||
, &nResend);
|
||
if (cinfo->fileindex < 0) {
|
||
if (AV_ER_TIMEOUT == cinfo->fileindex) {
|
||
printf("TTTTT\n");
|
||
return ;
|
||
/* continue; */
|
||
}
|
||
|
||
printf("cinfo->fileindex=%d\n", cinfo->fileindex);
|
||
goto exit;
|
||
}
|
||
|
||
avServSetResendSize(cinfo->fileindex, 5 * 1024 * 1024);
|
||
|
||
printf("nResend=%d\n", nResend);
|
||
|
||
|
||
while (1) {
|
||
if (cinfo->task_kill) {
|
||
goto exit2;
|
||
}
|
||
|
||
ret = avRecvIOCtrl(cinfo->fileindex, &ioType, (char *)&file_info, sizeof(FILE_t), 10 * 1000);
|
||
if (ret < 0) {
|
||
if (ret == AV_ER_TIMEOUT) {
|
||
|
||
printf("tutk recv timeout\n");
|
||
continue;
|
||
}
|
||
printf("avRecvIOCtrl ret = %d", ret);
|
||
goto exit2;
|
||
}
|
||
do_file_server_event(cinfo->fileindex, &file_info);
|
||
|
||
/* avServStop(cinfo->fileindex); */
|
||
|
||
}
|
||
|
||
|
||
exit2:
|
||
avServStop(cinfo->fileindex);
|
||
exit:
|
||
/* IOTC_Session_Close(cinfo->session_id); */
|
||
|
||
printf("\n thread_ForFileServerStart exit\n");
|
||
}
|
||
#endif
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
static void tutk_do_listen(void *arg)
|
||
{
|
||
int ret;
|
||
int SID;
|
||
struct st_SInfo Sinfo;
|
||
|
||
while (1) {
|
||
SID = IOTC_Listen(0); //0表示不超时
|
||
if (SID < 0) {
|
||
if (SID == IOTC_ER_EXCEED_MAX_SESSION) {
|
||
os_time_dly(100);
|
||
continue;
|
||
}
|
||
printf("SID=%d\n", SID);
|
||
break;
|
||
}
|
||
|
||
|
||
|
||
if (IOTC_Session_Check(SID, &Sinfo) == IOTC_ER_NoERROR) {
|
||
char *mode[3] = {"P2P", "RLY", "LAN"};
|
||
// print session information(not a must)
|
||
// if( isdigit( Sinfo.RemoteIP[0] ))
|
||
/* printf("Client is from[IP:%s, Port:%d] Mode[%s] VPG[%d:%d:%d] VER[%X] NAT[%d] AES[%d]\n", Sinfo.RemoteIP, Sinfo.RemotePort, mode[(int)Sinfo.Mode], Sinfo.VID, Sinfo.PID, Sinfo.GID, Sinfo.IOTCVersion, Sinfo.NatType, Sinfo.isSecure); */
|
||
}
|
||
|
||
printf("\n [ERROR] %s -yuyu %d\n", __FUNCTION__, __LINE__);
|
||
struct tutk_client_info *cinfo = calloc(1, sizeof(struct tutk_client_info));
|
||
printf("\n [ERROR] %s -yuyu %d\n", __FUNCTION__, __LINE__);
|
||
if (!cinfo) {
|
||
printf("tutk malloc fail\n");
|
||
IOTC_Session_Close(SID);
|
||
continue;
|
||
|
||
}
|
||
|
||
|
||
cinfo->session_id = SID;
|
||
|
||
os_mutex_pend(&tinfo.mutex, 0);
|
||
list_add_tail(&cinfo->entry, &tinfo.head);
|
||
|
||
os_mutex_post(&tinfo.mutex);
|
||
char thread_name[64];
|
||
static u32 count;
|
||
#if 1
|
||
sprintf(thread_name, "CmdServerStart_%X", count++);
|
||
printf("\n thread_name = %s \n", thread_name);
|
||
ret = thread_fork(thread_name, 28, 0x1000, 64, &cinfo->cmd_task_pid, thread_ForCMDServerStart, (void *)cinfo);
|
||
if (ret != OS_NO_ERR) {
|
||
printf("\n create %s err ,ret = %d", thread_name, ret);
|
||
}
|
||
#endif
|
||
|
||
|
||
#if 1
|
||
//文件系统子线程
|
||
sprintf(thread_name, "FileServerStart_%X", count++);
|
||
printf("\n thread_name = %s \n", thread_name);
|
||
ret = thread_fork(thread_name, 10, 0x1000, 64, &cinfo->file_task_pid, thread_ForFileServerStart, (void *)cinfo);
|
||
if (ret != OS_NO_ERR) {
|
||
printf("\n create %s err ,ret = %d", thread_name, ret);
|
||
}
|
||
|
||
#endif
|
||
|
||
}
|
||
printf("end tutk_do_listen_task \n\n");
|
||
}
|
||
|
||
|
||
void *tutk_session_cli_get(void)
|
||
{
|
||
|
||
struct tutk_client_info *cinfo = NULL;
|
||
|
||
if (list_empty(&tinfo.head)) {
|
||
|
||
return NULL;
|
||
}
|
||
|
||
cinfo = list_first_entry(&tinfo.head, struct tutk_client_info, entry);
|
||
|
||
return (void *)cinfo;
|
||
|
||
}
|
||
|
||
|
||
static int tutk_session_cli_exit(int arg)
|
||
{
|
||
|
||
struct tutk_client_info *cinfo = (struct tutk_client_info *)arg;
|
||
os_mutex_pend(&tinfo.mutex, 0);
|
||
list_del(&cinfo->entry);
|
||
os_mutex_post(&tinfo.mutex);
|
||
|
||
cinfo->task_kill = 1;
|
||
//关闭所有应用
|
||
|
||
/* video0_tutk_stop(cinfo); */
|
||
/* tutk_speak_uninit(cinfo); */
|
||
|
||
thread_kill(&cinfo->file_task_pid, KILL_WAIT);
|
||
thread_kill(&cinfo->cmd_task_pid, KILL_WAIT);
|
||
cinfo->task_kill = 0;
|
||
|
||
IOTC_Session_Close(cinfo->session_id);
|
||
|
||
free(cinfo);
|
||
|
||
return 0;
|
||
|
||
}
|
||
|
||
int tutk_noitfy_cli(void *hdl, char *msg, int msg_len)
|
||
{
|
||
struct tutk_client_info *info = (struct tutk_client_info *)hdl;
|
||
struct tutk_client_info *p = NULL;
|
||
int ret = 0;
|
||
|
||
if (!tinfo.inited) {
|
||
return -1;
|
||
}
|
||
|
||
if (info) {
|
||
if ((ret = avSendIOCtrl(info->cmdindex, IOTYPE_USER_CTP_CMD_MSG, msg, msg_len)) < 0) {
|
||
printf("start_ipcam_stream failed[%d]\n", ret);
|
||
return -1;
|
||
}
|
||
return 0;
|
||
|
||
}
|
||
|
||
|
||
|
||
os_mutex_pend(&tinfo.mutex, 0);
|
||
if (list_empty(&tinfo.head)) {
|
||
os_mutex_post(&tinfo.mutex);
|
||
return -1;
|
||
}
|
||
|
||
list_for_each_entry(p, &tinfo.head, entry) {
|
||
if ((ret = avSendIOCtrl(p->cmdindex, IOTYPE_USER_CTP_CMD_MSG, msg, msg_len)) < 0) {
|
||
printf("start_ipcam_stream failed[%d]\n", ret);
|
||
}
|
||
}
|
||
|
||
os_mutex_post(&tinfo.mutex);
|
||
|
||
return 0;
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
static void tutk_state_task(void *arg)
|
||
{
|
||
int res;
|
||
int msg[8];
|
||
|
||
while (1) {
|
||
res = os_task_pend("taskq", msg, ARRAY_SIZE(msg));
|
||
|
||
switch (res) {
|
||
case OS_TASKQ:
|
||
switch (msg[1]) {
|
||
case TUTK_CMD_TIMEOUT:
|
||
|
||
tutk_session_cli_exit(msg[2]);
|
||
break;
|
||
case TUTK_ERR:
|
||
|
||
tutk_session_cli_exit(msg[2]);
|
||
break;
|
||
|
||
|
||
|
||
case TUTK_KILL_TASK:
|
||
printf("end tutk_state_task \n\n");
|
||
return;
|
||
default:
|
||
break;
|
||
}
|
||
break;
|
||
case OS_TIMER:
|
||
break;
|
||
case OS_TIMEOUT:
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
#define BIND_TOKEN "174f9d4e-b5bf-4194-8158-f00bf00ea619"
|
||
#define DEV_INFO_JSON "{\"device_uuid\":\"%s\",\"bind_token\":\"%s\"}"
|
||
static char buffer[1024];
|
||
static char *dev_info()
|
||
{
|
||
/*后面改成都VM*/
|
||
sprintf(buffer, DEV_INFO_JSON, TEST_UID, BIND_TOKEN);
|
||
return buffer;
|
||
}
|
||
static void network_ssdp_cb(u32 dest_ipaddr, enum mssdp_recv_msg_type type, char *buf, void *priv)
|
||
{
|
||
if (type == MSSDP_SEARCH_MSG) {
|
||
printf("ssdp client[0x%x] search, %s\n", dest_ipaddr, buf);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
int tutk_platform_init(const char *username, const char *password)
|
||
{
|
||
int ret;
|
||
strcpy(tinfo.username, username);
|
||
strcpy(tinfo.password, password);
|
||
|
||
IOTC_Set_Max_Session_Number(MAX_CLIENT_NUMBER);
|
||
|
||
ret = IOTC_Initialize2(55556);
|
||
if (ret != IOTC_ER_NoERROR) {
|
||
printf("\n IOTC_Initialize2(), ret=[%d]\n", ret);
|
||
goto exit;
|
||
}
|
||
|
||
ret = os_mutex_create(&tinfo.mutex);
|
||
if (ret != OS_NO_ERR) {
|
||
printf("\n create list mutex err\n");
|
||
goto exit;
|
||
}
|
||
|
||
|
||
unsigned int iotcVer;
|
||
IOTC_Get_Version(&iotcVer);
|
||
int avVer = avGetAVApiVer();
|
||
unsigned char *p = (unsigned char *)&iotcVer;
|
||
unsigned char *p2 = (unsigned char *)&avVer;
|
||
char szIOTCVer[16], szAVVer[16];
|
||
sprintf(szIOTCVer, "%d.%d.%d.%d", p[3], p[2], p[1], p[0]);
|
||
sprintf(szAVVer, "%d.%d.%d.%d", p2[3], p2[2], p2[1], p2[0]);
|
||
printf("IOTCAPI version[%s] AVAPI version[%s]\n", szIOTCVer, szAVVer);
|
||
|
||
printf("UUID:%s\n", TEST_UID);
|
||
|
||
|
||
IOTC_Get_Login_Info_ByCallBackFn(tutk_login_info_cb);
|
||
|
||
avInitialize(MAX_CLIENT_NUMBER * 4);
|
||
|
||
INIT_LIST_HEAD(&tinfo.head);
|
||
|
||
ret = thread_fork("tutk_login_task", 10, 0x2000, 0, &tinfo.login_pid, tutk_login_task, NULL);
|
||
if (ret != OS_NO_ERR) {
|
||
printf("\n create thread_Login err , ret = %d \n", ret);
|
||
}
|
||
|
||
|
||
ret = thread_fork("tutk_do_listen_task", 10, 0x2000, 0, 0, tutk_do_listen, NULL);
|
||
if (ret != OS_NO_ERR) {
|
||
printf("\n create thread_listen err , ret = %d \n", ret);
|
||
}
|
||
|
||
|
||
ret = thread_fork("tutk_state_task", 25, 2048, 64, 0, tutk_state_task, NULL);
|
||
if (ret != OS_NO_ERR) {
|
||
printf("\n create tutk_state_task err , ret = %d \n", ret);
|
||
}
|
||
|
||
|
||
|
||
mssdp_init("MSSDP_SEARCH ", "MSSDP_NOTIFY ", "MSSDP_REGISTER ", 3889, network_ssdp_cb, NULL);
|
||
mssdp_set_notify_msg(dev_info(), 60);
|
||
|
||
|
||
|
||
tinfo.inited = 1;
|
||
|
||
|
||
|
||
|
||
|
||
|
||
return 0;
|
||
exit:
|
||
return -1;
|
||
}
|
||
|
||
int tutk_platform_uninit()
|
||
{
|
||
|
||
struct tutk_client_info *p = NULL;
|
||
|
||
if (!tinfo.inited) {
|
||
return 0;
|
||
}
|
||
|
||
if (!list_empty(&tinfo.head)) {
|
||
list_for_each_entry(p, &tinfo.head, entry) {
|
||
tutk_session_cli_exit((int)p);
|
||
}
|
||
}
|
||
|
||
mssdp_uninit();
|
||
|
||
IOTC_Listen_Exit();
|
||
|
||
|
||
os_taskq_post("tutk_state_task", 1, TUTK_KILL_TASK);
|
||
|
||
|
||
tinfo.kill_task = 1;
|
||
|
||
thread_kill(&tinfo.login_pid, KILL_WAIT);
|
||
|
||
tinfo.kill_task = 0;
|
||
avDeInitialize();
|
||
IOTC_DeInitialize();
|
||
|
||
|
||
os_mutex_del(&tinfo.mutex, 0);
|
||
tinfo.inited = 0;
|
||
|
||
return 0;
|
||
}
|
||
#endif
|
||
|
||
|