Added support for wi-fi on wearable emulator

Signed-off-by: Abhishek Sansanwal <abhishek.s94@samsung.com>
Change-Id: I263b7e10d92a824459aeb746c0634b4a7edc2188

diff --git a/sources/wearable/CMakeLists.txt b/sources/wearable/CMakeLists.txt
old mode 100755 (executable)
new mode 100644 (file)
index 9584176..46168a9
--- a/sources/wearable/CMakeLists.txt
+++ b/sources/wearable/CMakeLists.txt
@@ -28,6 +28,11 @@ SET(SRCS ${SRCS}
        src/net/wifi_generate_pin.c
        src/net/util/wifi_address.c
        src/util/idler.c)
+IF(TIZEN_EMULATOR)
+       SET(SRCS ${SRCS}
+               src/net/emulator.c)
+ENDIF(TIZEN_EMULATOR)
+
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/inc)
 
 SET(ENGINE_PKGCONFIGS
@@ -72,10 +77,15 @@ pkg_check_modules(pkgs REQUIRED
        efl-extension
        capi-ui-efl-util
        ecore-input
-       capi-network-wifi
        capi-appfw-application
        capi-network-connection)
 
+IF(NOT TIZEN_EMULATOR)
+       INCLUDE(FindPkgConfig)
+       pkg_check_modules(pkgs REQUIRED
+               capi-network-wifi)
+ENDIF(TIZEN_EMULATOR)
+
 FIND_LIBRARY(LIB_M m)
 
 ADD_DEFINITIONS(${pkgs_CFLAGS})

diff --git a/sources/wearable/src/net/emulator.c b/sources/wearable/src/net/emulator.c
new file mode 100644 (file)
index 0000000..d8ef50b
--- /dev/null
+++ b/sources/wearable/src/net/emulator.c
@@ -0,0 +1,433 @@
+/*
+ * Copyright (c) 2014 - 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of
+ * SAMSUNG ELECTRONICS (Confidential Information).
+ * You shall not disclose such Confidential Information and shall
+ * use it only in accordance with the terms of the license agreement
+ * you entered into with SAMSUNG ELECTRONICS.  SAMSUNG make no
+ * representations or warranties about the suitability
+ * of the software, either express or implied, including but not
+ * limited to the implied warranties of merchantability, fitness for a particular purpose, or non-
+ * infringement. SAMSUNG shall not be liable for any damages suffered by licensee as
+ * a result of using, modifying or distributing this software or its derivatives.
+ */
+
+
+#include<wifi.h>
+#include<dlog.h>
+#include<glib.h>
+
+#define INET_ADDRSTRLEN 16
+#define EMU_AP_LENGTH 5
+#define EMU_AP_COUNT 5
+#define NET_WLAN_ESSID_LEN 128
+#define WIFI_SECURITY_TYPE_WPA2_PSK 3
+typedef struct {
+       char essid[NET_WLAN_ESSID_LEN];
+} fake_ap;
+fake_ap fake_ap_list[EMU_AP_COUNT] = { {"DLINK"}, {"INTERNET AP"}, {"NETGEAR"},
+       {"SAMSUNG"}, {"WIFINET"} };
+
+struct _wifi_cb_s {
+       wifi_device_state_changed_cb device_state_cb;
+       void *device_state_user_data;
+       wifi_scan_finished_cb bg_scan_cb;
+       void *bg_scan_user_data;
+       wifi_scan_finished_cb scan_request_cb;
+       void *scan_request_user_data;
+       wifi_scan_finished_cb specific_scan_cb;
+       void *specific_scan_user_data;
+       wifi_connection_state_changed_cb connection_state_cb;
+       void *connection_state_user_data;
+       wifi_activated_cb activated_cb;
+       void *activated_user_data;
+       wifi_deactivated_cb deactivated_cb;
+       void *deactivated_user_data;
+       wifi_connected_cb connected_cb;
+       void *connected_user_data;
+       wifi_disconnected_cb disconnected_cb;
+       void *disconnected_user_data;
+};
+
+struct _wifi_manager_object {
+       GList *cb_data_list;
+       GList *config_list;
+};
+
+typedef struct _wifi_manager_object wifi_manager_object;
+struct _wifi_ap_object {
+       wifi_ap_h ap;
+       gint rssi;
+       bool wps_mode;
+
+       wifi_error_e last_connection_error;
+       gboolean is_captiveportal;
+};
+
+typedef enum {
+       WIFI_MANAGER_CB_DEVICE_STATE_CHANGED,
+       WIFI_MANAGER_CB_CONNECTION_STATE_CHANGED,
+       WIFI_MANAGER_CB_BACKGROUND_SCAN
+} wifi_manager_cb_type;
+typedef struct _wifi_ap_object wifi_ap_object;
+typedef void (*wifi_manager_generic_cb)(wifi_manager_object *manager,
+                                       wifi_ap_object *ap, wifi_error_e error_code, gpointer user_data);
+typedef void (*wifi_manager_generic_state_changed_cb)(wifi_manager_object *manager,
+                                                     wifi_device_state_e device_state,
+                                                     wifi_connection_state_e connection_state, wifi_ap_object *ap,
+                                                     wifi_rssi_level_e rssi_level, gpointer user_data);
+typedef struct {
+       wifi_manager_object *manager;
+       wifi_ap_object *ap;
+       wifi_manager_cb_type type;
+       wifi_manager_generic_cb cb;
+       wifi_manager_generic_state_changed_cb state_changed_cb;
+       gpointer user_data;
+} wifi_manager_cb_data;
+
+
+static struct _wifi_cb_s wifi_callbacks = { 0, };
+
+int wifi_ap_create(const char* essid, wifi_ap_h* ap)
+{
+       ap = (wifi_ap_h *)g_try_malloc0(sizeof(wifi_ap_h));
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_hidden_create(const char* essid, wifi_ap_h* ap)
+{
+       ap = (wifi_ap_h *)g_try_malloc0(sizeof(wifi_ap_h));
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_destroy(wifi_ap_h ap)
+{
+       g_free(ap);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_clone(wifi_ap_h* cloned_ap, wifi_ap_h origin)
+{
+       cloned_ap = (wifi_ap_h *)g_try_malloc0(sizeof(wifi_ap_h));
+       *cloned_ap = origin;
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_refresh(wifi_ap_h ap)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_essid(wifi_ap_h ap, char** essid)
+{
+       static int counter = 0;
+       *essid = g_try_malloc(sizeof(char)*(EMU_AP_LENGTH +1));
+       *essid = g_strdup(fake_ap_list[counter++ % EMU_AP_COUNT].essid);
+       dlog_print(DLOG_ERROR, "WIFI_EFL", "%s", *essid);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_rssi(wifi_ap_h ap, int* rssi)
+{
+       *rssi = (int)g_random_int_range(1, 100);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_frequency(wifi_ap_h ap, int* frequency)
+{
+       *frequency = 2412;
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_max_speed(wifi_ap_h ap, int* max_speed)
+{
+       *max_speed = 0;
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_is_favorite(wifi_ap_h ap, bool* favorite)
+{
+       *favorite = false;
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_is_passpoint(wifi_ap_h ap, bool* passpoint)
+{
+       *passpoint = false;
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_connection_state(wifi_ap_h ap, wifi_connection_state_e* state)
+{
+       *state = WIFI_CONNECTION_STATE_DISCONNECTED;
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_ip_config_type(wifi_ap_h ap, wifi_address_family_e address_family, wifi_ip_config_type_e* type)
+{
+       *type = WIFI_IP_CONFIG_TYPE_DYNAMIC;
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_set_ip_config_type(wifi_ap_h ap, wifi_address_family_e address_family, wifi_ip_config_type_e type)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_ip_address(wifi_ap_h ap, wifi_address_family_e address_family, char** ip_address)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_set_ip_address(wifi_ap_h ap, wifi_address_family_e address_family, const char* ip_address)
+{
+       ip_address = g_try_malloc0(INET_ADDRSTRLEN);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_subnet_mask(wifi_ap_h ap, wifi_address_family_e address_family, char** subnet_mask)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_set_subnet_mask(wifi_ap_h ap, wifi_address_family_e address_family, const char* subnet_mask)
+{
+       subnet_mask = g_try_malloc0(INET_ADDRSTRLEN);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_gateway_address(wifi_ap_h ap, wifi_address_family_e address_family, char** gateway_address)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_set_gateway_address(wifi_ap_h ap, wifi_address_family_e address_family, const char* gateway_address)
+{
+       gateway_address = g_try_malloc0(INET_ADDRSTRLEN);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_proxy_address(wifi_ap_h ap, wifi_address_family_e address_family, char** proxy_address)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_set_proxy_address(wifi_ap_h ap, wifi_address_family_e address_family, const char* proxy_address)
+{
+       proxy_address = g_try_malloc0(INET_ADDRSTRLEN);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_proxy_type(wifi_ap_h ap, wifi_proxy_type_e* type)
+{
+       *type = WIFI_PROXY_TYPE_AUTO;
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_set_proxy_type(wifi_ap_h ap, wifi_proxy_type_e proxy_type)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_dns_address(wifi_ap_h ap, int order, wifi_address_family_e address_family, char** dns_address)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_set_dns_address(wifi_ap_h ap, int order, wifi_address_family_e address_family, const char* dns_address)
+{
+       dns_address = g_try_malloc0(INET_ADDRSTRLEN);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_security_type(wifi_ap_h ap, wifi_security_type_e* type)
+{
+       *type = (wifi_security_type_e)WIFI_SECURITY_TYPE_WPA2_PSK;
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_set_security_type(wifi_ap_h ap, wifi_security_type_e type)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_encryption_type(wifi_ap_h ap, wifi_encryption_type_e* type)
+{
+       *type = (wifi_encryption_type_e)g_random_int_range(0, 5);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_set_encryption_type(wifi_ap_h ap, wifi_encryption_type_e type)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_is_passphrase_required(wifi_ap_h ap, bool* required)
+{
+       static bool flip = true;
+       flip = !flip;
+       *required = flip;
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_set_passphrase(wifi_ap_h ap, const char* passphrase)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_is_wps_supported(wifi_ap_h ap, bool* supported)
+{
+       static bool flip = true;
+       flip = !flip;
+       *supported = flip;
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_get_eap_type(wifi_ap_h ap, wifi_eap_type_e* type)
+{
+       *type = (wifi_eap_type_e)g_random_int_range(0, 5);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_ap_set_eap_type(wifi_ap_h ap, wifi_eap_type_e type)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_initialize(void)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_deinitialize(void)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_activate(wifi_activated_cb callback, void* user_data)
+{
+
+       callback(WIFI_ERROR_NONE, user_data);
+       wifi_callbacks.device_state_cb(WIFI_DEVICE_STATE_ACTIVATED,
+                                      wifi_callbacks.device_state_user_data);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_deactivate(wifi_deactivated_cb callback, void* user_data)
+{
+
+       callback(WIFI_ERROR_NONE, user_data);
+       wifi_callbacks.device_state_cb(WIFI_DEVICE_STATE_DEACTIVATED,
+                                      wifi_callbacks.device_state_user_data);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_is_activated(bool* activated)
+{
+       *activated = true;
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_scan(wifi_scan_finished_cb callback, void* user_data)
+{
+       callback(WIFI_ERROR_NONE, user_data);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_get_connected_ap(wifi_ap_h *ap)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_foreach_found_aps(wifi_found_ap_cb callback, void* user_data)
+{
+       int ap_count = (int)g_random_int_range(5, 10);
+       int i;
+       wifi_ap_h *dummy = g_try_malloc0(sizeof(wifi_ap_h));
+       for (i = 0; i < ap_count; i++)
+               callback(dummy, user_data);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_forget_ap(wifi_ap_h ap)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_get_connection_state(wifi_connection_state_e *connection_state)
+{
+       *connection_state =  WIFI_CONNECTION_STATE_DISCONNECTED;
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_set_device_state_changed_cb(wifi_device_state_changed_cb callback, void* user_data)
+{
+       wifi_callbacks.device_state_cb = callback;
+       wifi_callbacks.device_state_user_data = user_data;
+
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_unset_device_state_changed_cb(void)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_set_background_scan_cb(wifi_scan_finished_cb callback, void* user_data)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_unset_background_scan_cb(void)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_set_connection_state_changed_cb(wifi_connection_state_changed_cb callback, void* user_data)
+{
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_unset_connection_state_changed_cb(void)
+{
+       return WIFI_ERROR_NONE;
+}
+
+
+
+int wifi_config_clone(wifi_config_h origin, wifi_config_h *cloned_config)
+{
+       cloned_config = g_try_malloc0(sizeof(wifi_config_h));
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_config_destroy(wifi_config_h config)
+{
+       g_free(config);
+       return WIFI_ERROR_NONE;
+}
+
+
+
+int wifi_config_foreach_configuration(wifi_config_list_cb callback, void *user_data)
+{
+       wifi_config_h *conf = g_try_malloc0(sizeof(wifi_config_h));
+       callback(conf, user_data);
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_config_get_name(wifi_config_h config, char **name)
+{
+       *name = g_strdup("config");
+       return WIFI_ERROR_NONE;
+}
+
+int wifi_config_get_security_type(wifi_config_h config, wifi_security_type_e *security_type)
+{
+       *security_type = (wifi_security_type_e)g_random_int_range(0, 4);
+       return WIFI_ERROR_NONE;
+}
+

diff --git a/sources/wearable/src/net/emulator.h b/sources/wearable/src/net/emulator.h
new file mode 100644 (file)
index 0000000..3ca364e
--- /dev/null
+++ b/sources/wearable/src/net/emulator.h
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2014 - 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of
+ * SAMSUNG ELECTRONICS (Confidential Information).
+ * You shall not disclose such Confidential Information and shall
+ * use it only in accordance with the terms of the license agreement
+ * you entered into with SAMSUNG ELECTRONICS.  SAMSUNG make no
+ * representations or warranties about the suitability
+ * of the software, either express or implied, including but not
+ * limited to the implied warranties of merchantability, fitness for a particular purpose, or non-
+ * infringement. SAMSUNG shall not be liable for any damages suffered by licensee as
+ * a result of using, modifying or distributing this software or its derivatives.
+ */
+
+
+int wifi_ap_create(const char* essid, wifi_ap_h* ap);
+
+int wifi_ap_hidden_create(const char* essid, wifi_ap_h* ap);
+
+int wifi_ap_destroy(wifi_ap_h ap);
+
+int wifi_ap_clone(wifi_ap_h* cloned_ap, wifi_ap_h origin);
+
+int wifi_ap_refresh(wifi_ap_h ap);
+
+int wifi_ap_get_essid(wifi_ap_h ap, char** essid);
+
+int wifi_ap_get_rssi(wifi_ap_h ap, int* rssi);
+
+int wifi_ap_get_frequency(wifi_ap_h ap, int* frequency);
+
+int wifi_ap_get_max_speed(wifi_ap_h ap, int* max_speed);
+
+int wifi_ap_is_favorite(wifi_ap_h ap, bool* favorite);
+
+int wifi_ap_is_passpoint(wifi_ap_h ap, bool* passpoint);
+
+int wifi_ap_get_connection_state(wifi_ap_h ap, wifi_connection_state_e* state);
+
+int wifi_ap_get_ip_config_type(wifi_ap_h ap, wifi_address_family_e address_family, wifi_ip_config_type_e* type);
+
+int wifi_ap_set_ip_config_type(wifi_ap_h ap, wifi_address_family_e address_family, wifi_ip_config_type_e type);
+
+int wifi_ap_get_ip_address(wifi_ap_h ap, wifi_address_family_e address_family, char** ip_address);
+
+int wifi_ap_set_ip_address(wifi_ap_h ap, wifi_address_family_e address_family, const char* ip_address);
+
+int wifi_ap_get_subnet_mask(wifi_ap_h ap, wifi_address_family_e address_family, char** subnet_mask);
+
+int wifi_ap_set_subnet_mask(wifi_ap_h ap, wifi_address_family_e address_family, const char* subnet_mask);
+
+int wifi_ap_get_gateway_address(wifi_ap_h ap, wifi_address_family_e address_family, char** gateway_address);
+
+int wifi_ap_set_gateway_address(wifi_ap_h ap, wifi_address_family_e address_family, const char* gateway_address);
+
+int wifi_ap_get_proxy_address(wifi_ap_h ap, wifi_address_family_e address_family, char** proxy_address);
+
+int wifi_ap_set_proxy_address(wifi_ap_h ap, wifi_address_family_e address_family, const char* proxy_address);
+
+int wifi_ap_get_proxy_type(wifi_ap_h ap, wifi_proxy_type_e* type);
+
+int wifi_ap_set_proxy_type(wifi_ap_h ap, wifi_proxy_type_e proxy_type);
+
+int wifi_ap_get_dns_address(wifi_ap_h ap, int order, wifi_address_family_e address_family, char** dns_address);
+
+int wifi_ap_set_dns_address(wifi_ap_h ap, int order, wifi_address_family_e address_family, const char* dns_address);
+
+int wifi_ap_get_security_type(wifi_ap_h ap, wifi_security_type_e* type);
+
+int wifi_ap_set_security_type(wifi_ap_h ap, wifi_security_type_e type);
+
+int wifi_ap_get_encryption_type(wifi_ap_h ap, wifi_encryption_type_e* type);
+
+int wifi_ap_set_encryption_type(wifi_ap_h ap, wifi_encryption_type_e type);
+
+int wifi_ap_is_passphrase_required(wifi_ap_h ap, bool* required);
+
+int wifi_ap_set_passphrase(wifi_ap_h ap, const char* passphrase);
+
+int wifi_ap_is_wps_supported(wifi_ap_h ap, bool* supported);
+
+int wifi_ap_get_eap_type(wifi_ap_h ap, wifi_eap_type_e* type);
+
+int wifi_ap_set_eap_type(wifi_ap_h ap, wifi_eap_type_e type);
+
+int wifi_initialize(void);
+
+int wifi_deinitialize(void);
+
+int wifi_activate(wifi_activated_cb callback, void* user_data);
+
+int wifi_deactivate(wifi_deactivated_cb callback, void* user_data);
+
+int wifi_is_activated(bool* activated);
+
+int wifi_scan(wifi_scan_finished_cb callback, void* user_data);
+
+int wifi_get_connected_ap(wifi_ap_h *ap);
+
+int wifi_foreach_found_aps(wifi_found_ap_cb callback, void* user_data);
+
+int wifi_forget_ap(wifi_ap_h ap);
+
+int wifi_get_connection_state(wifi_connection_state_e *connection_state);
+
+int wifi_set_device_state_changed_cb(wifi_device_state_changed_cb callback, void* user_data);
+
+int wifi_unset_device_state_changed_cb(void);
+
+int wifi_set_background_scan_cb(wifi_scan_finished_cb callback, void* user_data);
+
+int wifi_unset_background_scan_cb(void);
+
+int wifi_set_connection_state_changed_cb(wifi_connection_state_changed_cb callback, void* user_data);
+
+int wifi_unset_connection_state_changed_cb(void);
+
+int wifi_config_clone(wifi_config_h origin, wifi_config_h *cloned_config);
+
+int wifi_config_destroy(wifi_config_h config);
+
+int wifi_config_foreach_configuration(wifi_config_list_cb callback, void *user_data);
+
+int wifi_config_get_name(wifi_config_h config, char **name);
+
+int wifi_config_get_security_type(wifi_config_h config, wifi_security_type_e *security_type);

diff --git a/sources/wearable/src/net/wifi_manager.c b/sources/wearable/src/net/wifi_manager.c
index 79175ff..4bda81d 100755 (executable)
--- a/sources/wearable/src/net/wifi_manager.c
+++ b/sources/wearable/src/net/wifi_manager.c
@@ -23,6 +23,9 @@
 #include "net/util/vconf_helper.h"
 #include "net/wifi_manager.h"
 #include "net/wifi_generate_pin.h"
+#ifdef TIZEN_EMULATOR
+#include "emulator.h"
+#endif
 
 typedef enum {
        WIFI_MANAGER_CB_DEVICE_STATE_CHANGED,
@@ -1271,6 +1274,9 @@ void wifi_manager_ap_set_proxy_address(wifi_ap_object *ap_obj, const gchar *prox
 
 bool wifi_manager_ap_is_wps_mode(wifi_ap_object *ap_obj)
 {
+#ifdef TIZEN_EMULATOR
+       return true;
+#endif
        return ap_obj->wps_mode;
 }
 

diff --git a/sources/wearable/src/wearable-circle/app_main.c b/sources/wearable/src/wearable-circle/app_main.c
old mode 100755 (executable)
new mode 100644 (file)
index 899c310..23bc005
--- a/sources/wearable/src/wearable-circle/app_main.c
+++ b/sources/wearable/src/wearable-circle/app_main.c
@@ -298,14 +298,18 @@ static void __wifi_manager_scan_finished_cb(wifi_manager_object *manager,
        app_object *app_obj = user_data;
 
        __WIFI_FUNC_ENTER__;
-
+#ifndef TIZEN_EMULATOR
        WIFI_RET_IF_FAIL(manager != NULL);
+#endif
        WIFI_RET_IF_FAIL(app_obj != NULL);
 
        if (app_obj->is_first_scan) {
+#ifdef TIZEN_EMULATOR
+                       app_obj->scan = _scan_create(app_obj->base, app_obj);
+#else
                if (!app_obj->scan)
                        app_obj->scan = _scan_create(app_obj->base, app_obj);
-
+#endif
                if (idler_util_managed_idle_add(_wifi_manager_scan_start_for_idle,
                                        app_obj) > 0) {
                        return;
@@ -391,8 +395,9 @@ static void __wifi_manager_device_state_changed_cb(wifi_manager_object *manager,
        WIFI_RET_IF_FAIL(app_obj != NULL);
 
        if (is_wifi_device_activated) {
+#ifndef TIZEN_EMULATOR
                if (app_obj->is_scanning_for_wifi_activate && !app_obj->popup_scanning) {
-                       WIFI_LOG_ERR("Scanning popup(for Wi-Fi activate) clolsed by user.");
+                       WIFI_LOG_ERR("Scanning popup(for Wi-Fi activate) closed by user.");
                        wifi_error_e err = wifi_manager_scan(app_obj->wifi_manager, NULL, NULL);
                        if (err != WIFI_ERROR_NONE) {
                                WIFI_LOG_ERR("Wi-Fi Scan failed. error code = %s",
@@ -400,6 +405,7 @@ static void __wifi_manager_device_state_changed_cb(wifi_manager_object *manager,
                        }
                        return;
                }
+#endif
                if (_wifi_manager_scan_start_for_wifi_activated(app_obj)) {
                        _popup_scanning_show(app_obj, FALSE);
                }
@@ -421,7 +427,7 @@ static void __wifi_manager_device_state_changed_cb(wifi_manager_object *manager,
 
 static void _wifi_selected_ap_destroy(app_object *app_obj)
 {
-    WIFI_LOG_INFO("selected_ap_destroy");
+       WIFI_LOG_INFO("selected_ap_destroy");
        wifi_manager_ap_destroy(app_obj->selected_wifi_ap);
        app_obj->selected_wifi_ap = NULL;
 }
@@ -1777,7 +1783,7 @@ static void _popup_change_ap_show_use_ap(app_object *app_obj, wifi_ap_object *ap
 
        app_obj->selected_wifi_ap = wifi_manager_ap_clone(ap); // seonah
        if (app_obj->selected_wifi_ap) {
-        WIFI_LOG_INFO("selected_wifi_ap isn't null!!");
+       WIFI_LOG_INFO("selected_wifi_ap isn't null!!");
        } else
            WIFI_LOG_INFO("selected_wifi_ap is null!!");
 
@@ -2366,7 +2372,7 @@ static void __password_entry_wearable_input_activated_cb(void *data,
        _password_filtering(&password);
        sec_type = wifi_manager_ap_get_security_type(app_obj->selected_wifi_ap);
        wifi_address_set_password(app_obj->address_for_connect, password);
-    WIFI_LOG_INFO("Password[%s]", password);
+       WIFI_LOG_INFO("Password[%s]", password);
        layout_ap_info_set_connect_button_enable(app_obj->ap_info,
                                                 __is_valid_password_length_for_connect_button(password, sec_type));
        layout_ap_info_pop_to(app_obj->ap_info);
@@ -3753,7 +3759,9 @@ static void __scan_button_tap_cb(void *data, Evas_Object *obj, void *event_info)
        }
 
        if (_wifi_manager_scan_start_by_scan_button(app_obj)) {
+#ifndef TIZEN_EMULATOR
                _popup_scanning_show(app_obj, FALSE);
+#endif
        }
 }
 
@@ -3840,7 +3848,7 @@ static gboolean __is_wifi_power_already_changed(wifi_manager_object *manager,
                      is_wifi_use ? "Y" : "N");
        WIFI_LOG_INFO("[Wi-Fi] activate      = %s",
                      is_wifi_activate ? "Y" : "N");
-    WIFI_LOG_INFO("[Wi-Fi] is_on      = %s",
+       WIFI_LOG_INFO("[Wi-Fi] is_on      = %s",
                      is_on ? "Y" : "N");
 
        if (is_on) {
@@ -3886,7 +3894,7 @@ static gboolean __check_wifi_already_power_off_for_main_menu_enable(gpointer use
                layout_main_menu_set_enable(app_obj->main, MAIN_MENU_POWER, EINA_TRUE);
        }
 
-    __WIFI_FUNC_EXIT__;
+       __WIFI_FUNC_EXIT__;
        return FALSE;
 }
 
@@ -3899,10 +3907,10 @@ static void _main_menu_disable_for_wifi_power_on(app_object *app_obj)
 
        if (_is_unable_to_scan_state(app_obj->wifi_manager)) {
                app_obj->popup_unable_scan = _popup_unable_scan_create(app_obj);
-        WIFI_LOG_INFO("Create popup");
+       WIFI_LOG_INFO("Create popup");
                if (app_obj->popup_unable_scan) {
                        popup_unable_scan_show(app_obj->popup_unable_scan);
-            WIFI_LOG_INFO("popup unable scan show");
+                       WIFI_LOG_INFO("popup unable scan show");
                }
        }
 }

diff --git a/sources/wearable/src/wearable-circle/view/layout_scan.c b/sources/wearable/src/wearable-circle/view/layout_scan.c
index 9966fd1..f701ff0 100755 (executable)
--- a/sources/wearable/src/wearable-circle/view/layout_scan.c
+++ b/sources/wearable/src/wearable-circle/view/layout_scan.c
@@ -217,10 +217,17 @@ static inline Elm_Genlist_Item_Class *_create_wifi_ap_itc(layout_scan_object *se
 static void _ap_list_append_ap_item(layout_scan_object *self,
                                    Elm_Genlist_Item_Class *itc, gpointer data)
 {
+#ifndef TIZEN_EMULATOR
        Elm_Object_Item *item = elm_genlist_item_append(self->ap_list, itc,
                                                        data, NULL, ELM_GENLIST_ITEM_NONE,
                                                        self->menu_cb[SCAN_MENU_WIFI_AP_ITEM].tap,
                                                        self->menu_cb[SCAN_MENU_WIFI_AP_ITEM].data);
+#else
+       Elm_Object_Item *item = elm_genlist_item_append(self->ap_list, itc,
+                                                       data, NULL,
+                                                       ELM_GENLIST_ITEM_NONE,
+                                                       NULL, NULL);
+#endif
        Evas_Object *obj = elm_object_item_widget_get(item);
        if (obj) {
                evas_object_data_set(obj, LAYOUT_SCAN_DATA_KEY_WIFI_AP_ITEM_SELECT,
@@ -380,7 +387,7 @@ void layout_scan_no_ap_show(layout_scan_object *self)
 {
        WIFI_RET_IF_FAIL(self);
 
-    __WIFI_FUNC_ENTER__;
+       __WIFI_FUNC_ENTER__;
 
        _layout_content_change(self, SCAN_VIEW_NO_AP);
 
@@ -399,8 +406,7 @@ void layout_scan_ap_list_show(layout_scan_object *self)
        layout_scan_ap_list_update(self);
 
        _layout_content_change(self, SCAN_VIEW_AP_LIST);
-
-    __WIFI_FUNC_ENTER__;
+       __WIFI_FUNC_ENTER__;
 
        WIFI_RET_IF_FAIL(!_is_in_naviframe(self));
        self->naviframe_item = view_base_naviframe_push(self->base,