[SystemInfo] Added SystemInfoEthernetNetwork property.

[Verification] Code compiles, TCT pass rate 100%.

Change-Id: I2f5346ec62a438650642ed21534bf1b8916a3751
Signed-off-by: Pawel Andruszkiewicz <p.andruszkie@samsung.com>

diff --git a/src/systeminfo/systeminfo-utils.cpp b/src/systeminfo/systeminfo-utils.cpp
index cf20b232caeaa01b83d09da04622467a8f5a65e2..841c722e8379de4dcda50c226c1285bbc4d00c42 100644 (file)
--- a/src/systeminfo/systeminfo-utils.cpp
+++ b/src/systeminfo/systeminfo-utils.cpp
@@ -40,44 +40,25 @@
 #include "common/platform_exception.h"
 #include "common/dbus_operation.h"
 
-//Hardcoded values for Kiran Device
-#define FEATURE_OPTIONAL_TELEPHONY 1
-#define FEATURE_OPTIONAL_BT 1
-#define ENABLE_KIRAN 1
-#define FEATURE_OPTIONAL_WI_FI 1
+// TODO:: hardcoded value, only for IsBluetoothAlwaysOn
 #define PROFILE_MOBILE 1
 
-#define DUID_KEY_STRING 28
-#define DUID_BUFFER_SIZE 100
-#define SEED_LENGTH 16
-#define CRYPT_KEY_SIZE 8
-
-#define TAPI_HANDLE_MAX 2
-#define DEFAULT_PROPERTY_COUNT 1
-
-#ifdef FEATURE_OPTIONAL_WI_FI
-#include <wifi.h>
-#endif
-
-#ifdef FEATURE_OPTIONAL_TELEPHONY
-#include <ITapiModem.h>
-#endif
-
-#ifdef FEATURE_OPTIONAL_BT
-#include <bluetooth.h>
-#endif
-
-
 namespace extension {
 namespace systeminfo {
 
 namespace {
+
 const std::string MEMORY_STATE_NORMAL = "NORMAL";
 const std::string MEMORY_STATE_WARNING = "WARNING";
 const int MEMORY_TO_BYTE = 1024;
 const int BASE_GATHERING_INTERVAL = 100;
 const double DISPLAY_INCH_TO_MILLIMETER = 2.54;
-}
+
+const int kTapiMaxHandle = 2;
+const int kDefaultPropertyCount = 1;
+
+}  // namespace
+
 using namespace common;
 
 //Callback functions declarations
@@ -439,7 +420,7 @@ long SimDetailsManager::GetSimCount(TapiHandle **tapi_handle){
       }
     } else {
       LoggerE("Failed to get cp list");
-      sim_count_ = TAPI_HANDLE_MAX;
+      sim_count_ = kTapiMaxHandle;
     }
     g_strfreev(cp_list);
   }
