1588 lines
39 KiB
C++
Executable File
1588 lines
39 KiB
C++
Executable File
#define TAG "wifi"
|
|
#include <tina_log.h>
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <wifi_intf.h>
|
|
#include <pthread.h>
|
|
|
|
#include <sys/time.h>
|
|
#include <uv.h>
|
|
#include <dbus/dbus.h>
|
|
#include <errno.h>
|
|
#include <cjson/s2j.h>
|
|
|
|
#include <uvdbus/log.h>
|
|
#include <uvdbus/libuv_dbus.h>
|
|
#include <uvdbus/crypto.h>
|
|
#include <uvdbus/json_struct.h>
|
|
#include <uvdbus/config_engine.h>
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <cstddef>
|
|
#include <algorithm>
|
|
|
|
|
|
#define PIPE_RET_SIZE 1024
|
|
|
|
#define WIFI_STATE_JS_KEY "wifi_state"
|
|
#define WIFI_STATE_RSSI_JS_KEY "wifi_rssi"
|
|
#define WIFI_STATE_SSID_JS_KEY "wifi_ssid"
|
|
#define WIFI_STATE_MAC_JS_KEY "wifi_mac"
|
|
|
|
#define WIFI_STATE_EVT_JS_KEY "wifi_evt"
|
|
|
|
#define RES_CODDE_STR "resCode"
|
|
#define SSID_JS_KEY "ssid"
|
|
#define PASSWD_JS_KEY "pwd"
|
|
#define PASSWD_ACCOUNT "account"
|
|
|
|
#define WLAN_CONFIG_CMD_STR "iwconfig"
|
|
#define WLAN_RSSI_STR_RRE "Signal level="
|
|
#define WLAN_BSSID_STR_RRE "Access Point: "
|
|
#define WLAN_ESSID_STR_RRE "ESSID:\""
|
|
|
|
|
|
#define WIFI_CONF_EVT_TAG 0xf000
|
|
#define WIFI_AUTO_EVT_TAG 0xf100
|
|
#define WIFI_CHANGE_AP_EVT_TAG 0xf200
|
|
|
|
|
|
static pthread_t app_scan_tid;
|
|
/* TO BE FIXED */
|
|
//extern pthread_mutex_t ctrl_mutex;
|
|
|
|
|
|
#define APP_WIFI_SUCCES 0
|
|
#define APP_WIFI_NULL -1
|
|
#define APP_WIFI_OVER -2
|
|
#define APP_WIFI_JSON_INVALID -3
|
|
#define RSSI_INVALID_NUM (-9999)
|
|
|
|
|
|
|
|
typedef enum
|
|
{
|
|
WIFI_STATE_KEY_STATE =0,
|
|
WIFI_STATE_KEY_RSSI,
|
|
WIFI_STATE_KEY_SSID,
|
|
WIFI_STATE_KEY_MAC,
|
|
WIFI_STATE_KEY_CNT,
|
|
}sWifiStateKeysEnum;
|
|
|
|
|
|
typedef enum
|
|
{
|
|
WIFI_EVT_KEY_EVT =0,
|
|
WIFI_EVT_KEY_RSSI,
|
|
WIFI_EVT_KEY_SSID,
|
|
WIFI_EVT_KEY_MAC,
|
|
WIFI_EVT_KEY_CNT,
|
|
}sWifiEvtKeysEnum;
|
|
|
|
|
|
typedef enum
|
|
{
|
|
APP_WIFI_CFG_SUCCESS =0,
|
|
APP_WIFI_CFG_SYS_ERR = 0xf001,
|
|
APP_WIFI_CFG_FMT_INVALID,
|
|
APP_WIFI_CFG_JSON_INVALID,
|
|
APP_WIFI_CFG_PARAMS_ERR,
|
|
APP_WIFI_CFG_SSID_NO_EXIT,
|
|
APP_WIFI_CFG_PWD_INVALID,
|
|
APP_WIFI_CFG_BUSY,
|
|
APP_WIFI_CFG_TIMEOUT,
|
|
APP_WIFI_CFG_WIFI_MD_ERR,
|
|
APP_WIFI_CFG_CODEC_ERR,
|
|
APP_WIFI_CFG_OTHER,
|
|
APP_WIFI_CFG_SYS_CFG_BUSY,
|
|
APP_WIFI_CFG_SERVER_ERR,
|
|
APP_WIFI_CFG_STATE_INVALID,
|
|
}app_wifi_cfg_code_edef;
|
|
|
|
|
|
typedef enum
|
|
{
|
|
|
|
APP_WIFI_AUTO_SET_SUCCESS,
|
|
APP_WIFI_AUTO_SET_BUSY,
|
|
APP_WIFI_AUTO_BT_CONF_COLLISION,
|
|
APP_WIFI_AUTO_OTHER_INVALID,
|
|
}app_wifi_auto_resp_code_edef;
|
|
|
|
|
|
typedef enum
|
|
{
|
|
APP_WIFI_EVT_NTF_CONNECTED =0,
|
|
APP_WIFI_EVT_NTF_DISCONNECT,
|
|
APP_WIFI_EVT_NTF_CONNECTING,
|
|
APP_WIFI_EVT_NTF_MAX,
|
|
}app_wifi_state_notify_edef;
|
|
|
|
int api_wifi_state_notify(int state);
|
|
|
|
|
|
static char * wifiStateKeys[WIFI_STATE_KEY_CNT] ={WIFI_STATE_JS_KEY,WIFI_STATE_RSSI_JS_KEY,WIFI_STATE_SSID_JS_KEY,WIFI_STATE_MAC_JS_KEY};
|
|
static char * wifiEvtKeys[WIFI_STATE_KEY_CNT] ={WIFI_STATE_EVT_JS_KEY,WIFI_STATE_RSSI_JS_KEY,WIFI_STATE_SSID_JS_KEY,WIFI_STATE_MAC_JS_KEY};
|
|
|
|
|
|
|
|
|
|
std::string VectorStrCompose(std::vector<std::string> recVec)
|
|
{
|
|
std::string ret;
|
|
|
|
if(0 == recVec.size()) return "";
|
|
|
|
for(auto str = recVec.begin(); str !=recVec.end();str++)
|
|
{
|
|
ret+= *str;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
int pipeExcute(const char * cmd,std::vector<std::string> & recVec )
|
|
{
|
|
if(NULL == cmd) return -1;
|
|
recVec.clear();
|
|
|
|
FILE * pPipe = popen(cmd, "r");
|
|
|
|
LOG_EX(LOG_Debug, "INFO: cmd is %s\r\n",cmd);
|
|
|
|
if (NULL==pPipe) {
|
|
return -1;
|
|
}
|
|
|
|
char ret[PIPE_RET_SIZE];
|
|
|
|
memset(ret,0x00,PIPE_RET_SIZE);
|
|
|
|
|
|
while (fgets(ret, sizeof(ret), pPipe) != NULL)
|
|
{
|
|
|
|
recVec.push_back(ret);
|
|
}
|
|
|
|
if(0 != pclose(pPipe))
|
|
{
|
|
recVec.push_back(strerror(errno));
|
|
if(0 != errno)
|
|
{
|
|
LOG_EX(LOG_Debug, "ERROR: pipe close error = %d\r\n",errno);
|
|
}
|
|
|
|
}
|
|
|
|
LOG_EX(LOG_Debug, "info: cmd excute complete\r\n");
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
int get_connected_ap_info(int *rssi, std::string &ssid, std::string &mac)
|
|
{
|
|
std::string shellCmd = WLAN_CONFIG_CMD_STR;
|
|
std::vector<std::string> vectorRes;
|
|
int status =0;
|
|
std::string out;
|
|
|
|
if (rssi == NULL)
|
|
return -1;
|
|
|
|
status =pipeExcute(shellCmd.c_str(),vectorRes);
|
|
if(0 == status)
|
|
{
|
|
out = VectorStrCompose(vectorRes);
|
|
LOG_EX(LOG_Debug, "info:cmd is %s, res is \r\n %s \r\n",shellCmd.c_str(),out.c_str());
|
|
|
|
std::size_t pos = out.find(WLAN_RSSI_STR_RRE);
|
|
|
|
if(pos == std::string::npos)
|
|
{
|
|
LOG_EX(LOG_Debug, "warn: no rssi\r\n");
|
|
*rssi = RSSI_INVALID_NUM;
|
|
}else
|
|
{
|
|
std::string rssiStr = out.substr(pos+strlen(WLAN_RSSI_STR_RRE),4);
|
|
LOG_EX(LOG_Debug, "---info: rssiStr is %s\r\n",rssiStr.c_str());
|
|
|
|
*rssi = std::stoi(rssiStr);
|
|
}
|
|
|
|
pos = out.find(WLAN_BSSID_STR_RRE);
|
|
|
|
if(pos == std::string::npos)
|
|
{
|
|
LOG_EX(LOG_Debug, "warn: no bssid\r\n");
|
|
mac = "";
|
|
}else
|
|
{
|
|
mac = out.substr(pos+strlen(WLAN_BSSID_STR_RRE),17);
|
|
LOG_EX(LOG_Debug, "---info: macStr is %s\r\n", mac.c_str());
|
|
}
|
|
|
|
pos = out.find(WLAN_ESSID_STR_RRE);
|
|
|
|
if(pos == std::string::npos)
|
|
{
|
|
LOG_EX(LOG_Debug, "warn: no essid\r\n");
|
|
ssid = "";
|
|
}else
|
|
{
|
|
std::string ssidStr = out.substr(pos+strlen(WLAN_ESSID_STR_RRE));
|
|
std::size_t pos_end = ssidStr.find("\n");
|
|
ssid = ssidStr.substr(0,pos_end-3);
|
|
LOG_EX(LOG_Debug, "---info: essidStr is %s\r\n", ssid.c_str());
|
|
}
|
|
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "error: pipe excute error\r\n");
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
#if 0
|
|
|
|
void *app_scan_task(void *args)
|
|
{
|
|
const aw_wifi_interface_t *p_wifi = (aw_wifi_interface_t *)args;
|
|
char scan_results[4096];
|
|
int len = 0;
|
|
int event_label = 0;
|
|
|
|
while(1){
|
|
event_label++;
|
|
p_wifi->start_scan(event_label);
|
|
len = 4096;
|
|
p_wifi->get_scan_results(scan_results, &len);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
*argc[1] ap ssid
|
|
*argc[2] ap passwd
|
|
*/
|
|
|
|
DBusConnection *pBus;
|
|
static const char* g_pDBusInterfaceName = NULL;
|
|
static uv_timer_t timerCurPosMsg;
|
|
|
|
|
|
|
|
int api_wifi_module_cmd_send(int mask, uint32_t cmd, const char* pContext)
|
|
{
|
|
int status =0;
|
|
|
|
status = DBusBoardcastCommand(NULL,
|
|
mask,
|
|
cmd,
|
|
pContext);
|
|
if(0 != status )
|
|
{
|
|
LOG_EX(LOG_Debug, "nevsps send module cmd err is %d\r\n",status);
|
|
}
|
|
|
|
|
|
return status;
|
|
}
|
|
|
|
char * api_wifi_res_json_get(int res)
|
|
{
|
|
cJSON* pRoot = NULL;
|
|
char * p=NULL;
|
|
|
|
pRoot=cJSON_CreateObject();
|
|
if(NULL == pRoot) return NULL;
|
|
|
|
cJSON_AddNumberToObject(pRoot,RES_CODDE_STR,res);
|
|
|
|
p = cJSON_Print(pRoot);
|
|
|
|
if(NULL == p)
|
|
{
|
|
cJSON_Delete(pRoot);
|
|
return NULL;
|
|
}
|
|
|
|
cJSON_Delete(pRoot);
|
|
|
|
return p;
|
|
}
|
|
|
|
char * api_wifi_scan_result_json_get(char *scan_results, int len)
|
|
{
|
|
cJSON *pRoot = NULL;
|
|
cJSON *pArrayItem = NULL;
|
|
cJSON *pArrayItem2 = NULL;
|
|
char *p=NULL;
|
|
char *pCh = NULL;
|
|
const char *split1 = "\n";
|
|
const char *split2 = "\t";
|
|
|
|
LOG_EX(LOG_Debug, "Scan result: %s\n", scan_results);
|
|
|
|
pRoot = cJSON_CreateArray();
|
|
if(NULL == pRoot)
|
|
return NULL;
|
|
|
|
// Skip title
|
|
pCh = strtok(scan_results, split1);
|
|
// Skip mac
|
|
pCh = strtok(NULL, split2);
|
|
while (pCh != NULL)
|
|
{
|
|
pArrayItem = cJSON_CreateObject();
|
|
if(NULL == pArrayItem)
|
|
{
|
|
cJSON_Delete(pRoot);
|
|
return NULL;
|
|
}
|
|
// Skip Freq
|
|
pCh = strtok(NULL, split2);
|
|
// Signal level
|
|
pCh = strtok(NULL, split2);
|
|
cJSON_AddItemToObject(pArrayItem, "Strength", cJSON_CreateString(pCh));
|
|
// Flags
|
|
pCh = strtok(NULL, split2);
|
|
cJSON_AddItemToObject(pArrayItem, "Security", cJSON_CreateString(pCh));
|
|
// SSID
|
|
pCh = strtok(NULL, split1);
|
|
cJSON_AddItemToObject(pArrayItem, "Ssid", cJSON_CreateString(pCh));
|
|
// Freq, support only 2.4GHz currently.
|
|
cJSON_AddItemToObject(pArrayItem, "Frequence", cJSON_CreateString("2.4GHz"));
|
|
|
|
cJSON_AddItemToArray(pRoot, pArrayItem);
|
|
|
|
// Skip next mac
|
|
pCh = strtok(NULL, split2);
|
|
}
|
|
|
|
p = cJSON_Print(pRoot);
|
|
|
|
if(NULL == p)
|
|
{
|
|
cJSON_Delete(pRoot);
|
|
return NULL;
|
|
}
|
|
|
|
cJSON_Delete(pRoot);
|
|
|
|
return p;
|
|
}
|
|
|
|
|
|
char * api_wifi_state_json_get(char * p_key,int res)
|
|
{
|
|
cJSON* pRoot = NULL;
|
|
char * p=NULL;
|
|
|
|
pRoot=cJSON_CreateObject();
|
|
if(NULL == pRoot) return NULL;
|
|
|
|
cJSON_AddNumberToObject(pRoot,p_key,res);
|
|
|
|
p = cJSON_Print(pRoot);
|
|
|
|
if(NULL == p)
|
|
{
|
|
cJSON_Delete(pRoot);
|
|
return NULL;
|
|
}
|
|
|
|
cJSON_Delete(pRoot);
|
|
|
|
return p;
|
|
}
|
|
|
|
char * api_wifi_state_json_get(int state, int rssi, std::string ssid, std::string mac)
|
|
{
|
|
cJSON* pRoot = NULL;
|
|
char * p=NULL;
|
|
|
|
pRoot=cJSON_CreateObject();
|
|
if(NULL == pRoot)
|
|
return NULL;
|
|
|
|
cJSON_AddNumberToObject(pRoot,wifiStateKeys[WIFI_STATE_KEY_STATE],state);
|
|
cJSON_AddNumberToObject(pRoot,wifiStateKeys[WIFI_STATE_KEY_RSSI],rssi);
|
|
cJSON_AddStringToObject(pRoot,wifiStateKeys[WIFI_STATE_KEY_SSID],ssid.c_str());
|
|
cJSON_AddStringToObject(pRoot,wifiStateKeys[WIFI_STATE_KEY_MAC],mac.c_str());
|
|
|
|
p = cJSON_Print(pRoot);
|
|
|
|
if(NULL == p)
|
|
{
|
|
cJSON_Delete(pRoot);
|
|
return NULL;
|
|
}
|
|
|
|
cJSON_Delete(pRoot);
|
|
|
|
return p;
|
|
}
|
|
|
|
|
|
char * api_wifi_evt_json_get(int state, int rssi, std::string ssid, std::string mac)
|
|
{
|
|
cJSON* pRoot = NULL;
|
|
char * p=NULL;
|
|
|
|
pRoot=cJSON_CreateObject();
|
|
if(NULL == pRoot)
|
|
return NULL;
|
|
|
|
cJSON_AddNumberToObject(pRoot,wifiEvtKeys[WIFI_EVT_KEY_EVT],state);
|
|
cJSON_AddNumberToObject(pRoot,wifiEvtKeys[WIFI_EVT_KEY_RSSI],rssi);
|
|
cJSON_AddStringToObject(pRoot,wifiEvtKeys[WIFI_EVT_KEY_SSID],ssid.c_str());
|
|
cJSON_AddStringToObject(pRoot,wifiEvtKeys[WIFI_EVT_KEY_MAC],mac.c_str());
|
|
|
|
p = cJSON_Print(pRoot);
|
|
|
|
if(NULL == p)
|
|
{
|
|
cJSON_Delete(pRoot);
|
|
return NULL;
|
|
}
|
|
|
|
cJSON_Delete(pRoot);
|
|
|
|
return p;
|
|
}
|
|
|
|
|
|
int api_wifi_state_notify(int state)
|
|
{
|
|
|
|
char * pStateJson = NULL;
|
|
int status = 0;
|
|
|
|
|
|
|
|
pStateJson = api_wifi_state_json_get(WIFI_STATE_EVT_JS_KEY,state);
|
|
if(NULL != pStateJson)
|
|
{
|
|
//status = api_wifi_module_cmd_send((1<<MODULE_CONTROLLER),CMD_WIFI_STATE_NTF, pStateJson);
|
|
status = api_wifi_module_cmd_send(0xffffffff,CMD_WIFI_STATE_NTF, pStateJson);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send wifi state notify msg to control er:%d\r\n",status);
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send wifi state notify msg : 0x%x to control module\r\n",state);
|
|
}
|
|
}else
|
|
{
|
|
status = APP_WIFI_NULL;
|
|
}
|
|
|
|
if(NULL != pStateJson)
|
|
{
|
|
free(pStateJson);
|
|
pStateJson =NULL;
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int api_wifi_state_notify(int state,int rssi, std::string ssid, std::string mac)
|
|
{
|
|
|
|
char * pEvtJson = NULL;
|
|
int status = 0;
|
|
|
|
pEvtJson = api_wifi_evt_json_get(state, rssi, ssid, mac);
|
|
if(NULL != pEvtJson)
|
|
{
|
|
//status = api_wifi_module_cmd_send((1<<MODULE_CONTROLLER),CMD_WIFI_STATE_NTF, pStateJson);
|
|
// TO BE FIXED. msg type & recver.
|
|
status = api_wifi_module_cmd_send((1<<MODULE_CLOCK_FRAME),CMD_WIFI_STATE_RESP, pEvtJson);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send wifi state notify msg to control er:%d\r\n",status);
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send wifi state notify msg : 0x%x to control module\r\n",state);
|
|
}
|
|
}else
|
|
{
|
|
status = APP_WIFI_NULL;
|
|
}
|
|
|
|
if(NULL != pEvtJson)
|
|
{
|
|
free(pEvtJson);
|
|
pEvtJson =NULL;
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
static void wifi_state_handle(struct Manager *w, int event_label)
|
|
{
|
|
int rssi = 0;
|
|
std::string ssid = "";
|
|
std::string mac = "";
|
|
|
|
LOG_EX(LOG_Debug, "app_wifi_manager event_label 0x%x, event 0x%x, state 0x%x\n", event_label, w->StaEvt.event, w->StaEvt.state);
|
|
|
|
switch(w->StaEvt.state)
|
|
{
|
|
case CONNECTING:
|
|
{
|
|
LOG_EX(LOG_Debug, "Connecting to the network......\n");
|
|
break;
|
|
}
|
|
case CONNECTED:
|
|
{
|
|
LOG_EX(LOG_Debug, "Connected to the AP\n");
|
|
start_udhcpc();
|
|
break;
|
|
}
|
|
|
|
case OBTAINING_IP:
|
|
{
|
|
LOG_EX(LOG_Debug, "Getting ip address......\n");
|
|
break;
|
|
}
|
|
|
|
case NETWORK_CONNECTED:
|
|
{
|
|
LOG_EX(LOG_Debug, "Successful network connection\n");
|
|
get_connected_ap_info(&rssi, ssid, mac);
|
|
if( 0 != api_wifi_state_notify(APP_WIFI_EVT_NTF_CONNECTED, rssi, ssid, mac))
|
|
{
|
|
LOG_EX(LOG_Debug, "Notify the wifi state error!!\r\n");
|
|
}
|
|
break;
|
|
}
|
|
case DISCONNECTED:
|
|
{
|
|
LOG_EX(LOG_Error, "Disconnected,the reason:%s\n",wmg_event_txt(w->StaEvt.event));
|
|
system("ifconfig wlan0 0.0.0.0");
|
|
if(0 != api_wifi_state_notify(APP_WIFI_EVT_NTF_DISCONNECT, RSSI_INVALID_NUM, ssid, mac))
|
|
{
|
|
LOG_EX(LOG_Debug, "Notify the wifi state error!!\r\n");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*static void wifi_event_handle(tWIFI_EVENT wifi_event, void *buf, int event_label)
|
|
{
|
|
int rssi = 0;
|
|
std::string ssid = "";
|
|
std::string mac = "";
|
|
LOG_EX(LOG_Debug, "app_wifi_manager event_label 0x%x,event 0x%x\n", event_label,wifi_event);
|
|
|
|
|
|
switch(wifi_event)
|
|
{
|
|
case WIFIMG_WIFI_ON_SUCCESS:
|
|
{
|
|
LOG_EX(LOG_Debug, "++++++WiFi on success!\n");
|
|
event = WIFIMG_WIFI_ON_SUCCESS;
|
|
break;
|
|
}
|
|
|
|
case WIFIMG_WIFI_ON_FAILED:
|
|
{
|
|
LOG_EX(LOG_Debug, "++++++WiFi on failed!\n");
|
|
event = WIFIMG_WIFI_ON_FAILED;
|
|
break;
|
|
}
|
|
|
|
case WIFIMG_WIFI_OFF_FAILED:
|
|
{
|
|
LOG_EX(LOG_Debug, "++++++wifi off failed!\n");
|
|
event = WIFIMG_WIFI_OFF_FAILED;
|
|
break;
|
|
}
|
|
|
|
case WIFIMG_WIFI_OFF_SUCCESS:
|
|
{
|
|
LOG_EX(LOG_Debug, "+++++wifi off success!\n");
|
|
event = WIFIMG_WIFI_OFF_SUCCESS;
|
|
break;
|
|
}
|
|
|
|
case WIFIMG_NETWORK_CONNECTED:
|
|
{
|
|
LOG_EX(LOG_Debug, "++++++WiFi connected ap!\n");
|
|
event = WIFIMG_NETWORK_CONNECTED;
|
|
|
|
get_connected_ap_info(&rssi, ssid, mac);
|
|
|
|
if( 0 != api_wifi_state_notify(APP_WIFI_EVT_NTF_CONNECTED, rssi, ssid, mac))
|
|
{
|
|
LOG_EX(LOG_Debug, "Notify the wifi state error!!\r\n");
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case WIFIMG_NETWORK_DISCONNECTED:
|
|
{
|
|
LOG_EX(LOG_Debug, "++++++WiFi disconnected!\n");
|
|
event = WIFIMG_NETWORK_DISCONNECTED;
|
|
system("ifconfig wlan0 0.0.0.0");
|
|
if(0 != api_wifi_state_notify(APP_WIFI_EVT_NTF_DISCONNECT, RSSI_INVALID_NUM, ssid, mac))
|
|
{
|
|
LOG_EX(LOG_Debug, "Notify the wifi state error!!\r\n");
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WIFIMG_PASSWORD_FAILED:
|
|
{
|
|
//if(1== ret_flag) break;
|
|
LOG_EX(LOG_Debug, "++++++Password authentication failed!\n");
|
|
event = WIFIMG_PASSWORD_FAILED;
|
|
ret_flag =1;
|
|
break;
|
|
}
|
|
|
|
case WIFIMG_CONNECT_TIMEOUT:
|
|
{
|
|
//if(1== ret_flag) break;
|
|
LOG_EX(LOG_Debug, "++++++Connected timeout!\n");
|
|
event = WIFIMG_CONNECT_TIMEOUT;
|
|
ret_flag =1;
|
|
break;
|
|
}
|
|
|
|
case WIFIMG_NO_NETWORK_CONNECTING:
|
|
{
|
|
LOG_EX(LOG_Debug, "++++++It has no wifi auto connect when wifi on!\n");
|
|
event = WIFIMG_NO_NETWORK_CONNECTING;
|
|
break;
|
|
}
|
|
|
|
case WIFIMG_CMD_OR_PARAMS_ERROR:
|
|
{
|
|
//if(1== ret_flag) break;
|
|
LOG_EX(LOG_Debug, "+++++cmd or params error!\n");
|
|
event = WIFIMG_CMD_OR_PARAMS_ERROR;
|
|
ret_flag =1;
|
|
break;
|
|
}
|
|
|
|
case WIFIMG_KEY_MGMT_NOT_SUPPORT:
|
|
{
|
|
//if(1== ret_flag) break;
|
|
LOG_EX(LOG_Debug, "++++++key mgmt is not supported!\n");
|
|
event = WIFIMG_KEY_MGMT_NOT_SUPPORT;
|
|
ret_flag =1;
|
|
break;
|
|
}
|
|
|
|
case WIFIMG_OPT_NO_USE_EVENT:
|
|
{
|
|
LOG_EX(LOG_Debug, "++++++operation no use!\n");
|
|
event = WIFIMG_OPT_NO_USE_EVENT;
|
|
break;
|
|
}
|
|
|
|
case WIFIMG_NETWORK_NOT_EXIST:
|
|
{
|
|
//if(1== ret_flag) break;
|
|
LOG_EX(LOG_Debug, "++++++network not exist!\n");
|
|
event = WIFIMG_NETWORK_NOT_EXIST;
|
|
ret_flag =1;
|
|
break;
|
|
}
|
|
|
|
case WIFIMG_DEV_BUSING_EVENT:
|
|
{
|
|
LOG_EX(LOG_Debug, "+++++wifi device busing!\n");
|
|
event = WIFIMG_DEV_BUSING_EVENT;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
LOG_EX(LOG_Debug, "+++++Other event, no care!\n");
|
|
}
|
|
}
|
|
|
|
}*/
|
|
|
|
|
|
|
|
int api_wifi_get_cfg_value(char * p_txt,char** pp_ssid,char** pp_pswd)
|
|
{
|
|
cJSON * p_root =NULL;
|
|
cJSON *p_sd_item = NULL;
|
|
cJSON *p_ps_item = NULL;
|
|
p_root=cJSON_Parse(p_txt);
|
|
if(NULL == p_root)
|
|
{
|
|
return APP_WIFI_JSON_INVALID;
|
|
}
|
|
|
|
p_sd_item = cJSON_GetObjectItem(p_root,SSID_JS_KEY);
|
|
if(NULL == p_sd_item)
|
|
{
|
|
cJSON_Delete(p_root);
|
|
return APP_WIFI_NULL;
|
|
}
|
|
|
|
*pp_ssid= cJSON_Print(p_sd_item);
|
|
if(NULL == *pp_ssid)
|
|
{
|
|
cJSON_Delete(p_root);
|
|
return APP_WIFI_NULL;
|
|
}
|
|
|
|
p_ps_item = cJSON_GetObjectItem(p_root,PASSWD_JS_KEY);
|
|
if(NULL == p_ps_item)
|
|
{
|
|
cJSON_Delete(p_root);
|
|
return APP_WIFI_NULL;
|
|
}
|
|
|
|
*pp_pswd = cJSON_Print(p_ps_item);
|
|
|
|
if(NULL == *pp_pswd)
|
|
{
|
|
cJSON_Delete(p_root);
|
|
return APP_WIFI_NULL;
|
|
}
|
|
|
|
cJSON_Delete(p_root);
|
|
|
|
return 0;
|
|
|
|
|
|
}
|
|
|
|
|
|
void DBusOnKeyEvent(uint16_t uType, uint16_t uKey, int32_t iValue){
|
|
|
|
}
|
|
|
|
|
|
int api_wifi_get_str_raw(char **p_str_brace)
|
|
{
|
|
int size =0;
|
|
char * p_ret = NULL;
|
|
if(NULL == *p_str_brace) return APP_WIFI_NULL;
|
|
|
|
size = strlen(*p_str_brace);
|
|
|
|
p_ret= (char *)malloc(size);
|
|
|
|
if(NULL == p_ret)
|
|
{
|
|
return APP_WIFI_NULL;
|
|
}
|
|
|
|
memset(p_ret,0x00,size);
|
|
|
|
memcpy(p_ret,(*p_str_brace+1),size -2);
|
|
|
|
free(*p_str_brace);
|
|
|
|
*p_str_brace = p_ret;
|
|
|
|
return 0;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#define WIFI_INFO_BASE64 0
|
|
|
|
|
|
PDBUS_MSG_PACK DBusOnMessage(uv_loop_t *pLoop, DBusConnection *pConn,
|
|
PDBUS_MSG_PACK pMsg) {
|
|
int event_label = 0;;
|
|
static const aw_wifi_interface_t *p_wifi_interface = NULL;
|
|
static int wifi_off_mode = 0;
|
|
//cJSON * root = NULL;
|
|
int status =0;
|
|
uint8_t * pResJson = NULL;
|
|
uint8_t * pStateJson = NULL;
|
|
|
|
char * p_ssid =NULL;
|
|
char * p_passwd = NULL;
|
|
|
|
#if WIFI_INFO_BASE64
|
|
|
|
char * pBaseSsid = NULL;
|
|
char * pBasePwd = NULL;
|
|
int ssidSize =0;
|
|
int pwdSize =0;
|
|
#endif
|
|
|
|
int rsp_code =APP_WIFI_CFG_SUCCESS;
|
|
int audo_code =0;
|
|
static int busy_conf =0;
|
|
static int busy_auto =0;
|
|
int mask =0;
|
|
static int wifi_connet_cnt =0;
|
|
enum wmgEvent wmg_event;
|
|
|
|
|
|
LOG_EX(LOG_Debug, "GetDbusCmd:0x%x\r\n",pMsg->busCmd);
|
|
if (!pMsg || !pLoop || !pConn) {
|
|
return NULL;
|
|
}
|
|
|
|
switch (pMsg->busCmd) {
|
|
case CMD_WIFI_CONF:
|
|
LOG_EX(LOG_Debug, "====================Get cmd CMD_WIFI_CONF==========================\r\n");
|
|
LOG_EX(LOG_Debug, "wifi module get cfg msg is %s\r\n",pMsg->pMsg);
|
|
if(0 == busy_conf || 1 == wifi_off_mode)
|
|
{
|
|
busy_conf =1;
|
|
status = api_wifi_get_cfg_value(pMsg->pMsg,&p_ssid,&p_passwd);
|
|
if(APP_WIFI_JSON_INVALID == status)
|
|
{
|
|
rsp_code = APP_WIFI_CFG_JSON_INVALID;
|
|
}else if(APP_WIFI_NULL == status)
|
|
{
|
|
rsp_code = APP_WIFI_CFG_FMT_INVALID;
|
|
}
|
|
|
|
if(APP_WIFI_CFG_SUCCESS== rsp_code)
|
|
{
|
|
LOG_EX(LOG_Debug, "+++++++Now wifi config cnt is %d\r\n",++wifi_connet_cnt);
|
|
LOG_EX(LOG_Debug, "ssid is %s,pd is %s\r\n",p_ssid,p_passwd);
|
|
|
|
|
|
status = api_wifi_get_str_raw(&p_ssid);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "ERROR:get ssid str raw err");
|
|
goto END_DO;
|
|
|
|
}
|
|
|
|
status = api_wifi_get_str_raw(&p_passwd);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "get passwd str raw err");
|
|
goto END_DO;
|
|
|
|
}
|
|
|
|
#if WIFI_INFO_BASE64
|
|
pBaseSsid = (char *)EvpBase64DecodeNoAlignV2((const char *)p_ssid, &ssidSize);
|
|
if(0 == ssidSize || NULL == pBaseSsid)
|
|
{
|
|
LOG_EX(LOG_Debug, "ERROR: ssid base64 error\r\n");
|
|
goto END_DO;
|
|
}
|
|
|
|
pBasePwd = (char *)EvpBase64DecodeNoAlignV2((const char *)p_passwd, &pwdSize);
|
|
|
|
LOG_EX(LOG_Debug, "INFO:pBasePwd is %d, pwdSize is %d\r\n",pBasePwd,pwdSize);
|
|
|
|
if(0 == pwdSize && NULL == pBasePwd)
|
|
{
|
|
LOG_EX(LOG_Debug, "warm: pswd null!!!\r\n");
|
|
}
|
|
|
|
|
|
free(p_ssid);
|
|
p_ssid = NULL;
|
|
free(p_passwd);
|
|
p_passwd = NULL;
|
|
|
|
p_ssid = pBaseSsid;
|
|
p_passwd = pBasePwd;
|
|
|
|
pBasePwd = NULL;
|
|
pBaseSsid = NULL;
|
|
#endif
|
|
|
|
LOG_EX(LOG_Debug, "New ssid is %s,new pd is %s\r\n",p_ssid,p_passwd);
|
|
|
|
event_label = WIFI_CONF_EVT_TAG;
|
|
|
|
if(NULL == p_wifi_interface)
|
|
{
|
|
p_wifi_interface = aw_wifi_on(wifi_state_handle, event_label);
|
|
if(p_wifi_interface == NULL){
|
|
LOG_EX(LOG_Debug, "wifi on failed event 0x%x\n", aw_wifi_get_wifi_event());
|
|
goto END_DO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(NETWORK_CONNECTED == aw_wifi_get_wifi_state())
|
|
{
|
|
status = p_wifi_interface->disconnect_ap(event_label);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "ERROR:wifi disconnect event 0x%x\n", aw_wifi_get_wifi_event());
|
|
goto END_DO;
|
|
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Disconnect the wifi connected ap\r\n");
|
|
}
|
|
}
|
|
|
|
event_label++;
|
|
LOG_EX(LOG_Debug, "INFO: ---- Now connecting ap\r\n");
|
|
status = p_wifi_interface->connect_ap(p_ssid,p_passwd, event_label);
|
|
|
|
while(aw_wifi_get_wifi_state() == CONNECTING || aw_wifi_get_wifi_state() == OBTAINING_IP){
|
|
LOG_EX(LOG_Debug, "wifi state busing,waiting\n");
|
|
usleep(400000);
|
|
}
|
|
|
|
}
|
|
|
|
wmg_event = aw_wifi_get_wifi_event();
|
|
LOG_EX(LOG_Debug, "wifi module final event 0x%x.\r\n", wmg_event_txt(wmg_event));
|
|
|
|
if(aw_wifi_get_wifi_state() == NETWORK_CONNECTED)
|
|
{
|
|
rsp_code = APP_WIFI_CFG_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
switch(wmg_event)
|
|
{
|
|
case WSE_DEV_BUSING:
|
|
rsp_code = APP_WIFI_CFG_BUSY;
|
|
break;
|
|
case WSE_CMD_OR_PARAMS_ERROR:
|
|
rsp_code = APP_WIFI_CFG_PARAMS_ERR;
|
|
break;
|
|
case WSE_KEYMT_NO_SUPPORT:
|
|
rsp_code = APP_WIFI_CFG_CODEC_ERR;
|
|
break;
|
|
case WSE_NETWORK_NOT_EXIST:
|
|
rsp_code = APP_WIFI_CFG_SSID_NO_EXIT;
|
|
break;
|
|
case WSE_PASSWORD_INCORRECT:
|
|
rsp_code = APP_WIFI_CFG_PWD_INVALID;
|
|
break;
|
|
case WSE_CONNECTED_TIMEOUT:
|
|
case WSE_OBTAINED_IP_TIMEOUT:
|
|
rsp_code = APP_WIFI_CFG_TIMEOUT;
|
|
break;
|
|
default:
|
|
rsp_code = APP_WIFI_CFG_OTHER;
|
|
break;
|
|
}
|
|
}
|
|
|
|
busy_conf =0;
|
|
}else
|
|
{
|
|
rsp_code = APP_WIFI_CFG_SYS_CFG_BUSY;
|
|
LOG_EX(LOG_Debug, "wifi module cfg busy!!!!\r\n");
|
|
}
|
|
|
|
LOG_EX(LOG_Debug, "wifi module CMD_WIFI_CONF rsp_code 0x%x.\r\n", rsp_code);
|
|
pResJson = (uint8_t *)api_wifi_res_json_get(rsp_code);
|
|
if(NULL != pResJson)
|
|
{
|
|
if(0 == rsp_code)mask = 1<<MODULE_CONTROLLER;
|
|
else mask = (1<<MODULE_BT)|(1<<MODULE_CONTROLLER)|(1<<MODULE_CLOCK_FRAME);
|
|
|
|
status = api_wifi_module_cmd_send(mask,CMD_WIFI_CONF_RESP, (const char *)pResJson);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send dbus msg to bt er:%d\r\n",status);
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send msg : 0x%x to bt module\r\n",rsp_code);
|
|
}
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module get res json err\r\n");
|
|
}
|
|
|
|
|
|
END_DO:
|
|
|
|
busy_conf =0;
|
|
|
|
if(NULL != pResJson)
|
|
{
|
|
free(pResJson);
|
|
pResJson = NULL;
|
|
}
|
|
#if WIFI_INFO_BASE64
|
|
free(pBasePwd);
|
|
pBasePwd = NULL;
|
|
|
|
free(pBaseSsid);
|
|
pBasePwd = NULL;
|
|
#endif
|
|
|
|
free(p_ssid);
|
|
p_ssid = NULL;
|
|
free(p_passwd);
|
|
p_passwd = NULL;
|
|
|
|
break;
|
|
case CMD_WIFI_AUTO_CONN:
|
|
{
|
|
LOG_EX(LOG_Debug, "====================Get cmd CMD_WIFI_AUTO_CONN==========================\r\n");
|
|
if(1== busy_conf || 1 == wifi_off_mode)
|
|
{
|
|
audo_code = APP_WIFI_AUTO_BT_CONF_COLLISION;
|
|
}
|
|
else if(1 == busy_auto){
|
|
audo_code = APP_WIFI_AUTO_SET_BUSY;
|
|
} else
|
|
{
|
|
audo_code = APP_WIFI_AUTO_SET_SUCCESS;
|
|
}
|
|
|
|
pResJson = (uint8_t *)api_wifi_res_json_get(audo_code);
|
|
if(NULL != pResJson)
|
|
{
|
|
status = api_wifi_module_cmd_send((1<<MODULE_CONTROLLER),CMD_WIFI_AUTO_CONN_RESP,(const char *)pResJson);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send dbus msg to control er:%d\r\n",status);
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send wifi_auto msg : 0x%x to control module\r\n",rsp_code);
|
|
}
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module get res json err\r\n");
|
|
|
|
}
|
|
|
|
if(NULL != pResJson)
|
|
{
|
|
free(pResJson);
|
|
pResJson = NULL;
|
|
}
|
|
|
|
if(0 == busy_auto && APP_WIFI_AUTO_SET_SUCCESS == audo_code)
|
|
{
|
|
busy_auto =1;
|
|
event_label = WIFI_AUTO_EVT_TAG;
|
|
|
|
if(NULL == p_wifi_interface)
|
|
{
|
|
p_wifi_interface = aw_wifi_on(wifi_state_handle, event_label);
|
|
if(p_wifi_interface == NULL){
|
|
LOG_EX(LOG_Debug, "wifi on failed event 0x%x\n", aw_wifi_get_wifi_event());
|
|
busy_auto =0;
|
|
break;
|
|
}
|
|
#if 0
|
|
status = p_wifi_interface->enable_all_network();
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "wifi on failed event 0x%x\n", event);
|
|
busy_auto =0;
|
|
break;
|
|
}
|
|
#endif
|
|
if(CONNECTED == aw_wifi_get_wifi_state())
|
|
status = p_wifi_interface->disconnect_ap(event_label);
|
|
}
|
|
|
|
if(CONNECTED != aw_wifi_get_wifi_state())
|
|
{
|
|
|
|
while(aw_wifi_get_wifi_state() == CONNECTING || aw_wifi_get_wifi_state() == OBTAINING_IP){
|
|
LOG_EX(LOG_Debug, "wifi state busing,waiting\n");
|
|
usleep(2000000);
|
|
}
|
|
status = p_wifi_interface->connect_ap_auto(event_label);
|
|
|
|
while(aw_wifi_get_wifi_state() == CONNECTING || aw_wifi_get_wifi_state() == OBTAINING_IP)
|
|
{
|
|
LOG_EX(LOG_Debug, "wifi state busing,waiting\n");
|
|
usleep(2000000);
|
|
}
|
|
|
|
if(NETWORK_CONNECTED !=aw_wifi_get_wifi_state() )
|
|
{
|
|
std::string ssid = "";
|
|
std::string mac = "";
|
|
if(0 != api_wifi_state_notify(APP_WIFI_EVT_NTF_CONNECTING, RSSI_INVALID_NUM, ssid, mac))
|
|
{
|
|
LOG_EX(LOG_Debug, "Notify the wifi state error!!\r\n");
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
int rssi = 0;
|
|
std::string ssid = "";
|
|
std::string mac = "";
|
|
get_connected_ap_info(&rssi, ssid, mac);
|
|
if(0 != api_wifi_state_notify(APP_WIFI_EVT_NTF_CONNECTED, rssi, ssid, mac))
|
|
{
|
|
LOG_EX(LOG_Debug, "Notify the wifi state error!!\r\n");
|
|
}
|
|
}
|
|
|
|
busy_auto =0;
|
|
|
|
|
|
status = api_wifi_module_cmd_send((1<<MODULE_CONTROLLER),CMD_WIFI_AUTO_CONN_OUT, NULL);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send dbus msg to control er:%d\r\n",status);
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send wifi_auto out to control module\r\n");
|
|
}
|
|
|
|
|
|
}
|
|
|
|
break;
|
|
}
|
|
case CMD_WIFI_SCAN:
|
|
{
|
|
LOG_EX(LOG_Debug, "====================Get cmd CMD_WIFI_SCAN==========================\r\n");
|
|
char scan_results[4096] = {0};
|
|
int len = 4096;
|
|
event_label= WIFI_CONF_EVT_TAG;;
|
|
|
|
/*status = api_wifi_module_cmd_send((1<<MODULE_CLOCK_FRAME),CMD_WIFI_CHANGE_VALID_AP_RESP, NULL);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send dbus msg to control er:%d\r\n",status);
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send wifi_auto msg to control module\r\n");
|
|
}*/
|
|
|
|
if(NULL == p_wifi_interface)
|
|
{
|
|
p_wifi_interface = aw_wifi_on(wifi_state_handle, event_label);
|
|
if(p_wifi_interface == NULL){
|
|
LOG_EX(LOG_Debug, "wifi on failed event 0x%x\n", aw_wifi_get_wifi_event());
|
|
busy_auto =0;
|
|
break;
|
|
}
|
|
}
|
|
while(aw_wifi_get_wifi_state() == CONNECTING || aw_wifi_get_wifi_state() == OBTAINING_IP){
|
|
LOG_EX(LOG_Debug, "wifi state busing,waiting\n");
|
|
usleep(2000000);
|
|
}
|
|
status = p_wifi_interface->get_scan_results(scan_results, &len);
|
|
if(status < 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
pResJson = (uint8_t *)api_wifi_scan_result_json_get(scan_results, len);
|
|
if(NULL != pResJson)
|
|
{
|
|
mask = 1<<MODULE_CLOCK_FRAME;
|
|
status = api_wifi_module_cmd_send(mask,CMD_WIFI_SCAN_RESP, (const char *)pResJson);
|
|
if (0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send dbus msg to clockFrame err:%d\r\n",status);
|
|
}
|
|
else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send msg : 0x%x to clockFrame module\r\n",pResJson);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module get scan results err\r\n");
|
|
}
|
|
|
|
if(NULL != pResJson)
|
|
{
|
|
free(pResJson);
|
|
pResJson = NULL;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case CMD_WIFI_DISCONNECT:
|
|
{
|
|
LOG_EX(LOG_Debug, "====================Get cmd CMD_WIFI_DISCONNECT==========================\r\n");
|
|
event_label= WIFI_CONF_EVT_TAG;;
|
|
|
|
/*status = api_wifi_module_cmd_send((1<<MODULE_CLOCK_FRAME),CMD_WIFI_CHANGE_VALID_AP_RESP, NULL);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send dbus msg to control er:%d\r\n",status);
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send wifi_auto msg to control module\r\n");
|
|
}*/
|
|
|
|
if(NULL == p_wifi_interface)
|
|
{
|
|
p_wifi_interface = aw_wifi_on(wifi_state_handle, event_label);
|
|
if(p_wifi_interface == NULL){
|
|
LOG_EX(LOG_Debug, "wifi on failed event 0x%x\n", aw_wifi_get_wifi_event());
|
|
busy_auto =0;
|
|
break;
|
|
}
|
|
}
|
|
while(aw_wifi_get_wifi_state() == CONNECTING || aw_wifi_get_wifi_state() == OBTAINING_IP){
|
|
LOG_EX(LOG_Debug, "wifi state busing,waiting\n");
|
|
usleep(2000000);
|
|
}
|
|
|
|
rsp_code = -1;
|
|
if(NETWORK_CONNECTED == aw_wifi_get_wifi_state())
|
|
{
|
|
rsp_code = p_wifi_interface->disconnect_ap(event_label);
|
|
if(0 != rsp_code)
|
|
{
|
|
LOG_EX(LOG_Debug, "ERROR:wifi disconnect event 0x%x\n", aw_wifi_get_wifi_event());
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Disconnect the wifi connected ap\r\n");
|
|
}
|
|
}
|
|
|
|
LOG_EX(LOG_Debug, "wifi module CMD_WIFI_CONF rsp_code 0x%x.\r\n", rsp_code);
|
|
pResJson = (uint8_t *)api_wifi_res_json_get(rsp_code);
|
|
if(NULL != pResJson)
|
|
{
|
|
mask = (1<<MODULE_CLOCK_FRAME);
|
|
status = api_wifi_module_cmd_send(mask, CMD_WIFI_DISCONNECT_RESP, (const char *)pResJson);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send dbus msg to clockFrame err:%d\r\n",status);
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send msg : 0x%x to clockFrame module\r\n",rsp_code);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module get res json err\r\n");
|
|
}
|
|
|
|
if(NULL != pResJson)
|
|
{
|
|
free(pResJson);
|
|
pResJson = NULL;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case CMD_WIFI_STATE_REQ:
|
|
{
|
|
int rssi = 0;
|
|
std::string ssid = "";
|
|
std::string mac = "";
|
|
int wifi_state = aw_wifi_get_wifi_state();
|
|
|
|
LOG_EX(LOG_Debug, "====================Get cmd CMD_WIFI_STATE_REQ==========================\r\n");
|
|
if(NETWORK_CONNECTED == wifi_state)
|
|
{
|
|
get_connected_ap_info(&rssi, ssid, mac);
|
|
}
|
|
|
|
pStateJson = (uint8_t *)api_wifi_state_json_get(wifi_state, rssi, ssid, mac);
|
|
if(NULL != pStateJson)
|
|
{
|
|
status = api_wifi_module_cmd_send((1<<MODULE_CONTROLLER),CMD_WIFI_STATE_RESP,(const char *) pStateJson);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send dbus msg to control er:%d\r\n",status);
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send wifi state msg : 0x%x to control module\r\n",wifi_state);
|
|
}
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module get res json err\r\n");
|
|
|
|
}
|
|
if(NULL != pStateJson)
|
|
{
|
|
free(pStateJson);
|
|
pStateJson = NULL;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case CMD_WIFI_CHANGE_VALID_AP:
|
|
LOG_EX(LOG_Debug, "====================Get cmd CMD_WIFI_CHANGE_VALID_AP==========================\r\n");
|
|
event_label= WIFI_CHANGE_AP_EVT_TAG;;
|
|
|
|
status = api_wifi_module_cmd_send((1<<MODULE_CONTROLLER),CMD_WIFI_CHANGE_VALID_AP_RESP, NULL);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send dbus msg to control er:%d\r\n",status);
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send wifi_auto msg to control module\r\n");
|
|
}
|
|
|
|
if(NULL == p_wifi_interface)
|
|
{
|
|
p_wifi_interface = aw_wifi_on(wifi_state_handle, event_label);
|
|
if(p_wifi_interface == NULL){
|
|
LOG_EX(LOG_Debug, "wifi on failed event 0x%x\n", aw_wifi_get_wifi_event());
|
|
busy_auto =0;
|
|
break;
|
|
}
|
|
}
|
|
while(aw_wifi_get_wifi_state() == CONNECTING || aw_wifi_get_wifi_state() == OBTAINING_IP){
|
|
LOG_EX(LOG_Debug, "wifi state busing,waiting\n");
|
|
usleep(2000000);
|
|
}
|
|
status = p_wifi_interface->change_ap(event_label);
|
|
|
|
while(aw_wifi_get_wifi_state() == CONNECTING || aw_wifi_get_wifi_state() == OBTAINING_IP)
|
|
{
|
|
LOG_EX(LOG_Debug, "wifi state busing,waiting\n");
|
|
usleep(2000000);
|
|
}
|
|
|
|
status = api_wifi_module_cmd_send((1<<MODULE_CONTROLLER),CMD_WIFI_CHANGE_VALID_AP_OUT, NULL);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send dbus msg to control er:%d\r\n",status);
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send change ap out msg to control module\r\n");
|
|
}
|
|
|
|
break;
|
|
case CMD_WIFI_UNBIND_ACCOUNT:
|
|
LOG_EX(LOG_Debug, "recv DBUS MSG: CMD_WIFI_UNBIND_ACCOUNT\r\n");
|
|
if(NULL == p_wifi_interface)
|
|
{
|
|
p_wifi_interface = aw_wifi_on(wifi_state_handle, event_label);
|
|
if(p_wifi_interface == NULL){
|
|
LOG_EX(LOG_Debug, "wifi on failed event L%d 0x%x\n", aw_wifi_get_wifi_event(), __LINE__);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(NETWORK_CONNECTED == aw_wifi_get_wifi_state())
|
|
{
|
|
status = p_wifi_interface->disconnect_ap(event_label);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "ERROR:wifi disconnect event 0x%x L%d\n", aw_wifi_get_wifi_event(), __LINE__);
|
|
}
|
|
else
|
|
{
|
|
LOG_EX(LOG_Debug, "Disconnect the wifi connected ap L%d \r\n", __LINE__);
|
|
}
|
|
}
|
|
|
|
status = p_wifi_interface->remove_all_networks();
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "ERROR:remove_all_networks event 0x%x L%d\n", aw_wifi_get_wifi_event(), __LINE__);
|
|
}
|
|
else
|
|
{
|
|
LOG_EX(LOG_Debug, "remove_all_networks L%d \r\n", __LINE__);
|
|
}
|
|
break;
|
|
case CMD_WIFI_ON:
|
|
status = APP_WIFI_CFG_SUCCESS;
|
|
if (wifi_off_mode == 0)
|
|
{
|
|
LOG_EX(LOG_Error, "Wifi interface already on, turn on wifi failed!\n");
|
|
status = APP_WIFI_CFG_SYS_ERR;
|
|
}
|
|
else
|
|
{
|
|
p_wifi_interface = aw_wifi_on(wifi_state_handle, WIFI_CONF_EVT_TAG);
|
|
if(p_wifi_interface == NULL){
|
|
LOG_EX(LOG_Error, "Turn on wifi failed!\n");
|
|
status = APP_WIFI_CFG_SYS_ERR;
|
|
}
|
|
else
|
|
{
|
|
wifi_off_mode = 0;
|
|
LOG_EX(LOG_Error, "Turn on wifi succeed!\n");
|
|
}
|
|
}
|
|
pResJson = (uint8_t *)api_wifi_res_json_get(status);
|
|
if(NULL != pResJson)
|
|
{
|
|
status = api_wifi_module_cmd_send((1<<MODULE_CONTROLLER),CMD_WIFI_ON_RESP,(const char *)pResJson);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send dbus msg to control er:%d\r\n",status);
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send wifi_auto msg : 0x%x to control module\r\n",rsp_code);
|
|
}
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module get res json err\r\n");
|
|
}
|
|
|
|
if(NULL != pResJson)
|
|
{
|
|
free(pResJson);
|
|
pResJson = NULL;
|
|
}
|
|
|
|
break;
|
|
case CMD_WIFI_OFF:
|
|
status = APP_WIFI_CFG_SUCCESS;
|
|
if (p_wifi_interface == NULL || wifi_off_mode == 1)
|
|
{
|
|
LOG_EX(LOG_Error, "Wifi interface not on, turn off wifi failed!\n");
|
|
status = APP_WIFI_CFG_SYS_ERR;
|
|
}
|
|
else
|
|
{
|
|
if(NETWORK_CONNECTED == aw_wifi_get_wifi_state())
|
|
{
|
|
status = p_wifi_interface->disconnect_ap(WIFI_CONF_EVT_TAG);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Error, "ERROR:wifi disconnect event 0x%x\n", aw_wifi_get_wifi_event());
|
|
status = APP_WIFI_CFG_SYS_ERR;
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Disconnect the wifi connected ap\r\n");
|
|
status = APP_WIFI_CFG_SUCCESS;
|
|
}
|
|
}
|
|
/* turn off wifi */
|
|
status = aw_wifi_off(p_wifi_interface);
|
|
if(status < 0)
|
|
{
|
|
LOG_EX(LOG_Error, "Turn off wifi failed!\n");
|
|
status = APP_WIFI_CFG_SYS_ERR;
|
|
}
|
|
else
|
|
{
|
|
LOG_EX(LOG_Error, "Turn off wifi succeed!\n");
|
|
wifi_off_mode = 1;
|
|
p_wifi_interface = NULL;
|
|
status = APP_WIFI_CFG_SUCCESS;
|
|
}
|
|
}
|
|
|
|
pResJson = (uint8_t *)api_wifi_res_json_get(status);
|
|
if(NULL != pResJson)
|
|
{
|
|
status = api_wifi_module_cmd_send((1<<MODULE_CONTROLLER),CMD_WIFI_OFF_RESP,(const char *)pResJson);
|
|
if(0 != status)
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module send dbus msg to control er:%d\r\n",status);
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module is send wifi_auto msg : 0x%x to control module\r\n",rsp_code);
|
|
}
|
|
}else
|
|
{
|
|
LOG_EX(LOG_Debug, "Wifi module get res json err\r\n");
|
|
}
|
|
|
|
if(NULL != pResJson)
|
|
{
|
|
free(pResJson);
|
|
pResJson = NULL;
|
|
}
|
|
break;
|
|
#if 0
|
|
case CMD_WIFI_BL_CONF:
|
|
case CMD_WIFI_BL_CONF_ABORT:
|
|
case CMD_WIFI_BL_CLOUD_CHALLENGE_SIGNATURE:
|
|
case CMD_WIFI_BL_CLOUD_SHAREDKEY:
|
|
case CMD_WIFI_BL_DEV_TOKEN_BOUND:
|
|
bl_event_handle(pMsg->busCmd, pMsg->pMsg);
|
|
break;
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void DBusMsgHandleLoop(void* param){
|
|
while(1)
|
|
{
|
|
PDBUS_MSG_PACK pMsg = DBusGetMessage();
|
|
PLIBUV_DBUS_PARAMS pInfo = DBusLibuvGetRuntime();
|
|
|
|
if(pMsg && pInfo)
|
|
DBusOnMessage(pInfo->pLoop, pInfo->pBus, pMsg);
|
|
if(pMsg)
|
|
DBusMsgCleanup(pMsg);
|
|
|
|
usleep(100);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
int main(int argv, char *argc[]){
|
|
|
|
int ret = 0;
|
|
DBusConnection* pBus = NULL;
|
|
uv_loop_t* pLoop = uv_default_loop();
|
|
int fd;
|
|
|
|
g_pDBusInterfaceName = g_pModInfoTable[MODULE_WIFI].modAliase;
|
|
|
|
|
|
//pBus = DBusWithLibuvInit(pLoop, g_pDBusInterfaceName, DBusOnMessage, NULL, NULL, &ret);
|
|
pBus = DBusWithLibuvInit(pLoop, g_pDBusInterfaceName, NULL, NULL, NULL, &ret);
|
|
|
|
if(pBus == NULL)
|
|
{
|
|
fprintf(stderr, "%s(%d): DBusWithLibuvInit Error: %d\n", g_pDBusInterfaceName, MODULE_PLAYER, ret);
|
|
return 0;
|
|
}
|
|
|
|
/* init a uv timer to report cur position */
|
|
uv_timer_init(pLoop, &timerCurPosMsg);
|
|
|
|
/* TO BE FIXED */
|
|
//pthread_mutex_init(&ctrl_mutex, NULL);
|
|
|
|
LOG_EX(LOG_Debug, "Start the wifi communication\n");
|
|
uv_thread_t uvSyncThread;
|
|
uv_thread_create(&uvSyncThread, DBusMsgHandleLoop, NULL);
|
|
|
|
//uv_run(pLoop, UV_RUN_DEFAULT);
|
|
RunUVLoop(pLoop);
|
|
|
|
/*while(TRUE)
|
|
{
|
|
usleep(1000);
|
|
}*/
|
|
|
|
return 0;
|
|
}
|