add log for debugging

- nfc, package

Change-Id: I994daf3a196b407e15ea72de931e097cd69e6700

diff --git a/src/nfc/aid_data.cc b/src/nfc/aid_data.cc
index dd6e1e1afb77a88b4422ffd9a79e4d6b65dbd799..c6af525e5d71ba2e1fc81abb44a7c22778647627 100644 (file)
--- a/src/nfc/aid_data.cc
+++ b/src/nfc/aid_data.cc
@@ -15,6 +15,7 @@
  */
 
 #include "nfc/aid_data.h"
+#include "common/logger.h"
 
 namespace extension {
 namespace nfc {
@@ -22,9 +23,13 @@ namespace nfc {
 AIDData::AIDData(nfc_se_type_e se_type, const char* aid, bool read_only)
     : se_type_(se_type),
       aid_(aid),
-      read_only_(read_only) {}
+      read_only_(read_only)
+{
+  LoggerD("Entered");
+}
 
 picojson::value AIDData::toJSON() const {
+  LoggerD("Entered");
   picojson::value retval = picojson::value(picojson::object());
   picojson::object& obj = retval.get<picojson::object>();
 

diff --git a/src/nfc/nfc_adapter.cc b/src/nfc/nfc_adapter.cc
index 46b8909bab0947844324cbf3628c91f9453d7165..61ce156bc127f4978245ef2b13577f5eba6122e9 100644 (file)
--- a/src/nfc/nfc_adapter.cc
+++ b/src/nfc/nfc_adapter.cc
@@ -89,7 +89,9 @@ NFCAdapter::NFCAdapter():
             m_latest_tag_id(0),
             m_last_tag_handle(nullptr),
             m_se_handle(nullptr),
-            responder_(nullptr) {
+            responder_(nullptr)
+{
+  LoggerD("Entered");
   // NFC library initialization
   int ret = nfc_manager_initialize();
   if(ret != NFC_ERROR_NONE) {
@@ -98,6 +100,7 @@ NFCAdapter::NFCAdapter():
 }
 
 NFCAdapter::~NFCAdapter() {
+  LoggerD("Entered");
   if (m_is_listener_set) {
     nfc_manager_unset_se_event_cb();
   }
@@ -128,16 +131,18 @@ NFCAdapter::~NFCAdapter() {
 }
 
 void NFCAdapter::SetResponder(IResponder* responder) {
+  LoggerD("Entered");
   responder_ = responder;
 }
 
 void NFCAdapter::RespondAsync(const char* msg) {
+  LoggerD("Entered");
   AssertMsg(GetInstance()->responder_, "Handler variable should be set");
   GetInstance()->responder_->RespondAsync(msg);
 }
 
 static picojson::value CreateEventError(double callbackId, const PlatformResult& ret) {
-
+  LoggerD("Entered");
   picojson::value event = picojson::value(picojson::object());
   picojson::object& obj = event.get<picojson::object>();
   tools::ReportError(ret, &obj);
@@ -147,6 +152,7 @@ static picojson::value CreateEventError(double callbackId, const PlatformResult&
 }
 
 static picojson::value createEventSuccess(double callbackId) {
+  LoggerD("Entered");
   picojson::value event = picojson::value(picojson::object());
   picojson::object& obj = event.get<picojson::object>();
   tools::ReportSuccess(obj);
@@ -156,7 +162,7 @@ static picojson::value createEventSuccess(double callbackId) {
 }
 
 static gboolean setPoweredCompleteCB(void* user_data) {
-
+  LoggerD("Entered");
   double* callbackId = static_cast<double*>(user_data);
   picojson::value event = createEventSuccess(*callbackId);
   NFCAdapter::GetInstance()->RespondAsync(event.serialize().c_str());
@@ -194,11 +200,13 @@ static void targetDetectedCallback(nfc_discovered_type_e type,
 }
 
 NFCAdapter* NFCAdapter::GetInstance() {
+  LoggerD("Entered");
   static NFCAdapter instance;
   return &instance;
 }
 
 bool NFCAdapter::GetPowered() {
+  LoggerD("Entered");
   return nfc_manager_is_activated();
 }
 
@@ -301,14 +309,14 @@ static void PostMessage(double* callbackId) {
 #endif
 
 PlatformResult NFCAdapter::SetPowered(const picojson::value& args) {
-
+  LoggerD("Entered");
   double* callbackId = new double(args.get(JSON_CALLBACK_ID).get<double>());
 
   bool powered = args.get("powered").get<bool>();
 
   if (nfc_manager_is_activated() == powered) {
     if (!g_idle_add(setPoweredCompleteCB, static_cast<void*>(callbackId))) {
-      LOGE("g_idle addition failed");
+      LoggerE("g_idle addition failed");
       delete callbackId;
       callbackId = NULL;
       return PlatformResult(ErrorCode::UNKNOWN_ERR, "SetPowered failed.");
@@ -321,7 +329,7 @@ PlatformResult NFCAdapter::SetPowered(const picojson::value& args) {
 
   int ret = app_control_create(&service);
   if (ret != APP_CONTROL_ERROR_NONE) {
-    LOGE("app_control_create failed: %d", ret);
+    LoggerE("app_control_create failed: %d", ret);
     delete callbackId;
     callbackId = NULL;
     return PlatformResult(ErrorCode::UNKNOWN_ERR, "SetPowered failed.");
@@ -330,7 +338,7 @@ PlatformResult NFCAdapter::SetPowered(const picojson::value& args) {
   ret = app_control_set_operation(service,
                                   "http://tizen.org/appcontrol/operation/setting/nfc");
   if (ret != APP_CONTROL_ERROR_NONE) {
-    LOGE("app_control_set_operation failed: %d", ret);
+    LoggerE("app_control_set_operation failed: %d", ret);
     app_control_destroy(service);
     delete callbackId;
     callbackId = NULL;
@@ -339,7 +347,7 @@ PlatformResult NFCAdapter::SetPowered(const picojson::value& args) {
 
   ret = app_control_add_extra_data(service, "type", "nfc");
   if (ret != APP_CONTROL_ERROR_NONE) {
-    LOGE("app_control_add_extra_data failed: %d", ret);
+    LoggerE("app_control_add_extra_data failed: %d", ret);
     app_control_destroy(service);
     delete callbackId;
     callbackId = NULL;
@@ -354,26 +362,26 @@ PlatformResult NFCAdapter::SetPowered(const picojson::value& args) {
       int ret = app_control_get_extra_data(reply, "nfc_status",
                                            &type);
       if (ret != APP_CONTROL_ERROR_NONE) {
-        LOGE("app_control_get_extra_data failed: %d", ret);
+        LoggerE("app_control_get_extra_data failed: %d", ret);
         PostMessage(callbackId);
         return;
       }
-      LOGD("app_control result: %s", type);
+      LoggerD("app_control result: %s", type);
     } else {
-      LOGE("NFC enable app control failed : %d", result);
+      LoggerE("NFC enable app control failed : %d", result);
       PostMessage(callbackId);
       return;
     }
 
     if (!g_idle_add(setPoweredCompleteCB, static_cast<void*>(callbackId))) {
-      LOGE("g_idle addition failed");
+      LoggerE("g_idle addition failed");
       PostMessage(callbackId);
       return;
     }
   }, static_cast<void*>(callbackId));
 
   if (ret != APP_CONTROL_ERROR_NONE) {
-    LOGE("app_control_send_launch_request failed: %d", ret);
+    LoggerE("app_control_send_launch_request failed: %d", ret);
     app_control_destroy(service);
     delete callbackId;
     callbackId = NULL;
@@ -382,7 +390,7 @@ PlatformResult NFCAdapter::SetPowered(const picojson::value& args) {
 
   ret = app_control_destroy(service);
   if (ret != APP_CONTROL_ERROR_NONE) {
-    LOGE("app_control_destroy failed: %d", ret);
+    LoggerE("app_control_destroy failed: %d", ret);
     return PlatformResult(ErrorCode::UNKNOWN_ERR, "SetPowered failed.");
   }
 #else
@@ -390,7 +398,7 @@ PlatformResult NFCAdapter::SetPowered(const picojson::value& args) {
       NFCSetActivationCompletedCallback, static_cast<void*>(callbackId));
 
   if (NFC_ERROR_NONE != ret) {
-    LOGE("setPowered failed %d",ret);
+    LoggerE("setPowered failed %d",ret);
     delete callbackId;
     callbackId = NULL;
     return NFCUtil::CodeToResult(ret, "setPowered failed.");
@@ -427,6 +435,7 @@ PlatformResult NFCAdapter::SetCardEmulationMode(const std::string& mode) {
   result = GetCardEmulationMode(&current_mode);
 
   if (result.IsError()) {
+    LoggerD("Error: %s", result.message().c_str());
     return result;
   }
 
@@ -482,6 +491,7 @@ PlatformResult NFCAdapter::SetActiveSecureElement(std::string element) {
   PlatformResult result = NFCUtil::ToSecureElementType(element, &new_type);
 
   if (result.IsError()) {
+    LoggerD("Error: %s", result.message().c_str());
     return result;
   }
   LoggerD("Secure element type value: %x", (int)new_type);
@@ -490,6 +500,7 @@ PlatformResult NFCAdapter::SetActiveSecureElement(std::string element) {
   result = GetActiveSecureElement(&current_type);
 
   if (result.IsError()) {
+    LoggerD("Error: %s", result.message().c_str());
     return result;
   }
 
@@ -526,10 +537,11 @@ PlatformResult NFCAdapter::SetExclusiveModeForTransaction(bool exmode) {
 }
 
 PlatformResult NFCAdapter::AddCardEmulationModeChangeListener() {
+  LoggerD("Entered");
   if (!m_is_listener_set) {
     int ret = nfc_manager_set_se_event_cb(se_event_callback, nullptr);
     if (NFC_ERROR_NONE != ret) {
-      LOGE("AddCardEmulationModeChangeListener failed: %d", ret);
+      LoggerE("AddCardEmulationModeChangeListener failed: %d", ret);
       return NFCUtil::CodeToResult(ret,
                                  NFCUtil::getNFCErrorMessage(ret).c_str());
     }
@@ -540,8 +552,9 @@ PlatformResult NFCAdapter::AddCardEmulationModeChangeListener() {
 }
 
 PlatformResult NFCAdapter::RemoveCardEmulationModeChangeListener() {
+  LoggerD("Entered");
   if (!nfc_manager_is_supported()) {
-    LOGE("NFC Not Supported");
+    LoggerE("NFC Not Supported");
     return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, "NFC Not Supported");
   }
 
@@ -555,11 +568,13 @@ PlatformResult NFCAdapter::RemoveCardEmulationModeChangeListener() {
 
 PlatformResult NFCAdapter::AddTransactionEventListener(
     const picojson::value& args) {
+  LoggerD("Entered");
 
   nfc_se_type_e se_type = NFC_SE_TYPE_DISABLE;
   PlatformResult result = NFCUtil::ToSecureElementType(
       args.get(JSON_TYPE).get<string>(), &se_type);
   if (result.IsError()) {
+    LoggerD("Error: %s", result.message().c_str());
     return result;
   }
 
@@ -585,7 +600,7 @@ PlatformResult NFCAdapter::AddTransactionEventListener(
   }
 
   if (NFC_ERROR_NONE != ret) {
-    LOGE("AddTransactionEventListener failed: %d", ret);
+    LoggerE("AddTransactionEventListener failed: %d", ret);
     return NFCUtil::CodeToResult(ret, NFCUtil::getNFCErrorMessage(ret).c_str());
   }
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -593,6 +608,7 @@ PlatformResult NFCAdapter::AddTransactionEventListener(
 
 PlatformResult NFCAdapter::RemoveTransactionEventListener(
     const picojson::value& args) {
+  LoggerD("Entered");
 
   nfc_se_type_e se_type = NFC_SE_TYPE_DISABLE;
   PlatformResult result =
@@ -617,10 +633,11 @@ PlatformResult NFCAdapter::RemoveTransactionEventListener(
 }
 
 PlatformResult NFCAdapter::AddActiveSecureElementChangeListener() {
+  LoggerD("Entered");
   if (!m_is_listener_set) {
     int ret = nfc_manager_set_se_event_cb(se_event_callback, nullptr);
     if (NFC_ERROR_NONE != ret) {
-      LOGE("AddActiveSecureElementChangeListener failed: %d", ret);
+      LoggerE("AddActiveSecureElementChangeListener failed: %d", ret);
       return NFCUtil::CodeToResult(ret,
                                  NFCUtil::getNFCErrorMessage(ret).c_str());
     }
@@ -631,8 +648,9 @@ PlatformResult NFCAdapter::AddActiveSecureElementChangeListener() {
 }
 
 PlatformResult NFCAdapter::RemoveActiveSecureElementChangeListener() {
+  LoggerD("Entered");
   if (!nfc_manager_is_supported()) {
-    LOGE("NFC Not Supported");
+    LoggerE("NFC Not Supported");
     return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, "NFC Not Supported");
   }
 
@@ -644,22 +662,27 @@ PlatformResult NFCAdapter::RemoveActiveSecureElementChangeListener() {
 }
 
 void NFCAdapter::SetPeerHandle(nfc_p2p_target_h handle) {
+  LoggerD("Entered");
   m_peer_handle = handle;
 }
 
 nfc_p2p_target_h NFCAdapter::GetPeerHandle() {
+  LoggerD("Entered");
   return m_peer_handle;
 }
 
 int NFCAdapter::GetPeerId() {
+  LoggerD("Entered");
   return m_latest_peer_id;
 }
 
 void NFCAdapter::IncreasePeerId() {
+  LoggerD("Entered");
   m_latest_peer_id++;
 }
 
 PlatformResult NFCAdapter::PeerIsConnectedGetter(int peer_id, bool* state) {
+  LoggerD("Entered");
   if (m_latest_peer_id != peer_id || !m_peer_handle) {
     *state = false;
     return PlatformResult(ErrorCode::NO_ERROR);
@@ -668,7 +691,7 @@ PlatformResult NFCAdapter::PeerIsConnectedGetter(int peer_id, bool* state) {
   nfc_p2p_target_h handle = NULL;
   int ret = nfc_manager_get_connected_target(&handle);
   if (NFC_ERROR_NONE != ret) {
-    LOGE("Failed to get connected target handle: %d", ret);
+    LoggerE("Failed to get connected target handle: %d", ret);
     return NFCUtil::CodeToResult(ret, "Failed to get connected target.");
   }
 
@@ -678,15 +701,16 @@ PlatformResult NFCAdapter::PeerIsConnectedGetter(int peer_id, bool* state) {
 }
 
 PlatformResult NFCAdapter::SetPeerListener() {
+  LoggerD("Entered");
   if (!nfc_manager_is_supported()) {
-    LOGE("NFC Not Supported");
+    LoggerE("NFC Not Supported");
     return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, "NFC Not Supported");
   }
 
   if (!m_is_peer_listener_set) {
     int ret = nfc_manager_set_p2p_target_discovered_cb (targetDetectedCallback, NULL);
     if (NFC_ERROR_NONE != ret) {
-      LOGE("Failed to set listener: %d", ret);
+      LoggerE("Failed to set listener: %d", ret);
       return NFCUtil::CodeToResult(ret, "setPeerListener failed");
     }
     m_is_peer_listener_set = true;
@@ -696,7 +720,9 @@ PlatformResult NFCAdapter::SetPeerListener() {
 }
 
 PlatformResult NFCAdapter::UnsetPeerListener() {
+  LoggerD("Entered");
   if (!nfc_manager_is_supported()) {
+    LoggerE("NFC Not Supported");
     return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, "NFC Not Supported");
   }
 
@@ -711,10 +737,11 @@ PlatformResult NFCAdapter::UnsetPeerListener() {
 static void targetReceivedCallback(nfc_p2p_target_h /*target*/,
                                    nfc_ndef_message_h message,
                                    void* /*data*/) {
+  LoggerD("Entered");
   unsigned char* raw_data = NULL;
   unsigned int size;
   if (NFC_ERROR_NONE != nfc_ndef_message_get_rawdata(message, &raw_data, &size)) {
-    LOGE("Unknown error while getting raw data of message.");
+    LoggerE("Unknown error while getting raw data of message.");
     free(raw_data);
     return;
   }
@@ -731,11 +758,12 @@ static void targetReceivedCallback(nfc_p2p_target_h /*target*/,
 }
 
 PlatformResult NFCAdapter::SetReceiveNDEFListener(int peer_id) {
+  LoggerD("Entered");
   //unregister previous NDEF listener
   if (m_is_ndef_listener_set) {
     int ret = nfc_p2p_unset_data_received_cb(m_peer_handle);
     if (NFC_ERROR_NONE != ret) {
-      LOGW("Unregister ReceiveNDEFListener error: %d", ret);
+      LoggerW("Unregister ReceiveNDEFListener error: %d", ret);
     }
     m_is_ndef_listener_set = false;
   }
@@ -744,17 +772,18 @@ PlatformResult NFCAdapter::SetReceiveNDEFListener(int peer_id) {
   bool is_connected = false;
   PlatformResult result = PeerIsConnectedGetter(peer_id, &is_connected);
   if (result.IsError()) {
+    LoggerD("Error: %s", result.message().c_str());
     return result;
   }
 
   if (!is_connected) {
-    LOGE("Target is not connected");
+    LoggerE("Target is not connected");
     return PlatformResult(ErrorCode::UNKNOWN_ERR, "Target is not connected.");
   }
 
   int ret = nfc_p2p_set_data_received_cb(m_peer_handle, targetReceivedCallback, NULL);
   if (NFC_ERROR_NONE != ret) {
-    LOGE("Failed to set NDEF listener: %d", ret);
+    LoggerE("Failed to set NDEF listener: %d", ret);
     return NFCUtil::CodeToResult(ret, "Failed to set NDEF listener");
   }
 
@@ -763,22 +792,24 @@ PlatformResult NFCAdapter::SetReceiveNDEFListener(int peer_id) {
 }
 
 PlatformResult NFCAdapter::UnsetReceiveNDEFListener(int peer_id) {
+  LoggerD("Entered");
   if (m_is_ndef_listener_set) {
     //check if peer object is still connected
 
     bool is_connected = false;
     PlatformResult result = PeerIsConnectedGetter(peer_id, &is_connected);
     if (result.IsError()) {
+      LoggerD("Error: %s", result.message().c_str());
       return result;
     }
 
     if (!is_connected) {
-      LOGE("Target is not connected");
+      LoggerE("Target is not connected");
     }
 
     int ret = nfc_p2p_unset_data_received_cb(m_peer_handle);
     if (NFC_ERROR_NONE != ret) {
-      LOGE("Unregister ReceiveNDEFListener error: %d", ret);
+      LoggerE("Unregister ReceiveNDEFListener error: %d", ret);
       return NFCUtil::CodeToResult(ret, "Failed to set NDEF listener");
     }
 
@@ -788,6 +819,7 @@ PlatformResult NFCAdapter::UnsetReceiveNDEFListener(int peer_id) {
 }
 
 bool NFCAdapter::IsNDEFListenerSet() {
+  LoggerD("Entered");
   return m_is_ndef_listener_set;
 }
 
@@ -840,6 +872,7 @@ static bool tagPropertiesGetterCb(const char* key,
                                   const unsigned char* value,
                                   int value_size,
                                   void* user_data) {
+  LoggerD("Entered");
   if (user_data) {
     UCharVector tag_info = NFCUtil::ToVector(value, value_size);
     (static_cast<NFCTagPropertiesT*>(user_data))->push_back(
@@ -898,7 +931,6 @@ PlatformResult NFCAdapter::TagIsConnectedGetter(int tag_id, bool* state) {
 }
 
 int NFCAdapter::GetNextTagId() {
-
   LoggerD("Entered");
   return ++m_latest_tag_id;
 }
@@ -974,6 +1006,7 @@ void NFCAdapter::UnsetTagListener() {
 }
 
 void NFCAdapter::SetTagHandle(nfc_tag_h tag) {
+  LoggerD("Entered");
   m_last_tag_handle = tag;
 }
 
@@ -1058,6 +1091,7 @@ PlatformResult NFCAdapter::TagReadNDEF(int tag_id,
     // for permission related error throw exception ...
     if(NFC_ERROR_SECURITY_RESTRICTED == ret ||
         NFC_ERROR_PERMISSION_DENIED == ret) {
+      LoggerD("Error: %d", ret);
       return PlatformResult(ErrorCode::SECURITY_ERR, "Failed to read NDEF - permission denied");
     }
 
@@ -1081,6 +1115,7 @@ PlatformResult NFCAdapter::TagWriteNDEF(int tag_id,
   bool is_connected = false;
   PlatformResult result = TagIsConnectedGetter(tag_id, &is_connected);
   if (result.IsError()) {
+    LoggerD("Error: %s", result.message().c_str());
     return result;
   }
 
@@ -1104,6 +1139,7 @@ PlatformResult NFCAdapter::TagWriteNDEF(int tag_id,
   result = NFCMessageUtils::NDEFMessageToStruct(records_array, size, &message);
 
   if (result.IsError()) {
+    LoggerD("Error: %s", result.message().c_str());
     return result;
   }
 
@@ -1116,6 +1152,7 @@ PlatformResult NFCAdapter::TagWriteNDEF(int tag_id,
       // for permission related error throw exception
       if(NFC_ERROR_SECURITY_RESTRICTED == ret ||
           NFC_ERROR_PERMISSION_DENIED == ret) {
+        LoggerE("Error: %d", ret);
         return PlatformResult(ErrorCode::SECURITY_ERR, "Failed to read NDEF - permission denied");
       }
 
@@ -1218,6 +1255,7 @@ PlatformResult NFCAdapter::TagTransceive(int tag_id, const picojson::value& args
     // for permission related error throw exception
     if(NFC_ERROR_SECURITY_RESTRICTED == ret ||
         NFC_ERROR_PERMISSION_DENIED == ret) {
+      LoggerE("Error: %d", ret);
       return PlatformResult(ErrorCode::SECURITY_ERR,
           "Failed to read NDEF - permission denied");
     }
@@ -1234,15 +1272,17 @@ PlatformResult NFCAdapter::TagTransceive(int tag_id, const picojson::value& args
 }
 
 PlatformResult NFCAdapter::GetCachedMessage(picojson::object& out) {
+  LoggerD("Entered");
   nfc_ndef_message_h message_handle = NULL;
   int result = nfc_manager_get_cached_message(&message_handle);
   if (NFC_ERROR_INVALID_NDEF_MESSAGE == result ||
       NFC_ERROR_NO_NDEF_MESSAGE == result) {
+    LoggerE("Error: %d", result);
     NFCMessageUtils::RemoveMessageHandle(message_handle);
     return PlatformResult(ErrorCode::NO_ERROR);
   }
   if (NFC_ERROR_NONE != result) {
-    LOGE("Failed to get cached message: %d", result);
+    LoggerE("Failed to get cached message: %d", result);
     NFCMessageUtils::RemoveMessageHandle(message_handle);
     return NFCUtil::CodeToResult(result, "Failed to get cached message");
   }
@@ -1250,7 +1290,7 @@ PlatformResult NFCAdapter::GetCachedMessage(picojson::object& out) {
   unsigned int size;
   if (NFC_ERROR_NONE != nfc_ndef_message_get_rawdata(message_handle,
                                                      &raw_data, &size)) {
-    LOGE("Unknown error while getting message.");
+    LoggerE("Unknown error while getting message.");
     free(raw_data);
     NFCMessageUtils::RemoveMessageHandle(message_handle);
     return PlatformResult(ErrorCode::NO_ERROR);
@@ -1259,6 +1299,7 @@ PlatformResult NFCAdapter::GetCachedMessage(picojson::object& out) {
       size, out);
   free(raw_data);
   if (ret.IsError()) {
+    LoggerE("Error: %d", ret.message().c_str());
     NFCMessageUtils::RemoveMessageHandle(message_handle);
     return ret;
   }
@@ -1267,9 +1308,11 @@ PlatformResult NFCAdapter::GetCachedMessage(picojson::object& out) {
 }
 
 static void peerSentCallback(nfc_error_e result, void* user_data) {
+  LoggerD("Entered");
   double* callbackId = static_cast<double*>(user_data);
 
   if (NFC_ERROR_NONE != result){
+    LoggerE("Error: %d", result);
     std::string error_message = NFCUtil::getNFCErrorMessage(result);
 
     PlatformResult ret = NFCUtil::CodeToResult(result, error_message.c_str());
@@ -1285,15 +1328,17 @@ static void peerSentCallback(nfc_error_e result, void* user_data) {
 }
 
 static gboolean sendNDEFErrorCB(void* user_data) {
+  LoggerD("Entered");
   peerSentCallback(NFC_ERROR_INVALID_NDEF_MESSAGE, user_data);
   return false;
 }
 
 PlatformResult NFCAdapter::sendNDEF(int peer_id, const picojson::value& args) {
-
+  LoggerD("Entered");
   bool is_connected = false;
   PlatformResult result = PeerIsConnectedGetter(peer_id, &is_connected);
   if (result.IsError()) {
+    LoggerE("Error: %s", result.message().c_str());
     return result;
   }
 
@@ -1320,14 +1365,14 @@ PlatformResult NFCAdapter::sendNDEF(int peer_id, const picojson::value& args) {
         static_cast<void*>(callbackId));
     NFCMessageUtils::RemoveMessageHandle(message);
     if (NFC_ERROR_NONE != ret) {
-      LOGE("sendNDEF failed %d",ret);
+      LoggerE("sendNDEF failed %d",ret);
       delete callbackId;
       callbackId = NULL;
       return NFCUtil::CodeToResult(ret, "sendNDEF failed.");
     }
   } else {
     if (!g_idle_add(sendNDEFErrorCB, static_cast<void*>(callbackId))) {
-      LOGE("g_idle addition failed");
+      LoggerE("g_idle addition failed");
       delete callbackId;
       callbackId = NULL;
     }
@@ -1336,10 +1381,12 @@ PlatformResult NFCAdapter::sendNDEF(int peer_id, const picojson::value& args) {
 }
 
 void NFCAdapter::SetSEHandle(nfc_se_h handle) {
+  LoggerD("Entered");
   m_se_handle = handle;
 }
 
 nfc_se_h NFCAdapter::GetSEHandle() {
+  LoggerD("Entered");
   return m_se_handle;
 }
 
@@ -1384,6 +1431,7 @@ void NFCAdapter::SendHostAPDUResponse(
   if (NFC_ERROR_NONE == ret) {
     success_cb();
   } else {
+    LoggerE("Error: %d", ret);
     error_cb(
         NFCUtil::CodeToResult(ret, NFCUtil::getNFCErrorMessage(ret).c_str()));
   }
@@ -1399,6 +1447,7 @@ PlatformResult NFCAdapter::IsActivatedHandlerForAID(
   nfc_se_type_e se_type;
   PlatformResult result = NFCUtil::ToSecureElementType(type, &se_type);
   if (!result.IsError()) {
+    LoggerE("Error: %s", result.message().c_str());
     return result;
   }
 
@@ -1417,11 +1466,13 @@ PlatformResult NFCAdapter::IsActivatedHandlerForCategory(
     const std::string& type,
     nfc_card_emulation_category_type_e category,
     bool* is_activated_handler) {
+  LoggerD("Entered");
   AssertMsg(is_activated_handler, "Poiner can not be null!");
 
   nfc_se_type_e se_type;
   PlatformResult result = NFCUtil::ToSecureElementType(type, &se_type);
   if (!result.IsError()) {
+    LoggerE("Error: %s", result.message().c_str());
     return result;
   }
 
@@ -1440,10 +1491,11 @@ PlatformResult NFCAdapter::RegisterAID(
     const std::string& type,
     const std::string& aid,
     nfc_card_emulation_category_type_e category) {
-
+  LoggerD("Entered");
   nfc_se_type_e se_type;
   PlatformResult result = NFCUtil::ToSecureElementType(type, &se_type);
   if (!result.IsError()) {
+    LoggerE("Error: %s", result.message().c_str());
     return result;
   }
 
@@ -1460,10 +1512,11 @@ PlatformResult NFCAdapter::UnregisterAID(
     const std::string& type,
     const std::string& aid,
     nfc_card_emulation_category_type_e category) {
-
+  LoggerD("Entered");
   nfc_se_type_e se_type;
   PlatformResult result = NFCUtil::ToSecureElementType(type, &se_type);
   if (!result.IsError()) {
+    LoggerE("Error: %s", result.message().c_str());
     return result;
   }
 
@@ -1492,10 +1545,11 @@ void NFCAdapter::GetAIDsForCategory(
     nfc_card_emulation_category_type_e category,
     const std::function<void(const AIDDataVector&)>& success_cb,
     const std::function<void(const PlatformResult&)>& error_cb) {
-
+  LoggerD("Entered");
   nfc_se_type_e se_type;
   PlatformResult result = NFCUtil::ToSecureElementType(type, &se_type);
   if (!result.IsError()) {
+    LoggerE("Error: %s", result.message().c_str());
     error_cb(result);
     return;
   }

diff --git a/src/nfc/nfc_extension.cc b/src/nfc/nfc_extension.cc
index 09896ce78029682a2228ea85651d1f706b3db444..4475d8d7f73b163a02a80518f480f2089ad8d040 100644 (file)
--- a/src/nfc/nfc_extension.cc
+++ b/src/nfc/nfc_extension.cc
@@ -17,6 +17,7 @@
 #include "nfc/nfc_extension.h"
 
 #include "nfc/nfc_instance.h"
+#include "common/logger.h"
 
 extern const char kSource_nfc_api[];
 
@@ -25,6 +26,7 @@ common::Extension* CreateExtension() {
 }
 
 NFCExtension::NFCExtension() {
+  LoggerD("Entered");
   SetExtensionName("tizen.nfc");
   SetJavaScriptAPI(kSource_nfc_api);
 
@@ -39,8 +41,12 @@ NFCExtension::NFCExtension() {
   SetExtraJSEntryPoints(entry_points);
 }
 
-NFCExtension::~NFCExtension() {}
+NFCExtension::~NFCExtension()
+{
+  LoggerD("Entered");
+}
 
 common::Instance* NFCExtension::CreateInstance() {
+  LoggerD("Entered");
   return new extension::nfc::NFCInstance();
 }

diff --git a/src/nfc/nfc_instance.cc b/src/nfc/nfc_instance.cc
index f38b37a1394cb76c37dcd2d32459d5882734a917..9f85ac7741d9de372b133f2585f28f54be4e6aab 100644 (file)
--- a/src/nfc/nfc_instance.cc
+++ b/src/nfc/nfc_instance.cc
@@ -35,10 +35,12 @@ using namespace common;
 using namespace extension::nfc;
 
 void NFCInstance::RespondAsync(const char* msg) {
+  LoggerD("Entered");
   PostMessage(msg);
 }
 
 NFCInstance::NFCInstance() {
+  LoggerD("Entered");
   using std::placeholders::_1;
   using std::placeholders::_2;
 #define REGISTER_ASYNC(c,x) \
@@ -123,6 +125,7 @@ NFCInstance::NFCInstance() {
   }
 
 NFCInstance::~NFCInstance() {
+  LoggerD("Entered");
 }
 
 void NFCInstance::GetDefaultAdapter(
@@ -146,11 +149,13 @@ void NFCInstance::GetDefaultAdapter(
 
 void NFCInstance::SetExclusiveMode(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   CHECK_EXIST(args, "exclusiveMode", out);
   bool exmode = args.get("exclusiveMode").get<bool>();
 
   int ret = nfc_manager_set_system_handler_enable(!exmode);
   if (NFC_ERROR_NONE != ret) {
+    LoggerE("Error: %d", ret);
     PlatformResult result = NFCUtil::CodeToResult(ret,
                                                   "Failed to set exclusive mode.");
     ReportError(result, &out);
@@ -162,79 +167,92 @@ void NFCInstance::SetExclusiveMode(
 //TODO(g.rynkowski): Rewrite to asynchronous approach
 void NFCInstance::SetPowered(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   PlatformResult result = NFCAdapter::GetInstance()->SetPowered(args);
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::GetPowered(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   bool ret = NFCAdapter::GetInstance()->GetPowered();
   ReportSuccess(picojson::value(ret), out);
 }
 
 void NFCInstance::CardEmulationModeSetter(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   CHECK_EXIST(args, "emulationMode", out);
   std::string mode = args.get("emulationMode").get<std::string>();
   PlatformResult result = NFCAdapter::GetInstance()->SetCardEmulationMode(mode);
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::CardEmulationModeGetter(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   std::string mode = "";
   PlatformResult result = NFCAdapter::GetInstance()->GetCardEmulationMode(&mode);
   if (result.IsSuccess()) {
     ReportSuccess(picojson::value(mode), out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::ActiveSecureElementSetter(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   CHECK_EXIST(args, "secureElement", out);
   std::string ase = args.get("secureElement").get<std::string>();
   PlatformResult result = NFCAdapter::GetInstance()->SetActiveSecureElement(ase);
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::ActiveSecureElementGetter(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   std::string ase = "";
   PlatformResult result = NFCAdapter::GetInstance()->GetActiveSecureElement(&ase);
   if (result.IsSuccess()) {
     ReportSuccess(picojson::value(ase), out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::SetTagListener(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   PlatformResult result = NFCAdapter::GetInstance()->SetTagListener();
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::PeerIsConnectedGetter(
     const picojson::value& args, picojson::object& out) {
-
+  LoggerD("Entered");
   CHECK_EXIST(args, "id", out);
 
   int peer_id = (int)args.get("id").get<double>();
@@ -244,6 +262,7 @@ void NFCInstance::PeerIsConnectedGetter(
   if (result.IsSuccess()) {
     ReportSuccess(picojson::value(ret), out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 
@@ -251,92 +270,110 @@ void NFCInstance::PeerIsConnectedGetter(
 
 void NFCInstance::SetPeerListener(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   PlatformResult result = NFCAdapter::GetInstance()->SetPeerListener();
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::UnsetTagListener(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   NFCAdapter::GetInstance()->UnsetTagListener();
   ReportSuccess(out);
 }
 
 void NFCInstance::UnsetPeerListener(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   PlatformResult result = NFCAdapter::GetInstance()->UnsetPeerListener();
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::AddCardEmulationModeChangeListener(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   PlatformResult result = NFCAdapter::GetInstance()->AddCardEmulationModeChangeListener();
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::RemoveCardEmulationModeChangeListener(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   PlatformResult result = NFCAdapter::GetInstance()->RemoveCardEmulationModeChangeListener();
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::AddTransactionEventListener(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   PlatformResult result = NFCAdapter::GetInstance()->AddTransactionEventListener(args);
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::RemoveTransactionEventListener(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   PlatformResult result = NFCAdapter::GetInstance()->RemoveTransactionEventListener(args);
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::AddActiveSecureElementChangeListener(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   PlatformResult result = NFCAdapter::GetInstance()->AddActiveSecureElementChangeListener();
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::RemoveActiveSecureElementChangeListener(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   PlatformResult result = NFCAdapter::GetInstance()->RemoveActiveSecureElementChangeListener();
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::GetCachedMessage(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   picojson::value result = picojson::value(picojson::object());
   picojson::object& result_obj = result.get<picojson::object>();
 
@@ -344,12 +381,14 @@ void NFCInstance::GetCachedMessage(
   if (ret.IsSuccess()) {
     ReportSuccess(result, out);
   } else {
+    LoggerE("Error: %s", ret.message().c_str());
     ReportError(ret, &out);
   }
 }
 
 void NFCInstance::SetExclusiveModeForTransaction(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   CHECK_EXIST(args, "transactionMode", out);
 
   bool transaction_mode = args.get("transactionMode").get<bool>();
@@ -358,6 +397,7 @@ void NFCInstance::SetExclusiveModeForTransaction(
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
@@ -365,6 +405,7 @@ void NFCInstance::SetExclusiveModeForTransaction(
 //TODO(g.rynkowski): Rewrite to asynchronous approach
 void NFCInstance::ReadNDEF(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   CHECK_EXIST(args, "id", out);
 
   int tag_id = static_cast<int>(args.get("id").get<double>());
@@ -374,6 +415,7 @@ void NFCInstance::ReadNDEF(
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
@@ -381,6 +423,7 @@ void NFCInstance::ReadNDEF(
 //TODO(g.rynkowski): Rewrite to asynchronous approach
 void NFCInstance::WriteNDEF(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   CHECK_EXIST(args, "id", out);
 
   int tag_id = static_cast<int>(args.get("id").get<double>());
@@ -390,6 +433,7 @@ void NFCInstance::WriteNDEF(
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
@@ -407,12 +451,14 @@ void NFCInstance::Transceive(
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::SetReceiveNDEFListener(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   CHECK_EXIST(args, "id", out);
 
   int peer_id = (int)args.get("id").get<double>();
@@ -420,12 +466,14 @@ void NFCInstance::SetReceiveNDEFListener(
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::UnsetReceiveNDEFListener(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   CHECK_EXIST(args, "id", out);
 
   int peer_id = (int)args.get("id").get<double>();
@@ -433,6 +481,7 @@ void NFCInstance::UnsetReceiveNDEFListener(
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
@@ -440,6 +489,7 @@ void NFCInstance::UnsetReceiveNDEFListener(
 //TODO(g.rynkowski): Rewrite to asynchronous approach
 void NFCInstance::SendNDEF(
     const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
   CHECK_EXIST(args, "id", out);
 
   int peer_id = static_cast<int>(args.get("id").get<double>());
@@ -450,6 +500,7 @@ void NFCInstance::SendNDEF(
   if (result.IsSuccess()) {
     ReportSuccess(out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
@@ -465,6 +516,7 @@ void NFCInstance::ToByte(
   if (ret.IsSuccess()) {
     ReportSuccess(result, out);
   } else {
+    LoggerE("Error: %s", ret.message().c_str());
     ReportError(ret, &out);
   }
 }
@@ -479,6 +531,7 @@ void NFCInstance::NDEFMessageContructor(const picojson::value& args, picojson::o
   if (ret.IsSuccess()) {
     ReportSuccess(result, out);
   } else {
+    LoggerE("Error: %s", ret.message().c_str());
     ReportError(ret, &out);
   }
 }
@@ -492,6 +545,7 @@ void NFCInstance::NDEFRecordContructor(const picojson::value& args, picojson::ob
   if (ret.IsSuccess()) {
     ReportSuccess(result, out);
   } else {
+    LoggerE("Error: %s", ret.message().c_str());
     ReportError(ret, &out);
   }
 }
@@ -506,6 +560,7 @@ void NFCInstance::NDEFRecordTextContructor(const picojson::value& args, picojson
   if (ret.IsSuccess()) {
     ReportSuccess(result, out);
   } else {
+    LoggerE("Error: %s", ret.message().c_str());
     ReportError(ret, &out);
   }
 }
@@ -519,6 +574,7 @@ void NFCInstance::NDEFRecordURIContructor(const picojson::value& args, picojson:
   if (ret.IsSuccess()) {
     ReportSuccess(result, out);
   } else {
+    LoggerE("Error: %s", ret.message().c_str());
     ReportError(ret, &out);
   }
 }
@@ -533,6 +589,7 @@ void NFCInstance::NDEFRecordMediaContructor(const picojson::value& args, picojso
   if (ret.IsSuccess()) {
     ReportSuccess(result, out);
   } else {
+    LoggerE("Error: %s", ret.message().c_str());
     ReportError(ret, &out);
   }
 }
@@ -540,7 +597,6 @@ void NFCInstance::NDEFRecordMediaContructor(const picojson::value& args, picojso
 // NFCTag attributes getters
 void NFCInstance::TagTypeGetter(
     const picojson::value& args, picojson::object& out) {
-
   LoggerD("Entered");
 
   CHECK_EXIST(args, "id", out);
@@ -552,6 +608,7 @@ void NFCInstance::TagTypeGetter(
   PlatformResult result = NFCAdapter::GetInstance()->TagIsConnectedGetter(tag_id, &is_connected);
 
   if (result.IsError()) {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
     return;
   }
@@ -570,13 +627,13 @@ void NFCInstance::TagTypeGetter(
   if (result.IsSuccess()) {
     ReportSuccess(picojson::value(tag_type), out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
 
 void NFCInstance::TagIsSupportedNDEFGetter(
     const picojson::value& args, picojson::object& out) {
-
   LoggerD("Entered");
 
   int tag_id = (int)args.get("id").get<double>();
@@ -587,6 +644,7 @@ void NFCInstance::TagIsSupportedNDEFGetter(
   PlatformResult result = NFCAdapter::GetInstance()->TagIsConnectedGetter(tag_id, &is_connected);
 
   if (result.IsError()) {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
     return;
   }
@@ -604,6 +662,7 @@ void NFCInstance::TagIsSupportedNDEFGetter(
   if (result.IsSuccess()) {
     ReportSuccess(picojson::value(is_supported), out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
@@ -621,6 +680,7 @@ void NFCInstance::TagNDEFSizeGetter(
   PlatformResult result = NFCAdapter::GetInstance()->TagIsConnectedGetter(tag_id, &is_connected);
 
   if (result.IsError()) {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
     return;
   }
@@ -639,6 +699,7 @@ void NFCInstance::TagNDEFSizeGetter(
   if (result.IsSuccess()) {
     ReportSuccess(picojson::value((double)ndef_size), out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
@@ -656,6 +717,7 @@ void NFCInstance::TagPropertiesGetter(
   PlatformResult result = NFCAdapter::GetInstance()->TagIsConnectedGetter(tag_id, &is_connected);
 
   if (result.IsError()) {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
     return;
   }
@@ -691,6 +753,7 @@ void NFCInstance::TagPropertiesGetter(
     }
     ReportSuccess(properties, out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 
@@ -709,8 +772,9 @@ void NFCInstance::TagIsConnectedGetter(
   PlatformResult result = NFCAdapter::GetInstance()->TagIsConnectedGetter(tag_id, &connected);
 
   if (result.IsSuccess()) {
-    ReportSuccess(out);
+    ReportSuccess(picojson::value(connected), out);
   } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
   }
 }
@@ -718,19 +782,23 @@ void NFCInstance::TagIsConnectedGetter(
 void NFCInstance::AddHCEEventListener(const picojson::value& args,
                                       picojson::object& out) {
   PlatformResult result = NFCAdapter::GetInstance()->AddHCEEventListener();
-  if (result.IsSuccess())
+  if (result.IsSuccess()) {
     ReportSuccess(out);
-  else
+  } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
+  }
 }
 
 void NFCInstance::RemoveHCEEventListener(const picojson::value& args,
                                          picojson::object& out) {
   PlatformResult result = NFCAdapter::GetInstance()->RemoveHCEEventListener();
-  if (result.IsSuccess())
+  if (result.IsSuccess()) {
     ReportSuccess(out);
-  else
+  } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
+  }
 }
 
 void NFCInstance::SendHostAPDUResponse(const picojson::value& args,
@@ -752,7 +820,7 @@ void NFCInstance::SendHostAPDUResponse(const picojson::value& args,
   };
 
   auto error_cb = [this, callback_id](const PlatformResult& error) -> void {
-    LoggerD("Entered");
+    LoggerD("Entered error_cb: %s", error.message().c_str());
     picojson::value response = picojson::value(picojson::object());
     picojson::object& response_obj = response.get<picojson::object>();
     response_obj[JSON_CALLBACK_ID] = picojson::value(callback_id);
@@ -778,10 +846,12 @@ void NFCInstance::IsActivatedHandlerForAID(const picojson::value& args,
       args.get(JSON_TYPE).get<std::string>(),
       aid,
       &is_activated_handler);
-  if (result.IsSuccess())
+  if (result.IsSuccess()) {
     ReportSuccess(picojson::value(is_activated_handler), out);
-  else
+  } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
+  }
 }
 
 void NFCInstance::IsActivatedHandlerForCategory(const picojson::value& args,
@@ -799,10 +869,12 @@ void NFCInstance::IsActivatedHandlerForCategory(const picojson::value& args,
           args.get(JSON_TYPE).get<std::string>(),
           category,
           &is_activated_handler);
-  if (result.IsSuccess())
+  if (result.IsSuccess()) {
     ReportSuccess(picojson::value(is_activated_handler), out);
-  else
+  } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
+  }
 }
 
 void NFCInstance::RegisterAID(const picojson::value& args,
@@ -819,10 +891,12 @@ void NFCInstance::RegisterAID(const picojson::value& args,
       args.get(JSON_TYPE).get<std::string>(),
       args.get(JSON_AID).get<std::string>(),
       category);
-  if (result.IsSuccess())
+  if (result.IsSuccess()) {
     ReportSuccess(out);
-  else
+  } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
+  }
 }
 
 void NFCInstance::UnregisterAID(const picojson::value& args,
@@ -840,10 +914,12 @@ void NFCInstance::UnregisterAID(const picojson::value& args,
           args.get(JSON_TYPE).get<std::string>(),
           args.get(JSON_AID).get<std::string>(),
           category);
-  if (result.IsSuccess())
+  if (result.IsSuccess()) {
     ReportSuccess(out);
-  else
+  } else {
+    LoggerE("Error: %s", result.message().c_str());
     ReportError(result, &out);
+  }
 }
 
 void NFCInstance::GetAIDsForCategory(const picojson::value& args,
@@ -871,7 +947,7 @@ void NFCInstance::GetAIDsForCategory(const picojson::value& args,
   };
 
   auto error_cb = [this, callback_id](const PlatformResult& error) -> void {
-    LoggerD("enter");
+    LoggerD("entered error_cb: %s", error.message().c_str());
     picojson::value response = picojson::value(picojson::object());
     picojson::object& response_obj = response.get<picojson::object>();
     response_obj[JSON_CALLBACK_ID] = picojson::value(callback_id);

diff --git a/src/nfc/nfc_message_utils.cc b/src/nfc/nfc_message_utils.cc
index 75877cacca60dd9d6124363dfc1e64f5426d0049..dd3741f5dfb0cfcedcbda8e8f8a6a1e7f85e7193 100644 (file)
--- a/src/nfc/nfc_message_utils.cc
+++ b/src/nfc/nfc_message_utils.cc
@@ -52,6 +52,7 @@ enum nfcTNF{
 /* -------------------------------COMMON FUNCTIONS------------------------------------ */
 void NFCMessageUtils::RemoveMessageHandle(nfc_ndef_message_h message_handle)
 {
+  LoggerD("Entered");
   if (message_handle) {
     int result = nfc_ndef_message_destroy(message_handle);
     if (NFC_ERROR_NONE != result) {
@@ -64,6 +65,7 @@ void NFCMessageUtils::RemoveMessageHandle(nfc_ndef_message_h message_handle)
 
 static void removeRecordHandle(nfc_ndef_record_h record_handle)
 {
+  LoggerD("Entered");
   if (record_handle) {
     int result = nfc_ndef_record_destroy(record_handle);
     if (NFC_ERROR_NONE != result) {
@@ -78,6 +80,7 @@ static PlatformResult getTnfFromHandle(nfc_ndef_record_h handle,
                               nfc_ndef_message_h message_handle,
                               short *tnf)
 {
+  LoggerD("Entered");
   nfc_record_tnf_e record_tnf;
   int result = nfc_ndef_record_get_tnf(handle, &record_tnf);
   if (NFC_ERROR_NONE != result) {
@@ -103,6 +106,7 @@ static PlatformResult getTypeNameFromHandle(nfc_ndef_record_h handle,
                                          nfc_ndef_message_h message_handle,
                                          UCharVector *type)
 {
+  LoggerD("Entered");
   unsigned char* type_name;
   int type_size, result;
 
@@ -128,6 +132,7 @@ static PlatformResult getIdFromHandle(nfc_ndef_record_h handle,
                                    nfc_ndef_message_h message_handle,
                                    UCharVector *id)
 {
+  LoggerD("Entered");
   unsigned char* tmp_id;
   int id_size, result;
 
@@ -154,6 +159,7 @@ static PlatformResult getPayloadFromHandle(nfc_ndef_record_h handle,
                                         nfc_ndef_message_h message_handle,
                                         UCharVector *payload)
 {
+  LoggerD("Entered");
   unsigned char* tmp_payload;
   unsigned int payload_size;
   int result;
@@ -179,6 +185,7 @@ static PlatformResult getPayloadFromHandle(nfc_ndef_record_h handle,
 
 static nfc_encode_type_e convertToNfcEncodeUTF(const std::string& encode_string)
 {
+  LoggerD("Entered");
   if (NFC_TEXT_UTF16 == encode_string) {
     return NFC_ENCODE_UTF_16;
   }
@@ -189,6 +196,7 @@ static nfc_encode_type_e convertToNfcEncodeUTF(const std::string& encode_string)
 
 static std::string convertEncodingToString(nfc_encode_type_e encoding)
 {
+  LoggerD("Entered");
   if (encoding == NFC_ENCODE_UTF_16) {
     return NFC_TEXT_UTF16;
   } else {
@@ -224,25 +232,30 @@ PlatformResult NFCMessageUtils::ToNdefRecords(const nfc_ndef_message_h message,
       short tnf;
       PlatformResult ret = getTnfFromHandle(record_handle, message, &tnf);
       if (ret.IsError()) {
+        LoggerE("Error: %s", ret.message().c_str());
         return ret;
       }
       UCharVector type;
       ret = getTypeNameFromHandle(record_handle, message, &type);
       if (ret.IsError()) {
+        LoggerE("Error: %s", ret.message().c_str());
         return ret;
       }
 
       if (NFC_RECORD_TNF_MIME_MEDIA == tnf) {
         ret = ReportNdefRecordMediaFromMessage(message, i, record_obj);
         if (ret.IsError()) {
+          LoggerE("Error: %s", ret.message().c_str());
           return ret;
         }
+        record_obj.insert(std::make_pair("recordType", picojson::value("RecordMedia")));
         continue;
       } else if (NFC_RECORD_TNF_WELL_KNOWN == tnf) {
         if (!type.empty()) {
           if (RECORD_TYPE_TEXT == type[0]) {
             ret = ReportNdefRecordTextFromMessage(message, i, record_obj);
             if (ret.IsError()) {
+              LoggerE("Error: %s", ret.message().c_str());
               return ret;
             }
             continue;
@@ -250,6 +263,7 @@ PlatformResult NFCMessageUtils::ToNdefRecords(const nfc_ndef_message_h message,
           if (RECORD_TYPE_URI == type[0]) {
             ret = ReportNdefRecordURIFromMessage(message, i, record_obj);
             if (ret.IsError()) {
+              LoggerE("Error: %s", ret.message().c_str());
               return ret;
             }
             continue;
@@ -258,6 +272,7 @@ PlatformResult NFCMessageUtils::ToNdefRecords(const nfc_ndef_message_h message,
       }
       ret = ConstructNdefRecordFromRecordHandle(record_handle, record_obj);
       if (ret.IsError()) {
+        LoggerE("Error: %s", ret.message().c_str());
         return ret;
       }
     }
@@ -281,6 +296,7 @@ PlatformResult NFCMessageUtils::ReportNdefMessageFromData(unsigned char* data, u
   PlatformResult ret = ToNdefRecords(message, records_array_obj);
 
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     RemoveMessageHandle(message);
     return ret;
   }
@@ -384,6 +400,7 @@ PlatformResult NFCMessageUtils::NDEFMessageToStruct(const picojson::array& recor
     PlatformResult ret = NdefRecordGetHandle(record, &record_handle);
 
     if (ret.IsError()) {
+      LoggerE("Error: %s", ret.message().c_str());
       RemoveMessageHandle(ndef_message);
       return ret;
     }
@@ -417,6 +434,7 @@ PlatformResult NFCMessageUtils::NDEFMessageToByte(const picojson::value& args, p
   PlatformResult ret = NDEFMessageToStruct(records_array, size, &message);
 
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
 
@@ -486,21 +504,25 @@ PlatformResult NFCMessageUtils::ConstructNdefRecordFromRecordHandle(nfc_ndef_rec
   short _tnf;
   PlatformResult ret = getTnfFromHandle(record_handle, NULL, &_tnf);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   UCharVector _type_name;
   ret = getTypeNameFromHandle(record_handle, NULL, &_type_name);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   UCharVector _id;
   ret = getIdFromHandle(record_handle, NULL, &_id);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   UCharVector _payload;
   ret = getPayloadFromHandle(record_handle, NULL, &_payload);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
 
@@ -559,6 +581,7 @@ PlatformResult NFCMessageUtils::ReportNDEFRecord(const picojson::value& args, pi
   RemoveMessageHandle(message_handle);
 
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
 
@@ -571,6 +594,7 @@ static PlatformResult getTextFromHandle(nfc_ndef_record_h handle,
                                      nfc_ndef_message_h message_handle,
                                      std::string *text)
 {
+  LoggerD("Entered");
   char* tmp_text = NULL;
   int result = nfc_ndef_record_get_text(handle, &tmp_text);
   if (NFC_ERROR_NONE != result) {
@@ -591,6 +615,7 @@ static PlatformResult getLanguageCodeFromHandle(nfc_ndef_record_h handle,
                                              nfc_ndef_message_h message_handle,
                                              std::string *language)
 {
+  LoggerD("Entered");
   char* language_code = NULL;
   int result = nfc_ndef_record_get_langcode(handle, &language_code);
   if (NFC_ERROR_NONE != result) {
@@ -611,6 +636,7 @@ static PlatformResult getEncodingFromHandle(nfc_ndef_record_h handle,
                                                nfc_ndef_message_h message_handle,
                                                nfc_encode_type_e *encoding_type)
 {
+  LoggerD("Entered");
   nfc_encode_type_e encoding;
   int result = nfc_ndef_record_get_encode_type(handle, &encoding);
   if (NFC_ERROR_NONE != result) {
@@ -627,6 +653,7 @@ static PlatformResult getEncodingFromHandle(nfc_ndef_record_h handle,
 static PlatformResult ReportNDEFRecordTextFromText(const std::string& text, const std::string& language_code,
                                          const std::string& encoding_str, picojson::object& out)
 {
+  LoggerD("Entered");
   nfc_encode_type_e encoding = convertToNfcEncodeUTF(encoding_str);
   nfc_ndef_record_h handle = NULL;
 
@@ -641,21 +668,25 @@ static PlatformResult ReportNDEFRecordTextFromText(const std::string& text, cons
   short _tnf;
   PlatformResult ret = getTnfFromHandle(handle, NULL, &_tnf);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   UCharVector _type_name;
   ret = getTypeNameFromHandle(handle, NULL, &_type_name);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   UCharVector _id;
   ret = getIdFromHandle(handle, NULL, &_id);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   UCharVector _payload;
   ret = getPayloadFromHandle(handle, NULL, &_payload);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
 
@@ -669,6 +700,7 @@ static PlatformResult ReportNDEFRecordTextFromText(const std::string& text, cons
 PlatformResult NFCMessageUtils::ReportNdefRecordTextFromMessage(nfc_ndef_message_h message_handle,
                                                       const int index, picojson::object& out)
 {
+  LoggerD("Entered");
   nfc_ndef_record_h record_handle = NULL;
   //This function just return the pointer of record.
   int result = nfc_ndef_message_get_record(message_handle, index, &record_handle);
@@ -683,6 +715,7 @@ PlatformResult NFCMessageUtils::ReportNdefRecordTextFromMessage(nfc_ndef_message
   nfc_encode_type_e encoding;
   PlatformResult ret = getEncodingFromHandle(record_handle, message_handle, &encoding);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   std::string encoding_str = convertEncodingToString(encoding);
@@ -690,16 +723,19 @@ PlatformResult NFCMessageUtils::ReportNdefRecordTextFromMessage(nfc_ndef_message
   std::string text;
   ret = getTextFromHandle(record_handle, message_handle, &text);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   std::string language_code;
   ret = getLanguageCodeFromHandle(record_handle, message_handle, &language_code);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
 
   ret = ReportNDEFRecordTextFromText(text, language_code, encoding_str, out);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
 
@@ -724,6 +760,7 @@ static PlatformResult getURIFromHandle(nfc_ndef_record_h handle,
                                     nfc_ndef_message_h message_handle,
                                     std::string* uri_handle)
 {
+  LoggerD("Entered");
   char* uri = NULL;
   int result = nfc_ndef_record_get_uri(handle, &uri);
   if (NFC_ERROR_NONE != result) {
@@ -742,6 +779,7 @@ static PlatformResult getURIFromHandle(nfc_ndef_record_h handle,
 
 static PlatformResult ReportNDEFRecordURIFromURI(const std::string& uri, picojson::object& out)
 {
+  LoggerD("Entered");
   nfc_ndef_record_h handle = NULL;
 
   int result = nfc_ndef_record_create_uri(&handle, uri.c_str());
@@ -754,21 +792,25 @@ static PlatformResult ReportNDEFRecordURIFromURI(const std::string& uri, picojso
   short _tnf;
   PlatformResult ret = getTnfFromHandle(handle, NULL, &_tnf);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   UCharVector _type_name;
   ret = getTypeNameFromHandle(handle, NULL, &_type_name);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   UCharVector _id;
   ret = getIdFromHandle(handle, NULL, &_id);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   UCharVector _payload;
   ret = getPayloadFromHandle(handle, NULL, &_payload);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
 
@@ -782,6 +824,7 @@ static PlatformResult ReportNDEFRecordURIFromURI(const std::string& uri, picojso
 PlatformResult NFCMessageUtils::ReportNdefRecordURIFromMessage(nfc_ndef_message_h message_handle,
                                                      const int index, picojson::object& out)
 {
+  LoggerD("Entered");
   nfc_ndef_record_h record_handle = NULL;
   //This function just return the pointer of record.
   int result = nfc_ndef_message_get_record(message_handle, index, &record_handle);
@@ -795,10 +838,12 @@ PlatformResult NFCMessageUtils::ReportNdefRecordURIFromMessage(nfc_ndef_message_
   std::string uri;
   PlatformResult ret = getURIFromHandle(record_handle, message_handle, &uri);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   ret = ReportNDEFRecordURIFromURI(uri, out);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   out.insert(std::make_pair("uri", picojson::value(uri)));
@@ -817,6 +862,7 @@ static PlatformResult getMimeTypeFromHandle(nfc_ndef_record_h handle,
                                          nfc_ndef_message_h message_handle,
                                          std::string *mime)
 {
+  LoggerD("Entered");
   char* mime_type = NULL;
   int result = nfc_ndef_record_get_mime_type(handle, &mime_type);
   if (NFC_ERROR_NONE != result) {
@@ -836,6 +882,7 @@ static PlatformResult getMimeTypeFromHandle(nfc_ndef_record_h handle,
 PlatformResult NFCMessageUtils::ReportNdefRecordMediaFromMessage(nfc_ndef_message_h message_handle,
                                                        const int index, picojson::object& out)
 {
+  LoggerD("Entered");
   nfc_ndef_record_h record_handle = NULL;
   //This function just return the pointer of record.
   int result = nfc_ndef_message_get_record(message_handle, index, &record_handle);
@@ -849,26 +896,31 @@ PlatformResult NFCMessageUtils::ReportNdefRecordMediaFromMessage(nfc_ndef_messag
   std::string mime_type;
   PlatformResult ret = getMimeTypeFromHandle(record_handle, message_handle, &mime_type);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   short _tnf;
   ret = getTnfFromHandle(record_handle, message_handle, &_tnf);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   UCharVector _type_name;
   ret = getTypeNameFromHandle(record_handle, message_handle, &_type_name);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   UCharVector _id;
   ret = getIdFromHandle(record_handle, message_handle, &_id);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
   UCharVector _payload;
   ret = getPayloadFromHandle(record_handle, message_handle, &_payload);
   if (ret.IsError()) {
+    LoggerE("Error: %s", ret.message().c_str());
     return ret;
   }
 
@@ -910,18 +962,22 @@ PlatformResult NFCMessageUtils::ReportNDEFRecordMedia(const picojson::value& arg
 
     PlatformResult ret = getTnfFromHandle(handle, NULL, &_tnf);
     if (ret.IsError()) {
+      LoggerE("Error: %s", ret.message().c_str());
       return ret;
     }
     ret = getTypeNameFromHandle(handle, NULL, &_type_name);
     if (ret.IsError()) {
+      LoggerE("Error: %s", ret.message().c_str());
       return ret;
     }
     ret = getIdFromHandle(handle, NULL, &_id);
     if (ret.IsError()) {
+      LoggerE("Error: %s", ret.message().c_str());
       return ret;
     }
     ret = getPayloadFromHandle(handle, NULL, &_payload);
     if (ret.IsError()) {
+      LoggerE("Error: %s", ret.message().c_str());
       return ret;
     }
   }

diff --git a/src/nfc/nfc_util.cc b/src/nfc/nfc_util.cc
index b75e99e19cd9ba0d6721e3989da299de479a9511..bcf25a4adad2ba2f8c933efd782ff29f089f011c 100644 (file)
--- a/src/nfc/nfc_util.cc
+++ b/src/nfc/nfc_util.cc
@@ -28,12 +28,14 @@ namespace nfc {
 
 UCharVector NFCUtil::ToVector(const unsigned char* ch, const int size)
 {
+  LoggerD("Entered");
   UCharVector vec(ch, ch + size / sizeof(char));
   return vec;
 }
 
 PlatformResult NFCUtil::CodeToResult(const int errorCode,
                                      const std::string& message) {
+  LoggerD("Entered");
   switch(errorCode) {
     case NFC_ERROR_INVALID_PARAMETER:
     case NFC_ERROR_INVALID_NDEF_MESSAGE:
@@ -58,7 +60,7 @@ PlatformResult NFCUtil::CodeToResult(const int errorCode,
 
 std::string NFCUtil::getNFCErrorString(const int error_code)
 {
-  LOGD("Error code : %d",error_code);
+  LoggerD("Error code : %d",error_code);
   switch(error_code) {
     case NFC_ERROR_ALREADY_ACTIVATED:
     case NFC_ERROR_ALREADY_DEACTIVATED:
@@ -84,7 +86,7 @@ std::string NFCUtil::getNFCErrorString(const int error_code)
 }
 
 const std::string NFCUtil::getNFCErrorMessage(const int error_code) {
-  LOGD("Error code : %d", error_code);
+  LoggerD("Error code : %d", error_code);
   switch(error_code) {
     case NFC_ERROR_ALREADY_ACTIVATED:
     case NFC_ERROR_ALREADY_DEACTIVATED:
@@ -126,6 +128,7 @@ const std::string NFCUtil::getNFCErrorMessage(const int error_code) {
 
 std::string NFCUtil::ToStringNFCTag(nfc_tag_type_e tag_type)
 {
+  LoggerD("Entered");
   switch (tag_type) {
     case NFC_GENERIC_PICC:
       return GENERIC_TARGET;
@@ -165,6 +168,7 @@ std::string NFCUtil::ToStringNFCTag(nfc_tag_type_e tag_type)
 
 PlatformResult NFCUtil::ToNfcTagString(const std::string& type_string, nfc_tag_type_e* tag_type)
 {
+  LoggerD("Entered");
   if (GENERIC_TARGET == type_string) {
     *tag_type = NFC_GENERIC_PICC;
   }
@@ -221,6 +225,7 @@ PlatformResult NFCUtil::ToNfcTagString(const std::string& type_string, nfc_tag_t
 PlatformResult NFCUtil::ToStringCardEmulationMode(
     const nfc_se_card_emulation_mode_type_e card_mode, std::string* mode)
 {
+  LoggerD("Entered");
   switch (card_mode)
   {
     case NFC_SE_CARD_EMULATION_MODE_OFF:
@@ -230,7 +235,7 @@ PlatformResult NFCUtil::ToStringCardEmulationMode(
       *mode = ALWAYS_ON;
       break;
     default:
-      LOGE("No Match Card Emulation mode: %x", card_mode);
+      LoggerE("No Match Card Emulation mode: %x", card_mode);
       return PlatformResult(ErrorCode::TYPE_MISMATCH_ERR, "No Match Card Emulation mode");
   }
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -239,12 +244,13 @@ PlatformResult NFCUtil::ToStringCardEmulationMode(
 PlatformResult NFCUtil::ToCardEmulationMode(
     const std::string& mode_string,
     nfc_se_card_emulation_mode_type_e* mode) {
+  LoggerD("Entered");
   if (mode_string == ALWAYS_ON) {
     *mode = NFC_SE_CARD_EMULATION_MODE_ON;
   } else if (mode_string == OFF) {
     *mode = NFC_SE_CARD_EMULATION_MODE_OFF;
   } else {
-    LOGE("No Match Card Emulation mode: %s", mode_string.c_str());
+    LoggerE("No Match Card Emulation mode: %s", mode_string.c_str());
     return PlatformResult(ErrorCode::TYPE_MISMATCH_ERR, "No Match Card Emulation mode");
   }
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -252,6 +258,7 @@ PlatformResult NFCUtil::ToCardEmulationMode(
 
 PlatformResult NFCUtil::ToStringSecureElementType(const nfc_se_type_e se_type,
                                                   std::string* type) {
+  LoggerD("Entered");
   switch (se_type) {
     case NFC_SE_TYPE_ESE:
       *type = DATA_NFC_SE_TYPE_ESE;
@@ -263,7 +270,7 @@ PlatformResult NFCUtil::ToStringSecureElementType(const nfc_se_type_e se_type,
       *type = DATA_NFC_SE_TYPE_HCE;
       break;
     default:
-      LOGE("No Match Secure Element Type: %x", se_type);
+      LoggerE("No Match Secure Element Type: %x", se_type);
       return PlatformResult(ErrorCode::TYPE_MISMATCH_ERR, "No Match Secure Element Type");
   }
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -271,6 +278,7 @@ PlatformResult NFCUtil::ToStringSecureElementType(const nfc_se_type_e se_type,
 
 PlatformResult NFCUtil::ToSecureElementType(const std::string& type_string,
                                             nfc_se_type_e* type) {
+  LoggerD("Entered");
   if (type_string == DATA_NFC_SE_TYPE_ESE) {
     *type = NFC_SE_TYPE_ESE;
   } else if (type_string == DATA_NFC_SE_TYPE_UICC) {
@@ -286,6 +294,7 @@ PlatformResult NFCUtil::ToSecureElementType(const std::string& type_string,
 
 void NFCUtil::setDefaultFilterValues(std::vector<nfc_tag_type_e>& filter)
 {
+  LoggerD("Entered");
   filter.push_back(NFC_GENERIC_PICC);
   filter.push_back(NFC_ISO14443_A_PICC);
   filter.push_back(NFC_ISO14443_3A_PICC);
@@ -306,6 +315,7 @@ void NFCUtil::setDefaultFilterValues(std::vector<nfc_tag_type_e>& filter)
 
 // Convertion of enum to HCEEventType(characters sequence).
 const char* NFCUtil::ToStr(nfc_hce_event_type_e event_type) {
+  LoggerD("Entered");
   switch (event_type) {
     case NFC_HCE_EVENT_DEACTIVATED:
       return "DEACTIVATED";
@@ -321,6 +331,7 @@ const char* NFCUtil::ToStr(nfc_hce_event_type_e event_type) {
 // Convertion of enum to SecureElementType(characters sequence).
 // Warning! DISABLE and SDCARD are not mentioned at widl spec.
 const char* NFCUtil::ToStr(nfc_se_type_e se_type) {
+  LoggerD("Entered");
   switch (se_type) {
     case NFC_SE_TYPE_DISABLE:
       return "DISABLE";
@@ -339,6 +350,7 @@ const char* NFCUtil::ToStr(nfc_se_type_e se_type) {
 
 // Convertion CardEmulationCategoryType(characters sequence) to enum.
 nfc_card_emulation_category_type_e NFCUtil::StringToCategory(const std::string& category_type) {
+  LoggerD("Entered");
   if (category_type == "PAYMENT")
     return NFC_CARD_EMULATION_CATEGORY_PAYMENT;
   if (category_type == "OTHER")
@@ -347,6 +359,7 @@ nfc_card_emulation_category_type_e NFCUtil::StringToCategory(const std::string&
 }
 
 unsigned char* NFCUtil::DoubleArrayToUCharArray(const picojson::array& array_in) {
+  LoggerD("Entered");
   unsigned char* result_array = new unsigned char[array_in.size()];
   for(std::size_t i = 0; i < array_in.size(); ++i) {
     result_array[i] = static_cast<unsigned char>(array_in.at(i).get<double>());
@@ -355,11 +368,13 @@ unsigned char* NFCUtil::DoubleArrayToUCharArray(const picojson::array& array_in)
 }
 
 UCharVector NFCUtil::DoubleArrayToUCharVector(const picojson::array& array_in) {
+  LoggerD("Entered");
   return ToVector(NFCUtil::DoubleArrayToUCharArray(array_in), array_in.size());
 }
 
 picojson::array NFCUtil::FromUCharArray(unsigned char* array,
                                         unsigned int apdu_len) {
+  LoggerD("Entered");
   picojson::array apdu_array;
   apdu_array.reserve(apdu_len);
   for(int i = 0; i < apdu_len; ++i)

diff --git a/src/package/package_info_provider.cc b/src/package/package_info_provider.cc
index eaf51b369d3615c45c537fadf44c76da1e7acd07..0c829d4297d0e52a55f61a4d6065c07b9cf7b74e 100644 (file)
--- a/src/package/package_info_provider.cc
+++ b/src/package/package_info_provider.cc
@@ -40,6 +40,8 @@ using common::NotFoundException;
 
 static int PackageInfoGetListCb(
     const pkgmgrinfo_pkginfo_h info, void *user_data) {
+  LoggerD("Enter");
+
   picojson::array* array_data = static_cast<picojson::array*>(user_data);
   if ( !array_data ) {
     LoggerE("user_data is NULL");
@@ -66,8 +68,7 @@ void PackageInfoProvider::GetPackagesInfo(
   if ( pkgmgrinfo_pkginfo_get_list(PackageInfoGetListCb, &array_data)
       != PMINFO_R_OK ) {
     LoggerE("Failed to get package information");
-    REPORT_ERROR(out, UnknownException(
-        "Any other platform error occurs"));
+    REPORT_ERROR(out, UnknownException("Any other platform error occurs"));
     return;
   }
 
@@ -89,8 +90,7 @@ void PackageInfoProvider::GetPackageInfo(picojson::object& out) {
     free(package_id);
   } else {
     LoggerE("Failed to get current package ID");
-    REPORT_ERROR(out, NotFoundException(
-        "The package with the specified ID is not found"));
+    REPORT_ERROR(out, NotFoundException("The package with the specified ID is not found"));
   }
 }
 
@@ -100,8 +100,7 @@ void PackageInfoProvider::GetPackageInfo(
 
   if ( strlen(package_id) <= 0 ) {
     LoggerE("Wrong Package ID");
-    REPORT_ERROR(out, NotFoundException(
-        "The package with the specified ID is not found"));
+    REPORT_ERROR(out, NotFoundException("The package with the specified ID is not found"));
     return;
   }
 
@@ -109,8 +108,7 @@ void PackageInfoProvider::GetPackageInfo(
   if ( pkgmgrinfo_pkginfo_get_pkginfo(package_id, &info)
       != PMINFO_R_OK ) {
     LoggerE("Failed to get pkginfo");
-    REPORT_ERROR(out, NotFoundException(
-        "The package with the specified ID is not found"));
+    REPORT_ERROR(out, NotFoundException("The package with the specified ID is not found"));
     return;
   }
 

diff --git a/src/package/package_instance.cc b/src/package/package_instance.cc
index 79dfc10b545a5cab9a3fc5a9644eb0277d21006b..b1dc06b632addf95a5fbf07502dcc22201002573 100644 (file)
--- a/src/package/package_instance.cc
+++ b/src/package/package_instance.cc
@@ -94,6 +94,7 @@ static void PackageRequestCb(
     package_manager_event_type_e event_type,
     package_manager_event_state_e event_state, int progress,
     package_manager_error_e error, void *user_data) {
+  LoggerD("Enter");
 
   PackageInstance* instance = static_cast<PackageInstance*>(user_data);
   if ( !instance ) {
@@ -266,6 +267,7 @@ void PackageInstance::RegisterCallback(
 }
 
 void PackageInstance::DeregisterCallback(int request_id) {
+  LoggerD("Enter");
   callbacks_map_.erase(request_id);
 }