@@ -487,6 +468,9 @@ class SystemInfoListeners {
   PlatformResult RegisterWifiNetworkListener(const SysteminfoUtilsCallback& callback,
                                              SysteminfoInstance& instance);
   PlatformResult UnregisterWifiNetworkListener();
+  PlatformResult RegisterEthernetNetworkListener(const SysteminfoUtilsCallback& callback,
+                                                 SysteminfoInstance& instance);
+  PlatformResult UnregisterEthernetNetworkListener();
   PlatformResult RegisterCellularNetworkListener(const SysteminfoUtilsCallback& callback,
                                                  SysteminfoInstance& instance);
   PlatformResult UnregisterCellularNetworkListener();
@@ -533,6 +517,7 @@ class SystemInfoListeners {
   static PlatformResult UnregisterVconfCallback(const char *in_key, vconf_callback_fn cb);
   PlatformResult RegisterIpChangeCallback(SysteminfoInstance& instance);
   PlatformResult UnregisterIpChangeCallback();
+  bool IsIpChangeCallbackInvalid();
   void InitTapiHandles();
 
   guint m_cpu_event_id;
@@ -553,12 +538,13 @@ class SystemInfoListeners {
   SysteminfoUtilsCallback m_locale_listener;
   SysteminfoUtilsCallback m_network_listener;
   SysteminfoUtilsCallback m_wifi_network_listener;
+  SysteminfoUtilsCallback m_ethernet_network_listener;
   SysteminfoUtilsCallback m_cellular_network_listener;
   SysteminfoUtilsCallback m_peripheral_listener;
   SysteminfoUtilsCallback m_memory_listener;
   SysteminfoUtilsCallback m_camera_flash_listener;
 
-  TapiHandle *m_tapi_handles[TAPI_HANDLE_MAX+1];
+  TapiHandle *m_tapi_handles[kTapiMaxHandle+1];
   //for ip change callback
   connection_h m_connection_handle;
   //! Sensor handle for DeviceOrientation purposes
@@ -582,6 +568,7 @@ SystemInfoListeners::SystemInfoListeners():
             m_locale_listener(nullptr),
             m_network_listener(nullptr),
             m_wifi_network_listener(nullptr),
+            m_ethernet_network_listener(nullptr),
             m_cellular_network_listener(nullptr),
             m_peripheral_listener(nullptr),
             m_memory_listener(nullptr),
@@ -892,14 +879,17 @@ PlatformResult SystemInfoListeners::UnregisterNetworkListener()
 PlatformResult SystemInfoListeners::RegisterWifiNetworkListener(const SysteminfoUtilsCallback& callback,
                                                                 SysteminfoInstance& instance)
 {
+  LoggerD("Entered");
+
+  if (IsIpChangeCallbackInvalid()) {
+    PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
+    CHECK_LISTENER_ERROR(RegisterIpChangeCallback(instance));
+    LoggerD("Registered IP change listener");
+  } else {
+    LoggerD("No need to register IP listener on platform, already registered");
+  }
+
   if (nullptr == m_wifi_network_listener) {
-    if (nullptr == m_cellular_network_listener){
-      //register if there is no callback both for wifi and cellular
-      PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
-      CHECK_LISTENER_ERROR(RegisterIpChangeCallback(instance))
-    } else {
-      LoggerD("No need to register ip listener on platform, already registered");
-    }
     LoggerD("Added callback for WIFI_NETWORK");
     m_wifi_network_listener = callback;
   }
@@ -908,29 +898,73 @@ PlatformResult SystemInfoListeners::RegisterWifiNetworkListener(const Systeminfo
 
 PlatformResult SystemInfoListeners::UnregisterWifiNetworkListener()
 {
-  //unregister if is wifi callback, but no cellular callback
-  if (nullptr != m_wifi_network_listener && nullptr == m_cellular_network_listener) {
+  LoggerD("Entered");
+
+  m_wifi_network_listener = nullptr;
+
+  if (IsIpChangeCallbackInvalid()) {
     PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
-    CHECK_LISTENER_ERROR(UnregisterIpChangeCallback())
-    LoggerD("Removed callback for WIFI_NETWORK");
+    CHECK_LISTENER_ERROR(UnregisterIpChangeCallback());
+    LoggerD("Removed IP change listener");
   } else {
-    LoggerD("Removed callback for WIFI_NETWORK, but cellular listener still works");
+    LoggerD("Removed callback for WIFI_NETWORK, but IP change listener still works");
   }
-  m_wifi_network_listener = nullptr;
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult SystemInfoListeners::RegisterEthernetNetworkListener(const SysteminfoUtilsCallback& callback,
+                                                                    SysteminfoInstance& instance)
+{
+  LoggerD("Entered");
+
+  if (IsIpChangeCallbackInvalid()) {
+    PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
+    CHECK_LISTENER_ERROR(RegisterIpChangeCallback(instance));
+    LoggerD("Registered IP change listener");
+  } else {
+    LoggerD("No need to register IP listener on platform, already registered");
+  }
+
+  if (nullptr == m_ethernet_network_listener) {
+    LoggerD("Added callback for ETHERNET_NETWORK");
+    m_ethernet_network_listener = callback;
+  }
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult SystemInfoListeners::UnregisterEthernetNetworkListener()
+{
+  LoggerD("Entered");
+
+  m_ethernet_network_listener = nullptr;
+
+  if (IsIpChangeCallbackInvalid()) {
+    PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
+    CHECK_LISTENER_ERROR(UnregisterIpChangeCallback());
+    LoggerD("Removed IP change listener");
+  } else {
+    LoggerD("Removed callback for ETHERNET_NETWORK, but IP change listener still works");
+  }
+
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
 PlatformResult SystemInfoListeners::RegisterCellularNetworkListener(const SysteminfoUtilsCallback& callback,
                                                                     SysteminfoInstance& instance)
 {
+  LoggerD("Entered");
+
+  if (IsIpChangeCallbackInvalid()) {
+    PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
+    CHECK_LISTENER_ERROR(RegisterIpChangeCallback(instance));
+    LoggerD("Registered IP change listener");
+  } else {
+    LoggerD("No need to register IP listener on platform, already registered");
+  }
+
   if (nullptr == m_cellular_network_listener) {
     PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
-    if (nullptr == m_wifi_network_listener){
-      //register if there is no callback both for wifi and cellular
-      CHECK_LISTENER_ERROR(RegisterIpChangeCallback(instance))
-    } else {
-      LoggerD("No need to register ip listener on platform, already registered");
-    }
     CHECK_LISTENER_ERROR(RegisterVconfCallback(VCONFKEY_TELEPHONY_FLIGHT_MODE,
                           OnCellularNetworkValueChangedCb, instance))
     CHECK_LISTENER_ERROR(RegisterVconfCallback(VCONFKEY_TELEPHONY_CELLID,
@@ -947,6 +981,8 @@ PlatformResult SystemInfoListeners::RegisterCellularNetworkListener(const System
 
 PlatformResult SystemInfoListeners::UnregisterCellularNetworkListener()
 {
+  LoggerD("Entered");
+
   if (nullptr != m_cellular_network_listener) {
     PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
     CHECK_LISTENER_ERROR(UnregisterVconfCallback(VCONFKEY_TELEPHONY_FLIGHT_MODE,
@@ -957,15 +993,17 @@ PlatformResult SystemInfoListeners::UnregisterCellularNetworkListener()
                             OnCellularNetworkValueChangedCb))
     CHECK_LISTENER_ERROR(UnregisterVconfCallback(VCONFKEY_TELEPHONY_SVC_ROAM,
                             OnCellularNetworkValueChangedCb))
-    if (nullptr == m_wifi_network_listener) {
-      //register if there is no callback both for wifi and cellular
-      CHECK_LISTENER_ERROR(UnregisterIpChangeCallback())
-      LoggerD("Removed callback for CELLULAR_NETWORK");
-    } else {
-      LoggerD("Removed callback for CELLULAR_NETWORK, but cellular listener still works");
-    }
   }
   m_cellular_network_listener = nullptr;
+
+  if (IsIpChangeCallbackInvalid()) {
+    PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
+    CHECK_LISTENER_ERROR(UnregisterIpChangeCallback());
+    LoggerD("Removed IP change listener");
+  } else {
+    LoggerD("Removed callback for CELLULAR_NETWORK, but IP change listener still works");
+  }
+
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
@@ -1188,10 +1226,15 @@ void SystemInfoListeners::OnNetworkChangedCallback(connection_type_e /*type*/, v
 void SystemInfoListeners::OnNetworkValueCallback(const char* /*ipv4_address*/,
                                                  const char* /*ipv6_address*/, void* event_ptr)
 {
+  LoggerD("Entered");
+
   SysteminfoInstance* instance = static_cast<SysteminfoInstance*>(event_ptr);
   if (nullptr != m_wifi_network_listener) {
     m_wifi_network_listener(*instance);
   }
+  if (nullptr != m_ethernet_network_listener) {
+    m_ethernet_network_listener(*instance);
+  }
   if (nullptr != m_cellular_network_listener) {
     m_cellular_network_listener(*instance);
   }
@@ -1248,7 +1291,7 @@ void SystemInfoListeners::InitTapiHandles()
       }
     } else {
       LoggerE("Failed to get cp list");
-      sim_count = TAPI_HANDLE_MAX;
+      sim_count = kTapiMaxHandle;
     }
     g_strfreev(cp_list);
   }
@@ -1332,6 +1375,12 @@ PlatformResult SystemInfoListeners::UnregisterIpChangeCallback()
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
+bool SystemInfoListeners::IsIpChangeCallbackInvalid() {
+  LoggerD("Entered");
+  return (nullptr == m_wifi_network_listener &&
+          nullptr == m_ethernet_network_listener &&
+          nullptr == m_cellular_network_listener);
+}
 
 /////////////////////////// system_info_listeners object ////////////////////////
 
@@ -1552,9 +1601,10 @@ PlatformResult SysteminfoUtils::GetCount(const std::string& property, unsigned l
   if ("BATTERY" == property || "CPU" == property || "STORAGE" == property ||
       "DISPLAY" == property || "DEVICE_ORIENTATION" == property ||
       "BUILD" == property || "LOCALE" == property || "NETWORK" == property ||
-      "WIFI_NETWORK" == property || "CELLULAR_NETWORK" == property ||
-      "PERIPHERAL" == property || "MEMORY" == property) {
-    count = DEFAULT_PROPERTY_COUNT;
+      "WIFI_NETWORK" == property || "ETHERNET_NETWORK" == property ||
+      "CELLULAR_NETWORK" == property || "PERIPHERAL" == property ||
+      "MEMORY" == property) {
+    count = kDefaultPropertyCount;
   } else if ("SIM" == property) {
     count = sim_mgr.GetSimCount(system_info_listeners.GetTapiHandles());
   } else if ("CAMERA_FLASH" == property) {
@@ -1587,6 +1637,8 @@ PlatformResult SysteminfoUtils::ReportProperty(const std::string& property, int
     return ReportNetwork(res_obj);
   } else if ("WIFI_NETWORK" == property) {
     return ReportWifiNetwork(res_obj);
+  } else if ("ETHERNET_NETWORK" == property) {
+    return ReportEthernetNetwork(res_obj);
   } else if ("CELLULAR_NETWORK" == property) {
     return ReportCellularNetwork(res_obj);
   } else if ("SIM" == property) {
@@ -2038,6 +2090,8 @@ static PlatformResult GetIps(connection_profile_h profile_handle, std::string* i
 }
 
 PlatformResult SysteminfoUtils::ReportWifiNetwork(picojson::object& out) {
+  LoggerD("Entered");
+
   bool result_status = false;
   std::string result_ssid;
   std::string result_ip_address;
@@ -2060,10 +2114,10 @@ PlatformResult SysteminfoUtils::ReportWifiNetwork(picojson::object& out) {
   connection_handle_ptr(connection_handle, &connection_destroy);
   // automatically release the memory
 
-  char* mac = NULL;
-  error = wifi_get_mac_address(&mac);
-  if(WIFI_ERROR_NONE == error) {
-    LoggerD("macAddress fetched: %s", mac);
+  char* mac = nullptr;
+  error = connection_get_mac_address(connection_handle, CONNECTION_TYPE_WIFI, &mac);
+  if (CONNECTION_ERROR_NONE == error && nullptr != mac) {
+    SLoggerD("MAC address fetched: %s", mac);
     result_mac_address = mac;
     free(mac);
   } else {
@@ -2136,6 +2190,126 @@ PlatformResult SysteminfoUtils::ReportWifiNetwork(picojson::object& out) {
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
+PlatformResult SysteminfoUtils::ReportEthernetNetwork(picojson::object& out) {
+  LoggerD("Entered");
+
+  std::string result_cable;
+  std::string result_status;
+  std::string result_ip_address;
+  std::string result_ipv6_address;
+  std::string result_mac_address;
+
+  connection_h connection_handle = nullptr;
+  connection_ethernet_state_e connection_state = CONNECTION_ETHERNET_STATE_DEACTIVATED;
+  connection_type_e connection_type = CONNECTION_TYPE_DISCONNECTED;
+  connection_profile_h profile_handle = nullptr;
+
+  // connection must be created in every call, in other case error occurs
+  int error = connection_create(&connection_handle);
+  if (CONNECTION_ERROR_NONE != error) {
+    std::string log_msg = "Cannot create connection: " + std::to_string(error);
+    LoggerE("%s", log_msg.c_str());
+    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+  }
+  std::unique_ptr<std::remove_pointer<connection_h>::type, int (*)(connection_h)> connection_handle_ptr(
+      connection_handle, &connection_destroy);  // automatically release the memory
+
+  error = connection_get_ethernet_state(connection_handle, &connection_state);
+  if (CONNECTION_ERROR_NONE != error) {
+    std::string log_msg = "Cannot get ethernet connection state: " + std::to_string(error);
+    LoggerE("%s", log_msg.c_str());
+    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+  }
+
+  switch (connection_state) {
+    case CONNECTION_ETHERNET_STATE_DEACTIVATED:
+      result_status = "DEACTIVATED";
+      break;
+
+    case CONNECTION_ETHERNET_STATE_DISCONNECTED:
+      result_status = "DISCONNECTED";
+      break;
+
+    case CONNECTION_ETHERNET_STATE_CONNECTED:
+      result_status = "CONNECTED";
+      break;
+
+    default:
+      result_status = "UNKNOWN";
+      break;
+  }
+
+  connection_ethernet_cable_state_e cable_state = CONNECTION_ETHERNET_CABLE_DETACHED;
+  error = connection_get_ethernet_cable_state(connection_handle, &cable_state);
+  if (CONNECTION_ERROR_NONE != error) {
+    std::string log_msg = "Cannot get ethernet cable state: " + std::to_string(error);
+    LoggerE("%s", log_msg.c_str());
+    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+  }
+
+  switch (cable_state) {
+    case CONNECTION_ETHERNET_CABLE_DETACHED:
+      result_cable = "DETACHED";
+      break;
+
+    case CONNECTION_ETHERNET_CABLE_ATTACHED:
+      result_cable = "ATTACHED";
+      break;
+
+    default:
+      result_cable = "UNKNOWN";
+      break;
+  }
+
+  char* mac = nullptr;
+  error = connection_get_mac_address(connection_handle, CONNECTION_TYPE_ETHERNET, &mac);
+  if (CONNECTION_ERROR_NONE == error && nullptr != mac) {
+    SLoggerD("MAC address fetched: %s", mac);
+    result_mac_address = mac;
+    free(mac);
+  } else {
+    std::string log_msg = "Failed to get mac address: " + std::to_string(error);
+    LoggerE("%s", log_msg.c_str());
+    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+  }
+
+  error = connection_get_type(connection_handle, &connection_type);
+  if (CONNECTION_ERROR_NONE != error) {
+    std::string log_msg = "Cannot get connection type: " + std::to_string(error);
+    LoggerE("%s", log_msg.c_str());
+    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+  }
+
+  if (CONNECTION_TYPE_ETHERNET == connection_type) {
+    //gathering profile
+    error = connection_get_current_profile(connection_handle, &profile_handle);
+    if (CONNECTION_ERROR_NONE != error) {
+      std::string log_msg = "Cannot get connection profile: " + std::to_string(error);
+      LoggerE("%s", log_msg.c_str());
+      return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    }
+    std::unique_ptr<std::remove_pointer<connection_profile_h>::type,
+        int (*)(connection_profile_h)> profile_handle_ptr(
+        profile_handle, &connection_profile_destroy); // automatically release the memory
+
+    //gathering ips
+    PlatformResult ret = GetIps(profile_handle, &result_ip_address, &result_ipv6_address);
+    if (ret.IsError()) {
+      return ret;
+    }
+  } else {
+    LoggerD("Connection type = %d. ETHERNET is disabled", connection_type);
+  }
+
+  out.insert(std::make_pair("cable", picojson::value(result_cable)));
+  out.insert(std::make_pair("status", picojson::value(result_status)));
+  out.insert(std::make_pair("ipAddress", picojson::value(result_ip_address)));
+  out.insert(std::make_pair("ipv6Address", picojson::value(result_ipv6_address)));
+  out.insert(std::make_pair("macAddress", picojson::value(result_mac_address)));
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
 static PlatformResult FetchVconfSettings(
     unsigned short *result_mcc,
     unsigned short *result_mnc,
@@ -2562,6 +2736,19 @@ PlatformResult SysteminfoUtils::UnregisterWifiNetworkListener()
   return system_info_listeners.UnregisterWifiNetworkListener();
 }
 
+PlatformResult SysteminfoUtils::RegisterEthernetNetworkListener(const SysteminfoUtilsCallback& callback,
+                                                                SysteminfoInstance& instance)
+{
+  LoggerD("Entered");
+  return system_info_listeners.RegisterEthernetNetworkListener(callback, instance);
+}
+
+PlatformResult SysteminfoUtils::UnregisterEthernetNetworkListener()
+{
+  LoggerD("Entered");
+  return system_info_listeners.UnregisterEthernetNetworkListener();
+}
+
 PlatformResult SysteminfoUtils::RegisterCellularNetworkListener(const SysteminfoUtilsCallback& callback,
                                                                 SysteminfoInstance& instance)
 {

diff --git a/src/systeminfo/systeminfo-utils.h b/src/systeminfo/systeminfo-utils.h
index 73f657ea794aadfd850aebbfb881514a37b0c015..4aa9b28e9fac198ebbbdb849766bdd6d1ae32a1d 100644 (file)
--- a/src/systeminfo/systeminfo-utils.h
+++ b/src/systeminfo/systeminfo-utils.h
@@ -69,6 +69,9 @@ class SysteminfoUtils {
   static common::PlatformResult RegisterWifiNetworkListener(const SysteminfoUtilsCallback& callback,
                                                             SysteminfoInstance& instance);
   static common::PlatformResult UnregisterWifiNetworkListener();
+  static common::PlatformResult RegisterEthernetNetworkListener(const SysteminfoUtilsCallback& callback,
+                                                                SysteminfoInstance& instance);
+  static common::PlatformResult UnregisterEthernetNetworkListener();
   static common::PlatformResult RegisterCellularNetworkListener(const SysteminfoUtilsCallback& callback,
                                                                 SysteminfoInstance& instance);
   static common::PlatformResult UnregisterCellularNetworkListener();
@@ -95,6 +98,7 @@ class SysteminfoUtils {
   static common::PlatformResult ReportLocale(picojson::object& out);
   static common::PlatformResult ReportNetwork(picojson::object& out);
   static common::PlatformResult ReportWifiNetwork(picojson::object& out);
+  static common::PlatformResult ReportEthernetNetwork(picojson::object& out);
   static common::PlatformResult ReportCellularNetwork(picojson::object& out);
   static common::PlatformResult ReportSim(picojson::object& out, unsigned long count);
   static common::PlatformResult ReportPeripheral(picojson::object& out);

diff --git a/src/systeminfo/systeminfo.gyp b/src/systeminfo/systeminfo.gyp
index 51e393bbd1e373ae72e4f4300951a260f85b5f4f..1137ebf4f37f331c68ecd34e2e4b54e1fdd53735 100644 (file)
--- a/src/systeminfo/systeminfo.gyp
+++ b/src/systeminfo/systeminfo.gyp
@@ -32,8 +32,6 @@
             'capi-network-connection',
             'capi-system-device',
             'capi-system-system-settings',
-            'capi-network-bluetooth',
-            'capi-network-wifi',
             'tapi',
             'sensor',
             ]

diff --git a/src/systeminfo/systeminfo_api.js b/src/systeminfo/systeminfo_api.js
index 1b55dbcce7975ed1f8609f1819db7aee57726e74..9847175970571f659a08b461b5adefbde83b9047 100644 (file)
--- a/src/systeminfo/systeminfo_api.js
+++ b/src/systeminfo/systeminfo_api.js
@@ -32,6 +32,7 @@ var SystemInfoPropertyId = {
         LOCALE : 'LOCALE',
         NETWORK : 'NETWORK',
         WIFI_NETWORK : 'WIFI_NETWORK',
+        ETHERNET_NETWORK : 'ETHERNET_NETWORK',
         CELLULAR_NETWORK : 'CELLULAR_NETWORK',
         SIM : 'SIM',
         PERIPHERAL : 'PERIPHERAL',
@@ -552,6 +553,17 @@ function SystemInfoWifiNetwork(data) {
     });
 }
 
+//class SystemInfoEthernetNetwork ////////////////////////////////////////////////////
+function SystemInfoEthernetNetwork(data) {
+    Object.defineProperties(this, {
+        cable : {value: data.cable, writable: false, enumerable: true},
+        status : {value: data.status, writable: false, enumerable: true},
+        ipAddress : {value: data.ipAddress, writable: false, enumerable: true},
+        ipv6Address : {value: data.ipv6Address, writable: false, enumerable: true},
+        macAddress : {value: data.macAddress, writable: false, enumerable: true},
+    });
+}
+
 //class SystemInfoCellularNetwork ////////////////////////////////////////////////////
 function SystemInfoCellularNetwork(data) {
     Object.defineProperties(this, {
@@ -817,6 +829,7 @@ var _deviceOrientationStr = SystemInfoPropertyId.DEVICE_ORIENTATION;
 var _localeStr = SystemInfoPropertyId.LOCALE;
 var _networkStr = SystemInfoPropertyId.NETWORK;
 var _wifiNetworkStr = SystemInfoPropertyId.WIFI_NETWORK;
+var _ethernetNetworkStr = SystemInfoPropertyId.ETHERNET_NETWORK;
 var _cellularNetworkStr = SystemInfoPropertyId.CELLULAR_NETWORK;
 var _simStr = SystemInfoPropertyId.SIM;
 var _peripheralStr = SystemInfoPropertyId.PERIPHERAL;
@@ -964,6 +977,21 @@ function _systeminfoWifiNetworkListenerCallback(eventObj) {
     }
 }
 
+function _systeminfoEthernetNetworkListenerCallback(eventObj) {
+  var property = _ethernetNetworkStr;
+  var callbacks = _propertyContainer[property].callbacks;
+
+  for (var watchId in callbacks) {
+      if (callbacks.hasOwnProperty(watchId)) {
+          var listener = callbacks[watchId];
+          var propObj = !listener.isArrayType ?
+                  _createProperty(property, eventObj.result.array[0]) :
+                      _createPropertyArray(property, eventObj.result);
+          callbacks[watchId].callback(propObj);
+      }
+  }
+}
+
 function _systeminfoCellularNetworkListenerCallback(eventObj) {
     var property = _cellularNetworkStr;
     var callbacks = _propertyContainer[property].callbacks;
@@ -1094,6 +1122,12 @@ var _propertyContainer = {
             broadcastFunction : _systeminfoWifiNetworkListenerCallback,
             signalLabel : 'SystemInfoWifiNetworkChangeBroadcast'
         },
+        'ETHERNET_NETWORK' : {
+            callbacks : {},
+            constructor : SystemInfoEthernetNetwork,
+            broadcastFunction : _systeminfoEthernetNetworkListenerCallback,
+            signalLabel : 'SystemInfoEthernetNetworkChangeBroadcast'
+        },
         'CELLULAR_NETWORK' : {
             callbacks : {},
             constructor : SystemInfoCellularNetwork,

diff --git a/src/systeminfo/systeminfo_instance.cc b/src/systeminfo/systeminfo_instance.cc
index 90d0a0541c041dd9277dd3eaae62900e390354a8..f09aaf5b8e1cdefe63bed7a08e1ffa96a1ec422c 100644 (file)
--- a/src/systeminfo/systeminfo_instance.cc
+++ b/src/systeminfo/systeminfo_instance.cc
@@ -42,6 +42,7 @@ static void OnDeviceOrientationChangedCallback(SysteminfoInstance& instance);
 static void OnLocaleChangedCallback(SysteminfoInstance& instance);
 static void OnNetworkChangedCallback(SysteminfoInstance& instance);
 static void OnWifiNetworkChangedCallback(SysteminfoInstance& instance);
+static void OnEthernetNetworkChangedCallback(SysteminfoInstance& instance);
 static void OnCellularNetworkChangedCallback(SysteminfoInstance& instance);
 static void OnPeripheralChangedCallback(SysteminfoInstance& instance);
 static void OnMemoryChangedCallback(SysteminfoInstance& instance);
@@ -61,6 +62,7 @@ const std::string kPropertyIdBuild = "BUILD";
 const std::string kPropertyIdLocale = "LOCALE";
 const std::string kPropertyIdNetwork = "NETWORK";
 const std::string kPropertyIdWifiNetwork = "WIFI_NETWORK";
+const std::string kPropertyIdEthernetNetwork = "ETHERNET_NETWORK";
 const std::string kPropertyIdCellularNetwork = "CELLULAR_NETWORK";
 const std::string kPropertyIdSim = "SIM";
 const std::string kPropertyIdPeripheral = "PERIPHERAL";
@@ -349,6 +351,8 @@ void SysteminfoInstance::AddPropertyValueChangeListener(const picojson::value& a
     ret = SysteminfoUtils::RegisterNetworkListener(OnNetworkChangedCallback, *this);
   } else if (property_name == kPropertyIdWifiNetwork) {
     ret = SysteminfoUtils::RegisterWifiNetworkListener(OnWifiNetworkChangedCallback, *this);
+  } else if (property_name == kPropertyIdEthernetNetwork) {
+    ret = SysteminfoUtils::RegisterEthernetNetworkListener(OnEthernetNetworkChangedCallback, *this);
   } else if (property_name == kPropertyIdCellularNetwork) {
     ret = SysteminfoUtils::RegisterCellularNetworkListener(OnCellularNetworkChangedCallback, *this);
   } else if (property_name == kPropertyIdSim) {
@@ -461,6 +465,8 @@ void SysteminfoInstance::RemovePropertyValueChangeListener(const picojson::value
     ret = SysteminfoUtils::UnregisterNetworkListener();
   } else if (property_name == kPropertyIdWifiNetwork) {
     ret = SysteminfoUtils::UnregisterWifiNetworkListener();
+  } else if (property_name == kPropertyIdEthernetNetwork) {
+    ret = SysteminfoUtils::UnregisterEthernetNetworkListener();
   } else if (property_name == kPropertyIdCellularNetwork) {
     ret = SysteminfoUtils::UnregisterCellularNetworkListener();
   } else if (property_name == kPropertyIdSim) {
@@ -663,6 +669,22 @@ void OnWifiNetworkChangedCallback(SysteminfoInstance& instance)
   }
 }
 
+void OnEthernetNetworkChangedCallback(SysteminfoInstance& instance)
+{
+  LoggerD("Entered");
+  const std::shared_ptr<picojson::value>& response =
+      std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
+  response->get<picojson::object>()[kPropertyIdString] = picojson::value(kPropertyIdEthernetNetwork);
+  response->get<picojson::object>()[kListenerIdString] = picojson::value(kListenerConstValue);
+
+  picojson::value result = picojson::value(picojson::object());
+  PlatformResult ret = SysteminfoUtils::GetPropertyValue(kPropertyIdEthernetNetwork, true, result);
+  if (ret.IsSuccess()) {
+    ReportSuccess(result,response->get<picojson::object>());
+    instance.PostMessage(response->serialize().c_str());
+  }
+}
+
 void OnCellularNetworkChangedCallback(SysteminfoInstance& instance)
 {
   LoggerD("Enter");