3571 lines
107 KiB
C
Executable File
3571 lines
107 KiB
C
Executable File
/**************************************************************************
|
|
*
|
|
* Copyright (c) 2009-2018 by SiFar Technology, Inc.
|
|
*
|
|
* This software is copyrighted by and is the property of SiFar
|
|
* Technology, Inc.. All rights are reserved by SiFar Technology, Inc..
|
|
* This software may only be used in accordance with the corresponding
|
|
* license agreement. Any unauthorized use, duplication, distribution,
|
|
* or disclosure of this software is expressly forbidden.
|
|
*
|
|
* This Copyright notice MUST not be removed or modified without prior
|
|
* written consent of SiFar Technology, Inc..
|
|
*
|
|
* SiFar Technology, Inc. reserves the right to modify this software without notice.
|
|
*
|
|
* Author: Payton
|
|
* Ver: 1.0.0 2023.02.14
|
|
* Description: pc tool code
|
|
*
|
|
**************************************************************************/
|
|
#include <sf_inc.h>
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <fcntl.h>
|
|
//#include <linux/input.h>
|
|
|
|
#include <sys/fcntl.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/ioctl.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <pthread.h>
|
|
|
|
#include <kwrap/util.h>
|
|
#include <sys/wait.h>
|
|
#include <errno.h>
|
|
#include <kwrap/debug.h>
|
|
#include <kwrap/stdio.h>
|
|
#include "NvtUser/NvtUser.h"
|
|
#include "AppControl/AppControl.h"
|
|
#include "comm/hwclock.h"
|
|
#include <time.h>
|
|
#include <io/gpio.h>
|
|
#include "UIInfo/UIInfo.h"
|
|
#include "IOCfg.h"
|
|
#include "SysCommon.h"
|
|
#include "SysMain.h"
|
|
#include "PrjInc.h"
|
|
#include "AppCommon.h"
|
|
#include "ImageApp/ImageApp_MovieMulti.h"
|
|
|
|
#include "avfile/movieinterface_def.h"
|
|
#include "GxTime.h"
|
|
#include "UIFlowPhoto/UIFlowPhotoFuncs.h"
|
|
#include "UIFlowMovie/UIFlowMovieFuncs.h"
|
|
#include "UIApp/Transcode/UIAppTranscode.h"
|
|
#include <sf_message_queue.h>
|
|
#include <sf_param_enum.h>
|
|
#include <sf_keymng.h>
|
|
#include <sf_param_struct.h>
|
|
#include "UIAppNetwork.h"
|
|
#include "kwrap/nvt_type.h"
|
|
#include "sf_common.h"
|
|
#include "sf_mcu.h"
|
|
#include "sf_4g_lpa.h"
|
|
#include <sf_wifi_svr.h>
|
|
#include <sf_log.h>
|
|
#include <sf_storeMng.h>
|
|
|
|
|
|
BOOL isGoing2PowerOff = FALSE;
|
|
UINT16 AutoOfftime = 0;
|
|
static unsigned int KeepAliveTime_s = DEFAULT_GO_TO_WORK_MODE_TIME_S;
|
|
BOOL isGoing2Pir = FALSE;
|
|
static UINT8 NetWorkFlag = 0; //SF_4G_STATUS_E
|
|
static INT8 simCardInsert = -1;
|
|
static int g_esim_flag = -1;
|
|
static int gModuleInitFlag = -1;
|
|
static UINT8 operationSelectResp = 0; //WIFICameraErrCode_t
|
|
UINT8 RtspFlag = 0;
|
|
static BOOL IsMenu = FALSE;
|
|
static BOOL IsCap = FALSE;
|
|
static BOOL IsSend = FALSE;
|
|
static short cq_Signal = SIGNAL_NOT_YET_GET;
|
|
static ID sf_hd_flag_id = 0;
|
|
static UINT8 hdFlagInit = 0;
|
|
static char HdflieName[32] = {0};
|
|
static UINT8 ModuleUpdating = 0;
|
|
static UINT8 FwUpdate = 0;
|
|
static UINT8 IsNightLedOn = 0;
|
|
static SF_BatteryLevel_e sf_LatestBattLevel = SF_BATT_LEVEL_0;
|
|
static UINT8 batteryVal = 0;
|
|
static UINT16 powerVal = 0;
|
|
static UINT8 batteryType = 0;
|
|
static SINT16 fTemper = 0;
|
|
static SINT16 cTemper = 0;
|
|
static pthread_cond_t condition;
|
|
static pthread_mutex_t Param_mutexLock;
|
|
static int shared_condition = 1;
|
|
static SINT32 WifiSocket = 0;
|
|
static UINT8 UiparaFlag = 0;
|
|
static SF_BLE_STATUS_E BleStatus = SF_BLE_OK;
|
|
static UINT8 McuUpdateFlag = 0;
|
|
static SF_GPS_STATUS_E gGpsSearching = SF_GPS_SEARCHING_UNKNOW;
|
|
static FTP_CONNECTING_E gFtpConnectingStatus = FTP_CONNECTING_END;
|
|
static char CamMode = 0;
|
|
static CHAR netGeneration = SF_NET_NO;
|
|
static SF_THREAD_S UpgradeTskParam =
|
|
{
|
|
.IsRun = 0,
|
|
.TskId = -1,
|
|
};
|
|
|
|
static SF_THREAD_S ParaTskCfg =
|
|
{
|
|
.IsRun = 0,
|
|
.TskId = -1,
|
|
};
|
|
static SF_THREAD_S WifiTskCfg =
|
|
{
|
|
.IsRun = 0,
|
|
.TskId = -1,
|
|
};
|
|
static SF_THREAD_S CapTskCfg =
|
|
{
|
|
.IsRun = 0,
|
|
.TskId = -1,
|
|
};
|
|
static SF_THREAD_S HdCapTskCfg =
|
|
{
|
|
.IsRun = 0,
|
|
.TskId = -1,
|
|
};
|
|
static SF_THREAD_S WaiParaTskCfg =
|
|
{
|
|
.IsRun = 0,
|
|
.TskId = -1,
|
|
};
|
|
|
|
static SF_THREAD_S LoadParaTskCfg =
|
|
{
|
|
.IsRun = 0,
|
|
.TskId = -1,
|
|
};
|
|
int sf_pir_statu_read(void)
|
|
{
|
|
static UINT8 state = 0;
|
|
if(0 == state)
|
|
{
|
|
state = 1;
|
|
gpio_direction_input(GPIO_PIR_STATE);
|
|
}
|
|
return gpio_get_value(GPIO_PIR_STATE);
|
|
}
|
|
|
|
BOOL sf_get_pir_power_off_flag(void)
|
|
{
|
|
return isGoing2PowerOff;
|
|
}
|
|
|
|
void sf_set_pir_power_off_flag(BOOL flag)
|
|
{
|
|
isGoing2PowerOff = flag;
|
|
}
|
|
|
|
BOOL sf_get_pir_statu_flag(void)
|
|
{
|
|
return isGoing2Pir;
|
|
}
|
|
|
|
void sf_set_pir_statu_flag(BOOL flag)
|
|
{
|
|
isGoing2Pir = flag;
|
|
}
|
|
|
|
void sf_set_auto_off_time(UINT16 time)
|
|
{
|
|
AutoOfftime = time;
|
|
}
|
|
|
|
UINT16 sf_get_auto_off_time(void)
|
|
{
|
|
return AutoOfftime;
|
|
}
|
|
void sf_set_keep_alive_time(unsigned int time_s)
|
|
{
|
|
KeepAliveTime_s = time_s;
|
|
}
|
|
|
|
void sf_set_wifi_socket(int fd)
|
|
{
|
|
WifiSocket = fd;
|
|
}
|
|
|
|
int sf_get_wifi_socket(void)
|
|
{
|
|
return WifiSocket;
|
|
}
|
|
void sf_mode_detect(void)
|
|
{
|
|
static UINT8 state = 0;
|
|
static UINT32 timeBak = 0;
|
|
static UINT32 time=0;
|
|
static UINT8 pwroffcnt = 0;
|
|
//static UINT8 countDownOffFlg = 0;
|
|
static UINT8 pirDelay = 0;
|
|
VOS_TICK tticktmp=0;
|
|
static VOS_TICK ttick=0;
|
|
static UINT32 cmdflag = 0;
|
|
static UINT32 time2 = 0;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if(sf_get_power_off_flag() || sf_is_usb_flag())
|
|
{
|
|
sf_set_pir_statu_flag(FALSE);
|
|
return;
|
|
}
|
|
//printf("[%s:%d] s\n", __FUNCTION__, __LINE__);
|
|
|
|
if(FwUpdate)
|
|
return;
|
|
|
|
if(sf_get_mode_flag())
|
|
{
|
|
//printf("PIR:%d,state:%d\n", sf_pir_statu_read(),state);
|
|
if(sf_pir_statu_read() != state)
|
|
{
|
|
state = sf_pir_statu_read();
|
|
//printf("PIR_STATE_READ:%d\n", state);
|
|
if(((!sf_get_pir_statu_flag()) && (AutoOfftime < KeepAliveTime_s)))
|
|
{
|
|
if(!state)
|
|
{
|
|
if(pirDelay == 0)
|
|
{
|
|
sf_sys_status_led_set(SF_LED_SYS_STATE_PIR_DETECT);
|
|
pirDelay++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sf_sys_status_led_set(SF_LED_SYS_STATE_PIR_NOT_DETECT);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(pirDelay)
|
|
{
|
|
pirDelay++;
|
|
|
|
if(pirDelay >= 10)
|
|
{
|
|
pirDelay = 0;
|
|
}
|
|
}
|
|
|
|
time++;
|
|
|
|
if(time<10)
|
|
return;
|
|
|
|
time=0;
|
|
|
|
//printf("[*x] get pir statu : %d ...\n", sf_get_pir_statu_flag());
|
|
if((sf_get_pir_statu_flag()) && (!gpio_getPin(GPIO_KEY_TEST)))
|
|
{
|
|
timeBak++;
|
|
if(timeBak == 1)
|
|
{
|
|
vos_perf_mark(&ttick);
|
|
//sf_sys_status_led_set(SF_LED_SYS_STATE_OFF);
|
|
//sf_enter_auto_mode_show(3);
|
|
//if(!countDownOffFlg)
|
|
sf_sys_status_led_set(SF_LED_SYS_STATE_GOING_TO_PIR);
|
|
}
|
|
vos_perf_mark(&tticktmp);
|
|
time2 = ((tticktmp/1000) - (ttick/1000));
|
|
|
|
//if((!cmdflag) && (0 == sf_get_fw_update()) && (time >= 3000))
|
|
if((!cmdflag) && (0 == sf_get_fw_update()) && (timeBak == 4))
|
|
{
|
|
cmdflag = 1;
|
|
printf("[%s:%d]time2=%dms\n",__FUNCTION__,__LINE__,time2);
|
|
sf_set_card_statu(CMD_FORMAT_SD_STA);
|
|
BKG_PostEvent(NVTEVT_BKW_FORMAT_CARD);
|
|
}
|
|
}
|
|
else if((sf_get_pir_statu_flag()) && (CMD_FORMAT_SD_STA != sf_get_card_statu()))
|
|
{
|
|
printf("[sf_mode_detect]start going to pir...\n");
|
|
pwroffcnt++;
|
|
//printf("[%s:%d]pwroffcnt=%d\n",__FUNCTION__,__LINE__,pwroffcnt);
|
|
//sf_enter_auto_mode_count_down_show(4 - pwroffcnt);
|
|
if(pwroffcnt == 1)
|
|
{
|
|
//sf_enter_auto_mode_show(3);
|
|
//if(!countDownOffFlg)
|
|
sf_sys_status_led_set(SF_LED_SYS_STATE_GOING_TO_PIR);
|
|
}
|
|
else if(pwroffcnt == 6)
|
|
{
|
|
sf_sys_status_led_set(SF_LED_SYS_STATE_POWER_OFF);
|
|
|
|
printf("[power off] %s(%d) AutoOfftime:%d\n", __FUNCTION__, __LINE__, AutoOfftime);
|
|
#define DO_NOT_SHOW_POWER_OFF 0
|
|
if(AutoOfftime >= KeepAliveTime_s)
|
|
{
|
|
Ux_PostEvent(NVTEVT_SYSTEM_SHUTDOWN, 2, APP_POWER_OFF_APO, DO_NOT_SHOW_POWER_OFF); //shutdown start
|
|
}
|
|
else
|
|
{
|
|
#if defined(_MODEL_565_HUNTING_EVB_LINUX_4G_68CS_)
|
|
Ux_PostEvent(NVTEVT_SYSTEM_SHUTDOWN, 1, APP_POWER_OFF_NORMAL); //shutdown start
|
|
#elif defined(_MODEL_565_HUNTING_EVB_LINUX_4G_S530_) || defined(_MODEL_565_HUNTING_EVB_LINUX_4G_S550_)
|
|
Ux_PostEvent(NVTEVT_SYSTEM_SHUTDOWN, 2, APP_POWER_OFF_APO, DO_NOT_SHOW_POWER_OFF); //shutdown start
|
|
#endif
|
|
}
|
|
sf_set_power_off_flag(1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pwroffcnt = 0;
|
|
cmdflag = 0;
|
|
timeBak = 0;
|
|
//countDownOffFlg = 0;
|
|
}
|
|
|
|
if(puiPara->AutoOffSwitch == 0 || SF_BLE_CON == sf_get_ble_status() || SF_WIFI_CON == sf_get_wifi_status() || (0x04 == NetWorkFlag/*SF_4G_SENDING*/) ||
|
|
(0x05 == NetWorkFlag/*SF_4G_SEARCHING*/) || (sf_get_fw_update()) || (sf_get_module_update()) ||
|
|
(sf_get_mcu_update_flag()) || ( System_GetState(SYS_STATE_CURRMODE) == PRIMARY_MODE_PLAYBACK)/*|| (appActiveStateGet() == APP_STATE_CUSTOMER_TRANSFER)*/)
|
|
{
|
|
AutoOfftime=0;
|
|
}
|
|
|
|
//if(((System_GetState(SYS_STATE_CURRMODE) == PRIMARY_MODE_PHOTO)&& (gPhotoData.State == PHOTO_ST_VIEW))
|
|
// || ((System_GetState(SYS_STATE_CURRMODE) == PRIMARY_MODE_MOVIE) && (FlowMovie_GetMovDataState() == MOV_ST_VIEW)))
|
|
//if(sf_is_preview())
|
|
if(FALSE == sf_get_cap_statu() && FALSE == sf_is_movie_running())
|
|
{
|
|
//printf("----AutoOfftime=%d\n",AutoOfftime);
|
|
/*if(AutoOfftime<184)
|
|
{
|
|
if(countDownOffFlg)
|
|
{
|
|
countDownOffFlg = 0;
|
|
|
|
if(!sf_get_pir_statu_flag())
|
|
sf_sys_status_led_set(SF_LED_SYS_STATE_EXIT_GO_TO_PIR);
|
|
}
|
|
}
|
|
else */if(AutoOfftime == KeepAliveTime_s - 1)
|
|
{
|
|
//sf_set_pir_statu_flag(TRUE);
|
|
//countDownOffFlg = 0;
|
|
//sf_sys_status_led_set(SF_LED_SYS_STATE_GOING_TO_PIR);
|
|
}
|
|
AutoOfftime++;
|
|
|
|
}
|
|
else
|
|
{
|
|
AutoOfftime=0;
|
|
}
|
|
|
|
}
|
|
//printf("[%s:%d] e\n", __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
UINT8 sf_get_mcu_update_flag(void)
|
|
{
|
|
return McuUpdateFlag;
|
|
}
|
|
|
|
void sf_set_mcu_update_flag(UINT8 flag)
|
|
{
|
|
McuUpdateFlag = flag;
|
|
}
|
|
|
|
UINT8 sf_get_module_update(void)
|
|
{
|
|
return ModuleUpdating;
|
|
}
|
|
|
|
void sf_set_module_update(UINT8 flag)
|
|
{
|
|
SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
if(ModuleUpdating != flag)
|
|
{
|
|
stMessageBuf.arg2 = flag;
|
|
stMessageBuf.arg1 = SF_PARA_CMD_MOUP;
|
|
stMessageBuf.cmdId = CMD_PARA;
|
|
sf_com_message_send_to_app(&stMessageBuf);
|
|
}
|
|
ModuleUpdating = flag;
|
|
}
|
|
|
|
UINT8 sf_get_fw_update(void)
|
|
{
|
|
return FwUpdate;
|
|
}
|
|
|
|
void sf_set_fw_update(UINT8 flag)
|
|
{
|
|
/*SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
if(FwUpdate != flag)
|
|
{
|
|
stMessageBuf.arg2 = flag;
|
|
stMessageBuf.arg1 = SF_PARA_CMD_FWUP;
|
|
stMessageBuf.cmdId = CMD_PARA;
|
|
sf_com_message_send_to_app(&stMessageBuf);
|
|
}*/
|
|
FwUpdate = flag;
|
|
}
|
|
|
|
//#SF#2023/03/02#Payton - begin
|
|
BOOL sf_cmd_cam_name_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
//printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(2 == argc)
|
|
{
|
|
sscanf_s(argv[0],"%d", &value);
|
|
if(value < SF_CAMID_MAX)
|
|
{
|
|
puiPara->CamNameSwitch = value;
|
|
}
|
|
strncpy(puiPara->CamNameStr, argv[1], ((12 <= strlen(argv[1])) ? 12 : (strlen(argv[1]))));
|
|
Save_MenuInfo();
|
|
}
|
|
|
|
printf("[%s:%d] CamNameSwitch:%d CamNameStr:%s\n", __FUNCTION__, __LINE__,value,puiPara->CamNameStr);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_flash_led(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_FLASH_LED_MAX){
|
|
puiPara->FlashLed = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] FlashLed:%d\n", __FUNCTION__, __LINE__,puiPara->FlashLed);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_img_size(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < PHOTO_SIZE_ID_MAX){
|
|
SysSetFlag(FL_PHOTO_SIZE, value);
|
|
Photo_SetUserIndex(PHOTO_USR_SIZE, puiPara->ImgSize);
|
|
puiPara->ImgSize = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] FL_PHOTO_SIZE:%d\n", __FUNCTION__, __LINE__,SysGetFlag(FL_PHOTO_SIZE));
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_night_mode(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_NIGHT_MODE_MAX){
|
|
puiPara->NightMode = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] NightMode:%d\n", __FUNCTION__, __LINE__,puiPara->NightMode);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_multishot_intevel(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_MULTISHOT_INTEVEL_MAX){
|
|
puiPara->MultiShotIntevel = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] MultiShotIntevel:%d\n", __FUNCTION__, __LINE__, puiPara->MultiShotIntevel);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_multishot(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < CONTINUE_SHOT_SETTING_MAX){
|
|
puiPara->Multishot = value;
|
|
SysSetFlag(FL_CONTINUE_SHOT, value);
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] FL_CONTINUE_SHOT:%d\n", __FUNCTION__, __LINE__,SysGetFlag(FL_CONTINUE_SHOT));
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_video_size(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < MOVIE_SIZE_ID_MAX){
|
|
puiPara->VideoSize = value;
|
|
SysSetFlag(FL_MOVIE_SIZE, value);
|
|
SysSetFlag(FL_MOVIE_SIZE_MENU, value);
|
|
Save_MenuInfo();
|
|
int iCurrMode = System_GetState(SYS_STATE_CURRMODE);
|
|
int iNextMode = PRIMARY_MODE_PHOTO;
|
|
|
|
if((puiPara->CamMode == SF_CAM_MODE_PHOTO) || (puiPara->CamMode == SF_CAM_MODE_PHOTO_VIDEO) || (puiPara->CamMode == SF_CAM_MODE_VIDEO2))
|
|
{
|
|
iNextMode = PRIMARY_MODE_PHOTO;
|
|
}
|
|
else if(puiPara->CamMode == SF_CAM_MODE_VIDEO)
|
|
{
|
|
iNextMode = PRIMARY_MODE_MOVIE;
|
|
}
|
|
else
|
|
{
|
|
iNextMode = PRIMARY_MODE_PHOTO;
|
|
}
|
|
|
|
UI_SetData(FL_PreMode, iCurrMode);
|
|
UI_SetData(FL_NextMode, iNextMode);
|
|
Ux_PostEvent(NVTEVT_SYSTEM_MODE, 1, iNextMode);
|
|
}
|
|
printf("[%s:%d] FL_MOVIE_SIZE:%d\n", __FUNCTION__, __LINE__,SysGetFlag(FL_MOVIE_SIZE));
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_video_lenth(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 uiSelect = 0;
|
|
UINT32 i, mask;
|
|
UINT32 movie_rec_mask, clone_rec_mask;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &uiSelect);
|
|
printf("[%s:%d] uiSelect:%d\n", __FUNCTION__, __LINE__,uiSelect);
|
|
|
|
//UI_SetData(FL_MOVIE_CYCLIC_REC, uiSelect);
|
|
switch (uiSelect) {
|
|
case VIDEO_LENTH_5:
|
|
case VIDEO_LENTH_10:
|
|
case VIDEO_LENTH_15:
|
|
case VIDEO_LENTH_20:
|
|
case VIDEO_LENTH_30:
|
|
case VIDEO_LENTH_40:
|
|
case VIDEO_LENTH_50:
|
|
case VIDEO_LENTH_59:
|
|
break;
|
|
default:
|
|
uiSelect = 10;
|
|
break;
|
|
}
|
|
puiPara->VideoLenth = uiSelect;
|
|
Save_MenuInfo();
|
|
|
|
gMovie_Rec_Option.seamless_sec = 15;
|
|
|
|
movie_rec_mask = Movie_GetMovieRecMask();
|
|
clone_rec_mask = Movie_GetCloneRecMask();
|
|
|
|
mask = 1;
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
if (movie_rec_mask & mask) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_SEAMLESSSEC, gMovie_Rec_Option.seamless_sec);
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_ENDTYPE, (uiSelect == MOVIE_CYCLICREC_OFF) ? MOVREC_ENDTYPE_CUT_TILLCARDFULL : MOVREC_ENDTYPE_CUTOVERLAP);
|
|
}
|
|
|
|
if (clone_rec_mask & mask) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_SEAMLESSSEC, (gMovie_Rec_Option.seamless_sec + 10));
|
|
ImageApp_MovieMulti_SetParam(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_ENDTYPE, (uiSelect == MOVIE_CYCLICREC_OFF) ? MOVREC_ENDTYPE_CUT_TILLCARDFULL : MOVREC_ENDTYPE_CUTOVERLAP);
|
|
}
|
|
|
|
mask <<= 1;
|
|
}
|
|
printf("[%s:%d] VideoLenth:%d\n", __FUNCTION__, __LINE__,puiPara->VideoLenth);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_pir_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->PirSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] PirSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->PirSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_pir_sensitivity(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_PIR_SENSITIVITY_MAX){
|
|
puiPara->PirSensitivity = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] PirSensitivity:%d\n", __FUNCTION__, __LINE__,puiPara->PirSensitivity);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_pir_delay_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if(argc == 4)
|
|
{
|
|
sscanf_s(argv[0],"%d", &value);
|
|
if(value < SF_ON_OFF_MAX)
|
|
{
|
|
puiPara->PirDelaySwitch = value;
|
|
sscanf_s(argv[1],"%d", &value);
|
|
puiPara->PirDelayTime.Hour = value;
|
|
sscanf_s(argv[2],"%d", &value);
|
|
puiPara->PirDelayTime.Min = value;
|
|
sscanf_s(argv[3],"%d", &value);
|
|
puiPara->PirDelayTime.Sec = value;
|
|
Save_MenuInfo();
|
|
}
|
|
}
|
|
printf("[%s:%d] argc:%d PirDelaySwitch:%d %d:%d:%d\n", __FUNCTION__, __LINE__, argc, puiPara->PirDelaySwitch,puiPara->PirDelayTime.Hour,puiPara->PirDelayTime.Min,puiPara->PirDelayTime.Sec);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_timelapse_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if(argc == 4)
|
|
{
|
|
sscanf_s(argv[0],"%d", &value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->TimelapseSwitch = value;
|
|
sscanf_s(argv[1],"%d", &value);
|
|
puiPara->TimelapseTime.Hour = value;
|
|
sscanf_s(argv[2],"%d", &value);
|
|
puiPara->TimelapseTime.Min = value;
|
|
sscanf_s(argv[3],"%d", &value);
|
|
puiPara->TimelapseTime.Sec = value;
|
|
if(puiPara->TimelapseSwitch)
|
|
{
|
|
sf_set_pir_sensitivity(0);
|
|
}
|
|
Save_MenuInfo();
|
|
}
|
|
}
|
|
printf("[%s:%d] argc:%d TimelapseSwitch:%d %d:%d:%d\n", __FUNCTION__, __LINE__, argc, puiPara->TimelapseSwitch,puiPara->TimelapseTime.Hour,puiPara->TimelapseTime.Min,puiPara->TimelapseTime.Sec);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_work_time_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if(argc == 6)
|
|
{
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value == 1)
|
|
{
|
|
sscanf_s(argv[1],"%d", &value);
|
|
if(value < SF_ON_OFF_MAX)
|
|
{
|
|
puiPara->WorkTime1Switch = value;
|
|
sscanf_s(argv[2],"%d", &value);
|
|
puiPara->WorkTime[0].StartTime.Hour = value;
|
|
sscanf_s(argv[3],"%d", &value);
|
|
puiPara->WorkTime[0].StartTime.Min = value;
|
|
sscanf_s(argv[4],"%d", &value);
|
|
puiPara->WorkTime[0].StopTime.Hour = value;
|
|
sscanf_s(argv[5],"%d", &value);
|
|
puiPara->WorkTime[0].StopTime.Min = value;
|
|
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] argc:%d WorkTime1Switch:%d %d:%d-%d:%d\n", __FUNCTION__, __LINE__, argc, puiPara->WorkTime1Switch,puiPara->WorkTime[0].StartTime.Hour,puiPara->WorkTime[0].StartTime.Min,puiPara->WorkTime[0].StopTime.Hour,puiPara->WorkTime[0].StopTime.Min);
|
|
}
|
|
else if(value == 2)
|
|
{
|
|
sscanf_s(argv[1],"%d", &value);
|
|
if(value < SF_ON_OFF_MAX)
|
|
{
|
|
puiPara->WorkTime2Switch = value;
|
|
sscanf_s(argv[2],"%d", &value);
|
|
puiPara->WorkTime[1].StartTime.Hour = value;
|
|
sscanf_s(argv[3],"%d", &value);
|
|
puiPara->WorkTime[1].StartTime.Min = value;
|
|
sscanf_s(argv[4],"%d", &value);
|
|
puiPara->WorkTime[1].StopTime.Hour = value;
|
|
sscanf_s(argv[5],"%d", &value);
|
|
puiPara->WorkTime[1].StopTime.Min = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] argc:%d WorkTime1Switch:%d %d:%d-%d:%d\n", __FUNCTION__, __LINE__, argc, puiPara->WorkTime2Switch,puiPara->WorkTime[1].StartTime.Hour,puiPara->WorkTime[1].StartTime.Min,puiPara->WorkTime[1].StopTime.Hour,puiPara->WorkTime[1].StopTime.Min);
|
|
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_sim_auto_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_SIM_SWITCH_MAX){
|
|
puiPara->SimAutoSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] SimAutoSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->SimAutoSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_sen_max_num(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_SEND_MAX_NUM_MAX){
|
|
puiPara->SendMaxNum = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] SendMaxNum:%d\n", __FUNCTION__, __LINE__,puiPara->SendMaxNum);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_gprs_mode(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_GPRS_MODE_MAX){
|
|
puiPara->GprsMode = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] GprsMode:%d\n", __FUNCTION__, __LINE__,puiPara->GprsMode);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_daily_report_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if(argc == 4)
|
|
{
|
|
sscanf_s(argv[0],"%d", &value);
|
|
if(value == 1)
|
|
{
|
|
sscanf_s(argv[1],"%d", &value);
|
|
if(value < SF_ON_OFF_MAX)
|
|
{
|
|
puiPara->DailyReportSwitch = value;
|
|
sscanf_s(argv[2],"%d", &value);
|
|
puiPara->DailyReportTime.Hour = value;
|
|
sscanf_s(argv[3],"%d", &value);
|
|
puiPara->DailyReportTime.Min = value;
|
|
}
|
|
printf("[%s:%d] DailyReportSwitch:%d H:%d M:%d\n", __FUNCTION__, __LINE__,puiPara->DailyReportSwitch,puiPara->DailyReportTime.Hour,puiPara->DailyReportTime.Min);
|
|
}
|
|
else if(value == 2)
|
|
{
|
|
sscanf_s(argv[1],"%d", &value);
|
|
if(value < SF_ON_OFF_MAX)
|
|
{
|
|
puiPara->ReDailyReport = value;
|
|
sscanf_s(argv[2],"%d", &value);
|
|
puiPara->DailyReportTime2.Hour = value;
|
|
sscanf_s(argv[3],"%d", &value);
|
|
puiPara->DailyReportTime2.Min = value;
|
|
}
|
|
printf("[%s:%d] DailyReportSwitch:%d H:%d M:%d\n", __FUNCTION__, __LINE__,puiPara->ReDailyReport,puiPara->DailyReportTime2.Hour,puiPara->DailyReportTime2.Min);
|
|
}
|
|
Save_MenuInfo();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_re_daily_report(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->ReDailyReport = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] ReDailyReport:%d\n", __FUNCTION__, __LINE__,puiPara->ReDailyReport);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_daily_report_test_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->DailyReportTestSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] DailyReportTestSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->DailyReportTestSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_sim_pin_flag(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->SimPinFlag = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] SimPinFlag:%d\n", __FUNCTION__, __LINE__,puiPara->SimPinFlag);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_gps_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->GpsSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] GpsSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->GpsSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_latitude(unsigned char argc, char **argv)
|
|
{
|
|
//UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
//printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(1 == argc)
|
|
{
|
|
strncpy(puiPara->Latitude, argv[0], ((sizeof(puiPara->Latitude) <= strlen(argv[0])) ? (sizeof(puiPara->Latitude)) : (strlen(argv[0]))));
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] Latitude:%s\n", __FUNCTION__, __LINE__,puiPara->Latitude);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_longitude(unsigned char argc, char **argv)
|
|
{
|
|
//UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
//printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(1 == argc)
|
|
{
|
|
strncpy(puiPara->Longitude, argv[0], ((sizeof(puiPara->Longitude) <= strlen(argv[0])) ? (sizeof(puiPara->Longitude)) : (strlen(argv[0]))));
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] Longitude:%s\n", __FUNCTION__, __LINE__,puiPara->Longitude);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL sf_cmd_language(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < LANG_ID_MAX){
|
|
SysSetFlag(FL_LANGUAGE, value);
|
|
puiPara->Language = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] FL_LANGUAGE:%d\n", __FUNCTION__, __LINE__,SysGetFlag(FL_LANGUAGE));
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_date_style(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_DATE_TIME_MAX){
|
|
puiPara->DateStyle = value;
|
|
SysSetFlag(FL_DateFormatIndex, value);
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] DateStyle:%d\n", __FUNCTION__, __LINE__,puiPara->DateStyle);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_stamp_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->StampSwitch = value;
|
|
SysSetFlag(FL_DATE_STAMP, ((1 == value) ? DATEIMPRINT_DATE_TIME : DATEIMPRINT_OFF));
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] StampSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->StampSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_battery_type(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_BATT_MAX){
|
|
puiPara->BatteryType = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] BatteryType:%d\n", __FUNCTION__, __LINE__,puiPara->BatteryType);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_sd_loop_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->SdLoopSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] SdLoopSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->SdLoopSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_pwd_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if(argc == 2)
|
|
{
|
|
sscanf_s(argv[0],"%d", &value);
|
|
if(value < SF_ON_OFF_MAX)
|
|
{
|
|
puiPara->PwdSwitch = value;
|
|
strncpy(puiPara->PwdStr, argv[1], ((6 <= strlen(argv[1])) ? 6 : (strlen(argv[1]))));
|
|
Save_MenuInfo();
|
|
}
|
|
}
|
|
printf("[%s:%d] PwdSwitch:%d PwdStr:%s\n", __FUNCTION__, __LINE__,puiPara->PwdSwitch, puiPara->PwdStr);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_send_photo_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->SendPhotoSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] SendPhotoSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->SendPhotoSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_send_video_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->SendVideoSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] SendVideoSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->SendVideoSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_send_pic_size(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_SEND_MAX){
|
|
puiPara->SendPicSize = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] SendPicSize:%d\n", __FUNCTION__, __LINE__,puiPara->SendPicSize);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_send_multishot_index(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
if(argc == 5)
|
|
{
|
|
sscanf_s(argv[0],"%d", &value);
|
|
puiPara->SendMultishotIndex1 = value;
|
|
sscanf_s(argv[1],"%d", &value);
|
|
puiPara->SendMultishotIndex2 = value;
|
|
sscanf_s(argv[2],"%d", &value);
|
|
puiPara->SendMultishotIndex3 = value;
|
|
sscanf_s(argv[3],"%d", &value);
|
|
puiPara->SendMultishotIndex4 = value;
|
|
sscanf_s(argv[4],"%d", &value);
|
|
puiPara->SendMultishotIndex5 = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] SendMultishotIndex:%d %d %d %d %d\n", __FUNCTION__, __LINE__,puiPara->SendMultishotIndex1,puiPara->SendMultishotIndex2,puiPara->SendMultishotIndex3,puiPara->SendMultishotIndex4,puiPara->SendMultishotIndex5);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_date_auto(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_DATE_MAX){
|
|
puiPara->DateAuto = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] DateAuto:%d\n", __FUNCTION__, __LINE__,puiPara->DateAuto);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_debug_mode(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->DebugMode = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] DebugMode:%d\n", __FUNCTION__, __LINE__,puiPara->DebugMode);
|
|
return TRUE;
|
|
}
|
|
BOOL sf_cmd_autolog_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->AutoLogSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] AutoLogSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->AutoLogSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_auto_off_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->AutoOffSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] AutoOffSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->AutoOffSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_auto_log_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->AutoLogSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] AutoLogSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->AutoLogSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_raw_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->RawSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] RawSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->RawSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_gprs_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->GprsSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] GprsSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->GprsSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_qlog_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->QLogSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] QLogSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->QLogSwitch);
|
|
return TRUE;
|
|
}
|
|
BOOL cmd_cam_mode(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
int iCurrMode = System_GetState(SYS_STATE_CURRMODE);
|
|
int iNextMode = PRIMARY_MODE_PHOTO;
|
|
if(value < SF_CAM_MODE_MAX){
|
|
puiPara->CamMode = value;
|
|
if((puiPara->CamMode == SF_CAM_MODE_PHOTO) || (puiPara->CamMode == SF_CAM_MODE_VIDEO2))
|
|
{
|
|
iNextMode = PRIMARY_MODE_PHOTO;
|
|
}
|
|
else if(puiPara->CamMode == SF_CAM_MODE_VIDEO)
|
|
{
|
|
iNextMode = PRIMARY_MODE_MOVIE;
|
|
}
|
|
else
|
|
{
|
|
iNextMode = PRIMARY_MODE_PHOTO;
|
|
}
|
|
|
|
UI_SetData(FL_PreMode, iCurrMode);
|
|
UI_SetData(FL_NextMode, iNextMode);
|
|
Ux_PostEvent(NVTEVT_SYSTEM_MODE, 1, iNextMode);
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] CamMode:%d\n", __FUNCTION__, __LINE__,puiPara->CamMode);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL cmd_sf_led_test(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0],"%d", &value);
|
|
sf_trigger_time_led_cb(value);
|
|
return TRUE;
|
|
}
|
|
BOOL cmd_rtc_set(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
if(6 == argc)
|
|
{
|
|
struct tm Curr_DateTime = {0};
|
|
|
|
sscanf_s(argv[0],"%d", &value);
|
|
if((value >= SF_DATE_TIME_YEAR_MIN) && (value <= SF_DATE_TIME_YEAR_MAX))
|
|
{
|
|
Curr_DateTime.tm_year = value ;
|
|
}
|
|
sscanf_s(argv[1],"%d", &value);
|
|
if((1 <= value) && (12 >=value))
|
|
{
|
|
Curr_DateTime.tm_mon = value ;
|
|
}
|
|
sscanf_s(argv[2],"%d", &value);
|
|
if((1 <= value) && (31 >=value))
|
|
{
|
|
Curr_DateTime.tm_mday = value ;
|
|
}
|
|
sscanf_s(argv[3],"%d", &value);
|
|
if((0 <= value) && (23 >=value))
|
|
{
|
|
Curr_DateTime.tm_hour = value ;
|
|
}
|
|
sscanf_s(argv[4],"%d", &value);
|
|
if((1 <= value) && (60 >=value))
|
|
{
|
|
Curr_DateTime.tm_min = value ;
|
|
}
|
|
sscanf_s(argv[5],"%d", &value);
|
|
if((1 <= value) && (60 >=value))
|
|
{
|
|
Curr_DateTime.tm_sec = value ;
|
|
}
|
|
|
|
GxTime_SetTime(Curr_DateTime);
|
|
system("hwclock -s");
|
|
printf("[%s:%d] DateTime:%d %d %d %d %d %d\n", __FUNCTION__, __LINE__,Curr_DateTime.tm_year,Curr_DateTime.tm_mon,Curr_DateTime.tm_mday,Curr_DateTime.tm_hour,Curr_DateTime.tm_min,Curr_DateTime.tm_sec);
|
|
sf_cardv_set_mcu_rtc_flag();
|
|
sleep(2);
|
|
GxTime_GetTime(&Curr_DateTime);
|
|
printf("[%s:%d] DateTime2:%d %d %d %d %d %d\n", __FUNCTION__, __LINE__,Curr_DateTime.tm_year,Curr_DateTime.tm_mon,Curr_DateTime.tm_mday,Curr_DateTime.tm_hour,Curr_DateTime.tm_min,Curr_DateTime.tm_sec);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_web_ip(unsigned char argc, char **argv)
|
|
{
|
|
//UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
//printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(1 == argc)
|
|
{
|
|
strncpy(puiPara->WebIp, argv[0], ((sizeof(puiPara->WebIp) <= strlen(argv[0])) ? (sizeof(puiPara->WebIp)) : (strlen(argv[0]))));
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] WebIp:%s\n", __FUNCTION__, __LINE__,puiPara->WebIp);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_acm_ip(unsigned char argc, char **argv)
|
|
{
|
|
//UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
//printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(1 == argc)
|
|
{
|
|
strncpy(puiPara->AcmIp, argv[0], ((sizeof(puiPara->AcmIp) <= strlen(argv[0])) ? (sizeof(puiPara->AcmIp)) : (strlen(argv[0]))));
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] AcmIp:%s\n", __FUNCTION__, __LINE__,puiPara->AcmIp);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_auto_off_time(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
if(1 == argc)
|
|
{
|
|
sscanf_s(argv[0],"%d", &value);
|
|
sf_set_auto_off_time(value);
|
|
}
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_battery_log_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->BatteryLogSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] BatteryLogSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->BatteryLogSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_get_cam_state(unsigned char argc, char **argv)
|
|
{
|
|
printf("[%s:%d] GetMovDataState:%d gPhotoDataState:%d\n", __FUNCTION__, __LINE__,FlowMovie_GetMovDataState(),gPhotoData.State);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_reset(unsigned char argc, char **argv)
|
|
{
|
|
printf("[%s:%d] Reset\n", __FUNCTION__, __LINE__);
|
|
Reset_MenuInfo();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_mcu_power_on_para_get(unsigned char argc, char **argv)
|
|
{
|
|
printf("[%s:%d] s\n", __FUNCTION__, __LINE__);
|
|
//sf_mcu_power_on_para_get(SF_MCU_POWERON);
|
|
SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
stMessageBuf.arg1 = SF_MCU_CMD_POWERON;
|
|
stMessageBuf.cmdId = CMD_MCU;
|
|
sf_com_message_send_to_app(&stMessageBuf);
|
|
printf("[%s:%d] e\n", __FUNCTION__, __LINE__);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_ftp(unsigned char argc, char **argv)
|
|
{
|
|
//UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
//printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(4 == argc)
|
|
{
|
|
memset(puiPara ->FtpIp,'\0', sizeof(puiPara ->FtpIp));
|
|
memset(puiPara ->FtpPort, '\0', sizeof(puiPara ->FtpPort));
|
|
memset(puiPara ->FtpUsr, '\0', sizeof(puiPara ->FtpUsr));
|
|
memset(puiPara ->FtpPwd,'\0', sizeof(puiPara ->FtpPwd));
|
|
strncpy((char *)puiPara->FtpIp, argv[0], ((sizeof(puiPara->FtpIp) <= strlen(argv[0])) ? (sizeof(puiPara->FtpIp)) : (strlen(argv[0]))));
|
|
strncpy((char *)puiPara->FtpPort, argv[1], ((sizeof(puiPara->FtpPort) <= strlen(argv[1])) ? (sizeof(puiPara->FtpPort)) : (strlen(argv[1]))));
|
|
strncpy((char *)puiPara->FtpUsr, argv[2], ((sizeof(puiPara->FtpUsr) <= strlen(argv[2])) ? (sizeof(puiPara->FtpUsr)) : (strlen(argv[2]))));
|
|
strncpy((char *)puiPara->FtpPwd, argv[3], ((sizeof(puiPara->FtpPwd) <= strlen(argv[3])) ? (sizeof(puiPara->FtpPwd)) : (strlen(argv[3]))));
|
|
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] FtpIp:%s FtpPort:%s FtpUsr:%s FtpPwd:%s\n", __FUNCTION__, __LINE__,puiPara->FtpIp,puiPara ->FtpPort,puiPara ->FtpUsr,puiPara ->FtpPwd);
|
|
|
|
return TRUE;
|
|
}
|
|
BOOL sf_cmd_ftps(unsigned char argc, char **argv)
|
|
{
|
|
//UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
//printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(4 == argc)
|
|
{
|
|
memset(puiPara ->FtpsIp,'\0', sizeof(puiPara ->FtpsIp));
|
|
memset(puiPara ->FtpsPort, '\0', sizeof(puiPara ->FtpsPort));
|
|
memset(puiPara ->FtpsUsr, '\0', sizeof(puiPara ->FtpsUsr));
|
|
memset(puiPara ->FtpsPwd,'\0', sizeof(puiPara ->FtpsPwd));
|
|
strncpy((char *)puiPara->FtpsIp, argv[0], ((sizeof(puiPara->FtpsIp) <= strlen(argv[0])) ? (sizeof(puiPara->FtpsIp)) : (strlen(argv[0]))));
|
|
strncpy((char *)puiPara->FtpsPort, argv[1], ((sizeof(puiPara->FtpsPort) <= strlen(argv[1])) ? (sizeof(puiPara->FtpsPort)) : (strlen(argv[1]))));
|
|
strncpy((char *)puiPara->FtpsUsr, argv[2], ((sizeof(puiPara->FtpsUsr) <= strlen(argv[2])) ? (sizeof(puiPara->FtpsUsr)) : (strlen(argv[2]))));
|
|
strncpy((char *)puiPara->FtpsPwd, argv[3], ((sizeof(puiPara->FtpsPwd) <= strlen(argv[3])) ? (sizeof(puiPara->FtpsPwd)) : (strlen(argv[3]))));
|
|
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] FtpsIp:%s FtpsPort:%s FtpsUsr:%s FtpsPwd:%s\n", __FUNCTION__, __LINE__,puiPara->FtpsIp,puiPara ->FtpsPort,puiPara ->FtpsUsr,puiPara ->FtpsPwd);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_ftp_ota(unsigned char argc, char **argv)
|
|
{
|
|
//UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if(4 == argc)
|
|
{
|
|
memset(puiPara ->OtaFtpIp,'\0', sizeof(puiPara ->OtaFtpIp));
|
|
memset(puiPara ->OtaFtpPort, '\0', sizeof(puiPara ->OtaFtpPort));
|
|
memset(puiPara ->OtaFtpUserName, '\0', sizeof(puiPara ->OtaFtpUserName));
|
|
memset(puiPara ->OtaFtpPassWord,'\0', sizeof(puiPara ->OtaFtpPassWord));
|
|
strncpy((char *)puiPara->OtaFtpIp, argv[0], ((sizeof(puiPara->OtaFtpIp) <= strlen(argv[0])) ? (sizeof(puiPara->OtaFtpIp)) : (strlen(argv[0]))));
|
|
strncpy((char *)puiPara->OtaFtpPort, argv[1], ((sizeof(puiPara->OtaFtpPort) <= strlen(argv[1])) ? (sizeof(puiPara->OtaFtpPort)) : (strlen(argv[1]))));
|
|
strncpy((char *)puiPara->OtaFtpUserName, argv[2], ((sizeof(puiPara->OtaFtpUserName) <= strlen(argv[2])) ? (sizeof(puiPara->OtaFtpUserName)) : (strlen(argv[2]))));
|
|
strncpy((char *)puiPara->OtaFtpPassWord, argv[3], ((sizeof(puiPara->OtaFtpPassWord) <= strlen(argv[3])) ? (sizeof(puiPara->OtaFtpPassWord)) : (strlen(argv[3]))));
|
|
|
|
Save_MenuInfo();
|
|
}
|
|
sleep(1);
|
|
SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
stMessageBuf.arg1 = SF_DEV_CMD_OTA;
|
|
stMessageBuf.cmdId = CMD_DEV;
|
|
sf_com_message_send_to_app(&stMessageBuf);
|
|
|
|
printf("[%s:%d] OtaFtpIp:%s\n", __FUNCTION__, __LINE__, puiPara->OtaFtpIp);
|
|
printf("[%s:%d] OtaFtpPort:%s\n", __FUNCTION__, __LINE__, puiPara->OtaFtpPort);
|
|
printf("[%s:%d] OtaFtpUserName:%s\n", __FUNCTION__, __LINE__, puiPara->OtaFtpUserName);
|
|
printf("[%s:%d] OtaFtpPassWord:%s\n", __FUNCTION__, __LINE__, puiPara->OtaFtpPassWord);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_switch_esim(unsigned char argc, char **argv)
|
|
{
|
|
//UINT32 value;
|
|
SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
stMessageBuf.arg1 = SF_DEV_CMD_ESIM_OPERATION_SWTICH;
|
|
stMessageBuf.cmdId = CMD_DEV;
|
|
sf_com_message_send_to_app(&stMessageBuf);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
UINT32 sf_set_pir_sensitivity(UINT8 pirs)
|
|
{
|
|
UINT8 digPirLevel[10] = {200, 38, 30, 24, 18, 16, 10, 9, 8, 7};
|
|
UINT8 digPirCount[10] = {0, 0, 0, 0, 0, 0, 1, 1, 1, 1};
|
|
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
//UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if(pirs >= 10)
|
|
return FAIL;
|
|
puiPara->PirSensitivity = pirs;
|
|
puiPara->DigitPirSensitivity = digPirLevel[pirs];
|
|
puiPara->DigitPirCnt = digPirCount[pirs];
|
|
puiPara->DigitPirWindowTime = 0;
|
|
//#if SF_IS_RELEASE == ENABLE
|
|
if(puiPara->PirSensitivity)
|
|
{
|
|
puiPara->TimelapseSwitch = SF_OFF;
|
|
puiPara->TimelapseTime.Hour = 0;
|
|
puiPara->TimelapseTime.Min = 0;
|
|
puiPara->TimelapseTime.Sec = 0;
|
|
//Save_MenuInfo();
|
|
}
|
|
//#endif
|
|
return SUCCESS;
|
|
}
|
|
|
|
//#SF#2023/03/02#Payton - end
|
|
|
|
void sf_usb_mux_s(UINT32 cnt)
|
|
{
|
|
static UINT8 cntflag = 1;
|
|
printf("[%s:%d] c s\n", __FUNCTION__, __LINE__);
|
|
if(1 == cntflag)
|
|
{
|
|
cntflag = 0;
|
|
gpio_direction_output(GPIO_USB_MUX_S, 1);
|
|
}
|
|
gpio_set_value(GPIO_USB_MUX_S, cnt);
|
|
printf("[%s:%d] e c cnt:%d\n", __FUNCTION__, __LINE__,cnt);
|
|
}
|
|
BOOL sf_cmd_usb_mux_s(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
sf_usb_mux_s(value);
|
|
}
|
|
printf("[%s:%d] e\n", __FUNCTION__, __LINE__);
|
|
return TRUE;
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_rtsp_stop
|
|
Description:
|
|
Input:
|
|
Output: N/A
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
void sf_rtsp_stop(void)
|
|
{
|
|
if(0 == RtspFlag)
|
|
{
|
|
/*SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
stMessageBuf.arg1 = SF_WIFI_CMD_STOP;
|
|
stMessageBuf.cmdId = CMD_WIFI;
|
|
sf_com_message_send_to_cardv(&stMessageBuf);*/
|
|
UINT32 tmp = ImageApp_Common_IsRtspStart(0);
|
|
printf("[%s:%d] RtspFlag = %d tmp:%d\n", __FUNCTION__, __LINE__,RtspFlag, tmp);
|
|
if(1 == tmp)
|
|
{
|
|
//ImageApp_Common_RtspStop(0);
|
|
RtspFlag = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf("[%s:%d] RtspFlag = %d\n", __FUNCTION__, __LINE__,RtspFlag);
|
|
}
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_rtsp_restart
|
|
Description:
|
|
Input:
|
|
Output: N/A
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
void sf_rtsp_restart(void)
|
|
{
|
|
if(1 == RtspFlag)
|
|
{
|
|
/*SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
stMessageBuf.arg1 = SF_WIFI_CMD_RESTART;
|
|
stMessageBuf.cmdId = CMD_WIFI;
|
|
sf_com_message_send_to_cardv(&stMessageBuf);*/
|
|
UINT32 tmp = ImageApp_Common_IsRtspStart(0);
|
|
printf("[%s:%d] RtspFlag = %d tmp:%d\n", __FUNCTION__, __LINE__,RtspFlag, tmp);
|
|
if(tmp == 0)
|
|
{
|
|
//ImageApp_Common_RtspStart(0);
|
|
RtspFlag = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf("[%s:%d] RtspFlag = %d\n", __FUNCTION__, __LINE__,RtspFlag);
|
|
}
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_set_rtsp_flag
|
|
Description:
|
|
Input:
|
|
Output: N/A
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
void sf_set_rtsp_flag(UINT8 flag)
|
|
{
|
|
RtspFlag = flag;
|
|
printf("[%s:%d] RtspFlag = %d\n", __FUNCTION__, __LINE__,RtspFlag);
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_get_rtsp_flag
|
|
Description:
|
|
Input:
|
|
Output: N/A
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT8 sf_get_rtsp_flag(void)
|
|
{
|
|
printf("[%s:%d] RtspFlag = %d\n", __FUNCTION__, __LINE__,RtspFlag);
|
|
return RtspFlag;
|
|
}
|
|
|
|
short sf_cardv_get_cq_signal(void)
|
|
{
|
|
return cq_Signal;
|
|
}
|
|
void sf_cardv_set_gps_status(const SF_GPS_STATUS_E status)
|
|
{
|
|
printf("sf_cardv_set_gps_status = %d\n", status);
|
|
gGpsSearching = status;
|
|
}
|
|
const SF_GPS_STATUS_E sf_cardv_get_gps_status(void)
|
|
{
|
|
return gGpsSearching;
|
|
}
|
|
void sf_cardv_set_ftp_status(const FTP_CONNECTING_E status)
|
|
{
|
|
printf("sf_cardv_set_ftp_status = %d\n", status);
|
|
gFtpConnectingStatus = status;
|
|
}
|
|
const FTP_CONNECTING_E sf_cardv_get_ftp_status(void)
|
|
{
|
|
return gFtpConnectingStatus;
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_cardv_adc_value_get
|
|
Description: get battery adc only once
|
|
Input: N/A
|
|
Output: N/A
|
|
Return: SUCCESS/FAIL
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT32 sf_cardv_adc_value_get(UINT32 mux, UINT32 *pval)
|
|
{
|
|
static UINT8 getAdcFlg = 0;
|
|
static UINT8 outputflag = 1;
|
|
*pval = 0;
|
|
|
|
if(getAdcFlg)
|
|
{
|
|
return FAIL;
|
|
}
|
|
getAdcFlg = 1;
|
|
|
|
if(outputflag)
|
|
{
|
|
outputflag = 0;
|
|
gpio_direction_output(P_GPIO_0,0);
|
|
gpio_direction_output(P_GPIO_1,0);
|
|
}
|
|
|
|
if(SF_ADC_BATT == mux)//bat_det
|
|
{
|
|
//B:0 A:0
|
|
gpio_set_value(P_GPIO_0, 0);//adc_muxa
|
|
gpio_set_value(P_GPIO_1, 0);//adc_muxb
|
|
}
|
|
else if(SF_ADC_LI == mux)//v-li_det
|
|
{
|
|
//B:0 A:1
|
|
gpio_set_value(P_GPIO_0, 1);//adc_muxa
|
|
gpio_set_value(P_GPIO_1, 0);//adc_muxb
|
|
|
|
}
|
|
else if(SF_ADC_DC == mux)//dc12_det
|
|
{
|
|
//B:1 A:0
|
|
gpio_set_value(P_GPIO_0, 0);//adc_muxa
|
|
gpio_set_value(P_GPIO_1, 1);//adc_muxb
|
|
}
|
|
else if(SF_ADC_TEMP == mux)//temp_det
|
|
{
|
|
//B:1 A:1
|
|
gpio_set_value(P_GPIO_0, 1);//adc_muxa
|
|
gpio_set_value(P_GPIO_1, 1);//adc_muxb
|
|
}
|
|
|
|
vos_util_delay_ms(1);
|
|
|
|
*pval = adc_readData(0);
|
|
//printf("[%s:%d] *pval:%d\n", __FUNCTION__, __LINE__,*pval);
|
|
getAdcFlg = 0;
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
void sf_transcode_bs_ready_cb(void* bitstream_va, UINT32 size)
|
|
{
|
|
//SF_HD_DIR
|
|
//char tmp[64] = {'\0'};
|
|
//snprintf(tmp, sizeof(tmp), "%s%s", SF_HD_DIR_CARDV, HdflieName);
|
|
SLOGI("bitstream_va = %lx , size = %lx File:%s\n", bitstream_va, size, HdflieName);
|
|
|
|
FST_FILE fp = FileSys_OpenFile(HdflieName, FST_OPEN_ALWAYS | FST_OPEN_WRITE);
|
|
FileSys_WriteFile(fp, (UINT8*)bitstream_va, &size, 0, NULL);
|
|
FileSys_CloseFile(fp);
|
|
|
|
sf_hd_flag_set_done(HD_FLAG_INITT_OK);
|
|
}
|
|
|
|
static BOOL sf_cmd_transcode_start(char **argv)
|
|
{
|
|
UIAppTranscode_User_Config user_config = {0};
|
|
|
|
|
|
user_config.filepath = (char*)argv[0];
|
|
SLOGI("transcode start filepath:%s\r\n",user_config.filepath);
|
|
|
|
user_config.bs_ready_cb = sf_transcode_bs_ready_cb;
|
|
|
|
Ux_SendEvent(&CustomTranscodeObjCtrl, NVTEVT_EXE_TRANSCODE_START, 1, &user_config);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static const SF_CHAR* sf_process_message_getstatusstring(SF_MESSAGE_TYPE_E enType)
|
|
{
|
|
switch(enType)
|
|
{
|
|
case CMD_KEY:
|
|
return "CMD_KEY";
|
|
case CMD_SD:
|
|
return "CMD_SD";
|
|
case CMD_LED:
|
|
return "CMD_LED";
|
|
case CMD_FILE:
|
|
return "CMD_FILE";
|
|
case CMD_POWEROFF:
|
|
return "CMD_POWEROFF";
|
|
case CMD_VENC:
|
|
return "CMD_VENC";
|
|
case CMD_MCU:
|
|
return "CMD_MCU";
|
|
case CMD_PARA:
|
|
return "CMD_PARA";
|
|
case CMD_GPRS:
|
|
return "CMD_GPRS";
|
|
case CMD_WIFI:
|
|
return "CMD_WIFI";
|
|
case CMD_DEV:
|
|
return "CMD_DEV";
|
|
default:
|
|
return "Unknown";
|
|
}
|
|
}
|
|
static SINT32 sf_cardv_proccess_cmd_mcu(SF_MESSAGE_BUF_S *pMessageBuf)
|
|
{
|
|
// static UINT8 wifistart = 0;
|
|
UINT8 powerOnMode = 0;
|
|
|
|
//printf("[%s:%d] ID = %#x\n", __FUNCTION__, __LINE__,pMessageBuf->arg1);
|
|
//SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
MLOGI("ID = %#x\n",pMessageBuf->arg1);
|
|
switch(pMessageBuf->arg1)
|
|
{
|
|
case SF_MCU_CMD_POWERON:
|
|
powerOnMode = sf_cardv_convert_power_on_mode();
|
|
if(pMessageBuf->arg2 != powerOnMode)
|
|
{
|
|
MLOGE("err get powerOnMode:%d powerOnMode:%d\n",pMessageBuf->arg2, powerOnMode);
|
|
Ux_PostEvent(NVTEVT_SYSTEM_SHUTDOWN, 1, APP_POWER_OFF_NORMAL);
|
|
}
|
|
sf_set_power_on_mode(pMessageBuf->arg2);
|
|
sf_mcu_set_irshtter(pMessageBuf->arg3);
|
|
break;
|
|
case SF_MCU_CMD_MCU_VER:
|
|
sf_set_mcu_sub_ver(pMessageBuf->arg2);
|
|
sf_set_mcu_ver(pMessageBuf->arg3);
|
|
MLOGI("%d.%d.%d\n",(pMessageBuf->arg3>>4)&0x0F, pMessageBuf->arg3 & 0x0F, pMessageBuf->arg2);
|
|
|
|
// if((0 == sf_get_fw_update()) && (sf_get_mode_flag()) && (0 == wifistart))
|
|
// {
|
|
// wifistart = 1;
|
|
// GOIO_Turn_Onoff_IRCUT(1);
|
|
// /*wifi init*/
|
|
// //stMessageBuf.arg1 = SF_WIFI_CMD_START;
|
|
// //stMessageBuf.cmdId = CMD_WIFI;
|
|
// //sf_com_message_send_to_cardv(&stMessageBuf);
|
|
// sf_cardv_wifi_start();
|
|
// //Ux_SendEvent(0, NVTEVT_EXE_WIFI_START, 0);
|
|
// //sleep(2);
|
|
// //sf_apinfo_thread_init();
|
|
// }
|
|
break;
|
|
case SF_MCU_CMD_MCU_RTC:
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return SF_SUCCESS;
|
|
}
|
|
|
|
static SINT32 sf_cardv_proccess_cmd_key(SF_MESSAGE_BUF_S *pMessageBuf)
|
|
{
|
|
//printf("[%s:%d] ID = %#x\n", __FUNCTION__, __LINE__,pMessageBuf->arg1);
|
|
//SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
MLOGI("ID = %#x\n",pMessageBuf->arg1);
|
|
switch(pMessageBuf->arg1)
|
|
{
|
|
case SF_EVENT_KEY_SHORT_CLICK:
|
|
if(SF_KEY_PIN_DATAREADY == pMessageBuf->arg2)
|
|
{
|
|
sf_mcu_dataready_ck(pMessageBuf->arg3);
|
|
}else if(SF_KEY_PIN_AOTU_MODE_POWOFF == pMessageBuf->arg2)
|
|
{
|
|
Ux_PostEvent(NVTEVT_SYSTEM_SHUTDOWN, 1, 0); //shutdown start
|
|
}
|
|
break;
|
|
case SF_EVENT_KEY_TEST:
|
|
sf_do_upgrade_thread();//update
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return SF_SUCCESS;
|
|
}
|
|
|
|
static SINT32 sf_cardv_proccess_cmd_para_update(SF_MESSAGE_BUF_S *pMessageBuf)
|
|
{
|
|
//UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
//printf("[%s:%d] ID = %#x\n", __FUNCTION__, __LINE__,pMessageBuf->arg1);
|
|
MLOGI("ID = %#x\n",pMessageBuf->arg1);
|
|
switch(pMessageBuf->arg1)
|
|
{
|
|
case SF_PARA_CMD_UPDATE:
|
|
//MLOGI("NeedTimeSyncStartUp = %d\n",puiPara->NeedTimeSyncStartUp);
|
|
sf_set_ui_para_flag(1);
|
|
sf_share_mem_customer_update();
|
|
//MLOGI("NeedTimeSyncStartUp = %d\n",puiPara->NeedTimeSyncStartUp);
|
|
break;
|
|
case SF_PARA_CMD_RESET:
|
|
Reset_MenuInfo();
|
|
break;
|
|
case SF_PARA_CMD_FWUP:
|
|
FwUpdate = pMessageBuf->arg2;
|
|
break;
|
|
case SF_PARA_CMD_MOUP:
|
|
ModuleUpdating = pMessageBuf->arg2;
|
|
break;
|
|
case SF_PARA_CMD_NET_STATUS:
|
|
sf_cardv_4G_status_set(pMessageBuf->arg2);
|
|
break;
|
|
case SF_PARA_CMD_WAIT:
|
|
sf_cardv_set_wait_shared_condition(0);
|
|
break;
|
|
case SF_PARA_CMD_SIG:
|
|
sf_cardv_para_signaling_start();
|
|
break;
|
|
case SF_PARA_CMD_BLE:
|
|
sf_set_ble_status(pMessageBuf->arg2);
|
|
break;
|
|
case SF_PARA_CMD_SIMISINSERT:
|
|
sf_cardv_set_sim_insert(pMessageBuf->arg2);
|
|
break;
|
|
case SF_PARA_CMD_ISESIM:
|
|
sf_cardv_set_is_esim(pMessageBuf->arg2);
|
|
break;
|
|
case SF_PARA_CMD_USB_INIT:
|
|
sf_cardv_set_usb_init(pMessageBuf->arg2);
|
|
break;
|
|
case SF_PARA_CMD_GPS_STATUS:
|
|
sf_cardv_set_gps_status(pMessageBuf->arg2);
|
|
break;
|
|
case SF_PARA_CMD_FTP_CONNECT_STATUS:
|
|
sf_cardv_set_ftp_status(pMessageBuf->arg2);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return SF_SUCCESS;
|
|
}
|
|
|
|
|
|
static SINT32 sf_cardv_proccess_cmd_gprs(SF_MESSAGE_BUF_S *pMessageBuf)
|
|
{
|
|
MLOGI("ID = %#x\n",pMessageBuf->arg1);
|
|
switch(pMessageBuf->arg1)
|
|
{
|
|
case SF_GPRS_CMD_SIGNAL:
|
|
cq_Signal = pMessageBuf->arg2;
|
|
sf_set_net_generation(pMessageBuf->arg3 & 0xFF);
|
|
sf_cardv_set_sim_insert((pMessageBuf->arg3>>16)&0x0F);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return SF_SUCCESS;
|
|
}
|
|
|
|
static SINT32 sf_cardv_proccess_cmd_wifi(SF_MESSAGE_BUF_S *pMessageBuf)
|
|
{
|
|
MLOGI("ID = %#x\n",pMessageBuf->arg1);
|
|
switch(pMessageBuf->arg1)
|
|
{
|
|
case SF_WIFI_CMD_START:
|
|
//if((0 == sf_get_mcu_update_flag()) && (0 == sf_get_fw_update()) && (sf_get_mode_flag()))
|
|
sf_cardv_wifi_start();
|
|
break;
|
|
|
|
case SF_WIFI_CMD_STOP:
|
|
ImageApp_Common_RtspStop(0);
|
|
break;
|
|
|
|
case SF_WIFI_CMD_RESTART:
|
|
ImageApp_Common_RtspStart(0);
|
|
break;
|
|
case SF_WIFI_CMD_CAPTURE:
|
|
sf_cardv_cap_start();
|
|
break;
|
|
case SF_WIFI_CMD_HD_TURE:
|
|
sf_cardv_hd_cap_start();
|
|
break;
|
|
|
|
case SF_WIFI_CMD_SEND:
|
|
sf_cardv_wifi_send();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return SF_SUCCESS;
|
|
}
|
|
|
|
static SINT32 sf_cardv_proccess_cmd_file(SF_MESSAGE_BUF_S *pMessageBuf)
|
|
{
|
|
//printf("[%s:%d] ID = %#x\n", __FUNCTION__, __LINE__,pMessageBuf->arg1);
|
|
//UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
MLOGI("ID = %#x\n",pMessageBuf->arg1);
|
|
switch(pMessageBuf->arg1)
|
|
{
|
|
case SF_PARA_CMD_UPDATE:
|
|
sf_share_mem_file_init();
|
|
sf_set_send_statu(FALSE);
|
|
#define SEND_SUCCEED 0
|
|
#define SEND_FAILED -1
|
|
sf_ui_sending_show(SEND_SUCCEED == pMessageBuf->arg2 ? FILE_SENDING_GUI_SEND_SUCCEED : FILE_SENDING_GUI_SEND_FAILED);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return SF_SUCCESS;
|
|
}
|
|
|
|
static SINT32 sf_cardv_proccess_cmd_dev(SF_MESSAGE_BUF_S *pMessageBuf)
|
|
{
|
|
//printf("[%s:%d] ID = %#x\n", __FUNCTION__, __LINE__,pMessageBuf->arg1);
|
|
if(pMessageBuf->arg1 != SF_DEV_CMD_TEMPER)
|
|
{
|
|
MLOGI("ID = %#x\n",pMessageBuf->arg1);
|
|
}
|
|
//SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
switch(pMessageBuf->arg1)
|
|
{
|
|
case SF_DEV_CMD_TEMPER:
|
|
cTemper = pMessageBuf->arg2;
|
|
fTemper = pMessageBuf->arg3;
|
|
//MLOGI("cTemper:%d fTemper:%d\n",cTemper,fTemper);
|
|
|
|
break;
|
|
case SF_DEV_CMD_BAT:
|
|
batteryVal = pMessageBuf->arg2;
|
|
batteryType = (pMessageBuf->arg3>>16)&0x0F;//pMessageBuf->arg3 & 0xf0;
|
|
powerVal = pMessageBuf->arg3 & 0xFF;
|
|
sf_cardv_battery_level_update(batteryVal);
|
|
MLOGI("batteryVal:%d batteryType:%d powerVal:%d p:%d\n",batteryVal, batteryType, powerVal,pMessageBuf->arg3);
|
|
|
|
break;
|
|
case SF_DEV_CMD_ESIM_OPERATION_SELECT_RESP:
|
|
sf_cardv_set_operationSelectResp(pMessageBuf->arg2);
|
|
MLOGI("operationSelectResp:%d\n", pMessageBuf->arg2);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return SF_SUCCESS;
|
|
}
|
|
static SINT32 sf_cardv_proccess_cmd_sd(SF_MESSAGE_BUF_S *pMessageBuf)
|
|
{
|
|
UINT32 ret = 0;
|
|
|
|
MLOGI("ID = %#x\n",pMessageBuf->arg1);
|
|
|
|
switch(pMessageBuf->arg1)
|
|
{
|
|
case CMD_SD_FORMAT:
|
|
sf_set_card_statu(CMD_FORMAT_SD_STA);
|
|
if(pMessageBuf->arg2 == 1)
|
|
{
|
|
BKG_PostEvent(NVTEVT_BKW_FORMAT_EMMC);
|
|
}
|
|
else
|
|
{
|
|
BKG_PostEvent(NVTEVT_BKW_FORMAT_CARD);
|
|
}
|
|
|
|
while(CMD_FORMAT_SD_STA == sf_get_card_statu())
|
|
{
|
|
usleep(10*1000);
|
|
}
|
|
ret = sf_get_card_statu();
|
|
MLOGI("FORMAT_CARD ret:%d\n",ret);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return SF_SUCCESS;
|
|
}
|
|
static SINT32 sf_cardv_proccess_cmd_poweroff(SF_MESSAGE_BUF_S *pMessageBuf)
|
|
{
|
|
//UINT32 ret = 0;
|
|
|
|
//MLOGI("ID = %#x\n",pMessageBuf->arg1);
|
|
|
|
Ux_PostEvent(NVTEVT_SYSTEM_SHUTDOWN, 1, pMessageBuf->arg1); //shutdown start
|
|
/*switch(pMessageBuf->arg1)
|
|
{
|
|
case APP_POWER_OFF_BATT_EMPTY:
|
|
|
|
break;
|
|
default:
|
|
break;
|
|
}*/
|
|
return SF_SUCCESS;
|
|
}
|
|
void* sf_cardv_message_thread(void *argv)
|
|
{
|
|
SINT32 ret = 0;
|
|
SF_MESSAGE_BUF_S stMessagebuf = {0};
|
|
while(1)
|
|
{
|
|
ret = sf_com_message_recv_from_cardv(&stMessagebuf);
|
|
if(ret !=SF_SUCCESS)
|
|
{
|
|
usleep(5*1000);
|
|
continue;
|
|
}
|
|
if((CMD_DEV != stMessagebuf.cmdId) && (CMD_MCU != stMessagebuf.cmdId))
|
|
{
|
|
MLOGI("cmdId:[%#x,%s]\n",stMessagebuf.cmdId,sf_process_message_getstatusstring(stMessagebuf.cmdId));
|
|
}
|
|
//printf("[%s:%d]cmdId:%#x,paramBuf[%d]\n", __FUNCTION__, __LINE__,stMessagebuf.cmdId,stMessagebuf.arg1);
|
|
switch(stMessagebuf.cmdId)
|
|
{
|
|
case CMD_MCU:
|
|
sf_cardv_proccess_cmd_mcu(&stMessagebuf);
|
|
break;
|
|
case CMD_KEY:
|
|
sf_cardv_proccess_cmd_key(&stMessagebuf);
|
|
break;
|
|
case CMD_PARA:
|
|
sf_cardv_proccess_cmd_para_update(&stMessagebuf);
|
|
break;
|
|
case CMD_GPRS:
|
|
sf_cardv_proccess_cmd_gprs(&stMessagebuf);
|
|
break;
|
|
case CMD_FILE:
|
|
sf_cardv_proccess_cmd_file(&stMessagebuf);
|
|
break;
|
|
case CMD_WIFI:
|
|
sf_cardv_proccess_cmd_wifi(&stMessagebuf);
|
|
break;
|
|
case CMD_DEV:
|
|
sf_cardv_proccess_cmd_dev(&stMessagebuf);
|
|
break;
|
|
case CMD_SD:
|
|
sf_cardv_proccess_cmd_sd(&stMessagebuf);
|
|
break;
|
|
case CMD_POWEROFF:
|
|
sf_cardv_proccess_cmd_poweroff(&stMessagebuf);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void sf_cardv_message_thread_init(void)
|
|
{
|
|
signed int s32Ret = 0;
|
|
pthread_t cardv_tStartUpThread = 0;
|
|
s32Ret = pthread_create(&cardv_tStartUpThread, NULL, sf_cardv_message_thread, NULL);
|
|
if (0 != s32Ret)
|
|
{
|
|
printf("%s:%d thread create failed\n", __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void sf_set_menu_open(BOOL is)
|
|
{
|
|
IsMenu = is;
|
|
}
|
|
|
|
BOOL sf_is_menu_open(void)
|
|
{
|
|
//printf("[%s]:%d IsMenu:%d\n", __FUNCTION__, __LINE__, IsMenu);
|
|
return IsMenu;
|
|
|
|
}
|
|
void sf_set_cap_statu(BOOL is)
|
|
{
|
|
IsCap = is;
|
|
//printf("[%s]:%d IsCap:%d\n", __FUNCTION__, __LINE__,IsCap);
|
|
}
|
|
|
|
BOOL sf_get_cap_statu(void)
|
|
{
|
|
//printf("[%s]:%d IsCap:%d\n", __FUNCTION__, __LINE__,IsCap);
|
|
return IsCap;
|
|
|
|
}
|
|
|
|
BOOL sf_is_movie_running(void)
|
|
{
|
|
if(ImageApp_MovieMulti_IsStreamRunning(_CFG_REC_ID_1))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
if(ImageApp_MovieMulti_IsStreamRunning(_CFG_CLONE_ID_1))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
//printf("[%s]:%d IsCardFull:%d\n", __FUNCTION__, __LINE__, IsCardFull);
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
BOOL sf_is_movie_preview(void)
|
|
{
|
|
if(FALSE == sf_is_movie_running() && (FALSE == sf_is_menu_open()) && (System_GetState(SYS_STATE_CURRMODE) == PRIMARY_MODE_MOVIE))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
//printf("[%s]:%d IsCardFull:%d\n", __FUNCTION__, __LINE__, IsCardFull);
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
BOOL sf_is_cap_preview(void)
|
|
{
|
|
if(FALSE == sf_get_cap_statu() && (FALSE == sf_is_menu_open()) && (System_GetState(SYS_STATE_CURRMODE) == PRIMARY_MODE_PHOTO))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
//printf("[%s]:%d IsCardFull:%d\n", __FUNCTION__, __LINE__, IsCardFull);
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
BOOL sf_is_preview(void)
|
|
{
|
|
if(TRUE == sf_is_cap_preview() || (TRUE == sf_is_movie_preview()))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
//printf("[%s]:%d IsCardFull:%d\n", __FUNCTION__, __LINE__, IsCardFull);
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
void sf_set_send_statu(BOOL is)
|
|
{
|
|
IsSend = is;
|
|
if (TRUE == is)
|
|
{
|
|
sf_ui_sending_show(FILE_SENDING_GUI_START_SENDING);
|
|
}
|
|
else
|
|
{
|
|
sf_ui_sending_show(FILE_SENDING_GUI_STOP_SENDING);
|
|
}
|
|
printf("[%s]:%d IsSend:%d\n", __FUNCTION__, __LINE__,IsSend);
|
|
}
|
|
void sf_ui_sending_show(unsigned short status)
|
|
{
|
|
// #define GUI_SHOW_SENDING 1
|
|
// if (TRUE == is)
|
|
{
|
|
Ux_PostEvent(NVT_SIFAR_MSG_SCREEN, 1, status);
|
|
// Ux_PostEvent(NVTEVT_CB_ZOOM, 1, status);
|
|
}
|
|
}
|
|
|
|
BOOL sf_get_send_statu(void)
|
|
{
|
|
// printf("[%s]:%d IsSend:%d\n", __FUNCTION__, __LINE__,IsSend);
|
|
return IsSend;
|
|
|
|
}
|
|
|
|
void sf_cardv_set_mcu_rtc_flag(void)
|
|
{
|
|
SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
stMessageBuf.arg1 = SF_MCU_CMD_MCU_RTC;
|
|
stMessageBuf.cmdId = CMD_MCU;
|
|
sf_com_message_send_to_app(&stMessageBuf);
|
|
}
|
|
|
|
void sf_hd_flag_init(void)
|
|
{
|
|
vos_flag_create(&sf_hd_flag_id, NULL, "sf_hd_flag_id");
|
|
vos_flag_clr(sf_hd_flag_id, (FLGPTN)-1);
|
|
}
|
|
|
|
void sf_hd_flag_set_done(HD_FLAG_INIT flag)
|
|
{
|
|
vos_flag_set(sf_hd_flag_id, (FLGPTN)(1 << flag));
|
|
}
|
|
|
|
void sf_hd_flag_wait_done(HD_FLAG_INIT flag)
|
|
{
|
|
FLGPTN flgptn;
|
|
vos_flag_wait(&flgptn, sf_hd_flag_id, (FLGPTN)(1 << flag), TWF_ANDW);
|
|
}
|
|
|
|
int sf_hd_flag_wait_done_timeout(HD_FLAG_INIT flag, int timeout_ms)
|
|
{
|
|
ER ret = E_OK;
|
|
FLGPTN flgptn;
|
|
|
|
ret = vos_flag_wait_timeout(&flgptn, sf_hd_flag_id, (FLGPTN)(1 << flag), TWF_ANDW, vos_util_msec_to_tick(timeout_ms));
|
|
if(unlikely(ret != E_OK)){
|
|
DBG_ERR("wait(%lu) init timeout(%ld ms)!\n", flag, timeout_ms);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void sf_hd_flag_clear_done(HD_FLAG_INIT flag)
|
|
{
|
|
vos_flag_clr(sf_hd_flag_id, (FLGPTN)-1);
|
|
}
|
|
|
|
#if !SF_UBOOT_UPDATA_FW
|
|
|
|
static UINT32 sf_fwupdate(void)
|
|
{
|
|
DBG_FUNC_BEGIN("\r\n");
|
|
|
|
UINT32 result = 0;
|
|
|
|
INT curMode = System_GetState(SYS_STATE_CURRMODE) ;
|
|
|
|
System_ChangeSubMode(SYS_SUBMODE_UPDFW);
|
|
Ux_SendEvent(0, NVTEVT_SYSTEM_MODE, 1, PRIMARY_MODE_UPDFW);
|
|
|
|
result = System_OnStrg_UploadFW(0);
|
|
if (result != 0)
|
|
DBG_ERR("System_OnStrg_UploadFW() fail(%d)\r\n",result);
|
|
|
|
if (result != 0) {
|
|
Ux_SendEvent(0, NVTEVT_SYSTEM_MODE, 1, curMode);
|
|
System_ChangeSubMode(SYS_SUBMODE_NORMAL);
|
|
|
|
}
|
|
|
|
DBG_FUNC_END("\r\n");
|
|
return result;
|
|
}
|
|
#else
|
|
BOOL sf_ota_trigger(void)
|
|
{
|
|
UINT32 uiUserData = 0;
|
|
char cmd[128]={0};
|
|
|
|
if((PWR_ON_SETUP == sf_cardv_convert_power_on_mode()))
|
|
{
|
|
uiUserData = WDT_OTA_MAKEFOURCC(WDT_OTA_STS_LINUX_TRIGGER);
|
|
}
|
|
else {
|
|
uiUserData = WDT_OTA_MAKEFOURCC(WDT_OTA_STS_LINUX_TRIGGER_AUTO);
|
|
}
|
|
Ux_PostEvent(NVTEVT_ALGMSG_FOCUSEND, 0);
|
|
|
|
sprintf(cmd, "mem w %x %lx",WDT_REG_ADDR(WDT_DATA_OFS),uiUserData);
|
|
system(cmd);
|
|
system("watchdog -T 1 -t 5 /dev/watchdog");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_ota_result(void)
|
|
{
|
|
|
|
system("devmem 0xF0050084 32 > /tmp/ota_sts");
|
|
|
|
FILE* fd = fopen("/tmp/ota_sts", "r");
|
|
char buf[16];
|
|
UINT32 ota_mask = 0x00FFFFFF; /* mask status */
|
|
UINT32 ota_prefix = WDT_OTA_MAKEFOURCC(WDT_OTA_STS_UBOOT_UPDATE_OK) & ota_mask; /* OTA */
|
|
|
|
if(fd){
|
|
|
|
buf[11] = '\0';
|
|
fread(buf, 10, 1, fd);
|
|
DBG_DUMP("ota_sts_str = %s\n", buf);
|
|
|
|
UINT32 ota_sts = strtoul(buf, NULL, 16);
|
|
|
|
DBG_DUMP("ota_sts = %08X , masked = %08X\n", ota_sts, ota_sts & ota_mask);
|
|
|
|
/* OTA success */
|
|
if(ota_sts == WDT_OTA_MAKEFOURCC(WDT_OTA_STS_UBOOT_UPDATE_OK)){
|
|
DBG_DUMP("update ok!\n");
|
|
sf_mcu_reg_set(SF_MCU_SOFT_UPDATE, 0);
|
|
sf_set_send_statu(FALSE);
|
|
}
|
|
/* not OTA */
|
|
else if(ota_sts == 0x0){
|
|
DBG_DUMP("not ota\n");
|
|
}
|
|
/* OTA wrong status */
|
|
else if ((ota_sts & ota_mask) == ota_prefix){
|
|
DBG_DUMP("ota error!\n");
|
|
sf_sys_status_led_set(SF_LED_SYS_STATE_ERROR);
|
|
sf_mcu_reg_set(SF_MCU_SOFT_UPDATE, 0);
|
|
sf_set_send_statu(FALSE);
|
|
vos_util_delay_ms(1000);
|
|
}
|
|
|
|
|
|
}
|
|
else{
|
|
DBG_ERR("/tmp/ota_sts not found!\n");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
int sf_ch_fw_file(void)
|
|
{
|
|
FST_FILE hFile = NULL;
|
|
|
|
hFile = FileSys_OpenFile(FW_UPDATE_NAME, FST_OPEN_READ);
|
|
|
|
if (hFile == 0) {
|
|
SLOGE("cannot find %s\r\n", FW_UPDATE_NAME);
|
|
return 0;
|
|
}
|
|
FileSys_CloseFile(hFile);
|
|
return 1;
|
|
}
|
|
void* sf_sys_do_upgrade(void *arg)
|
|
{
|
|
//int s32Ret = 0;
|
|
#if !SF_UBOOT_UPDATA_FW
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
#endif
|
|
SLOGW("Begin to do Upgrade!\n");
|
|
|
|
//if(sf_is_enough_power_to_update() == FALSE)
|
|
if(sf_cardv_battery_value_get() < 40){
|
|
sf_sys_status_led_set(SF_LED_SYS_STATE_ERROR);
|
|
}
|
|
// else if(0 == sf_ch_fw_file()){
|
|
// sf_set_fw_update(0);
|
|
// }
|
|
else{
|
|
sf_mcu_reg_set(SF_MCU_SOFT_UPDATE, 1);
|
|
//sf_set_fw_update(1);
|
|
sf_set_send_statu(TRUE);
|
|
sf_sys_status_led_set(SF_LED_SYS_STATE_UPDATE);
|
|
vos_util_delay_ms(500);
|
|
|
|
#if SF_UBOOT_UPDATA_FW
|
|
sf_ota_trigger();
|
|
#else
|
|
//BKG_PostEvent(NVTEVT_BKW_FW_UPDATE);
|
|
if(0 != sf_fwupdate()){
|
|
sf_sys_status_led_set(SF_LED_SYS_STATE_ERROR);
|
|
}
|
|
else {
|
|
//SysResetFlag();
|
|
puiPara->OtaFlag = 1;
|
|
Save_MenuInfo();
|
|
//sync();
|
|
}
|
|
|
|
sf_mcu_reg_set(SF_MCU_SOFT_UPDATE, 0);
|
|
sf_set_send_statu(FALSE);
|
|
//if(PWR_ON_SETUP == sf_cardv_convert_power_on_mode())
|
|
{
|
|
vos_util_delay_ms(1000);
|
|
Ux_PostEvent(NVTEVT_SYSTEM_SHUTDOWN, 1, 0);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
//sf_set_fw_update(0);
|
|
UpgradeTskParam.IsRun = 2;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void sf_do_upgrade_thread(void)
|
|
{
|
|
printf("UpgradeTskParam.IsRun:%d\n", UpgradeTskParam.IsRun);
|
|
if(UpgradeTskParam.IsRun == 2)
|
|
{
|
|
UpgradeTskParam.IsRun = 0;
|
|
pthread_join(UpgradeTskParam.TskId, NULL);
|
|
}
|
|
|
|
if(!UpgradeTskParam.IsRun)
|
|
{
|
|
pthread_create(&UpgradeTskParam.TskId, NULL, sf_sys_do_upgrade, NULL);
|
|
UpgradeTskParam.IsRun = 1;
|
|
}
|
|
}
|
|
|
|
|
|
void* sf_cardv_para_signaling_thread(void* arg)
|
|
{
|
|
pthread_mutex_lock(&Param_mutexLock);
|
|
|
|
// Modify the status that meets the conditions
|
|
shared_condition = 1;
|
|
|
|
// Wake up waiting threads
|
|
pthread_cond_signal(&condition);
|
|
|
|
pthread_mutex_unlock(&Param_mutexLock);
|
|
WaiParaTskCfg.IsRun = 0;
|
|
pthread_exit(NULL);
|
|
}
|
|
|
|
int sf_cardv_para_signaling_start(void)
|
|
{
|
|
int ret = SF_FAILURE;
|
|
if(WaiParaTskCfg.IsRun)
|
|
{
|
|
SLOGE("thread has already run !!!\n");
|
|
return SF_FAILURE;
|
|
}
|
|
SLOGI("thread run\n");
|
|
ret = pthread_create(&WaiParaTskCfg.TskId, NULL, sf_cardv_para_signaling_thread, NULL);
|
|
if(ret != SF_SUCCESS)
|
|
{
|
|
MLOGD("thread creat fail!\n");
|
|
return ret;
|
|
}
|
|
return SF_SUCCESS;
|
|
}
|
|
|
|
void sf_cardv_set_wait_shared_condition(int in)
|
|
{
|
|
shared_condition = in;
|
|
SLOGI("shared_condition:%d\n", shared_condition);
|
|
}
|
|
|
|
|
|
void* sf_cardv_para_check_thread(void *arg)
|
|
{
|
|
SLOGI("thread run\n");
|
|
ParaTskCfg.IsRun = 1;
|
|
while(ParaTskCfg.IsRun)
|
|
{
|
|
if(TRUE == sf_get_cardv_para_check_flag()){
|
|
MLOGI("menu info is changed\n");
|
|
sf_share_mem_customer_down(0);
|
|
}
|
|
//sleep(1);
|
|
vos_util_delay_ms(10);
|
|
|
|
}
|
|
SLOGI("thread end\n");
|
|
|
|
ParaTskCfg.IsRun = 0;
|
|
|
|
return NULL;
|
|
}
|
|
UINT32 sf_cardv_para_check_start(void)
|
|
{
|
|
SINT32 ret = 1;
|
|
if(ParaTskCfg.IsRun)
|
|
{
|
|
SLOGE("thread has already run !!!\n");
|
|
return 1;
|
|
}
|
|
pthread_cond_init(&condition, NULL);
|
|
ret = pthread_create(&ParaTskCfg.TskId, NULL, sf_cardv_para_check_thread, NULL);
|
|
if(ret != SF_SUCCESS)
|
|
{
|
|
MLOGD("thread creat fail!\n");
|
|
return ret;
|
|
}
|
|
return SF_SUCCESS;
|
|
|
|
}
|
|
UINT32 sf_cardv_para_check_stop(void)
|
|
{
|
|
SINT32 ret = 1;
|
|
MLOGD("stop\n");
|
|
if(0 == ParaTskCfg.IsRun){
|
|
return SF_SUCCESS;
|
|
}
|
|
|
|
ParaTskCfg.IsRun = 0;
|
|
MLOGD("sf_flash_poweroff_stop\n");
|
|
|
|
if(TRUE == sf_get_cardv_para_check_flag()){
|
|
MLOGI("menu info is changed\n");
|
|
sf_share_mem_customer_down(0);
|
|
}
|
|
|
|
ret = pthread_join(ParaTskCfg.TskId, NULL);
|
|
if(ret != SF_SUCCESS)
|
|
{
|
|
MLOGD("thread stop fail!\n");
|
|
return ret;
|
|
}
|
|
return SF_SUCCESS;
|
|
}
|
|
UINT8 sf_get_night_led_flag(void)
|
|
{
|
|
return IsNightLedOn;
|
|
}
|
|
|
|
void sf_set_night_led_flag(UINT8 flag)
|
|
{
|
|
if(flag != IsNightLedOn){
|
|
#if HUNTING_CAMERA_4G == ENABLE
|
|
SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
stMessageBuf.arg2 = flag;
|
|
stMessageBuf.arg1 = SF_PARA_CMD_IR_LED_STATUS;
|
|
stMessageBuf.cmdId = CMD_PARA;
|
|
sf_com_message_send_to_app(&stMessageBuf);
|
|
#endif
|
|
}
|
|
IsNightLedOn = flag;
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_battery_level_update
|
|
Description: Get battery Voltage with Level.
|
|
Input: N/A
|
|
Output: N/A
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
void sf_cardv_battery_level_update(UINT8 batteryVal)
|
|
{
|
|
|
|
UINT8 batteryLevel = SF_BATT_LEVEL_0;
|
|
|
|
if(batteryVal >= 70)
|
|
{
|
|
batteryLevel = SF_BATT_LEVEL_4;
|
|
}
|
|
else if(batteryVal >= 40)
|
|
{
|
|
batteryLevel = SF_BATT_LEVEL_3;
|
|
}
|
|
else if(batteryVal >= 20)
|
|
{
|
|
batteryLevel = SF_BATT_LEVEL_2;
|
|
}
|
|
else if(batteryVal >= 1)
|
|
{
|
|
batteryLevel = SF_BATT_LEVEL_1;
|
|
}
|
|
else
|
|
{
|
|
batteryLevel = SF_BATT_LEVEL_0;
|
|
}
|
|
|
|
sf_LatestBattLevel = batteryLevel;
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_battery_level_get
|
|
Description: get battery level
|
|
Input: N/A
|
|
Output: N/A
|
|
Return: SUCCESS/FAIL
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT32 sf_cardv_battery_level_get(void)
|
|
{
|
|
return (UINT32)sf_LatestBattLevel;
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_battery_level_set
|
|
Description: set battery level
|
|
Input: N/A
|
|
Output: N/A
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
void sf_cardv_battery_level_set(UINT32 val)
|
|
{
|
|
sf_LatestBattLevel = val;
|
|
}
|
|
/*************************************************
|
|
Function: sf_battery_value_get
|
|
Description: get battery value x%
|
|
Input: nightMode or no
|
|
Output: N/A
|
|
Return: battery value x%
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT8 sf_cardv_battery_value_get(void)
|
|
{
|
|
return batteryVal;
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_battery_type_get
|
|
Description: Get battery type.
|
|
Input: N/A
|
|
Output: N/A
|
|
Return: value: battery type, 0:normal 1:LiPolymer
|
|
Others: N/A
|
|
*************************************************/
|
|
UINT8 sf_cardv_battery_type_get(void)
|
|
{
|
|
return batteryType;
|
|
}
|
|
|
|
/*************************************************
|
|
Function: sf_is_flash_voltage_abnormal
|
|
Description: Is it lower than the flash safe voltage
|
|
Input: N/A
|
|
Output: N/A
|
|
Return: TRUE/FALSE
|
|
Others: N/A
|
|
*************************************************/
|
|
BOOL sf_is_flash_voltage_abnormal(void)
|
|
{
|
|
|
|
printf("powerVal=%d batteryType=%d \n", powerVal, batteryType);
|
|
|
|
if((/*SF_POWER_TYPE_DC*/1 != batteryType) && (powerVal < 55) )
|
|
{
|
|
printf("low battery no write flash\n");
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void sf_4g_usb_remove(void)
|
|
{
|
|
SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
stMessageBuf.arg1 = SF_DEV_CMD_4G_USB_RM;
|
|
stMessageBuf.cmdId = CMD_DEV;
|
|
sf_com_message_send_to_app(&stMessageBuf);
|
|
vos_util_delay_ms(400);
|
|
}
|
|
|
|
void sf_stamp_temperature_get(INT16 *fTem,INT16 *cTem) /*0:F 1:C*/
|
|
{
|
|
*fTem = fTemper;
|
|
*cTem = cTemper;
|
|
}
|
|
|
|
BOOL sf_cmd_cardv_4g_usb_boot(unsigned char argc, char **argv)
|
|
{
|
|
printf("[%s:%d] s\n", __FUNCTION__, __LINE__);
|
|
gpio_direction_output(GPIO_4G_USB_BOOT, 1);
|
|
gpio_set_value(GPIO_4G_USB_BOOT, 1);
|
|
sf_mcu_reg_set(SF_MCU_RESET_MODULE, 0);
|
|
sleep(2);
|
|
printf("[%s:%d] e\n", __FUNCTION__, __LINE__);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_fs_ro_check(unsigned char argc, char **argv)
|
|
{
|
|
|
|
printf("read only = %llu\n", FileSys_GetDiskInfoEx('A', FST_INFO_IS_READ_ONLY));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_check_net_work_flag(void)
|
|
{
|
|
if((SF_4G_SENDING == NetWorkFlag/*SF_4G_SENDING*/) || (SF_4G_SEARCHING == NetWorkFlag/*SF_4G_SEARCHING*/)){
|
|
return TRUE;
|
|
}
|
|
else{
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
void sf_cardv_4G_status_set(UINT8 status)
|
|
{
|
|
NetWorkFlag = status;
|
|
// if((SF_4G_SENDING == NetWorkFlag) && (TRUE == sf_get_send_statu()))
|
|
// {
|
|
// sf_ui_sending_show(FILE_SENDING_GUI_START_SENDING);
|
|
// }
|
|
printf("cardv NetWorkFlag:%d\n",NetWorkFlag);
|
|
}
|
|
|
|
UINT8 sf_cardv_4G_status_get(void)
|
|
{
|
|
return NetWorkFlag;
|
|
}
|
|
|
|
void sf_cardv_set_sim_insert(INT8 sim)
|
|
{
|
|
simCardInsert = sim;
|
|
printf("cardv simCardInsert:%d\n",simCardInsert);
|
|
}
|
|
|
|
INT8 sf_cardv_get_sim_insert(void)
|
|
{
|
|
return simCardInsert;
|
|
}
|
|
|
|
void sf_cardv_set_is_esim(int flag)
|
|
{
|
|
g_esim_flag = flag;
|
|
printf("cardv g_esim_flag:%d\n",g_esim_flag);
|
|
}
|
|
|
|
INT8 sf_cardv_get_is_esim(void)
|
|
{
|
|
return g_esim_flag;
|
|
}
|
|
void sf_cardv_set_usb_init(int flag)
|
|
{
|
|
gModuleInitFlag = flag;
|
|
printf("cardv gModuleInitFlag:%d\n",gModuleInitFlag);
|
|
}
|
|
|
|
int sf_cardv_get_usb_init(void)
|
|
{
|
|
return gModuleInitFlag;
|
|
}
|
|
|
|
void sf_cardv_set_operationSelectResp(UINT8 resp)
|
|
{
|
|
operationSelectResp = resp;
|
|
}
|
|
|
|
UINT8 sf_cardv_get_operationSelectResp(void)
|
|
{
|
|
return operationSelectResp;
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
Function: sf_save_camera_info
|
|
Description: save camera info to sd
|
|
Input: N/A
|
|
Output: N/A
|
|
Return: N/A
|
|
Others: N/A
|
|
*************************************************/
|
|
void sf_save_camera_info(void)
|
|
{
|
|
#if 1
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
char *temp = NULL;
|
|
UINT8 localver[20] = {0}, mcuver[20] = {0};
|
|
//UINT8 imeibuff[20] = {0};
|
|
//UINT8 modulebuff[50] = {0};
|
|
//UINT8 SimICCID[33] = {0};
|
|
char wifissid[30] = {0};
|
|
static UINT8 fristRun = 1;
|
|
int fd = 0;
|
|
printf("[%s:%d] s\n", __FUNCTION__, __LINE__);
|
|
|
|
if(fristRun == 0)
|
|
return;
|
|
|
|
fristRun = 0;
|
|
temp = malloc(300);
|
|
if (temp == NULL) {
|
|
MLOGE("temp malloc err\n");
|
|
return;
|
|
}
|
|
|
|
strcpy((char *)localver, SF_BASE_VERSION);
|
|
|
|
sf_mcu_version_get(mcuver);
|
|
|
|
/*if(puiPara->ModuleImei[0] != '\0')
|
|
{
|
|
SF_STRCPY(imeibuff, puiPara->ModuleImei);
|
|
}
|
|
|
|
if(puiPara->ModuleSubver[0] != '\0')
|
|
{
|
|
SF_STRCPY(modulebuff, puiPara->ModuleSubver);
|
|
}
|
|
if(puiPara->SimIccid[0] != '\0')
|
|
{
|
|
SF_STRCPY(SimICCID, puiPara->SimIccid);
|
|
}*/
|
|
sf_get_wifi_ssid(wifissid);
|
|
|
|
snprintf(temp, 300, "IMEI:%s\r\nSoftwareVER:%s\r\nModuleVER:%s\r\nMcuVER:%s\r\nICCID:%s\r\nICCID-A:%s\r\nICCID-V:%s\r\nSSID:%s\r\nBLE:%s\r\n",
|
|
puiPara->ModuleImei, localver, puiPara->ModuleSubver, mcuver, puiPara->SimIccid, puiPara->SimIccidA, puiPara->SimIccidV, wifissid,puiPara->BluSsid);
|
|
|
|
if(access((char*)SF_CAMERA_INFO_FILENAME, F_OK) == 0)
|
|
{
|
|
system("rm -rf /mnt/sd/CAM_INFO.TXT");
|
|
system("sync");
|
|
//FileSys_DeleteFile();
|
|
}
|
|
fd = open(SF_CAMERA_INFO_FILENAME, O_WRONLY | O_CREAT);
|
|
if(fd)
|
|
{
|
|
lseek(fd, 0, SEEK_END);
|
|
write(fd, temp, strlen(temp));
|
|
close(fd);
|
|
system("sync");
|
|
}
|
|
free(temp);
|
|
|
|
printf("[%s:%d] e\n", __FUNCTION__, __LINE__);
|
|
|
|
#endif
|
|
}
|
|
|
|
void* sf_cardv_wifi_thread(void *arg)
|
|
{
|
|
/*wifi init*/
|
|
UINet_AppIpc_Init();
|
|
sf_net_wifi_init(NET_AP_MODE, NET_AUTH_WPA2);
|
|
WifiTskCfg.IsRun = 0;
|
|
return NULL;
|
|
}
|
|
|
|
UINT32 sf_cardv_wifi_start(void)
|
|
{
|
|
SINT32 ret = 1;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
SLOGI("thread run\n");
|
|
|
|
if((0 == sf_is_usb_flag()) && (0 == sf_get_mcu_update_flag()) && (0 == sf_get_fw_update()) && (sf_get_mode_flag()) && (puiPara->WifiSwitch))
|
|
{
|
|
if(WifiTskCfg.IsRun)
|
|
{
|
|
SLOGE("thread has already run !!!\n");
|
|
return 1;
|
|
}
|
|
ret = pthread_create(&WifiTskCfg.TskId, NULL, sf_cardv_wifi_thread, NULL);
|
|
if(ret != SF_SUCCESS)
|
|
{
|
|
MLOGD("thread creat fail!\n");
|
|
return ret;
|
|
}
|
|
WifiTskCfg.IsRun = 1;
|
|
return SF_SUCCESS;
|
|
}
|
|
SLOGI("WifiSwitch OFF\n");
|
|
return 1;
|
|
}
|
|
|
|
BOOL sf_cmd_disp_para_set(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value = 0;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
puiPara->x1 = value;
|
|
|
|
sscanf_s(argv[1],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
puiPara->x2 = value;
|
|
|
|
sscanf_s(argv[2],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
puiPara->x3 = value;
|
|
|
|
sscanf_s(argv[3],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
puiPara->x4 = value;
|
|
|
|
sscanf_s(argv[4],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
puiPara->x5 = value;
|
|
|
|
sscanf_s(argv[5],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
puiPara->x6 = value;
|
|
|
|
Save_MenuInfo();
|
|
printf("[%s:%d]disp para set:%d %d %d %d %d %d\n", __FUNCTION__, __LINE__, puiPara->x1, puiPara->x2, puiPara->x3, puiPara->x4, puiPara->x5, puiPara->x6);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL sf_cmd_ftp_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if(argc == 1)
|
|
{
|
|
sscanf_s(argv[0],"%d", &value);
|
|
if(value < SF_FTP_MAX)
|
|
{
|
|
puiPara->FtpSwitch = value;
|
|
Save_MenuInfo();
|
|
}
|
|
}
|
|
printf("[%s:%d] FtpSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->FtpSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
void* sf_cardv_cap_thread(void *arg)
|
|
{
|
|
if(PWR_ON_SETUP != sf_cardv_convert_power_on_mode()){
|
|
if(TRUE != sf_is_preview()){
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
int iCurrMode = System_GetState(SYS_STATE_CURRMODE);
|
|
int iNextMode = PRIMARY_MODE_PHOTO;
|
|
if((puiPara->CamMode == SF_CAM_MODE_PHOTO) || (puiPara->CamMode == SF_CAM_MODE_VIDEO2))
|
|
{
|
|
iNextMode = PRIMARY_MODE_PHOTO;
|
|
}
|
|
else if(puiPara->CamMode == SF_CAM_MODE_VIDEO)
|
|
{
|
|
iNextMode = PRIMARY_MODE_MOVIE;
|
|
}
|
|
else
|
|
{
|
|
iNextMode = PRIMARY_MODE_PHOTO;
|
|
}
|
|
UI_SetData(FL_PreMode, iCurrMode);
|
|
UI_SetData(FL_NextMode, iNextMode);
|
|
Ux_PostEvent(NVTEVT_SYSTEM_MODE, 1, iNextMode);
|
|
vos_util_delay_ms(1000);
|
|
}
|
|
}
|
|
|
|
FlowPhoto_DoCapture();
|
|
CapTskCfg.IsRun = 0;
|
|
return NULL;
|
|
}
|
|
|
|
UINT32 sf_cardv_cap_start(void)
|
|
{
|
|
SINT32 ret = 1;
|
|
if(CapTskCfg.IsRun)
|
|
{
|
|
SLOGE("thread has already run !!!\n");
|
|
return 1;
|
|
}
|
|
ret = pthread_create(&CapTskCfg.TskId, NULL, sf_cardv_cap_thread, NULL);
|
|
if(ret != SF_SUCCESS)
|
|
{
|
|
MLOGD("thread creat fail!\n");
|
|
return ret;
|
|
}
|
|
CapTskCfg.IsRun = 1;
|
|
return SF_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
void* sf_cardv_hd_cap_thread(void *arg)
|
|
{
|
|
UINT8 PowerOnMode = sf_cardv_convert_power_on_mode();
|
|
MLOGD(" HD start PowerOnMode:%d\n", PowerOnMode);
|
|
|
|
if((PWR_ON_SMS == PowerOnMode) || (PWR_ON_TIME_SYNC == PowerOnMode))
|
|
{
|
|
//if(TRUE != sf_is_preview())
|
|
{
|
|
if(!hdFlagInit)
|
|
{
|
|
hdFlagInit = 1;
|
|
sf_hd_flag_init();
|
|
}
|
|
char *arg[2] = { 0 };
|
|
char *str = malloc(64);
|
|
if(NULL != str)
|
|
{
|
|
if(SF_SUCCESS == sf_share_mem_hd_update())
|
|
{
|
|
SF_HDFILE_ATTR_S* fileCfg = sf_file_hd_cfg_get();
|
|
|
|
UINT8 fileIndex = 0;
|
|
|
|
for(fileIndex = 0; fileIndex < fileCfg->filecnt; fileIndex++)
|
|
{
|
|
//HdflieName
|
|
memset(HdflieName, '\0', sizeof(HdflieName));
|
|
sf_hd_flag_clear_done(0);
|
|
if(fileCfg->stfileattr[fileIndex].storage == 1)
|
|
{
|
|
snprintf(HdflieName, sizeof(HdflieName), "%s%c%03d%04d.JPG", SF_HD_DIR_CARDV, (SF_SD_DCF_HANDLE), fileCfg->stfileattr[fileIndex].dirKey, fileCfg->stfileattr[fileIndex].fileKey);
|
|
snprintf(str, 64, "A:\\DCIM\\%03d%s\\%s%04d.JPG", fileCfg->stfileattr[fileIndex].dirKey, DCF_DIR_NAME, SF_SD_DCF_FILE_NAME, fileCfg->stfileattr[fileIndex].fileKey);
|
|
}
|
|
else {
|
|
snprintf(HdflieName, sizeof(HdflieName), "%s%c%03d%04d.JPG", SF_HD_DIR_EMMC , (SF_EMMC_DCF_HANDLE), fileCfg->stfileattr[fileIndex].dirKey, fileCfg->stfileattr[fileIndex].fileKey);
|
|
snprintf(str, 64, "B:\\DCIM\\%03d%s\\%s%04d.JPG", fileCfg->stfileattr[fileIndex].dirKey, DCF_DIR_NAME, SF_EMMC_DCF_FILE_NAME, fileCfg->stfileattr[fileIndex].fileKey);
|
|
}
|
|
printf("flie:%s HdflieName:%s\n", str, HdflieName);
|
|
arg[0] = str;
|
|
sf_cmd_transcode_start(arg);
|
|
if(sf_hd_flag_wait_done_timeout(HD_FLAG_INITT_OK, 5000))
|
|
{
|
|
MLOGE("HD timeout\n");
|
|
//return - 1;
|
|
}
|
|
}
|
|
}
|
|
free(str);
|
|
}
|
|
sf_share_mem_hd_down(0);
|
|
}
|
|
}
|
|
MLOGD(" HD end\n");
|
|
|
|
HdCapTskCfg.IsRun = 0;
|
|
return NULL;
|
|
}
|
|
|
|
UINT32 sf_cardv_hd_cap_start(void)
|
|
{
|
|
SINT32 ret = 1;
|
|
MLOGD(" HD start\n");
|
|
if(HdCapTskCfg.IsRun)
|
|
{
|
|
SLOGE("thread has already run !!!\n");
|
|
return 1;
|
|
}
|
|
ret = pthread_create(&HdCapTskCfg.TskId, NULL, sf_cardv_hd_cap_thread, NULL);
|
|
if(ret != SF_SUCCESS)
|
|
{
|
|
MLOGD("thread creat fail!\n");
|
|
return ret;
|
|
}
|
|
HdCapTskCfg.IsRun = 1;
|
|
return SF_SUCCESS;
|
|
}
|
|
|
|
UINT32 sf_cardv_wifi_send(void)
|
|
{
|
|
SINT32 fd = 0;
|
|
SINT32 sendBuffLen = 0;
|
|
SINT8 sendBuff[1024] = { 0 };
|
|
SINT32 i = 0;
|
|
struct stat statBuf;
|
|
|
|
if(SF_SUCCESS == sf_share_mem_hd_update())
|
|
{
|
|
//SF_REPORT_WIFI_ATTR_S* wifiCfg = sf_wifi_cfg_get();
|
|
fd = sf_get_wifi_socket();
|
|
|
|
SF_CHAR filePath[64] = { 0 };
|
|
SINT32 fdWifi = -1;
|
|
sprintf(filePath, "/tmp/wifiData.txt");
|
|
printf("filePath:%s\n", filePath);
|
|
|
|
fdWifi = open(filePath, O_RDWR, 0777);
|
|
if(fdWifi >= 0)
|
|
{
|
|
fstat(fdWifi, &statBuf);
|
|
sendBuffLen = statBuf.st_size;
|
|
printf("fSize=%d\n", sendBuffLen);
|
|
read(fdWifi, sendBuff, sendBuffLen);
|
|
close(fdWifi);
|
|
|
|
for(i = 0; i < sendBuffLen; i++)
|
|
{
|
|
printf("[%x]-", sendBuff[i]);
|
|
}
|
|
printf("\n[cardv-sendBuff-1] e\n");
|
|
|
|
send(fd, sendBuff, sendBuffLen, 0);
|
|
remove("/tmp/wifiData.txt");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
UINT8 sf_get_ui_para_flag(void)
|
|
{
|
|
return UiparaFlag;
|
|
}
|
|
|
|
void sf_set_ui_para_flag(UINT8 flag)
|
|
{
|
|
UiparaFlag = flag;
|
|
}
|
|
|
|
void sf_set_debug_mode(void)
|
|
{
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
|
|
if(1 == puiPara->DebugMode)
|
|
{
|
|
puiPara->DebugMode = 0;
|
|
sf_sys_status_led_set(SF_LED_SYS_STATE_DEBUG_OFF);
|
|
}
|
|
else
|
|
{
|
|
puiPara->DebugMode = 1;
|
|
sf_sys_status_led_set(SF_LED_SYS_STATE_DEBUG_ON);
|
|
}
|
|
}
|
|
|
|
BOOL sf_cmd_para_printf(unsigned char argc, char **argv)
|
|
{
|
|
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
MLOGD(" s\n");
|
|
|
|
printf("OtaFlag:%d\n", puiPara->OtaFlag);
|
|
printf("strMakerString:%s\n", puiPara->strMakerString);
|
|
printf("strModelString:%s\n", puiPara->strModelString);
|
|
printf("strSoftwareVer:%s\n", puiPara->strSoftwareVer);
|
|
printf("strMakeNote:%s\n", puiPara->strMakeNote);
|
|
printf("strImageDescription:%s\n", puiPara->strImageDescription);
|
|
printf("uhInfoSize:%d\n", puiPara->uhInfoSize);
|
|
MLOGD(" UIParameter start\n");
|
|
printf("FL_PHOTO_SIZE:%d\n", SysGetFlag(FL_PHOTO_SIZE));
|
|
printf("FL_QUALITY:%d\n", SysGetFlag(FL_QUALITY));
|
|
printf("FL_COLOR_EFFECT:%d\n", SysGetFlag(FL_COLOR_EFFECT));
|
|
printf("FL_SCENE:%d\n", SysGetFlag(FL_SCENE));
|
|
printf("FL_EV:%d\n", SysGetFlag(FL_EV));
|
|
printf("FL_ISO:%d\n", SysGetFlag(FL_ISO));
|
|
printf("FL_WB:%d\n", SysGetFlag(FL_WB));
|
|
printf("FL_METERING:%d\n", SysGetFlag(FL_METERING));
|
|
printf("FL_SHARPNESS:%d\n", SysGetFlag(FL_SHARPNESS));
|
|
printf("FL_SATURATION:%d\n", SysGetFlag(FL_SATURATION));
|
|
printf("FL_FD:%d\n", SysGetFlag(FL_FD));
|
|
printf("FL_ANTISHAKE:%d\n", SysGetFlag(FL_ANTISHAKE));
|
|
printf("FL_FLASH:%d\n", SysGetFlag(FL_FLASH));
|
|
printf("FL_RSC:%d\n", SysGetFlag(FL_RSC));
|
|
printf("FL_HDR:%d\n", SysGetFlag(FL_HDR));
|
|
printf("FL_WDR:%d\n", SysGetFlag(FL_WDR));
|
|
printf("FL_DUAL_CAM:%d\n", SysGetFlag(FL_DUAL_CAM));
|
|
printf("FL_DUAL_CAM_MENU:%d\n", SysGetFlag(FL_DUAL_CAM_MENU));
|
|
printf("FL_QUICK_REVIEW:%d\n", SysGetFlag(FL_QUICK_REVIEW));
|
|
printf("FL_DATE_STAMP:%d\n", SysGetFlag(FL_DATE_STAMP));
|
|
printf("FL_SELFTIMER:%d\n", SysGetFlag(FL_SELFTIMER));
|
|
printf("FL_FLASH_MODE:%d\n", SysGetFlag(FL_FLASH_MODE));
|
|
printf("FL_CONTINUE_SHOT:%d\n", SysGetFlag(FL_CONTINUE_SHOT));
|
|
printf("FL_SHDR:%d\n", SysGetFlag(FL_SHDR));
|
|
printf("FL_MOVIE_REC:%d\n", SysGetFlag(FL_MOVIE_REC));
|
|
printf("FL_MOVIE_SIZE:%d\n", SysGetFlag(FL_MOVIE_SIZE));
|
|
printf("FL_MOVIE_SIZE_MENU:%d\n", SysGetFlag(FL_MOVIE_SIZE_MENU));
|
|
printf("FL_MOVIE_HDR:%d\n", SysGetFlag(FL_MOVIE_HDR));
|
|
printf("FL_MOVIE_HDR_MENU:%d\n", SysGetFlag(FL_MOVIE_HDR_MENU));
|
|
printf("FL_MOVIE_WDR:%d\n", SysGetFlag(FL_MOVIE_WDR));
|
|
printf("FL_MOVIE_WDR_MENU:%d\n", SysGetFlag(FL_MOVIE_WDR_MENU));
|
|
printf("FL_MOVIE_QUALITY:%d\n", SysGetFlag(FL_MOVIE_QUALITY));
|
|
printf("FL_MOVIE_COLOR:%d\n", SysGetFlag(FL_MOVIE_COLOR));
|
|
printf("FL_MOVIE_CYCLIC_REC:%d\n", SysGetFlag(FL_MOVIE_CYCLIC_REC));
|
|
printf("FL_MOVIE_MOTION_DET:%d\n", SysGetFlag(FL_MOVIE_MOTION_DET));
|
|
printf("FL_MOVIE_AUDIO:%d\n", SysGetFlag(FL_MOVIE_AUDIO));
|
|
printf("FL_MOVIE_DATEIMPRINT:%d\n", SysGetFlag(FL_MOVIE_DATEIMPRINT));
|
|
printf("FL_MOVIE_TIMELAPSE_REC:%d\n", SysGetFlag(FL_MOVIE_TIMELAPSE_REC));
|
|
printf("FL_MOVIE_IR_CUT:%d\n", SysGetFlag(FL_MOVIE_IR_CUT));
|
|
printf("FL_MOVIE_SENSOR_ROTATE:%d\n", SysGetFlag(FL_MOVIE_SENSOR_ROTATE));
|
|
printf("FL_MOVIE_PTZ:%d\n", SysGetFlag(FL_MOVIE_PTZ));
|
|
printf("FL_MOVIE_URGENT_PROTECT_AUTO:%d\n", SysGetFlag(FL_MOVIE_URGENT_PROTECT_AUTO));
|
|
printf("FL_MOVIE_URGENT_PROTECT_MANUAL:%d\n", SysGetFlag(FL_MOVIE_URGENT_PROTECT_MANUAL));
|
|
printf("FL_MOVIE_PIM:%d\n", SysGetFlag(FL_MOVIE_PIM));
|
|
printf("FL_MOVIE_FCW:%d\n", SysGetFlag(FL_MOVIE_FCW));
|
|
printf("FL_MOVIE_LDWS:%d\n", SysGetFlag(FL_MOVIE_LDWS));
|
|
printf("FL_MOVIE_DDD:%d\n", SysGetFlag(FL_MOVIE_DDD));
|
|
printf("FL_MOVIE_ADAS_CAL:%d\n", SysGetFlag(FL_MOVIE_ADAS_CAL));
|
|
printf("FL_MOVIE_CONTRAST:%d\n", SysGetFlag(FL_MOVIE_CONTRAST));
|
|
printf("FL_MOVIE_AUDIOIN:%d\n", SysGetFlag(FL_MOVIE_AUDIOIN));
|
|
printf("FL_MOVIE_AUDIOIN_SR:%d\n", SysGetFlag(FL_MOVIE_AUDIOIN_SR));
|
|
printf("FL_MOVIE_FLIP_MIRROR:%d\n", SysGetFlag(FL_MOVIE_FLIP_MIRROR));
|
|
printf("FL_MOVIE_QUALITY_SET:%d\n", SysGetFlag(FL_MOVIE_QUALITY_SET));
|
|
printf("FL_MOVIE_SBS_MODE:%d\n", SysGetFlag(FL_MOVIE_SBS_MODE));
|
|
printf("FL_MOVIE_CODEC:%d\n", SysGetFlag(FL_MOVIE_CODEC));
|
|
printf("FL_PROTECT:%d\n", SysGetFlag(FL_PROTECT));
|
|
printf("FL_COMMON_MODE:%d\n", SysGetFlag(FL_COMMON_MODE));
|
|
printf("FL_COMMON_MENU:%d\n", SysGetFlag(FL_COMMON_MENU));
|
|
printf("FL_COMMON_LOCAL:%d\n", SysGetFlag(FL_COMMON_LOCAL));
|
|
printf("FL_COMMON_CLOUD:%d\n", SysGetFlag(FL_COMMON_CLOUD));
|
|
printf("FL_COMMON_SETUP:%d\n", SysGetFlag(FL_COMMON_SETUP));
|
|
printf("FL_COMMON_EXT_SETUP:%d\n", SysGetFlag(FL_COMMON_EXT_SETUP));
|
|
printf("FL_AUTO_POWER_OFF:%d\n", SysGetFlag(FL_AUTO_POWER_OFF));
|
|
printf("FL_BEEP:%d\n", SysGetFlag(FL_BEEP));
|
|
printf("FL_LANGUAGE:%d\n", SysGetFlag(FL_LANGUAGE));
|
|
printf("FL_FREQUENCY:%d\n", SysGetFlag(FL_FREQUENCY));
|
|
printf("FL_TV_MODE:%d\n", SysGetFlag(FL_TV_MODE));
|
|
printf("FL_HDMI_MODE:%d\n", SysGetFlag(FL_HDMI_MODE));
|
|
printf("FL_FORMAT:%d\n", SysGetFlag(FL_FORMAT));
|
|
printf("FL_DEFAULT:%d\n", SysGetFlag(FL_DEFAULT));
|
|
printf("FL_DATE_FORMAT:%d\n", SysGetFlag(FL_DATE_FORMAT));
|
|
printf("FL_TIME_FORMAT:%d\n", SysGetFlag(FL_TIME_FORMAT));
|
|
printf("FL_HOUR_FORMAT:%d\n", SysGetFlag(FL_HOUR_FORMAT));
|
|
printf("FL_DATE_TIME_SETUP:%d\n", SysGetFlag(FL_DATE_TIME_SETUP));
|
|
printf("FL_OPENING_LOGO:%d\n", SysGetFlag(FL_OPENING_LOGO));
|
|
printf("FL_SETUP:%d\n", SysGetFlag(FL_SETUP));
|
|
printf("FL_GSENSOR:%d\n", SysGetFlag(FL_GSENSOR));
|
|
printf("FL_EDGE:%d\n", SysGetFlag(FL_EDGE));
|
|
printf("FL_NR:%d\n", SysGetFlag(FL_NR));
|
|
printf("FL_IPP_ISO:%d\n", SysGetFlag(FL_IPP_ISO));
|
|
printf("FL_WARP:%d\n", SysGetFlag(FL_WARP));
|
|
printf("FL_CPU2_DEFAULT:%d\n", SysGetFlag(FL_CPU2_DEFAULT));
|
|
printf("FL_DCF_DIR_ID:%d\n", SysGetFlag(FL_DCF_DIR_ID));
|
|
printf("FL_DCF_FILE_ID:%d\n", SysGetFlag(FL_DCF_FILE_ID));
|
|
printf("FL_LCD_DISPLAY:%d\n", SysGetFlag(FL_LCD_DISPLAY));
|
|
printf("FL_MACRO:%d\n", SysGetFlag(FL_MACRO));
|
|
printf("FL_LCD_BRIGHTNESS:%d\n", SysGetFlag(FL_LCD_BRIGHTNESS));
|
|
printf("FL_USB_MODE:%d\n", SysGetFlag(FL_USB_MODE));
|
|
printf("FL_ModeIndex:%d\n", SysGetFlag(FL_ModeIndex));
|
|
printf("FL_PreMode:%d\n", SysGetFlag(FL_PreMode));
|
|
printf("FL_NextMode:%d\n", SysGetFlag(FL_NextMode));
|
|
printf("FL_ModeTransParam:%d\n", SysGetFlag(FL_ModeTransParam));
|
|
printf("FL_ModeTransDir:%d\n", SysGetFlag(FL_ModeTransDir));
|
|
printf("FL_SceneModeIndex:%d\n", SysGetFlag(FL_SceneModeIndex));
|
|
printf("FL_IsInitSettingFlag:%d\n", SysGetFlag(FL_IsInitSettingFlag));
|
|
printf("FL_AFWindowIndex:%d\n", SysGetFlag(FL_AFWindowIndex));
|
|
printf("FL_ContAFIndex:%d\n", SysGetFlag(FL_ContAFIndex));
|
|
printf("FL_AFBeamIndex:%d\n", SysGetFlag(FL_AFBeamIndex));
|
|
printf("FL_CapModeIndex:%d\n", SysGetFlag(FL_CapModeIndex));
|
|
printf("FL_Dzoom:%d\n", SysGetFlag(FL_Dzoom));
|
|
printf("FL_DzoomReset:%d\n", SysGetFlag(FL_DzoomReset));
|
|
printf("FL_ZoomIFIndex:%d\n", SysGetFlag(FL_ZoomIFIndex));
|
|
printf("FL_ZoomIsDigital:%d\n", SysGetFlag(FL_ZoomIsDigital));
|
|
printf("FL_ZoomOzmDzmChange:%d\n", SysGetFlag(FL_ZoomOzmDzmChange));
|
|
printf("FL_DzoomIndex:%d\n", SysGetFlag(FL_DzoomIndex));
|
|
printf("FL_ContShotIndex:%d\n", SysGetFlag(FL_ContShotIndex));
|
|
printf("FL_IsSingleCapture:%d\n", SysGetFlag(FL_IsSingleCapture));
|
|
printf("FL_MovieDisIndex:%d\n", SysGetFlag(FL_MovieDisIndex));
|
|
printf("FL_MovieMCTFIndex:%d\n", SysGetFlag(FL_MovieMCTFIndex));
|
|
printf("FL_MovieRSCIndex:%d\n", SysGetFlag(FL_MovieRSCIndex));
|
|
printf("FL_MovieRSCIndex_MENU:%d\n", SysGetFlag(FL_MovieRSCIndex_MENU));
|
|
printf("FL_MovieGdcIndex:%d\n", SysGetFlag(FL_MovieGdcIndex));
|
|
printf("FL_MovieSmearIndex:%d\n", SysGetFlag(FL_MovieSmearIndex));
|
|
printf("FL_MovieAudioPlayIndex:%d\n", SysGetFlag(FL_MovieAudioPlayIndex));
|
|
printf("FL_MovieAudioRecIndex:%d\n", SysGetFlag(FL_MovieAudioRecIndex));
|
|
printf("FL_MovieAudioRec:%d\n", SysGetFlag(FL_MovieAudioRec));
|
|
printf("FL_LCD_OFF:%d\n", SysGetFlag(FL_LCD_OFF));
|
|
printf("FL_BrightAdjIndex:%d\n", SysGetFlag(FL_BrightAdjIndex));
|
|
printf("FL_DateFormatIndex:%d\n", SysGetFlag(FL_DateFormatIndex));
|
|
printf("FL_TimeFormatIndex:%d\n", SysGetFlag(FL_TimeFormatIndex));
|
|
printf("FL_DualDisp:%d\n", SysGetFlag(FL_DualDisp));
|
|
printf("FL_BeepVolumnIndex:%d\n", SysGetFlag(FL_BeepVolumnIndex));
|
|
printf("FL_AudioPlayIndex:%d\n", SysGetFlag(FL_AudioPlayIndex));
|
|
printf("FL_LensOpen:%d\n", SysGetFlag(FL_LensOpen));
|
|
printf("FL_TakePictCnt:%d\n", SysGetFlag(FL_TakePictCnt));
|
|
printf("FL_IsDCIMReadOnly:%d\n", SysGetFlag(FL_IsDCIMReadOnly));
|
|
printf("FL_ResetFlag:%d\n", SysGetFlag(FL_ResetFlag));
|
|
printf("FL_DeleteAllFlag:%d\n", SysGetFlag(FL_DeleteAllFlag));
|
|
printf("FL_PhotoFrameWriteSts:%d\n", SysGetFlag(FL_PhotoFrameWriteSts));
|
|
printf("FL_SSWAVWriteSts:%d\n", SysGetFlag(FL_SSWAVWriteSts));
|
|
printf("FL_IsCIPARunning:%d\n", SysGetFlag(FL_IsCIPARunning));
|
|
printf("FL_IsEmptyBatt:%d\n", SysGetFlag(FL_IsEmptyBatt));
|
|
printf("FL_IslensStopping:%d\n", SysGetFlag(FL_IslensStopping));
|
|
printf("FL_IsStopCharge:%d\n", SysGetFlag(FL_IsStopCharge));
|
|
printf("FL_IsCopyToCarding:%d\n", SysGetFlag(FL_IsCopyToCarding));
|
|
printf("FL_IsUseFileDB:%d\n", SysGetFlag(FL_IsUseFileDB));
|
|
printf("FL_IsCloneRec:%d\n", SysGetFlag(FL_IsCloneRec));
|
|
printf("FL_NetWorkMode:%d\n", SysGetFlag(FL_NetWorkMode));
|
|
printf("FL_WIFI:%d\n", SysGetFlag(FL_WIFI));
|
|
printf("FL_WIFI_MOVIE_MAXRECTIME:%d\n", SysGetFlag(FL_WIFI_MOVIE_MAXRECTIME));
|
|
printf("FL_WIFI_PHOTO_FREEPICNUM:%d\n", SysGetFlag(FL_WIFI_PHOTO_FREEPICNUM));
|
|
printf("FL_WIFI_LINK:%d\n", SysGetFlag(FL_WIFI_LINK));
|
|
printf("FL_WIFI_MOVIE_APP_PREVIEW_SIZE:%d\n", SysGetFlag(FL_WIFI_MOVIE_APP_PREVIEW_SIZE));
|
|
printf("FL_WIFI_AUTO_RECORDING:%d\n", SysGetFlag(FL_WIFI_AUTO_RECORDING));
|
|
printf("FL_MOVIE_FCW_MENU:%d\n", SysGetFlag(FL_MOVIE_FCW_MENU));
|
|
printf("FL_MOVIE_LDWS_MENU:%d\n", SysGetFlag(FL_MOVIE_LDWS_MENU));
|
|
printf("FL_MOVIE_TIMELAPSE_REC_MENU:%d\n", SysGetFlag(FL_MOVIE_TIMELAPSE_REC_MENU));
|
|
printf("FL_WDR_MENU:%d\n", SysGetFlag(FL_WDR_MENU));
|
|
printf("FL_SHDR_MENU:%d\n", SysGetFlag(FL_SHDR_MENU));
|
|
printf("FL_RSC_MENU:%d\n", SysGetFlag(FL_RSC_MENU));
|
|
printf("FL_DEFOG:%d\n", SysGetFlag(FL_DEFOG));
|
|
printf("FL_DEFOG_MENU:%d\n", SysGetFlag(FL_DEFOG_MENU));
|
|
printf("FL_MOVIE_DEFOG:%d\n", SysGetFlag(FL_MOVIE_DEFOG));
|
|
printf("FL_MOVIE_DEFOG_MENU:%d\n", SysGetFlag(FL_MOVIE_DEFOG_MENU));
|
|
printf("FL_ETHCAM_TX_IP_ADDR:%d\n", SysGetFlag(FL_ETHCAM_TX_IP_ADDR));
|
|
printf("FL_MOVIE_CODEC_MENU:%d\n", SysGetFlag(FL_MOVIE_CODEC_MENU));
|
|
printf("FL_MOVIE_SENSOR_ROTATE_MENU:%d\n", SysGetFlag(FL_MOVIE_SENSOR_ROTATE_MENU));
|
|
MLOGD(" UIParameter end\n");
|
|
|
|
printf("ulmodeIndex:%d\n", puiPara->ulmodeIndex);
|
|
printf("cbYear:%d\n", puiPara->cbYear);
|
|
printf("cbMonth:%d\n", puiPara->cbMonth);
|
|
printf("cbDay:%d\n", puiPara->cbDay);
|
|
printf("cbFileID:%d\n", puiPara->cbFileID);
|
|
printf("ubLanguageIndex:%d\n", puiPara->ubLanguageIndex);
|
|
printf("ubAFWindowIndex:%d\n", puiPara->ubAFWindowIndex);
|
|
printf("ubAFBeamIndex:%d\n", puiPara->ubAFBeamIndex);
|
|
printf("ubContAF:%d\n", puiPara->ubContAF);
|
|
printf("ubAEmode:%d\n", puiPara->ubAEmode);
|
|
printf("ubQviewIndex:%d\n", puiPara->ubQviewIndex);
|
|
printf("ubDzoom:%d\n", puiPara->ubDzoom);
|
|
printf("ubBlinkDet:%d\n", puiPara->ubBlinkDet);
|
|
printf("ubSlowShutter:%d\n", puiPara->ubSlowShutter);
|
|
printf("ubContshotIndex:%d\n", puiPara->ubContshotIndex);
|
|
printf("ubTimelapseIndex:%d\n", puiPara->ubTimelapseIndex);
|
|
printf("ubDatePrint:%d\n", puiPara->ubDatePrint);
|
|
printf("ubPanModeIndex:%d\n", puiPara->ubPanModeIndex);
|
|
printf("ubFlashIndex:%d\n", puiPara->ubFlashIndex);
|
|
printf("ubEVIndex:%d\n", puiPara->ubEVIndex);
|
|
printf("ubSizeIndex:%d\n", puiPara->ubSizeIndex);
|
|
printf("ubQualityIndex:%d\n", puiPara->ubQualityIndex);
|
|
printf("ubWBIndex:%d\n", puiPara->ubWBIndex);
|
|
printf("ubColorIndex:%d\n", puiPara->ubColorIndex);
|
|
printf("ubISOIndex:%d\n", puiPara->ubISOIndex);
|
|
printf("ubFDIndex:%d\n", puiPara->ubFDIndex);
|
|
printf("ubSharpnessIndex:%d\n", puiPara->ubSharpnessIndex);
|
|
printf("ubPhotoDispMode:%d\n", puiPara->ubPhotoDispMode);
|
|
printf("strSSID:%s\n", puiPara->strSSID);
|
|
printf("strPASSPHRASE:%s\n", puiPara->strPASSPHRASE);
|
|
printf("strSSID_hotspot_1:%s\n", puiPara->strSSID_hotspot_1);
|
|
printf("strPASSPHRASE_hotspot_1:%s\n", puiPara->strPASSPHRASE_hotspot_1);
|
|
|
|
MLOGD(" sf Parameter start\n");
|
|
printf("CamNameSwitch:%d\n", puiPara->CamNameSwitch);
|
|
printf("CamNameStr:%s\n", puiPara->CamNameStr);
|
|
printf("CamMode:%d\n", puiPara->CamMode);
|
|
printf("FlashLed:%d\n", puiPara->FlashLed);
|
|
printf("ImgSize:%d\n", puiPara->ImgSize);
|
|
printf("NightMode:%d\n", puiPara->NightMode);
|
|
printf("Multishot:%d\n", puiPara->Multishot);
|
|
printf("MultiShotIntevel:%d\n", puiPara->MultiShotIntevel);
|
|
printf("SendMulti:%d\n", puiPara->SendMulti);
|
|
printf("VideoSize:%d\n", puiPara->VideoSize);
|
|
printf("VideoTimeMenu:%d\n", puiPara->VideoTimeMenu);
|
|
printf("VideoLenth:%d\n", puiPara->VideoLenth);
|
|
printf("PirSwitch:%d\n", puiPara->PirSwitch);
|
|
printf("PirSensitivity:%d\n", puiPara->PirSensitivity);
|
|
printf("PirDelaySwitch:%d %d:%d:%d\n", puiPara->PirDelaySwitch,puiPara->PirDelayTime.Hour,puiPara->PirDelayTime.Min,puiPara->PirDelayTime.Sec);
|
|
printf("TimelapseSwitch:%d %d:%d:%d\n", puiPara->TimelapseSwitch,puiPara->TimelapseTime.Hour,puiPara->TimelapseTime.Min,puiPara->TimelapseTime.Sec);
|
|
printf("WorkTime1Switch:%d %d:%d-%d:%d\n", puiPara->WorkTime1Switch,puiPara->WorkTime[0].StartTime.Hour,puiPara->WorkTime[0].StartTime.Min,puiPara->WorkTime[0].StopTime.Hour,puiPara->WorkTime[0].StopTime.Min);
|
|
printf("WorkTime1Switch:%d %d:%d-%d:%d\n", puiPara->WorkTime2Switch,puiPara->WorkTime[1].StartTime.Hour,puiPara->WorkTime[1].StartTime.Min,puiPara->WorkTime[1].StopTime.Hour,puiPara->WorkTime[1].StopTime.Min);
|
|
printf("SimAutoSwitch:%d\n", puiPara->SimAutoSwitch);
|
|
printf("SendMaxNum:%d\n", puiPara->SendMaxNum);
|
|
printf("GprsMode:%d\n", puiPara->GprsMode);
|
|
printf("DailyReportSwitch:%d H:%d M:%d\n",puiPara->DailyReportSwitch,puiPara->DailyReportTime.Hour,puiPara->DailyReportTime.Min);
|
|
printf("ReDailyReport:%d H:%d M:%d\n",puiPara->ReDailyReport,puiPara->DailyReportTime2.Hour,puiPara->DailyReportTime2.Min);
|
|
printf("DailyReportTestSwitch:%d\n", puiPara->DailyReportTestSwitch);
|
|
printf("SimPinFlag:%d\n", puiPara->SimPinFlag);
|
|
printf("GpsSwitch:%d\n", puiPara->GpsSwitch);
|
|
printf("Language:%d\n", puiPara->Language);
|
|
printf("DateStyle:%d\n", puiPara->DateStyle);
|
|
printf("StampSwitch:%d\n", puiPara->StampSwitch);
|
|
printf("BatteryType:%d\n", puiPara->BatteryType);
|
|
printf("SdLoopSwitch:%d\n", puiPara->SdLoopSwitch);
|
|
printf("PwdSwitch:%d %s\n", puiPara->PwdSwitch, puiPara->PwdStr);
|
|
printf("SendPhotoSwitch:%d\n", puiPara->SendPhotoSwitch);
|
|
printf("SendVideoSwitch:%d\n", puiPara->SendVideoSwitch);
|
|
printf("SendPicSize:%d\n", puiPara->SendPicSize);
|
|
printf("SendMultishotIndex1:%d\n", puiPara->SendMultishotIndex1);
|
|
printf("SendMultishotIndex2:%d\n", puiPara->SendMultishotIndex2);
|
|
printf("SendMultishotIndex3:%d\n", puiPara->SendMultishotIndex3);
|
|
printf("SendMultishotIndex4:%d\n", puiPara->SendMultishotIndex4);
|
|
printf("SendMultishotIndex5:%d\n", puiPara->SendMultishotIndex5);
|
|
printf("DateAuto:%d\n", puiPara->DateAuto);
|
|
printf("NTPZoneS:%d\n", puiPara->NTPZoneS);
|
|
printf("NTPZoneH:%d\n", puiPara->NTPZoneH);
|
|
printf("NTPZoneM:%d\n", puiPara->NTPZoneM);
|
|
printf("DigitPirSensitivity:%d\n", puiPara->DigitPirSensitivity);
|
|
printf("DigitPirCnt:%d\n", puiPara->DigitPirCnt);
|
|
printf("DigitPirWindowTime:%d\n", puiPara->DigitPirWindowTime);
|
|
printf("CamArmDiable:%d\n", puiPara->CamArmDiable);
|
|
printf("DebugMode:%d\n", puiPara->DebugMode);
|
|
printf("AutoOffSwitch:%d\n", puiPara->AutoOffSwitch);
|
|
printf("AutoLogSwitch:%d\n", puiPara->AutoLogSwitch);
|
|
printf("RawSwitch:%d\n", puiPara->RawSwitch);
|
|
printf("GprsSwitch:%d\n", puiPara->GprsSwitch);
|
|
printf("GpsSendFlag:%d\n", puiPara->GpsSendFlag);
|
|
printf("FristSendDailyAndGps:%d\n", puiPara->FristSendDailyAndGps);
|
|
printf("NetGeneration:%d\n", puiPara->NetGeneration);
|
|
printf("NeedTimeSyncStartUp:%d\n", puiPara->NeedTimeSyncStartUp);
|
|
printf("NetWorkNeedSearch:%d\n", puiPara->NetWorkNeedSearch);
|
|
printf("QLogSwitch:%d\n", puiPara->QLogSwitch);
|
|
printf("GpsAntiTheftSwitch:%d\n", puiPara->GpsAntiTheftSwitch);
|
|
printf("BatteryLogSwitch:%d\n", puiPara->BatteryLogSwitch);
|
|
printf("GpsNumber:%d\n", puiPara->GpsNumber);
|
|
printf("TimeSend1Switch:%d\n", puiPara->TimeSend1Switch);
|
|
printf("TimeSend1:%d:%d:%d\n", puiPara->TimeSend1.Hour,puiPara->TimeSend1.Min,puiPara->TimeSend1.Sec);
|
|
printf("TimeSend2Switch:%d\n", puiPara->TimeSend2Switch);
|
|
printf("TimeSend2:%d:%d:%d\n", puiPara->TimeSend2.Hour,puiPara->TimeSend2.Min,puiPara->TimeSend2.Sec);
|
|
printf("TimeSend3Switch:%d\n", puiPara->TimeSend3Switch);
|
|
printf("TimeSend3:%d:%d:%d\n", puiPara->TimeSend3.Hour,puiPara->TimeSend3.Min,puiPara->TimeSend3.Sec);
|
|
printf("TimeSend4Switch:%d\n", puiPara->TimeSend4Switch);
|
|
printf("TimeSend4:%d:%d:%d\n", puiPara->TimeSend4.Hour,puiPara->TimeSend4.Min,puiPara->TimeSend4.Sec);
|
|
printf("SendType:%d\n", puiPara->SendType);
|
|
printf("PicUpDailyReport:%d\n", puiPara->PicUpDailyReport);
|
|
printf("ProfileSwitchFlg:%d\n", puiPara->ProfileSwitchFlg);
|
|
printf("ProfileEnableCmdVal:%d\n", puiPara->ProfileEnableCmdVal);
|
|
printf("UpdateFlg:%d\n", puiPara->UpdateFlg);
|
|
printf("PreActiveProfileIccid:%s\n", puiPara->PreActiveProfileIccid);
|
|
printf("EsimEid:%s\n", puiPara->EsimEid);
|
|
printf("Latitude:%s Longitude:%s\n", puiPara->Latitude, puiPara->Longitude);
|
|
printf("Sim4gApn:%s\n", puiPara->Sim4gApn);
|
|
printf("Sim4gUsr:%s\n", puiPara->Sim4gUsr);
|
|
printf("Sim4gPwd:%s\n", puiPara->Sim4gPwd);
|
|
printf("SimPinStr:%s\n", puiPara->SimPinStr);
|
|
printf("MmsMmsc:%s\n", puiPara->MmsMmsc);
|
|
printf("MmsApn:%s\n", puiPara->MmsApn);
|
|
printf("MmsProxy:%s\n", puiPara->MmsProxy);
|
|
printf("MmsPort:%s\n", puiPara->MmsPort);
|
|
printf("MmsUsr:%s\n", puiPara->MmsUsr);
|
|
printf("MmsPwd:%s\n", puiPara->MmsPwd);
|
|
printf("ModuleImei:%s\n", puiPara->ModuleImei);
|
|
printf("ModuleVer:%s\n", puiPara->ModuleVer);
|
|
printf("ModuleSubver:%s\n", puiPara->ModuleSubver);
|
|
printf("AcmIp:%s\n", puiPara->AcmIp);
|
|
printf("AcmPort:%s\n", puiPara->AcmPort);
|
|
printf("WebIp:%s\n", puiPara->WebIp);
|
|
printf("OperatorCode:%s\n", puiPara->OperatorCode);
|
|
printf("SimIccid:%s\n", puiPara->SimIccid);
|
|
printf("ServiceProvider:%s\n", puiPara->ServiceProvider);
|
|
printf("SimSignal:%d\n", puiPara->SimSignal);
|
|
printf("SimType:%d\n", puiPara->SimType);
|
|
printf("FtpSwitch:%d\n", puiPara->FtpSwitch);
|
|
printf("FtpIp:%s\n", puiPara->FtpIp);
|
|
printf("FtpPort:%s\n", puiPara->FtpPort);
|
|
printf("FtpUsr:%s\n", puiPara->FtpUsr);
|
|
printf("FtpPwd:%s\n", puiPara->FtpPwd);
|
|
printf("FtpsIp:%s\n", puiPara->FtpsIp);
|
|
printf("FtpsPort:%s\n", puiPara->FtpsPort);
|
|
printf("FtpsUsr:%s\n", puiPara->FtpsUsr);
|
|
printf("FtpsPwd:%s\n", puiPara->FtpsPwd);
|
|
printf("OtaFtpIp:%s\n", puiPara->OtaFtpIp);
|
|
printf("OtaFtpPort:%s\n", puiPara->OtaFtpPort);
|
|
printf("OtaFtpUserName:%s\n", puiPara->OtaFtpUserName);
|
|
printf("OtaFtpPassWord:%s\n", puiPara->OtaFtpPassWord);
|
|
printf("WifiSwitch:%d\n", puiPara->WifiSwitch);
|
|
printf("WifiMode:%d\n", puiPara->WifiMode);
|
|
printf("WifiApPWD:%s\n", puiPara->WifiApPWD);
|
|
printf("Zoom:%d\n", puiPara->Zoom);
|
|
printf("FileKey:%d\n", puiPara->FileKey);
|
|
printf("BluSsid:%s\n", puiPara->BluSsid);
|
|
printf("BluSwitch:%d\n", puiPara->BluSwitch);
|
|
MLOGD(" sf Parameter end\n");
|
|
|
|
MLOGD(" end\n");
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL cmd_blu_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->BluSwitch = value;
|
|
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] BluSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->BluSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL cmd_wifi_switch(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
sscanf_s(argv[0],"%d", &value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
puiPara->WifiSwitch = value;
|
|
|
|
Save_MenuInfo();
|
|
}
|
|
printf("[%s:%d] WifiSwitch:%d\n", __FUNCTION__, __LINE__,puiPara->WifiSwitch);
|
|
return TRUE;
|
|
}
|
|
|
|
SF_BLE_STATUS_E sf_get_ble_status(void)
|
|
{
|
|
return BleStatus;
|
|
}
|
|
|
|
void sf_set_ble_status(SF_BLE_STATUS_E enStatus)
|
|
{
|
|
if(enStatus < SF_BLE_BUTT)
|
|
{
|
|
BleStatus = enStatus;
|
|
if(BleStatus == SF_BLE_CON)
|
|
{
|
|
printf("[%s]set ble on status", __FUNCTION__);
|
|
sf_wifi_set_cam_mode();
|
|
}
|
|
}
|
|
|
|
else
|
|
SLOGE("Type format error\n");
|
|
return;
|
|
|
|
}
|
|
|
|
void sf_set_msdc_clk(void)
|
|
{
|
|
printf("[%s:%d] s\n", __FUNCTION__, __LINE__);
|
|
system("echo 24000000 > /sys/kernel/debug/mmc0/clock");
|
|
printf("[%s:%d] e \n", __FUNCTION__, __LINE__);
|
|
}
|
|
void sf_send_message_to_create_qrcode(void)
|
|
{
|
|
SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
stMessageBuf.arg1 = SF_EVENT_KEY_MOCK_CREATE_QR_CODE;
|
|
stMessageBuf.cmdId = CMD_KEY;
|
|
sf_com_message_send_to_app(&stMessageBuf);
|
|
}
|
|
|
|
void sf_set_cammode_statu(char is)
|
|
{
|
|
CamMode = is;
|
|
//printf("[%s]:%d IsCap:%d\n", __FUNCTION__, __LINE__,IsCap);
|
|
}
|
|
|
|
char sf_get_cammode_statu(void)
|
|
{
|
|
//printf("[%s]:%d IsCap:%d\n", __FUNCTION__, __LINE__,IsCap);
|
|
return CamMode;
|
|
|
|
}
|
|
|
|
BOOL sf_set_backlight_status(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0],"%d", &value);
|
|
printf("[%s:%d] value:%d\n", __FUNCTION__, __LINE__,value);
|
|
if(value < SF_ON_OFF_MAX){
|
|
printf("[%s:%d] Status:%d\n", __FUNCTION__, __LINE__,GPIO_SetBacklightStatus(value));
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
UINT8 sf_get_net_generation(void)
|
|
{
|
|
return netGeneration;
|
|
}
|
|
|
|
void sf_set_net_generation(UINT8 value)
|
|
{
|
|
//MLOGI("netGeneration:%d value:%d\n",netGeneration, value);
|
|
if((value >= SF_NET_NO) && (value <= SF_NET_4G))
|
|
{
|
|
netGeneration = value;
|
|
}
|
|
else
|
|
{
|
|
printf("[%s:%d]value(%d) invalid,no set.\n", __FUNCTION__, __LINE__, value);
|
|
}
|
|
}
|
|
|
|
void* sf_cardv_load_menu_info_thread(void *arg)
|
|
{
|
|
vos_perf_list_mark(__func__, __LINE__, 0);
|
|
SLOGI("thread run\n");
|
|
LoadParaTskCfg.IsRun = 1;
|
|
Load_MenuInfo();
|
|
SLOGI("thread end\n");
|
|
|
|
LoadParaTskCfg.IsRun = 0;
|
|
vos_perf_list_mark(__func__, __LINE__, 0);
|
|
return NULL;
|
|
}
|
|
UINT32 sf_cardv_load_menu_info_start(void)
|
|
{
|
|
SINT32 ret = 1;
|
|
if(LoadParaTskCfg.IsRun)
|
|
{
|
|
SLOGE("thread has already run !!!\n");
|
|
return 1;
|
|
}
|
|
ret = pthread_create(&LoadParaTskCfg.TskId, NULL, sf_cardv_load_menu_info_thread, NULL);
|
|
if(ret != SF_SUCCESS)
|
|
{
|
|
MLOGD("thread creat fail!\n");
|
|
return ret;
|
|
}
|
|
return SF_SUCCESS;
|
|
|
|
}
|
|
|
|
BOOL sf_vos_perf_list_dump(unsigned char argc, char **argv)
|
|
{
|
|
vos_perf_list_dump();
|
|
sleep(1);
|
|
system("dmesg");
|
|
return TRUE;
|
|
}
|
|
|
|
void sf_mem_free(void)
|
|
{
|
|
printf("[%s]:%d sf s\n", __FUNCTION__, __LINE__);
|
|
system("sync");
|
|
system("echo 3 >/proc/sys/vm/drop_caches");
|
|
printf("[%s]:%d sf e\n", __FUNCTION__, __LINE__);
|
|
}
|
|
void sf_cardv_statistics_param_reset(void)
|
|
{
|
|
SF_MESSAGE_BUF_S stMessageBuf = {0};
|
|
stMessageBuf.arg1 = SF_PARA_CMD_RESET;
|
|
stMessageBuf.cmdId = CMD_PARA;
|
|
sf_com_message_send_to_app(&stMessageBuf);
|
|
printf("[%s]:%d sf e\n", __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
void sf_cardv_set_wifi_en(UINT32 cnt)
|
|
{
|
|
static UINT8 state = 0;
|
|
if(0 == state)
|
|
{
|
|
state = 1;
|
|
gpio_direction_output(SF_WIFI_EN, 1);
|
|
}
|
|
gpio_set_value(SF_WIFI_EN, cnt);
|
|
printf("[%s:%d] e cnt:%d\n", __FUNCTION__, __LINE__,cnt);
|
|
} |