[Callhistory] Adjust code to google style.

[Verification] Code compiles without error.

Change-Id: I847251ca46a3a8d223948c80aedc8b8ec602c230
Signed-off-by: Lukasz Bardeli <l.bardeli@samsung.com>

diff --git a/src/callhistory/callhistory.cc b/src/callhistory/callhistory.cc
index 2ee73fa..0b8dbd0 100644 (file)
--- a/src/callhistory/callhistory.cc
+++ b/src/callhistory/callhistory.cc
@@ -25,612 +25,612 @@ namespace callhistory {
 namespace {
 static void get_sim_msisdn_cb(TapiHandle *handle, int result, void *data, void *user_data)
 {
-    LoggerD("Entered");
+  LoggerD("Entered");
 
-    TelSimMsisdnList_t *list;
-    std::promise<std::string> *prom = reinterpret_cast<std::promise<std::string> *>(user_data);
-    char *number = NULL;
+  TelSimMsisdnList_t *list;
+  std::promise<std::string> *prom = reinterpret_cast<std::promise<std::string> *>(user_data);
+  char *number = NULL;
 
-    if (TAPI_SIM_ACCESS_SUCCESS == result) {
-        list = static_cast<TelSimMsisdnList_t *>(data);
-        if (list->count) {
-            number = list->list[0].num;
-        }
-        LoggerD("Phone number: %s", number);
-    } else {
-        LoggerE("Failed to access sim: %d", result);
+  if (TAPI_SIM_ACCESS_SUCCESS == result) {
+    list = static_cast<TelSimMsisdnList_t *>(data);
+    if (list->count) {
+      number = list->list[0].num;
     }
+    LoggerD("Phone number: %s", number);
+  } else {
+    LoggerE("Failed to access sim: %d", result);
+  }
 
-    std::string n = number ? std::string(number) : "";
-    prom->set_value(n);
+  std::string n = number ? std::string(number) : "";
+  prom->set_value(n);
 }
 }
 
 CallHistory::CallHistory():
-        m_is_listener_set(false)
+            m_is_listener_set(false)
 {
-    LoggerD("Entered");
-    if (CONTACTS_ERROR_NONE == contacts_connect()) {
-        LoggerD("Successful to connect Call history DB");
-    } else {
-        LoggerD("Failed to connect Call history DB");
-    }
-    //TODO Uncomment below line if getting sim info will be possible
-    //loadPhoneNumbers();
+  LoggerD("Entered");
+  if (CONTACTS_ERROR_NONE == contacts_connect()) {
+    LoggerD("Successful to connect Call history DB");
+  } else {
+    LoggerD("Failed to connect Call history DB");
+  }
+  //TODO Uncomment below line if getting sim info will be possible
+  //loadPhoneNumbers();
 }
 
 CallHistory::~CallHistory()
 {
-    LoggerD("Entered");
+  LoggerD("Entered");
 
-    if (m_is_listener_set) {
-        int ret = contacts_db_remove_changed_cb_with_info(_contacts_phone_log._uri,
-                changeListenerCB, NULL);
+  if (m_is_listener_set) {
+    int ret = contacts_db_remove_changed_cb_with_info(_contacts_phone_log._uri,
+                                                      changeListenerCB, NULL);
 
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerW("Failed to remove ChangeListener");
-        }
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerW("Failed to remove ChangeListener");
     }
+  }
 
-    if (CONTACTS_ERROR_NONE == contacts_disconnect()) {
-        LoggerD("Successful to disconnect Call history DB");
-    } else {
-        LoggerD("Failed to disconnect Call history DB");
-    }
+  if (CONTACTS_ERROR_NONE == contacts_disconnect()) {
+    LoggerD("Successful to disconnect Call history DB");
+  } else {
+    LoggerD("Failed to disconnect Call history DB");
+  }
 }
 
 CallHistory* CallHistory::getInstance(){
-    static CallHistory instance;
-    return &instance;
+  static CallHistory instance;
+  return &instance;
 }
 
 void CallHistory::find(const picojson::object& args)
 {
-    LoggerD("Entered");
-
-    const auto it_args_end = args.end();
-    const auto it_filter = args.find("filter");
-    picojson::object filter_obj;
-    if (it_filter != it_args_end &&
-            it_filter->second.is<picojson::object>()) {
-        filter_obj = it_filter->second.get<picojson::object>();
+  LoggerD("Entered");
+
+  const auto it_args_end = args.end();
+  const auto it_filter = args.find("filter");
+  picojson::object filter_obj;
+  if (it_filter != it_args_end &&
+      it_filter->second.is<picojson::object>()) {
+    filter_obj = it_filter->second.get<picojson::object>();
+  }
+
+  const auto it_sort_mode = args.find("sortMode");
+  picojson::object sort_mode;
+  if (it_sort_mode != it_args_end &&
+      it_sort_mode->second.is<picojson::object>()) {
+    sort_mode = it_sort_mode->second.get<picojson::object>();
+  }
+
+  std::string sort_attr_name;
+  std::string sort_order;
+  if (!sort_mode.empty()) {
+    const auto it_sort_end = sort_mode.end();
+    const auto it_sort_attr_name = sort_mode.find("attributeName");
+    if (it_sort_attr_name != it_sort_end &&
+        it_sort_attr_name->second.is<std::string>()) {
+      sort_attr_name = it_sort_attr_name->second.get<std::string>();
     }
 
-    const auto it_sort_mode = args.find("sortMode");
-    picojson::object sort_mode;
-    if (it_sort_mode != it_args_end &&
-            it_sort_mode->second.is<picojson::object>()) {
-        sort_mode = it_sort_mode->second.get<picojson::object>();
+    const auto it_sort_order = sort_mode.find("order");
+    if (it_sort_order != it_sort_end &&
+        it_sort_order->second.is<std::string>()) {
+      sort_order = it_sort_order->second.get<std::string>();
     }
+  }
+
+  const auto it_limit = args.find("limit");
+  int limit = 0;
+  if (it_limit != it_args_end &&
+      it_limit->second.is<double>()) {
+    limit = static_cast<int>(it_limit->second.get<double>());
+  }
+
+  const auto it_offset = args.find("offset");
+  int offset = 0;
+  if (it_offset != it_args_end &&
+      it_offset->second.is<double>()) {
+    offset = static_cast<int>(it_offset->second.get<double>());
+  }
+
+  const double callback_id = args.find("callbackId")->second.get<double>();
+  int phone_numbers = m_phone_numbers.size();
+
+  auto find = [filter_obj, sort_attr_name, sort_order, limit, offset, phone_numbers](
+      const std::shared_ptr<picojson::value>& response) -> void {
+
+    contacts_query_h query = nullptr;
+    contacts_filter_h filter = nullptr;
+    contacts_list_h record_list = nullptr;
+    SCOPE_EXIT {
+      contacts_query_destroy(query);
+      contacts_filter_destroy(filter);
+      contacts_list_destroy(record_list, true);
+    };
 
-    std::string sort_attr_name;
-    std::string sort_order;
-    if (!sort_mode.empty()) {
-        const auto it_sort_end = sort_mode.end();
-        const auto it_sort_attr_name = sort_mode.find("attributeName");
-        if (it_sort_attr_name != it_sort_end &&
-            it_sort_attr_name->second.is<std::string>()) {
-            sort_attr_name = it_sort_attr_name->second.get<std::string>();
-        }
-
-        const auto it_sort_order = sort_mode.find("order");
-        if (it_sort_order != it_sort_end &&
-            it_sort_order->second.is<std::string>()) {
-            sort_order = it_sort_order->second.get<std::string>();
-        }
+    if (phone_numbers == 0) {
+      LoggerE("Phone numbers list is empty.");
+      //Uncomment below line if getting sim info will be possible (loadPhonesNumbers)
+      //            ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
+      //                        "Phone numbers list is empty."),
+      //                    &response->get<picojson::object>());
+      //            return;
     }
 
-    const auto it_limit = args.find("limit");
-    int limit = 0;
-    if (it_limit != it_args_end &&
-        it_limit->second.is<double>()) {
-        limit = static_cast<int>(it_limit->second.get<double>());
+    int ret = CONTACTS_ERROR_NONE;
+    ret = contacts_connect_on_thread();
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerW("contacts_connect_on_thread failed");
     }
 
-    const auto it_offset = args.find("offset");
-    int offset = 0;
-    if (it_offset != it_args_end &&
-        it_offset->second.is<double>()) {
-        offset = static_cast<int>(it_offset->second.get<double>());
+    ret = contacts_query_create(_contacts_phone_log._uri, &query);
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerW("contacts_query_create failed");
     }
 
-    const double callback_id = args.find("callbackId")->second.get<double>();
-    int phone_numbers = m_phone_numbers.size();
-
-    auto find = [filter_obj, sort_attr_name, sort_order, limit, offset, phone_numbers](
-            const std::shared_ptr<picojson::value>& response) -> void {
-
-        contacts_query_h query = nullptr;
-        contacts_filter_h filter = nullptr;
-        contacts_list_h record_list = nullptr;
-        SCOPE_EXIT {
-            contacts_query_destroy(query);
-            contacts_filter_destroy(filter);
-            contacts_list_destroy(record_list, true);
-        };
-
-        if (phone_numbers == 0) {
-            LoggerE("Phone numbers list is empty.");
-            //Uncomment below line if getting sim info will be possible (loadPhonesNumbers)
-//            ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
-//                        "Phone numbers list is empty."),
-//                    &response->get<picojson::object>());
-//            return;
-        }
-
-        int ret = CONTACTS_ERROR_NONE;
-        ret = contacts_connect_on_thread();
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerW("contacts_connect_on_thread failed");
-        }
-
-        ret = contacts_query_create(_contacts_phone_log._uri, &query);
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerW("contacts_query_create failed");
-        }
-
-        ret = contacts_filter_create(_contacts_phone_log._uri, &filter);
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerW("contacts_filter_create failed");
-        }
+    ret = contacts_filter_create(_contacts_phone_log._uri, &filter);
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerW("contacts_filter_create failed");
+    }
 
-        //filter
-        if (!filter_obj.empty()) {
-            LoggerD("Filter is set");
-            CallHistoryUtils::createFilter(filter, filter_obj);
-            ret = contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_AND);
-            if (CONTACTS_ERROR_NONE != ret) {
-                LoggerW("contacts_filter_add_operator failed");
-            }
-        }
+    //filter
+    if (!filter_obj.empty()) {
+      LoggerD("Filter is set");
+      CallHistoryUtils::createFilter(filter, filter_obj);
+      ret = contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_AND);
+      if (CONTACTS_ERROR_NONE != ret) {
+        LoggerW("contacts_filter_add_operator failed");
+      }
+    }
 
-        ret = contacts_filter_add_int(filter, _contacts_phone_log.log_type,
-                CONTACTS_MATCH_LESS_THAN_OR_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_BLOCKED);
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerW("contacts_filter_add_int failed");
-        }
+    ret = contacts_filter_add_int(filter, _contacts_phone_log.log_type,
+                                  CONTACTS_MATCH_LESS_THAN_OR_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_BLOCKED);
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerW("contacts_filter_add_int failed");
+    }
 
-        ret = contacts_query_set_filter(query, filter);
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerW("contacts_query_set_filter failed");
-        }
+    ret = contacts_query_set_filter(query, filter);
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerW("contacts_query_set_filter failed");
+    }
 
-        //sort mode
-        bool is_asc = false;
-        if (!sort_order.empty()) {
-            if (STR_ORDER_ASC == sort_order) {
-                is_asc = true;
-            }
-            unsigned int attribute = CallHistoryUtils::convertAttributeName(sort_attr_name);
-            ret = contacts_query_set_sort(query, attribute, is_asc);
-        } else {
-            ret = contacts_query_set_sort(query, _contacts_phone_log.id, is_asc);
-        }
+    //sort mode
+    bool is_asc = false;
+    if (!sort_order.empty()) {
+      if (STR_ORDER_ASC == sort_order) {
+        is_asc = true;
+      }
+      unsigned int attribute = CallHistoryUtils::convertAttributeName(sort_attr_name);
+      ret = contacts_query_set_sort(query, attribute, is_asc);
+    } else {
+      ret = contacts_query_set_sort(query, _contacts_phone_log.id, is_asc);
+    }
 
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerW("contacts_query_set_sort failed");
-        }
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerW("contacts_query_set_sort failed");
+    }
 
-        //get records with limit and offset
-        ret = contacts_db_get_records_with_query(query, offset, limit, &record_list);
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerW("contacts_db_get_records_with_query failed");
-        }
+    //get records with limit and offset
+    ret = contacts_db_get_records_with_query(query, offset, limit, &record_list);
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerW("contacts_db_get_records_with_query failed");
+    }
 
-        picojson::object& obj = response->get<picojson::object>();
-        picojson::array& array = obj.insert(std::make_pair(STR_DATA, picojson::value(
-                                 picojson::array()))).first->second.get<picojson::array>();
-        if (record_list) {
-            CallHistoryUtils::parseRecordList(&record_list, array);
-        }
+    picojson::object& obj = response->get<picojson::object>();
+    picojson::array& array = obj.insert(std::make_pair(STR_DATA, picojson::value(
+        picojson::array()))).first->second.get<picojson::array>();
+    if (record_list) {
+      CallHistoryUtils::parseRecordList(&record_list, array);
+    }
 
-        ret = contacts_disconnect_on_thread();
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerW("contacts_disconnect_on_thread failed");
-        }
+    ret = contacts_disconnect_on_thread();
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerW("contacts_disconnect_on_thread failed");
+    }
 
-        ReportSuccess(response->get<picojson::object>());
+    ReportSuccess(response->get<picojson::object>());
 
-    };
+  };
 
-    auto find_response = [callback_id](const std::shared_ptr<picojson::value>& response) -> void {
-        picojson::object& obj = response->get<picojson::object>();
-        obj.insert(std::make_pair("callbackId", callback_id));
-        CallHistoryInstance::getInstance().PostMessage(response->serialize().c_str());
-    };
+  auto find_response = [callback_id](const std::shared_ptr<picojson::value>& response) -> void {
+    picojson::object& obj = response->get<picojson::object>();
+    obj.insert(std::make_pair("callbackId", callback_id));
+    CallHistoryInstance::getInstance().PostMessage(response->serialize().c_str());
+  };
 
-    TaskQueue::GetInstance().Queue<picojson::value>(
-            find,
-            find_response,
-            std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
+  TaskQueue::GetInstance().Queue<picojson::value>(
+      find,
+      find_response,
+      std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
 }
 
 PlatformResult CallHistory::remove(const picojson::object& args)
 {
-    LoggerD("Entered");
-
-    const auto it_uid = args.find("uid");
-    const auto it_args_end = args.end();
-
-    if (it_uid == it_args_end ||
-        !it_uid->second.is<std::string>()) {
-        LoggerE("Invalid parameter was passed.");
-        return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
-                            "Invalid parameter was passed.");
-    }
-
-    int uid = atoi((it_uid->second.get<std::string>()).c_str());
-    int ret = contacts_db_delete_record(_contacts_phone_log._uri, (int)uid);
-    if (CONTACTS_ERROR_NONE != ret) {
-        LoggerE("Failed to delete log record [%d] with error: %d", uid, ret);
-        return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Failed to delete log record.");
-    }
-    return PlatformResult(ErrorCode::NO_ERROR);
+  LoggerD("Entered");
+
+  const auto it_uid = args.find("uid");
+  const auto it_args_end = args.end();
+
+  if (it_uid == it_args_end ||
+      !it_uid->second.is<std::string>()) {
+    LoggerE("Invalid parameter was passed.");
+    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                          "Invalid parameter was passed.");
+  }
+
+  int uid = atoi((it_uid->second.get<std::string>()).c_str());
+  int ret = contacts_db_delete_record(_contacts_phone_log._uri, (int)uid);
+  if (CONTACTS_ERROR_NONE != ret) {
+    LoggerE("Failed to delete log record [%d] with error: %d", uid, ret);
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Failed to delete log record.");
+  }
+  return PlatformResult(ErrorCode::NO_ERROR);
 }
 
 common::PlatformResult CallHistory::removeBatch(const picojson::object& args)
 {
-    LoggerD("Entered");
-
-    const auto it_uid = args.find("uid");
-    const auto it_args_end = args.end();
-
-    if (it_uid == it_args_end ||
-        !it_uid->second.is<picojson::array>()) {
-        LoggerE("Invalid parameter was passed.");
-        return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
-                            "Invalid parameter was passed.");
+  LoggerD("Entered");
+
+  const auto it_uid = args.find("uid");
+  const auto it_args_end = args.end();
+
+  if (it_uid == it_args_end ||
+      !it_uid->second.is<picojson::array>()) {
+    LoggerE("Invalid parameter was passed.");
+    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                          "Invalid parameter was passed.");
+  }
+  const picojson::array& uids = it_uid->second.get<picojson::array>();
+  const double callback_id = args.find("callbackId")->second.get<double>();
+
+  auto remove_batch = [uids](const std::shared_ptr<picojson::value>& response) -> void {
+    if (uids.size() == 0) {
+      ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
+                                 "Object is null."),
+                  &response->get<picojson::object>());
+      return;
     }
-    const picojson::array& uids = it_uid->second.get<picojson::array>();
-    const double callback_id = args.find("callbackId")->second.get<double>();
 
-    auto remove_batch = [uids](const std::shared_ptr<picojson::value>& response) -> void {
-        if (uids.size() == 0) {
-            ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
-                        "Object is null."),
+    int uid;
+    int ret = CONTACTS_ERROR_NONE;
+    for (unsigned int i = 0; i < uids.size(); ++i) {
+      uid = atoi(uids[i].get<std::string>().c_str());
+      ret = contacts_db_delete_record(_contacts_phone_log._uri, (int)uid);
+      if (CONTACTS_ERROR_NONE != ret) {
+        LoggerE("Failed to delete log [%d] with code %d", uid, ret);
+        ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
+                                   "Remove record failed."),
                     &response->get<picojson::object>());
-            return;
-        }
-
-        int uid;
-        int ret = CONTACTS_ERROR_NONE;
-        for (unsigned int i = 0; i < uids.size(); ++i) {
-            uid = atoi(uids[i].get<std::string>().c_str());
-            ret = contacts_db_delete_record(_contacts_phone_log._uri, (int)uid);
-            if (CONTACTS_ERROR_NONE != ret) {
-                LoggerE("Failed to delete log [%d] with code %d", uid, ret);
-                ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Remove record failed."),
-                        &response->get<picojson::object>());
-                return;
-            }
-        }
-        ReportSuccess(response->get<picojson::object>());
-    };
-
-    auto remove_batch_response = [callback_id](const std::shared_ptr<picojson::value>& response) -> void {
-        picojson::object& obj = response->get<picojson::object>();
-        obj.insert(std::make_pair("callbackId", callback_id));
-        CallHistoryInstance::getInstance().PostMessage(response->serialize().c_str());
-    };
-
-    TaskQueue::GetInstance().Queue<picojson::value>(
-            remove_batch,
-            remove_batch_response,
-            std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
-    return PlatformResult(ErrorCode::NO_ERROR);
+        return;
+      }
+    }
+    ReportSuccess(response->get<picojson::object>());
+  };
+
+  auto remove_batch_response = [callback_id](const std::shared_ptr<picojson::value>& response) -> void {
+    picojson::object& obj = response->get<picojson::object>();
+    obj.insert(std::make_pair("callbackId", callback_id));
+    CallHistoryInstance::getInstance().PostMessage(response->serialize().c_str());
+  };
+
+  TaskQueue::GetInstance().Queue<picojson::value>(
+      remove_batch,
+      remove_batch_response,
+      std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
+  return PlatformResult(ErrorCode::NO_ERROR);
 }
 
 void CallHistory::removeAll(const picojson::object& args)
 {
-    LoggerD("Entered");
+  LoggerD("Entered");
 
-    const double callback_id = args.find("callbackId")->second.get<double>();
+  const double callback_id = args.find("callbackId")->second.get<double>();
 
-    auto remove_all = [](const std::shared_ptr<picojson::value>& response) -> void {
+  auto remove_all = [](const std::shared_ptr<picojson::value>& response) -> void {
 
-        contacts_list_h record_list = nullptr;
-        int* list = NULL;
-        SCOPE_EXIT {
-            contacts_list_destroy(record_list, true);
-            delete[] list;
-        };
+    contacts_list_h record_list = nullptr;
+    int* list = NULL;
+    SCOPE_EXIT {
+      contacts_list_destroy(record_list, true);
+      delete[] list;
+    };
 
-        contacts_record_h record = NULL;
-        int ret = CONTACTS_ERROR_NONE;
-        int total = 0;
-        int value;
-        unsigned int cnt = 0;
+    contacts_record_h record = NULL;
+    int ret = CONTACTS_ERROR_NONE;
+    int total = 0;
+    int value;
+    unsigned int cnt = 0;
 
-        ret = contacts_connect_on_thread();
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerW("contacts_connect_on_thread failed");
-        }
+    ret = contacts_connect_on_thread();
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerW("contacts_connect_on_thread failed");
+    }
 
-        ret = contacts_db_get_all_records(_contacts_phone_log._uri, 0, 0, &record_list);
-        if (CONTACTS_ERROR_NONE != ret || !record_list) {
-            LoggerE("Failed to get all records list");
-            ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
-                        "Failed to get all records list."),
-                    &response->get<picojson::object>());
-            return;
-        }
+    ret = contacts_db_get_all_records(_contacts_phone_log._uri, 0, 0, &record_list);
+    if (CONTACTS_ERROR_NONE != ret || !record_list) {
+      LoggerE("Failed to get all records list");
+      ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
+                                 "Failed to get all records list."),
+                  &response->get<picojson::object>());
+      return;
+    }
 
-        ret = contacts_list_get_count(record_list, &total);
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerW("Failed to get count");
-        }
+    ret = contacts_list_get_count(record_list, &total);
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerW("Failed to get count");
+    }
 
-        list = new int[total];
-        for (int i = 0; i < total; i++) {
-            LoggerD("Record number: %d", i);
-            ret = contacts_list_get_current_record_p(record_list, &record);
-            if (CONTACTS_ERROR_NONE != ret) {
-                LoggerW("contacts_list_get_current_record_p function failed");
-            }
-
-            if (!record) {
-                ret = contacts_list_next(record_list);
-                if (CONTACTS_ERROR_NONE != ret && CONTACTS_ERROR_NO_DATA != ret) {
-                    LoggerE("contacts_list_next function failed");
-                    ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
-                                "Get next record from list failed."),
-                            &response->get<picojson::object>());
-                    return;
-                }
-                continue;
-            }
-
-            if (CONTACTS_ERROR_NONE == ret) {
-                ret = contacts_record_get_int(record, _contacts_phone_log.id , &value);
-                if (CONTACTS_ERROR_NONE == ret) {
-                    list[cnt++] = value;
-                }
-            }
-
-            value = 0;
-            ret = contacts_list_next(record_list);
-            if (CONTACTS_ERROR_NONE != ret && CONTACTS_ERROR_NO_DATA != ret) {
-                LoggerE("contacts_list_next function failed");
-                ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Get next record from list failed."),
-                        &response->get<picojson::object>());
-                return;
-            }
+    list = new int[total];
+    for (int i = 0; i < total; i++) {
+      LoggerD("Record number: %d", i);
+      ret = contacts_list_get_current_record_p(record_list, &record);
+      if (CONTACTS_ERROR_NONE != ret) {
+        LoggerW("contacts_list_get_current_record_p function failed");
+      }
+
+      if (!record) {
+        ret = contacts_list_next(record_list);
+        if (CONTACTS_ERROR_NONE != ret && CONTACTS_ERROR_NO_DATA != ret) {
+          LoggerE("contacts_list_next function failed");
+          ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
+                                     "Get next record from list failed."),
+                      &response->get<picojson::object>());
+          return;
         }
+        continue;
+      }
 
-        if (cnt > 0) {
-            ret = contacts_db_delete_records(_contacts_phone_log._uri, list, cnt);
-            if (CONTACTS_ERROR_NONE != ret) {
-                LoggerE("contacts_db_delete_records function failed");
-                ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Delete records function failed."),
-                        &response->get<picojson::object>());
-                return;
-            }
+      if (CONTACTS_ERROR_NONE == ret) {
+        ret = contacts_record_get_int(record, _contacts_phone_log.id , &value);
+        if (CONTACTS_ERROR_NONE == ret) {
+          list[cnt++] = value;
         }
+      }
+
+      value = 0;
+      ret = contacts_list_next(record_list);
+      if (CONTACTS_ERROR_NONE != ret && CONTACTS_ERROR_NO_DATA != ret) {
+        LoggerE("contacts_list_next function failed");
+        ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
+                                   "Get next record from list failed."),
+                    &response->get<picojson::object>());
+        return;
+      }
+    }
 
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerW("contacts_list_destroy failed");
-        }
+    if (cnt > 0) {
+      ret = contacts_db_delete_records(_contacts_phone_log._uri, list, cnt);
+      if (CONTACTS_ERROR_NONE != ret) {
+        LoggerE("contacts_db_delete_records function failed");
+        ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR,
+                                   "Delete records function failed."),
+                    &response->get<picojson::object>());
+        return;
+      }
+    }
 
-        ret = contacts_disconnect_on_thread();
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerW("contacts_disconnect_on_thread failed");
-        }
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerW("contacts_list_destroy failed");
+    }
 
-        ReportSuccess(response->get<picojson::object>());
-    };
+    ret = contacts_disconnect_on_thread();
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerW("contacts_disconnect_on_thread failed");
+    }
 
-    auto remove_all_response = [callback_id](const std::shared_ptr<picojson::value>& response) -> void {
-        picojson::object& obj = response->get<picojson::object>();
-        obj.insert(std::make_pair("callbackId", callback_id));
-        CallHistoryInstance::getInstance().PostMessage(response->serialize().c_str());
-    };
+    ReportSuccess(response->get<picojson::object>());
+  };
+
+  auto remove_all_response = [callback_id](const std::shared_ptr<picojson::value>& response) -> void {
+    picojson::object& obj = response->get<picojson::object>();
+    obj.insert(std::make_pair("callbackId", callback_id));
+    CallHistoryInstance::getInstance().PostMessage(response->serialize().c_str());
+  };
 
-    TaskQueue::GetInstance().Queue<picojson::value>(
-            remove_all,
-            remove_all_response,
-            std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
+  TaskQueue::GetInstance().Queue<picojson::value>(
+      remove_all,
+      remove_all_response,
+      std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
 }
 
 std::vector<std::string>& CallHistory::getPhoneNumbers()
 {
-    return m_phone_numbers;
+  return m_phone_numbers;
 }
 
 void CallHistory::changeListenerCB(const char* view_uri, char *changes, void* user_data)
 {
-    LoggerD("Entered");
-
-    if (NULL == changes) {
-        LoggerW("changes is NULL");
-        return;
-    }
-    if (0 == strlen(changes)) {
-        LoggerW("changes is empty");
-        return;
+  LoggerD("Entered");
+
+  if (NULL == changes) {
+    LoggerW("changes is NULL");
+    return;
+  }
+  if (0 == strlen(changes)) {
+    LoggerW("changes is empty");
+    return;
+  }
+
+  char seps[] = ",:";
+  char* token_type = NULL;
+  char* token_id = NULL;
+  int change_type = 0;
+  int change_id = 0;
+
+  picojson::value added = picojson::value(picojson::object());
+  picojson::object& added_obj = added.get<picojson::object>();
+  picojson::array& added_array = added_obj.insert(std::make_pair(STR_DATA, picojson::value(
+      picojson::array()))).first->second.get<picojson::array>();
+
+  picojson::value changed = picojson::value(picojson::object());
+  picojson::object& changed_obj = changed.get<picojson::object>();
+  picojson::array& changed_array = changed_obj.insert(std::make_pair(STR_DATA, picojson::value(
+      picojson::array()))).first->second.get<picojson::array>();
+
+  picojson::value removed = picojson::value(picojson::object());
+  picojson::object& removed_obj = removed.get<picojson::object>();
+  picojson::array& removed_array = removed_obj.insert(std::make_pair(STR_DATA, picojson::value(
+      picojson::array()))).first->second.get<picojson::array>();
+
+  token_type = strtok(changes, seps);
+  while (NULL != token_type) {
+    token_id = strtok(NULL, seps);
+    change_type = atoi((const char*)token_type);
+
+    if (NULL != token_id) {
+      change_id = atoi((const char*)token_id);
+    } else {
+      LoggerD("There is no (more) changed Item : %s", token_id);
+      break;
     }
 
-    char seps[] = ",:";
-    char* token_type = NULL;
-    char* token_id = NULL;
-    int change_type = 0;
-    int change_id = 0;
-
-    picojson::value added = picojson::value(picojson::object());
-    picojson::object& added_obj = added.get<picojson::object>();
-    picojson::array& added_array = added_obj.insert(std::make_pair(STR_DATA, picojson::value(
-                                   picojson::array()))).first->second.get<picojson::array>();
-
-    picojson::value changed = picojson::value(picojson::object());
-    picojson::object& changed_obj = changed.get<picojson::object>();
-    picojson::array& changed_array = changed_obj.insert(std::make_pair(STR_DATA, picojson::value(
-                                     picojson::array()))).first->second.get<picojson::array>();
-
-    picojson::value removed = picojson::value(picojson::object());
-    picojson::object& removed_obj = removed.get<picojson::object>();
-    picojson::array& removed_array = removed_obj.insert(std::make_pair(STR_DATA, picojson::value(
-                                     picojson::array()))).first->second.get<picojson::array>();
-
-    token_type = strtok(changes, seps);
-    while (NULL != token_type) {
-        token_id = strtok(NULL, seps);
-        change_type = atoi((const char*)token_type);
-
-        if (NULL != token_id) {
-            change_id = atoi((const char*)token_id);
-        } else {
-            LoggerD("There is no (more) changed Item : %s", token_id);
-            break;
-        }
-
-        contacts_query_h query = NULL;
-        contacts_filter_h filter = NULL;
-        contacts_list_h record_list = NULL;
-        int ret = CONTACTS_ERROR_NONE;
+    contacts_query_h query = NULL;
+    contacts_filter_h filter = NULL;
+    contacts_list_h record_list = NULL;
+    int ret = CONTACTS_ERROR_NONE;
 
-        contacts_query_create(_contacts_phone_log._uri, &query);
-        contacts_filter_create(_contacts_phone_log._uri, &filter);
-        contacts_filter_add_int(filter, _contacts_phone_log.id, CONTACTS_MATCH_EQUAL, change_id);
-
-        contacts_query_set_filter(query, filter);
-        ret = contacts_query_set_sort(query, _contacts_phone_log.id, false);
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerD("Callhistory query error: %d", ret);
-        }
+    contacts_query_create(_contacts_phone_log._uri, &query);
+    contacts_filter_create(_contacts_phone_log._uri, &filter);
+    contacts_filter_add_int(filter, _contacts_phone_log.id, CONTACTS_MATCH_EQUAL, change_id);
 
-        ret = contacts_db_get_records_with_query(query, 0, 1, &record_list);
-        if (CONTACTS_ERROR_NONE != ret) {
-            contacts_list_destroy(record_list, true);
-            contacts_query_destroy(query);
-            contacts_filter_destroy(filter);
-            LoggerD("Callhistory query error: %d", ret);
-            return;
-        }
-
-        if (CONTACTS_CHANGE_INSERTED == change_type) {
-            CallHistoryUtils::parseRecordList(&record_list, added_array);
-        } else if (CONTACTS_CHANGE_UPDATED == change_type) {
-            CallHistoryUtils::parseRecordList(&record_list, changed_array);
-        } else if (CONTACTS_CHANGE_DELETED == change_type) {
-            removed_array.push_back(picojson::value(token_id));
-        }
-
-        contacts_list_destroy(record_list, true);
-        contacts_query_destroy(query);
-        contacts_filter_destroy(filter);
-
-        token_type = strtok( NULL, seps);
+    contacts_query_set_filter(query, filter);
+    ret = contacts_query_set_sort(query, _contacts_phone_log.id, false);
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerD("Callhistory query error: %d", ret);
     }
 
-    if (added_array.size() > 0) {
-        added_obj[STR_ACTION] = picojson::value("onadded");
-        CallHistoryInstance::getInstance().CallHistoryChange(added_obj);
-    }
-    if (changed_array.size() > 0) {
-        changed_obj[STR_ACTION] = picojson::value("onchanged");
-        CallHistoryInstance::getInstance().CallHistoryChange(changed_obj);
+    ret = contacts_db_get_records_with_query(query, 0, 1, &record_list);
+    if (CONTACTS_ERROR_NONE != ret) {
+      contacts_list_destroy(record_list, true);
+      contacts_query_destroy(query);
+      contacts_filter_destroy(filter);
+      LoggerD("Callhistory query error: %d", ret);
+      return;
     }
-    if (removed_array.size() > 0) {
-        removed_obj[STR_ACTION] = picojson::value("onremoved");
-        CallHistoryInstance::getInstance().CallHistoryChange(removed_obj);
+
+    if (CONTACTS_CHANGE_INSERTED == change_type) {
+      CallHistoryUtils::parseRecordList(&record_list, added_array);
+    } else if (CONTACTS_CHANGE_UPDATED == change_type) {
+      CallHistoryUtils::parseRecordList(&record_list, changed_array);
+    } else if (CONTACTS_CHANGE_DELETED == change_type) {
+      removed_array.push_back(picojson::value(token_id));
     }
+
+    contacts_list_destroy(record_list, true);
+    contacts_query_destroy(query);
+    contacts_filter_destroy(filter);
+
+    token_type = strtok( NULL, seps);
+  }
+
+  if (added_array.size() > 0) {
+    added_obj[STR_ACTION] = picojson::value("onadded");
+    CallHistoryInstance::getInstance().CallHistoryChange(added_obj);
+  }
+  if (changed_array.size() > 0) {
+    changed_obj[STR_ACTION] = picojson::value("onchanged");
+    CallHistoryInstance::getInstance().CallHistoryChange(changed_obj);
+  }
+  if (removed_array.size() > 0) {
+    removed_obj[STR_ACTION] = picojson::value("onremoved");
+    CallHistoryInstance::getInstance().CallHistoryChange(removed_obj);
+  }
 }
 
 PlatformResult CallHistory::startCallHistoryChangeListener()
 {
-    LoggerD("Entered");
+  LoggerD("Entered");
 
-    if (!m_is_listener_set) {
-        int ret = contacts_db_add_changed_cb_with_info(_contacts_phone_log._uri,
-                changeListenerCB, NULL);
+  if (!m_is_listener_set) {
+    int ret = contacts_db_add_changed_cb_with_info(_contacts_phone_log._uri,
+                                                   changeListenerCB, NULL);
 
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerE("Failed to add ChangeListener");
-            return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                                "Failed to add ChangeListener");
-        }
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerE("Failed to add ChangeListener");
+      return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                            "Failed to add ChangeListener");
     }
+  }
 
-    m_is_listener_set = true;
-    return PlatformResult(ErrorCode::NO_ERROR);
+  m_is_listener_set = true;
+  return PlatformResult(ErrorCode::NO_ERROR);
 }
 
 PlatformResult CallHistory::stopCallHistoryChangeListener()
 {
-    LoggerD("Entered");
-    if (m_is_listener_set) {
-        int ret = contacts_db_remove_changed_cb_with_info(_contacts_phone_log._uri,
-                changeListenerCB, NULL);
-
-        if (CONTACTS_ERROR_NONE != ret) {
-            LoggerE("Failed to remove ChangeListener");
-            return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                    "Failed to remove ChangeListener");
-        }
+  LoggerD("Entered");
+  if (m_is_listener_set) {
+    int ret = contacts_db_remove_changed_cb_with_info(_contacts_phone_log._uri,
+                                                      changeListenerCB, NULL);
+
+    if (CONTACTS_ERROR_NONE != ret) {
+      LoggerE("Failed to remove ChangeListener");
+      return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                            "Failed to remove ChangeListener");
     }
-    m_is_listener_set = false;
-    return PlatformResult(ErrorCode::NO_ERROR);
+  }
+  m_is_listener_set = false;
+  return PlatformResult(ErrorCode::NO_ERROR);
 }
 
 void CallHistory::loadPhoneNumbers()
 {
-    LoggerD("Entered");
-
-    char **cp_list = NULL;
-    cp_list = tel_get_cp_name_list();
-
-    if (!cp_list) {
-        LoggerE("Failed to get cp name list.");
-        return;
-    }
-
-    unsigned int modem_num = 0;
-    while (cp_list[modem_num]) {
-        std::string n = "";
-        TapiHandle* handle;
-        do {
-            std::promise<std::string> prom;
-            handle = tel_init(cp_list[modem_num]);
-            if (!handle) {
-                LoggerE("Failed to init tapi handle.");
-                break;
-            }
-
-            int card_changed;
-            TelSimCardStatus_t card_status;
-            int ret = tel_get_sim_init_info(handle, &card_status, &card_changed);
-            if (TAPI_API_SUCCESS != ret) {
-                LoggerE("Failed to get sim init info: %d", ret);
-                break;
-            }
-            LoggerD("Card status: %d Card Changed: %d", card_status, card_changed);
-            if (TAPI_SIM_STATUS_SIM_INIT_COMPLETED != card_status) {
-                LoggerW("SIM is not ready, we can't get other properties");
-                break;
-            }
-
-            ret = tel_get_sim_msisdn(handle, get_sim_msisdn_cb, &prom);
-            if (TAPI_API_SUCCESS != ret) {
-                LoggerE("Failed to get msisdn : %d", ret);
-                break;
-            }
-
-            auto fut = prom.get_future();
-            LoggerD("wait...");
-            fut.wait();
-            n = fut.get();
-            LoggerD("Phone number [%d] : %s", modem_num, n.c_str());
-        } while(false);
-
-        m_phone_numbers.push_back(n);
-        tel_deinit(handle);
-        modem_num++;
-    }
-
-    g_strfreev(cp_list);
+  LoggerD("Entered");
+
+  char **cp_list = NULL;
+  cp_list = tel_get_cp_name_list();
+
+  if (!cp_list) {
+    LoggerE("Failed to get cp name list.");
+    return;
+  }
+
+  unsigned int modem_num = 0;
+  while (cp_list[modem_num]) {
+    std::string n = "";
+    TapiHandle* handle;
+    do {
+      std::promise<std::string> prom;
+      handle = tel_init(cp_list[modem_num]);
+      if (!handle) {
+        LoggerE("Failed to init tapi handle.");
+        break;
+      }
+
+      int card_changed;
+      TelSimCardStatus_t card_status;
+      int ret = tel_get_sim_init_info(handle, &card_status, &card_changed);
+      if (TAPI_API_SUCCESS != ret) {
+        LoggerE("Failed to get sim init info: %d", ret);
+        break;
+      }
+      LoggerD("Card status: %d Card Changed: %d", card_status, card_changed);
+      if (TAPI_SIM_STATUS_SIM_INIT_COMPLETED != card_status) {
+        LoggerW("SIM is not ready, we can't get other properties");
+        break;
+      }
+
+      ret = tel_get_sim_msisdn(handle, get_sim_msisdn_cb, &prom);
+      if (TAPI_API_SUCCESS != ret) {
+        LoggerE("Failed to get msisdn : %d", ret);
+        break;
+      }
+
+      auto fut = prom.get_future();
+      LoggerD("wait...");
+      fut.wait();
+      n = fut.get();
+      LoggerD("Phone number [%d] : %s", modem_num, n.c_str());
+    } while(false);
+
+    m_phone_numbers.push_back(n);
+    tel_deinit(handle);
+    modem_num++;
+  }
+
+  g_strfreev(cp_list);
 }
 
 } // namespace callhistory

diff --git a/src/callhistory/callhistory.h b/src/callhistory/callhistory.h
index 32c9d8c..5477293 100644 (file)
--- a/src/callhistory/callhistory.h
+++ b/src/callhistory/callhistory.h
@@ -20,26 +20,26 @@ class CallHistoryInstance;
 
 class CallHistory
 {
-public:
-    static CallHistory* getInstance();
-    std::vector<std::string>& getPhoneNumbers();
-
-    void find(const picojson::object& args);
-    common::PlatformResult remove(const picojson::object& args);
-    common::PlatformResult removeBatch(const picojson::object& args);
-    void removeAll(const picojson::object& args);
-    common::PlatformResult startCallHistoryChangeListener();
-    common::PlatformResult stopCallHistoryChangeListener();
-
-private:
-    CallHistory();
-    virtual ~CallHistory();
-
-    static void changeListenerCB(const char* view_uri, char *changes, void* user_data);
-    void loadPhoneNumbers();
-
-    bool m_is_listener_set;
-    std::vector<std::string> m_phone_numbers;
+ public:
+  static CallHistory* getInstance();
+  std::vector<std::string>& getPhoneNumbers();
+
+  void find(const picojson::object& args);
+  common::PlatformResult remove(const picojson::object& args);
+  common::PlatformResult removeBatch(const picojson::object& args);
+  void removeAll(const picojson::object& args);
+  common::PlatformResult startCallHistoryChangeListener();
+  common::PlatformResult stopCallHistoryChangeListener();
+
+ private:
+  CallHistory();
+  virtual ~CallHistory();
+
+  static void changeListenerCB(const char* view_uri, char *changes, void* user_data);
+  void loadPhoneNumbers();
+
+  bool m_is_listener_set;
+  std::vector<std::string> m_phone_numbers;
 };
 
 } // namespace callhistory

diff --git a/src/callhistory/callhistory_extension.cc b/src/callhistory/callhistory_extension.cc
index 8486877..f5724c5 100644 (file)
--- a/src/callhistory/callhistory_extension.cc
+++ b/src/callhistory/callhistory_extension.cc
@@ -9,16 +9,16 @@
 extern const char kSource_callhistory_api[];
 
 common::Extension* CreateExtension() {
-    return new CallHistoryExtension;
+  return new CallHistoryExtension;
 }
 
 CallHistoryExtension::CallHistoryExtension() {
-    SetExtensionName("tizen.callhistory");
-    SetJavaScriptAPI(kSource_callhistory_api);
+  SetExtensionName("tizen.callhistory");
+  SetJavaScriptAPI(kSource_callhistory_api);
 }
 
 CallHistoryExtension::~CallHistoryExtension() {}
 
 common::Instance* CallHistoryExtension::CreateInstance() {
-    return &extension::callhistory::CallHistoryInstance::getInstance();
+  return &extension::callhistory::CallHistoryInstance::getInstance();
 }

diff --git a/src/callhistory/callhistory_extension.h b/src/callhistory/callhistory_extension.h
index 3924eae..9505c47 100644 (file)
--- a/src/callhistory/callhistory_extension.h
+++ b/src/callhistory/callhistory_extension.h
@@ -8,12 +8,12 @@
 #include "common/extension.h"
 
 class CallHistoryExtension : public common::Extension {
-public:
-    CallHistoryExtension();
-    virtual ~CallHistoryExtension();
+ public:
+  CallHistoryExtension();
+  virtual ~CallHistoryExtension();
 
-private:
-    virtual common::Instance* CreateInstance();
+ private:
+  virtual common::Instance* CreateInstance();
 };
 
 #endif // CALLHISTORY_CALLHISTORY_EXTENSION_H_

diff --git a/src/callhistory/callhistory_instance.cc b/src/callhistory/callhistory_instance.cc
index 239c5bd..77d5dca 100644 (file)
--- a/src/callhistory/callhistory_instance.cc
+++ b/src/callhistory/callhistory_instance.cc
@@ -20,23 +20,23 @@ const std::string kPrivilegeCallHistoryWrite = "http://tizen.org/privilege/callh
 using namespace common;
 
 CallHistoryInstance& CallHistoryInstance::getInstance() {
-    static CallHistoryInstance instance;
-    return instance;
+  static CallHistoryInstance instance;
+  return instance;
 }
 
 CallHistoryInstance::CallHistoryInstance() {
-    using namespace std::placeholders;
+  using namespace std::placeholders;
 #define REGISTER_SYNC(c,x) \
-        RegisterSyncHandler(c, std::bind(&CallHistoryInstance::x, this, _1, _2));
-    REGISTER_SYNC("CallHistory_remove", Remove);
-    REGISTER_SYNC("CallHistory_addChangeListener", AddChangeListener);
-    REGISTER_SYNC("CallHistory_removeChangeListener", RemoveChangeListener);
+    RegisterSyncHandler(c, std::bind(&CallHistoryInstance::x, this, _1, _2));
+  REGISTER_SYNC("CallHistory_remove", Remove);
+  REGISTER_SYNC("CallHistory_addChangeListener", AddChangeListener);
+  REGISTER_SYNC("CallHistory_removeChangeListener", RemoveChangeListener);
 #undef REGISTER_SYNC
 #define REGISTER_ASYNC(c,x) \
-        RegisterHandler(c, std::bind(&CallHistoryInstance::x, this, _1, _2));
-    REGISTER_ASYNC("CallHistory_find", Find);
-    REGISTER_ASYNC("CallHistory_removeBatch", RemoveBatch);
-    REGISTER_ASYNC("CallHistory_removeAll", RemoveAll);
+    RegisterHandler(c, std::bind(&CallHistoryInstance::x, this, _1, _2));
+  REGISTER_ASYNC("CallHistory_find", Find);
+  REGISTER_ASYNC("CallHistory_removeBatch", RemoveBatch);
+  REGISTER_ASYNC("CallHistory_removeAll", RemoveAll);
 #undef REGISTER_ASYNC
 }
 
@@ -44,64 +44,64 @@ CallHistoryInstance::~CallHistoryInstance() {
 }
 
 void CallHistoryInstance::Find(const picojson::value& args, picojson::object& out) {
-    LoggerD("Entered");
-    CallHistory::getInstance()->find(args.get<picojson::object>());
-    ReportSuccess(out);
+  LoggerD("Entered");
+  CallHistory::getInstance()->find(args.get<picojson::object>());
+  ReportSuccess(out);
 }
 
 void CallHistoryInstance::Remove(const picojson::value& args, picojson::object& out) {
-    LoggerD("Entered");
-    PlatformResult result = CallHistory::getInstance()->remove(args.get<picojson::object>());
-    if (result.IsSuccess()) {
-        ReportSuccess(out);
-    } else {
-        ReportError(result, &out);
-    }
+  LoggerD("Entered");
+  PlatformResult result = CallHistory::getInstance()->remove(args.get<picojson::object>());
+  if (result.IsSuccess()) {
+    ReportSuccess(out);
+  } else {
+    ReportError(result, &out);
+  }
 }
 
 void CallHistoryInstance::RemoveBatch(const picojson::value& args, picojson::object& out) {
-    LoggerD("Entered");
-    PlatformResult result = CallHistory::getInstance()->removeBatch(args.get<picojson::object>());
-    if (result.IsSuccess()) {
-        ReportSuccess(out);
-    } else {
-        ReportError(result, &out);
-    }
+  LoggerD("Entered");
+  PlatformResult result = CallHistory::getInstance()->removeBatch(args.get<picojson::object>());
+  if (result.IsSuccess()) {
+    ReportSuccess(out);
+  } else {
+    ReportError(result, &out);
+  }
 }
 
 void CallHistoryInstance::RemoveAll(const picojson::value& args, picojson::object& out) {
-    LoggerD("Entered");
-    CallHistory::getInstance()->removeAll(args.get<picojson::object>());
-    ReportSuccess(out);
+  LoggerD("Entered");
+  CallHistory::getInstance()->removeAll(args.get<picojson::object>());
+  ReportSuccess(out);
 }
 
 void CallHistoryInstance::AddChangeListener(const picojson::value& args, picojson::object& out) {
-    LoggerD("Entered");
-    PlatformResult result = CallHistory::getInstance()->startCallHistoryChangeListener();
-    if (result.IsSuccess()) {
-        ReportSuccess(out);
-    } else {
-        ReportError(result, &out);
-    }
+  LoggerD("Entered");
+  PlatformResult result = CallHistory::getInstance()->startCallHistoryChangeListener();
+  if (result.IsSuccess()) {
+    ReportSuccess(out);
+  } else {
+    ReportError(result, &out);
+  }
 }
 
 void CallHistoryInstance::RemoveChangeListener(const picojson::value& args, picojson::object& out) {
-    LoggerD("Entered");
-    PlatformResult result = CallHistory::getInstance()->stopCallHistoryChangeListener();
-    if (result.IsSuccess()) {
-        ReportSuccess(out);
-    } else {
-        ReportError(result, &out);
-    }
+  LoggerD("Entered");
+  PlatformResult result = CallHistory::getInstance()->stopCallHistoryChangeListener();
+  if (result.IsSuccess()) {
+    ReportSuccess(out);
+  } else {
+    ReportError(result, &out);
+  }
 }
 
 void CallHistoryInstance::CallHistoryChange(picojson::object& data) {
-    LoggerD("Entered");
-    picojson::value event = picojson::value(data);
-    picojson::object& obj = event.get<picojson::object>();
-    obj["listenerId"] = picojson::value("CallHistoryChangeCallback");
+  LoggerD("Entered");
+  picojson::value event = picojson::value(data);
+  picojson::object& obj = event.get<picojson::object>();
+  obj["listenerId"] = picojson::value("CallHistoryChangeCallback");
 
-    PostMessage(event.serialize().c_str());
+  PostMessage(event.serialize().c_str());
 }
 
 } // namespace callhistory

diff --git a/src/callhistory/callhistory_instance.h b/src/callhistory/callhistory_instance.h
index eb4fade..99b7555 100644 (file)
--- a/src/callhistory/callhistory_instance.h
+++ b/src/callhistory/callhistory_instance.h
@@ -12,20 +12,20 @@ namespace extension {
 namespace callhistory {
 
 class CallHistoryInstance : public common::ParsedInstance {
-public:
-    static CallHistoryInstance& getInstance();
-
-    void CallHistoryChange(picojson::object& data);
-private:
-    CallHistoryInstance();
-    virtual ~CallHistoryInstance();
-
-    void Find(const picojson::value& args, picojson::object& out);
-    void Remove(const picojson::value& args, picojson::object& out);
-    void RemoveBatch(const picojson::value& args, picojson::object& out);
-    void RemoveAll(const picojson::value& args, picojson::object& out);
-    void AddChangeListener (const picojson::value& args, picojson::object& out);
-    void RemoveChangeListener(const picojson::value& args, picojson::object& out);
+ public:
+  static CallHistoryInstance& getInstance();
+
+  void CallHistoryChange(picojson::object& data);
+ private:
+  CallHistoryInstance();
+  virtual ~CallHistoryInstance();
+
+  void Find(const picojson::value& args, picojson::object& out);
+  void Remove(const picojson::value& args, picojson::object& out);
+  void RemoveBatch(const picojson::value& args, picojson::object& out);
+  void RemoveAll(const picojson::value& args, picojson::object& out);
+  void AddChangeListener (const picojson::value& args, picojson::object& out);
+  void RemoveChangeListener(const picojson::value& args, picojson::object& out);
 };
 
 } // namespace callhistory

diff --git a/src/callhistory/callhistory_utils.cc b/src/callhistory/callhistory_utils.cc
index f234b9d..1458194 100644 (file)
--- a/src/callhistory/callhistory_utils.cc
+++ b/src/callhistory/callhistory_utils.cc
@@ -16,636 +16,636 @@ namespace callhistory {
 
 namespace {
 enum FilterTypeEnum {
-    FILTER_ATTRIBUTE = 0,
-    FILTER_ATTRIBUTE_RANGE = 1,
-    FILTER_COMPOSITE = 2,
-    FILTER_UNKNOWN = 3
+  FILTER_ATTRIBUTE = 0,
+  FILTER_ATTRIBUTE_RANGE = 1,
+  FILTER_COMPOSITE = 2,
+  FILTER_UNKNOWN = 3
 };
 
 enum CompositeTypeEnum {
-    UNION = 0,
-    INTERSECTION = 1,
-    NONE = 2
+  UNION = 0,
+  INTERSECTION = 1,
+  NONE = 2
 };
 }
 
 void CallHistoryUtils::parseRecordList(contacts_list_h *record_list, picojson::array& array)
 {
-    LoggerD("Entered");
-
-    int ret = CONTACTS_ERROR_NONE;
-    contacts_record_h record = NULL;
-    int total = 0;
-
-    ret = contacts_list_get_count(*record_list, &total);
-    if (CONTACTS_ERROR_NONE != ret) {
-        LoggerW("Failed to get contacts list: %d", ret);
+  LoggerD("Entered");
+
+  int ret = CONTACTS_ERROR_NONE;
+  contacts_record_h record = NULL;
+  int total = 0;
+
+  ret = contacts_list_get_count(*record_list, &total);
+  if (CONTACTS_ERROR_NONE != ret) {
+    LoggerW("Failed to get contacts list: %d", ret);
+    return;
+  }
+
+  for (int i = 0; i < total; i++) {
+    ret = contacts_list_get_current_record_p(*record_list, &record);
+    if (NULL != record) {
+      array.push_back(picojson::value(picojson::object()));
+      picojson::object& obj = array.back().get<picojson::object>();
+      parseRecord(&record, obj);
+    } else {
+      ret = contacts_list_next(*record_list);
+      if (CONTACTS_ERROR_NONE != ret && CONTACTS_ERROR_NO_DATA != ret) {
+        LoggerW("Callhistory list parse error: %d", ret);
         return;
+      }
     }
-
-    for (int i = 0; i < total; i++) {
-        ret = contacts_list_get_current_record_p(*record_list, &record);
-        if (NULL != record) {
-            array.push_back(picojson::value(picojson::object()));
-            picojson::object& obj = array.back().get<picojson::object>();
-            parseRecord(&record, obj);
-        } else {
-            ret = contacts_list_next(*record_list);
-            if (CONTACTS_ERROR_NONE != ret && CONTACTS_ERROR_NO_DATA != ret) {
-                LoggerW("Callhistory list parse error: %d", ret);
-                return;
-            }
-        }
-        ret = contacts_list_next(*record_list);
-        if (CONTACTS_ERROR_NONE != ret && CONTACTS_ERROR_NO_DATA != ret) {
-            LoggerW("Callhistory list parse error: %d", ret);
-            return;
-        }
+    ret = contacts_list_next(*record_list);
+    if (CONTACTS_ERROR_NONE != ret && CONTACTS_ERROR_NO_DATA != ret) {
+      LoggerW("Callhistory list parse error: %d", ret);
+      return;
     }
+  }
 }
 
 void CallHistoryUtils::parseRecord(contacts_record_h *record, picojson::object& obj)
 {
-    LoggerD("Entered");
-
-    int ret = CONTACTS_ERROR_NONE;
-    int int_data;
-
-    ret = contacts_record_get_int(*record, _contacts_phone_log.id, &int_data);
-    if (CONTACTS_ERROR_NONE != ret) {
-        LoggerD("Failed to get contacts phone log id: %d", ret);
-    } else {
-        obj[STR_ENTRY_ID] = picojson::value(static_cast<double>(int_data));
-    }
-
-    ret = contacts_record_get_int(*record, _contacts_phone_log.log_type, &int_data);
-    if (CONTACTS_ERROR_NONE != ret) {
-        LoggerD("Failed to get contacts phone log type: %d", ret);
-    } else {
-        parseLogType(static_cast<contacts_phone_log_type_e>(int_data), obj);
-    }
-
-    ret = contacts_record_get_int(*record, _contacts_phone_log.log_time, &int_data);
-    if (CONTACTS_ERROR_NONE != ret) {
-        LoggerD("Failed to get contacts phone log time: %d", ret);
-    } else {
-        obj[STR_START_TIME] = picojson::value(static_cast<double>(int_data));
-    }
-
-    ret = contacts_record_get_int(*record, _contacts_phone_log.extra_data1, &int_data);
-    if (CONTACTS_ERROR_NONE != ret) {
-        LoggerD("Failed to get contacts phone log extra data: %d", ret);
-    } else {
-        obj[STR_DURATION] = picojson::value(static_cast<double>(int_data));
-    }
-
-    parseRemoteParties(record, obj);
-    parseCallingParty(record, obj);
+  LoggerD("Entered");
+
+  int ret = CONTACTS_ERROR_NONE;
+  int int_data;
+
+  ret = contacts_record_get_int(*record, _contacts_phone_log.id, &int_data);
+  if (CONTACTS_ERROR_NONE != ret) {
+    LoggerD("Failed to get contacts phone log id: %d", ret);
+  } else {
+    obj[STR_ENTRY_ID] = picojson::value(static_cast<double>(int_data));
+  }
+
+  ret = contacts_record_get_int(*record, _contacts_phone_log.log_type, &int_data);
+  if (CONTACTS_ERROR_NONE != ret) {
+    LoggerD("Failed to get contacts phone log type: %d", ret);
+  } else {
+    parseLogType(static_cast<contacts_phone_log_type_e>(int_data), obj);
+  }
+
+  ret = contacts_record_get_int(*record, _contacts_phone_log.log_time, &int_data);
+  if (CONTACTS_ERROR_NONE != ret) {
+    LoggerD("Failed to get contacts phone log time: %d", ret);
+  } else {
+    obj[STR_START_TIME] = picojson::value(static_cast<double>(int_data));
+  }
+
+  ret = contacts_record_get_int(*record, _contacts_phone_log.extra_data1, &int_data);
+  if (CONTACTS_ERROR_NONE != ret) {
+    LoggerD("Failed to get contacts phone log extra data: %d", ret);
+  } else {
+    obj[STR_DURATION] = picojson::value(static_cast<double>(int_data));
+  }
+
+  parseRemoteParties(record, obj);
+  parseCallingParty(record, obj);
 }
 
 void CallHistoryUtils::parseLogType(contacts_phone_log_type_e log_type, picojson::object& obj)
 {
-    LoggerD("Entered");
-
-    picojson::value val = picojson::value(picojson::array());
-    picojson::array& features = val.get<picojson::array>();
-
-    switch(log_type) {
-        case CONTACTS_PLOG_TYPE_VOICE_INCOMMING:
-            obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
-            obj[STR_DIRECTION] = picojson::value(STR_RECEIVED);
-            features.push_back(picojson::value(STR_CALL_VOICE));
-            break;
-        case CONTACTS_PLOG_TYPE_VOICE_OUTGOING:
-            obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
-            obj[STR_DIRECTION] = picojson::value(STR_DIALED);
-            features.push_back(picojson::value(STR_CALL_VOICE));
-            break;
-        case CONTACTS_PLOG_TYPE_VOICE_INCOMMING_SEEN:
-            obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
-            obj[STR_DIRECTION] = picojson::value(STR_MISSED);
-            features.push_back(picojson::value(STR_CALL_VOICE));
-            break;
-        case CONTACTS_PLOG_TYPE_VOICE_INCOMMING_UNSEEN:
-            obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
-            obj[STR_DIRECTION] = picojson::value(STR_MISSED_NEW);
-            features.push_back(picojson::value(STR_CALL_VOICE));
-            break;
-        case CONTACTS_PLOG_TYPE_VOICE_REJECT:
-            obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
-            obj[STR_DIRECTION] = picojson::value(STR_REJECTED);
-            features.push_back(picojson::value(STR_CALL_VOICE));
-            break;
-        case CONTACTS_PLOG_TYPE_VOICE_BLOCKED:
-            obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
-            obj[STR_DIRECTION] = picojson::value(STR_BLOCKED);
-            features.push_back(picojson::value(STR_CALL_VOICE));
-            break;
-        case CONTACTS_PLOG_TYPE_VIDEO_INCOMMING:
-            obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
-            obj[STR_DIRECTION] = picojson::value(STR_RECEIVED);
-            features.push_back(picojson::value(STR_CALL_VIDEO));
-            break;
-        case CONTACTS_PLOG_TYPE_VIDEO_OUTGOING:
-            obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
-            obj[STR_DIRECTION] = picojson::value(STR_DIALED);
-            features.push_back(picojson::value(STR_CALL_VIDEO));
-            break;
-        case CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_SEEN:
-            obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
-            obj[STR_DIRECTION] = picojson::value(STR_MISSED);
-            features.push_back(picojson::value(STR_CALL_VIDEO));
-            break;
-        case CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_UNSEEN:
-            obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
-            obj[STR_DIRECTION] = picojson::value(STR_MISSED_NEW);
-            features.push_back(picojson::value(STR_CALL_VIDEO));
-            break;
-        case CONTACTS_PLOG_TYPE_VIDEO_REJECT:
-            obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
-            obj[STR_DIRECTION] = picojson::value(STR_REJECTED);
-            features.push_back(picojson::value(STR_CALL_VIDEO));
-            break;
-        case CONTACTS_PLOG_TYPE_VIDEO_BLOCKED:
-            obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
-            obj[STR_DIRECTION] = picojson::value(STR_BLOCKED);
-            features.push_back(picojson::value(STR_CALL_VIDEO));
-            break;
-        default:
-            LoggerW("Wrong phone log type: %d", log_type);
-            return;
-    }
-
-    if (features.size() > 0) {
-        obj.insert(std::make_pair(STR_TAGS, features));
-    }
+  LoggerD("Entered");
+
+  picojson::value val = picojson::value(picojson::array());
+  picojson::array& features = val.get<picojson::array>();
+
+  switch(log_type) {
+    case CONTACTS_PLOG_TYPE_VOICE_INCOMMING:
+      obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
+      obj[STR_DIRECTION] = picojson::value(STR_RECEIVED);
+      features.push_back(picojson::value(STR_CALL_VOICE));
+      break;
+    case CONTACTS_PLOG_TYPE_VOICE_OUTGOING:
+      obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
+      obj[STR_DIRECTION] = picojson::value(STR_DIALED);
+      features.push_back(picojson::value(STR_CALL_VOICE));
+      break;
+    case CONTACTS_PLOG_TYPE_VOICE_INCOMMING_SEEN:
+      obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
+      obj[STR_DIRECTION] = picojson::value(STR_MISSED);
+      features.push_back(picojson::value(STR_CALL_VOICE));
+      break;
+    case CONTACTS_PLOG_TYPE_VOICE_INCOMMING_UNSEEN:
+      obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
+      obj[STR_DIRECTION] = picojson::value(STR_MISSED_NEW);
+      features.push_back(picojson::value(STR_CALL_VOICE));
+      break;
+    case CONTACTS_PLOG_TYPE_VOICE_REJECT:
+      obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
+      obj[STR_DIRECTION] = picojson::value(STR_REJECTED);
+      features.push_back(picojson::value(STR_CALL_VOICE));
+      break;
+    case CONTACTS_PLOG_TYPE_VOICE_BLOCKED:
+      obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
+      obj[STR_DIRECTION] = picojson::value(STR_BLOCKED);
+      features.push_back(picojson::value(STR_CALL_VOICE));
+      break;
+    case CONTACTS_PLOG_TYPE_VIDEO_INCOMMING:
+      obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
+      obj[STR_DIRECTION] = picojson::value(STR_RECEIVED);
+      features.push_back(picojson::value(STR_CALL_VIDEO));
+      break;
+    case CONTACTS_PLOG_TYPE_VIDEO_OUTGOING:
+      obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
+      obj[STR_DIRECTION] = picojson::value(STR_DIALED);
+      features.push_back(picojson::value(STR_CALL_VIDEO));
+      break;
+    case CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_SEEN:
+      obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
+      obj[STR_DIRECTION] = picojson::value(STR_MISSED);
+      features.push_back(picojson::value(STR_CALL_VIDEO));
+      break;
+    case CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_UNSEEN:
+      obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
+      obj[STR_DIRECTION] = picojson::value(STR_MISSED_NEW);
+      features.push_back(picojson::value(STR_CALL_VIDEO));
+      break;
+    case CONTACTS_PLOG_TYPE_VIDEO_REJECT:
+      obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
+      obj[STR_DIRECTION] = picojson::value(STR_REJECTED);
+      features.push_back(picojson::value(STR_CALL_VIDEO));
+      break;
+    case CONTACTS_PLOG_TYPE_VIDEO_BLOCKED:
+      obj[STR_CALL_TYPE] = picojson::value(STR_CALLTYPE_TEL);
+      obj[STR_DIRECTION] = picojson::value(STR_BLOCKED);
+      features.push_back(picojson::value(STR_CALL_VIDEO));
+      break;
+    default:
+      LoggerW("Wrong phone log type: %d", log_type);
+      return;
+  }
+
+  if (features.size() > 0) {
+    obj.insert(std::make_pair(STR_TAGS, features));
+  }
 }
 
 void CallHistoryUtils::parseRemoteParties(contacts_record_h *record, picojson::object& obj)
 {
-    LoggerD("Entered");
-
-    int ret = CONTACTS_ERROR_NONE;
-    char * char_data = NULL;
-    int int_data;
-
-    picojson::array& remote_parties = obj.insert(std::make_pair(STR_REMOTE_PARTIES, picojson::value(
-                                      picojson::array()))).first->second.get<picojson::array>();
-    remote_parties.push_back(picojson::value(picojson::object()));
-    picojson::object& parties_obj = remote_parties.back().get<picojson::object>();
-
-    ret = contacts_record_get_int(*record, _contacts_phone_log.person_id, &int_data);
-    if (CONTACTS_ERROR_NONE != ret) {
-        LoggerD("Failed to get contacts phone log person id: %d", ret);
-    } else {
-        parties_obj[STR_PERSON_ID] = picojson::value(static_cast<double>(int_data));
-    }
-
-    ret = contacts_record_get_str_p(*record, _contacts_phone_log.address, &char_data);
-    if (CONTACTS_ERROR_NONE != ret) {
-        LoggerD("Failed to get contacts phone log address: %d", ret);
-    } else if (NULL != char_data) {
-        parties_obj[STR_REMOTE_PARTY] = picojson::value(char_data);
-    }
+  LoggerD("Entered");
+
+  int ret = CONTACTS_ERROR_NONE;
+  char * char_data = NULL;
+  int int_data;
+
+  picojson::array& remote_parties = obj.insert(std::make_pair(STR_REMOTE_PARTIES, picojson::value(
+      picojson::array()))).first->second.get<picojson::array>();
+  remote_parties.push_back(picojson::value(picojson::object()));
+  picojson::object& parties_obj = remote_parties.back().get<picojson::object>();
+
+  ret = contacts_record_get_int(*record, _contacts_phone_log.person_id, &int_data);
+  if (CONTACTS_ERROR_NONE != ret) {
+    LoggerD("Failed to get contacts phone log person id: %d", ret);
+  } else {
+    parties_obj[STR_PERSON_ID] = picojson::value(static_cast<double>(int_data));
+  }
+
+  ret = contacts_record_get_str_p(*record, _contacts_phone_log.address, &char_data);
+  if (CONTACTS_ERROR_NONE != ret) {
+    LoggerD("Failed to get contacts phone log address: %d", ret);
+  } else if (NULL != char_data) {
+    parties_obj[STR_REMOTE_PARTY] = picojson::value(char_data);
+  }
 }
 
 void CallHistoryUtils::parseCallingParty(contacts_record_h *record, picojson::object& obj)
 {
-    LoggerD("Entered");
-
-    int ret = CONTACTS_ERROR_NONE;
-    const std::vector<std::string>& phone_numbers = CallHistory::getInstance()->getPhoneNumbers();
-    int sim_count = phone_numbers.size();
-    int sim_index;
-
-    ret = contacts_record_get_int(*record, _contacts_phone_log.sim_slot_no, &sim_index);
-    if (CONTACTS_ERROR_NONE != ret) {
-        LoggerW("Failed to get sim slot no. %d", ret);
-    }
-
-    if (sim_index >= sim_count) {
-        LoggerE("sim slot no. [%d] is out of count %d", sim_index, sim_count);
-    } else if (sim_index > 0) {
-        obj[STR_CALLING_PARTY] = picojson::value(phone_numbers.at(sim_index));
-    }
+  LoggerD("Entered");
+
+  int ret = CONTACTS_ERROR_NONE;
+  const std::vector<std::string>& phone_numbers = CallHistory::getInstance()->getPhoneNumbers();
+  int sim_count = phone_numbers.size();
+  int sim_index;
+
+  ret = contacts_record_get_int(*record, _contacts_phone_log.sim_slot_no, &sim_index);
+  if (CONTACTS_ERROR_NONE != ret) {
+    LoggerW("Failed to get sim slot no. %d", ret);
+  }
+
+  if (sim_index >= sim_count) {
+    LoggerE("sim slot no. [%d] is out of count %d", sim_index, sim_count);
+  } else if (sim_index > 0) {
+    obj[STR_CALLING_PARTY] = picojson::value(phone_numbers.at(sim_index));
+  }
 }
 
 unsigned int CallHistoryUtils::convertAttributeName(const std::string attribute_name)
 {
-    LoggerD("Entered");
-
-    if (STR_RP_REMOTEPARTY == attribute_name) {
-        return _contacts_phone_log.address;
-    } else if (STR_START_TIME == attribute_name) {
-        return _contacts_phone_log.log_time;
-    } else if (STR_DURATION == attribute_name) {
-        return _contacts_phone_log.extra_data1;
-    } else if (STR_DIRECTION == attribute_name) {
-        return _contacts_phone_log.log_type;
-    } else if (STR_ENTRY_ID == attribute_name) {
-        return _contacts_phone_log.id;
-    } else {
-        return 0;
-    }
+  LoggerD("Entered");
+
+  if (STR_RP_REMOTEPARTY == attribute_name) {
+    return _contacts_phone_log.address;
+  } else if (STR_START_TIME == attribute_name) {
+    return _contacts_phone_log.log_time;
+  } else if (STR_DURATION == attribute_name) {
+    return _contacts_phone_log.extra_data1;
+  } else if (STR_DIRECTION == attribute_name) {
+    return _contacts_phone_log.log_type;
+  } else if (STR_ENTRY_ID == attribute_name) {
+    return _contacts_phone_log.id;
+  } else {
+    return 0;
+  }
 }
 
 static FilterTypeEnum getFilterType(const picojson::object &filter)
 {
-    const auto it_end = filter.end();
-
-    FilterTypeEnum type = FILTER_UNKNOWN;
-
-    const auto it_match_flag = filter.find("matchFlag");
-    if (it_match_flag != it_end) {
-        type = FILTER_ATTRIBUTE;
-    }
-
-    const auto it_initial_value = filter.find("initialValue");
-    const auto it_end_value = filter.find("endValue");
-    if (it_initial_value != it_end && it_end_value != it_end) {
-        type = FILTER_ATTRIBUTE_RANGE;
-    }
-
-    const auto it_type = filter.find("type");
-    if (it_type != it_end) {
-        type = FILTER_COMPOSITE;
-    }
-    return type;
+  const auto it_end = filter.end();
+
+  FilterTypeEnum type = FILTER_UNKNOWN;
+
+  const auto it_match_flag = filter.find("matchFlag");
+  if (it_match_flag != it_end) {
+    type = FILTER_ATTRIBUTE;
+  }
+
+  const auto it_initial_value = filter.find("initialValue");
+  const auto it_end_value = filter.find("endValue");
+  if (it_initial_value != it_end && it_end_value != it_end) {
+    type = FILTER_ATTRIBUTE_RANGE;
+  }
+
+  const auto it_type = filter.find("type");
+  if (it_type != it_end) {
+    type = FILTER_COMPOSITE;
+  }
+  return type;
 }
 
 static CompositeTypeEnum getCompositeType(const picojson::object &filter)
 {
-    CompositeTypeEnum type = NONE;
-    const std::string& str_type = filter.find("type")->second.get<std::string>();
-
-    if ("UNION" == str_type) {
-        type = UNION;
-    } else if ("INTERSECTION" == str_type) {
-        type = INTERSECTION;
-    }
-    return type;
+  CompositeTypeEnum type = NONE;
+  const std::string& str_type = filter.find("type")->second.get<std::string>();
+
+  if ("UNION" == str_type) {
+    type = UNION;
+  } else if ("INTERSECTION" == str_type) {
+    type = INTERSECTION;
+  }
+  return type;
 }
 
 static contacts_match_str_flag_e getMatchFlag(const std::string& match_flag)
 {
-    if (STR_FILTER_FULLSTRING == match_flag) {
-        return CONTACTS_MATCH_FULLSTRING;
-    } else if (STR_FILTER_CONTAINS == match_flag) {
-        return CONTACTS_MATCH_CONTAINS;
-    } else if (STR_FILTER_STARTSWITH == match_flag) {
-        return CONTACTS_MATCH_STARTSWITH;
-    } else if (STR_FILTER_ENDSWITH == match_flag) {
-        return CONTACTS_MATCH_ENDSWITH;
-    } else if (STR_FILTER_EXISTS == match_flag) {
-        return CONTACTS_MATCH_EXISTS;
-    } else {
-        return CONTACTS_MATCH_EXACTLY;
-    }
+  if (STR_FILTER_FULLSTRING == match_flag) {
+    return CONTACTS_MATCH_FULLSTRING;
+  } else if (STR_FILTER_CONTAINS == match_flag) {
+    return CONTACTS_MATCH_CONTAINS;
+  } else if (STR_FILTER_STARTSWITH == match_flag) {
+    return CONTACTS_MATCH_STARTSWITH;
+  } else if (STR_FILTER_ENDSWITH == match_flag) {
+    return CONTACTS_MATCH_ENDSWITH;
+  } else if (STR_FILTER_EXISTS == match_flag) {
+    return CONTACTS_MATCH_EXISTS;
+  } else {
+    return CONTACTS_MATCH_EXACTLY;
+  }
 }
 
 static std::time_t toTimeT(const std::string &value)
 {
-    struct tm date;
-    if (nullptr == strptime(value.c_str(), "%Y-%m-%dT%H:%M:%S", &date)) {
-        LOGW("Couldn't convert supplied date.");
-    }
-    return mktime(&date);
+  struct tm date;
+  if (nullptr == strptime(value.c_str(), "%Y-%m-%dT%H:%M:%S", &date)) {
+    LOGW("Couldn't convert supplied date.");
+  }
+  return mktime(&date);
 }
 
 static void visitAttribute(std::stack<contacts_filter_h>& stack, const picojson::object filter)
 {
-    LoggerD("Entered");
-
-    contacts_filter_h filter_top = stack.top();
-    contacts_filter_h sub_filter = NULL;
-    contacts_filter_create(_contacts_phone_log._uri, &sub_filter);
+  LoggerD("Entered");
 
-    const auto it_attr_name = filter.find("attributeName");
-    const std::string &attr_name = it_attr_name->second.get<std::string>();
+  contacts_filter_h filter_top = stack.top();
+  contacts_filter_h sub_filter = NULL;
+  contacts_filter_create(_contacts_phone_log._uri, &sub_filter);
 
-    const auto it_match_flag = filter.find("matchFlag");
-    const std::string &match_flag = it_match_flag->second.get<std::string>();
-    contacts_match_str_flag_e c_match_flag = getMatchFlag(match_flag);
+  const auto it_attr_name = filter.find("attributeName");
+  const std::string &attr_name = it_attr_name->second.get<std::string>();
 
-    const auto it_match_value = filter.find("matchValue");
-    std::string match_value_str;
-    if (!it_match_value->second.is<picojson::null>()) {
-        if (it_match_value->second.is<double>()) {
-            match_value_str = std::to_string(it_match_value->second.get<double>());
-        } else {
-            match_value_str = it_match_value->second.get<std::string>();
-        }
-    }
+  const auto it_match_flag = filter.find("matchFlag");
+  const std::string &match_flag = it_match_flag->second.get<std::string>();
+  contacts_match_str_flag_e c_match_flag = getMatchFlag(match_flag);
 
-    if (STR_DIRECTION == attr_name) {
-        if (STR_RECEIVED == match_value_str) {
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING);
-            contacts_filter_add_filter(filter_top, sub_filter);
-        }
-        else if (STR_DIALED == match_value_str) {
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_OUTGOING);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_OUTGOING);
-            contacts_filter_add_filter(filter_top, sub_filter);
-        }
-        else if (STR_MISSED == match_value_str) {
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING_SEEN);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_SEEN);
-            contacts_filter_add_filter(filter_top, sub_filter);
-        }
-        else if (STR_MISSED_NEW == match_value_str) {
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING_UNSEEN);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_UNSEEN);
-            contacts_filter_add_filter(filter_top, sub_filter);
-        }
-        else if (STR_REJECTED == match_value_str) {
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_REJECT);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_REJECT);
-            contacts_filter_add_filter(filter_top, sub_filter);
-        }
-        else if (STR_BLOCKED == match_value_str) {
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_BLOCKED);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_BLOCKED);
-            contacts_filter_add_filter(filter_top, sub_filter);
-        }
-        else {
-            contacts_filter_add_int(filter_top, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_NONE);
-        }
-    }
-    else if (STR_TAGS == attr_name) {
-        if (STR_CALL == match_value_str) {
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_GREATER_THAN_OR_EQUAL,
-                    CONTACTS_PLOG_TYPE_VOICE_INCOMMING);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_AND);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_LESS_THAN_OR_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_BLOCKED);
-            contacts_filter_add_filter(filter_top, sub_filter);
-        }
-        else if (STR_CALL_VOICE == match_value_str) {
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_OUTGOING);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING_UNSEEN);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING_SEEN);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_REJECT);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_BLOCKED);
-            contacts_filter_add_filter(filter_top, sub_filter);
-        }
-        else if (STR_CALL_VIDEO == match_value_str) {
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_OUTGOING);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_UNSEEN);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_SEEN);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_REJECT);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_BLOCKED);
-            contacts_filter_add_filter(filter_top, sub_filter);
-        }
-        else if (STR_CALL_EMERGENCY == match_value_str) {
-            contacts_filter_add_str(filter_top, _contacts_phone_log.extra_data2,
-                    CONTACTS_MATCH_EXACTLY, "001");
-        }
-        else {
-            contacts_filter_add_int(filter_top, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_NONE);
-        }
-    }
-    else if (STR_RP_REMOTEPARTY == attr_name) {
-        contacts_filter_add_str(filter_top, _contacts_phone_log.address, c_match_flag,
-                match_value_str.c_str());
-    }
-    else if (STR_RP_PERSONID == attr_name) {
-        contacts_filter_add_str(filter_top, _contacts_phone_log.person_id, c_match_flag,
-                match_value_str.c_str());
-    }
-    else if (STR_START_TIME == attr_name) {
-        LoggerD("DATE _____>>>>>>>>> %s", match_value_str.c_str());
-        contacts_filter_add_int(filter_top, _contacts_phone_log.log_time,
-                CONTACTS_MATCH_EQUAL, static_cast<int>(toTimeT(match_value_str)));
-    }
-    else if (STR_DURATION == attr_name) {
-        contacts_filter_add_str(filter_top, _contacts_phone_log.extra_data1, c_match_flag,
-                match_value_str.c_str());
-    }
-    else if (STR_CALL_TYPE == attr_name) {
-        if (STR_CALLTYPE_TEL == match_value_str) {
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_GREATER_THAN_OR_EQUAL,
-                    CONTACTS_PLOG_TYPE_VOICE_INCOMMING);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_AND);
-            contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_LESS_THAN_OR_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_BLOCKED);
-            contacts_filter_add_filter(filter_top, sub_filter);
-        }
-        else {
-            contacts_filter_add_int(filter_top, _contacts_phone_log.log_type,
-                    CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_NONE);
-        }
+  const auto it_match_value = filter.find("matchValue");
+  std::string match_value_str;
+  if (!it_match_value->second.is<picojson::null>()) {
+    if (it_match_value->second.is<double>()) {
+      match_value_str = std::to_string(it_match_value->second.get<double>());
+    } else {
+      match_value_str = it_match_value->second.get<std::string>();
+    }
+  }
+
+  if (STR_DIRECTION == attr_name) {
+    if (STR_RECEIVED == match_value_str) {
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING);
+      contacts_filter_add_filter(filter_top, sub_filter);
+    }
+    else if (STR_DIALED == match_value_str) {
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_OUTGOING);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_OUTGOING);
+      contacts_filter_add_filter(filter_top, sub_filter);
+    }
+    else if (STR_MISSED == match_value_str) {
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING_SEEN);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_SEEN);
+      contacts_filter_add_filter(filter_top, sub_filter);
+    }
+    else if (STR_MISSED_NEW == match_value_str) {
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING_UNSEEN);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_UNSEEN);
+      contacts_filter_add_filter(filter_top, sub_filter);
+    }
+    else if (STR_REJECTED == match_value_str) {
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_REJECT);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_REJECT);
+      contacts_filter_add_filter(filter_top, sub_filter);
+    }
+    else if (STR_BLOCKED == match_value_str) {
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_BLOCKED);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_BLOCKED);
+      contacts_filter_add_filter(filter_top, sub_filter);
     }
-    else if (STR_ENTRY_ID == attr_name) {
-        contacts_filter_add_str(filter_top, _contacts_phone_log.id, c_match_flag,
-                match_value_str.c_str());
+    else {
+      contacts_filter_add_int(filter_top, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_NONE);
+    }
+  }
+  else if (STR_TAGS == attr_name) {
+    if (STR_CALL == match_value_str) {
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_GREATER_THAN_OR_EQUAL,
+                              CONTACTS_PLOG_TYPE_VOICE_INCOMMING);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_AND);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_LESS_THAN_OR_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_BLOCKED);
+      contacts_filter_add_filter(filter_top, sub_filter);
+    }
+    else if (STR_CALL_VOICE == match_value_str) {
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_OUTGOING);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING_UNSEEN);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING_SEEN);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_REJECT);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_BLOCKED);
+      contacts_filter_add_filter(filter_top, sub_filter);
+    }
+    else if (STR_CALL_VIDEO == match_value_str) {
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_OUTGOING);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_UNSEEN);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_SEEN);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_REJECT);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_OR);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_BLOCKED);
+      contacts_filter_add_filter(filter_top, sub_filter);
+    }
+    else if (STR_CALL_EMERGENCY == match_value_str) {
+      contacts_filter_add_str(filter_top, _contacts_phone_log.extra_data2,
+                              CONTACTS_MATCH_EXACTLY, "001");
     }
     else {
-        contacts_filter_add_int(filter_top, _contacts_phone_log.log_type,
-                CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_NONE);
+      contacts_filter_add_int(filter_top, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_NONE);
+    }
+  }
+  else if (STR_RP_REMOTEPARTY == attr_name) {
+    contacts_filter_add_str(filter_top, _contacts_phone_log.address, c_match_flag,
+                            match_value_str.c_str());
+  }
+  else if (STR_RP_PERSONID == attr_name) {
+    contacts_filter_add_str(filter_top, _contacts_phone_log.person_id, c_match_flag,
+                            match_value_str.c_str());
+  }
+  else if (STR_START_TIME == attr_name) {
+    LoggerD("DATE _____>>>>>>>>> %s", match_value_str.c_str());
+    contacts_filter_add_int(filter_top, _contacts_phone_log.log_time,
+                            CONTACTS_MATCH_EQUAL, static_cast<int>(toTimeT(match_value_str)));
+  }
+  else if (STR_DURATION == attr_name) {
+    contacts_filter_add_str(filter_top, _contacts_phone_log.extra_data1, c_match_flag,
+                            match_value_str.c_str());
+  }
+  else if (STR_CALL_TYPE == attr_name) {
+    if (STR_CALLTYPE_TEL == match_value_str) {
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_GREATER_THAN_OR_EQUAL,
+                              CONTACTS_PLOG_TYPE_VOICE_INCOMMING);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_AND);
+      contacts_filter_add_int(sub_filter, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_LESS_THAN_OR_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_BLOCKED);
+      contacts_filter_add_filter(filter_top, sub_filter);
     }
-
-    contacts_filter_destroy(sub_filter);
+    else {
+      contacts_filter_add_int(filter_top, _contacts_phone_log.log_type,
+                              CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_NONE);
+    }
+  }
+  else if (STR_ENTRY_ID == attr_name) {
+    contacts_filter_add_str(filter_top, _contacts_phone_log.id, c_match_flag,
+                            match_value_str.c_str());
+  }
+  else {
+    contacts_filter_add_int(filter_top, _contacts_phone_log.log_type,
+                            CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_NONE);
+  }
+
+  contacts_filter_destroy(sub_filter);
 }
 
 static void visitAttributeRange(std::stack<contacts_filter_h>& stack, const picojson::object filter)
 {
-    LoggerD("Entered");
-
-    unsigned int prop_id = 0;
-    const auto it_attr_name = filter.find("attributeName");
-    const std::string &attr_name = it_attr_name->second.get<std::string>();
-
-    if (STR_RP_REMOTEPARTY == attr_name) {
-        prop_id = _contacts_phone_log.address;
-    } else if (STR_RP_PERSONID == attr_name) {
-        prop_id = _contacts_phone_log.person_id;
-    } else if (STR_START_TIME == attr_name) {
-        prop_id = _contacts_phone_log.log_time;
-    } else if (STR_DURATION == attr_name) {
-        prop_id = _contacts_phone_log.extra_data1;
-    } else if (STR_ENTRY_ID == attr_name) {
-        prop_id = _contacts_phone_log.id;
+  LoggerD("Entered");
+
+  unsigned int prop_id = 0;
+  const auto it_attr_name = filter.find("attributeName");
+  const std::string &attr_name = it_attr_name->second.get<std::string>();
+
+  if (STR_RP_REMOTEPARTY == attr_name) {
+    prop_id = _contacts_phone_log.address;
+  } else if (STR_RP_PERSONID == attr_name) {
+    prop_id = _contacts_phone_log.person_id;
+  } else if (STR_START_TIME == attr_name) {
+    prop_id = _contacts_phone_log.log_time;
+  } else if (STR_DURATION == attr_name) {
+    prop_id = _contacts_phone_log.extra_data1;
+  } else if (STR_ENTRY_ID == attr_name) {
+    prop_id = _contacts_phone_log.id;
+  } else {
+    LoggerW("attribute: %s is not supported", attr_name.c_str());
+    return;
+  }
+
+  std::string i_val;
+  std::string e_val;
+  contacts_filter_h filter_top = stack.top();
+  contacts_filter_h sub_filter = NULL;
+
+  const auto it_initial_value = filter.find("initialValue");
+  const auto it_end_value = filter.find("endValue");
+  bool is_i_val_null = it_initial_value->second.is<picojson::null>();
+  bool is_e_val_null = it_end_value->second.is<picojson::null>();
+
+  if (!is_i_val_null) {
+    if (it_initial_value->second.is<double>()) {
+      i_val = std::to_string(it_initial_value->second.is<double>());
     } else {
-        LoggerW("attribute: %s is not supported", attr_name.c_str());
-        return;
+      i_val = it_initial_value->second.get<std::string>();
     }
+  }
 
-    std::string i_val;
-    std::string e_val;
-    contacts_filter_h filter_top = stack.top();
-    contacts_filter_h sub_filter = NULL;
+  if (!is_e_val_null) {
+    if (it_end_value->second.is<double>()) {
+      e_val = std::to_string(it_end_value->second.is<double>());
+    } else {
+      e_val = it_end_value->second.get<std::string>();
+    }
+  }
 
-    const auto it_initial_value = filter.find("initialValue");
-    const auto it_end_value = filter.find("endValue");
-    bool is_i_val_null = it_initial_value->second.is<picojson::null>();
-    bool is_e_val_null = it_end_value->second.is<picojson::null>();
+  contacts_filter_create(_contacts_phone_log._uri, &sub_filter);
 
-    if (!is_i_val_null) {
-        if (it_initial_value->second.is<double>()) {
-            i_val = std::to_string(it_initial_value->second.is<double>());
-        } else {
-            i_val = it_initial_value->second.get<std::string>();
-        }
+  if (_contacts_phone_log.address == prop_id) {
+    if (!is_i_val_null && is_e_val_null) {
+      contacts_filter_add_str(filter_top, prop_id, CONTACTS_MATCH_STARTSWITH,i_val.c_str());
     }
-
-    if (!is_e_val_null) {
-        if (it_end_value->second.is<double>()) {
-            e_val = std::to_string(it_end_value->second.is<double>());
-        } else {
-            e_val = it_end_value->second.get<std::string>();
-        }
+    else if (is_i_val_null && !is_e_val_null) {
+      contacts_filter_add_str(filter_top, prop_id, CONTACTS_MATCH_ENDSWITH, e_val.c_str());
     }
-
-    contacts_filter_create(_contacts_phone_log._uri, &sub_filter);
-
-    if (_contacts_phone_log.address == prop_id) {
-        if (!is_i_val_null && is_e_val_null) {
-            contacts_filter_add_str(filter_top, prop_id, CONTACTS_MATCH_STARTSWITH,i_val.c_str());
-        }
-        else if (is_i_val_null && !is_e_val_null) {
-            contacts_filter_add_str(filter_top, prop_id, CONTACTS_MATCH_ENDSWITH, e_val.c_str());
-        }
-        else if (!is_i_val_null && !is_e_val_null) {
-            contacts_filter_add_str(sub_filter, prop_id, CONTACTS_MATCH_STARTSWITH, i_val.c_str());
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_AND);
-            contacts_filter_add_str(sub_filter, prop_id, CONTACTS_MATCH_ENDSWITH, e_val.c_str());
-            contacts_filter_add_filter(filter_top, sub_filter);
-        }
+    else if (!is_i_val_null && !is_e_val_null) {
+      contacts_filter_add_str(sub_filter, prop_id, CONTACTS_MATCH_STARTSWITH, i_val.c_str());
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_AND);
+      contacts_filter_add_str(sub_filter, prop_id, CONTACTS_MATCH_ENDSWITH, e_val.c_str());
+      contacts_filter_add_filter(filter_top, sub_filter);
     }
-    else {
-        int i_val_int = atoi(i_val.c_str());
-        int e_val_int = atoi(e_val.c_str());
+  }
+  else {
+    int i_val_int = atoi(i_val.c_str());
+    int e_val_int = atoi(e_val.c_str());
 
-        if (!is_i_val_null && is_e_val_null) {
-            contacts_filter_add_int(filter_top, prop_id,
-                    CONTACTS_MATCH_GREATER_THAN_OR_EQUAL, i_val_int);
-        }
-        else if (is_i_val_null && !is_e_val_null) {
-            contacts_filter_add_int(filter_top, prop_id, CONTACTS_MATCH_LESS_THAN, e_val_int);
-        }
-        else if (!is_i_val_null && !is_e_val_null) {
-            contacts_filter_add_int(sub_filter, prop_id,
-                    CONTACTS_MATCH_GREATER_THAN_OR_EQUAL, i_val_int);
-            contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_AND);
-            contacts_filter_add_int(sub_filter, prop_id, CONTACTS_MATCH_LESS_THAN, e_val_int);
-            contacts_filter_add_filter(filter_top, sub_filter);
-        }
+    if (!is_i_val_null && is_e_val_null) {
+      contacts_filter_add_int(filter_top, prop_id,
+                              CONTACTS_MATCH_GREATER_THAN_OR_EQUAL, i_val_int);
+    }
+    else if (is_i_val_null && !is_e_val_null) {
+      contacts_filter_add_int(filter_top, prop_id, CONTACTS_MATCH_LESS_THAN, e_val_int);
     }
-    contacts_filter_destroy(sub_filter);
+    else if (!is_i_val_null && !is_e_val_null) {
+      contacts_filter_add_int(sub_filter, prop_id,
+                              CONTACTS_MATCH_GREATER_THAN_OR_EQUAL, i_val_int);
+      contacts_filter_add_operator(sub_filter, CONTACTS_FILTER_OPERATOR_AND);
+      contacts_filter_add_int(sub_filter, prop_id, CONTACTS_MATCH_LESS_THAN, e_val_int);
+      contacts_filter_add_filter(filter_top, sub_filter);
+    }
+  }
+  contacts_filter_destroy(sub_filter);
 }
 
 static void generateFilter(std::stack<contacts_filter_h>& stack,
-        const picojson::object filter,
-        CompositeTypeEnum type)
+                           const picojson::object filter,
+                           CompositeTypeEnum type)
 {
-    LoggerD("Entered");
-    switch (getFilterType(filter)) {
-        case FILTER_ATTRIBUTE: {
-                visitAttribute(stack, filter);
-                if (type != NONE) {
-                    contacts_filter_h top_filter = stack.top();
-                    if (type == UNION) {
-                        contacts_filter_add_operator(top_filter, CONTACTS_FILTER_OPERATOR_OR);
-                    } else {
-                        contacts_filter_add_operator(top_filter, CONTACTS_FILTER_OPERATOR_AND);
-                    }
-                }
-            }
-            break;
-        case FILTER_ATTRIBUTE_RANGE: {
-                visitAttributeRange(stack, filter);
-                if (type != NONE) {
-                    contacts_filter_h top_filter = stack.top();
-                    if (type == UNION) {
-                        contacts_filter_add_operator(top_filter, CONTACTS_FILTER_OPERATOR_OR);
-                    } else {
-                        contacts_filter_add_operator(top_filter, CONTACTS_FILTER_OPERATOR_AND);
-                    }
-                }
-            }
-            break;
-        case FILTER_COMPOSITE: {
-                contacts_filter_h contact_filter = NULL;
-                contacts_filter_create(_contacts_phone_log._uri, &contact_filter);
-                if (contact_filter != NULL) {
-                stack.push(contact_filter);
-                }
-
-                CompositeTypeEnum composite_type = getCompositeType(filter);
-                const picojson::array& filters =
-                        filter.find("filters")->second.get<picojson::array>();
-
-                for (auto it = filters.begin(); it != filters.end(); ++it) {
-                    generateFilter(stack, it->get<picojson::object>(), composite_type);
-                }
-
-                contacts_filter_h top_filter = stack.top();
-                if (stack.size() > 1) {
-                    stack.pop();
-                    contacts_filter_h parent_filter = stack.top();
-                    contacts_filter_add_filter(parent_filter, top_filter);
-                    contacts_filter_destroy(top_filter);
-                }
-            }
-            break;
-        case FILTER_UNKNOWN:
-            return;
-            break;
-    }
+  LoggerD("Entered");
+  switch (getFilterType(filter)) {
+    case FILTER_ATTRIBUTE: {
+      visitAttribute(stack, filter);
+      if (type != NONE) {
+        contacts_filter_h top_filter = stack.top();
+        if (type == UNION) {
+          contacts_filter_add_operator(top_filter, CONTACTS_FILTER_OPERATOR_OR);
+        } else {
+          contacts_filter_add_operator(top_filter, CONTACTS_FILTER_OPERATOR_AND);
+        }
+      }
+    }
+    break;
+    case FILTER_ATTRIBUTE_RANGE: {
+      visitAttributeRange(stack, filter);
+      if (type != NONE) {
+        contacts_filter_h top_filter = stack.top();
+        if (type == UNION) {
+          contacts_filter_add_operator(top_filter, CONTACTS_FILTER_OPERATOR_OR);
+        } else {
+          contacts_filter_add_operator(top_filter, CONTACTS_FILTER_OPERATOR_AND);
+        }
+      }
+    }
+    break;
+    case FILTER_COMPOSITE: {
+      contacts_filter_h contact_filter = NULL;
+      contacts_filter_create(_contacts_phone_log._uri, &contact_filter);
+      if (contact_filter != NULL) {
+        stack.push(contact_filter);
+      }
+
+      CompositeTypeEnum composite_type = getCompositeType(filter);
+      const picojson::array& filters =
+          filter.find("filters")->second.get<picojson::array>();
+
+      for (auto it = filters.begin(); it != filters.end(); ++it) {
+        generateFilter(stack, it->get<picojson::object>(), composite_type);
+      }
+
+      contacts_filter_h top_filter = stack.top();
+      if (stack.size() > 1) {
+        stack.pop();
+        contacts_filter_h parent_filter = stack.top();
+        contacts_filter_add_filter(parent_filter, top_filter);
+        contacts_filter_destroy(top_filter);
+      }
+    }
+    break;
+    case FILTER_UNKNOWN:
+      return;
+      break;
+  }
 }
 
 void CallHistoryUtils::createFilter(contacts_filter_h filter, const picojson::object filter_obj)
 {
-    std::stack<contacts_filter_h> filter_stack;
-    filter_stack.push(filter);
-    generateFilter(filter_stack, filter_obj, CompositeTypeEnum::NONE);
+  std::stack<contacts_filter_h> filter_stack;
+  filter_stack.push(filter);
+  generateFilter(filter_stack, filter_obj, CompositeTypeEnum::NONE);
 }
 
 } // namespace callhistory

diff --git a/src/callhistory/callhistory_utils.h b/src/callhistory/callhistory_utils.h
index 64825fc..e180695 100644 (file)
--- a/src/callhistory/callhistory_utils.h
+++ b/src/callhistory/callhistory_utils.h
@@ -14,14 +14,14 @@ namespace extension {
 namespace callhistory {
 
 class CallHistoryUtils {
-public:
-    static void parseRecordList(contacts_list_h *record_list, picojson::array& array);
-    static void parseRecord(contacts_record_h *record, picojson::object& obj);
-    static void parseLogType(contacts_phone_log_type_e log_type, picojson::object& obj);
-    static void parseRemoteParties(contacts_record_h *record, picojson::object& obj);
-    static void parseCallingParty(contacts_record_h *record, picojson::object& obj);
-    static unsigned int convertAttributeName(const std::string attribute_name);
-    static void createFilter(contacts_filter_h filter, const picojson::object filter_obj);
+ public:
+  static void parseRecordList(contacts_list_h *record_list, picojson::array& array);
+  static void parseRecord(contacts_record_h *record, picojson::object& obj);
+  static void parseLogType(contacts_phone_log_type_e log_type, picojson::object& obj);
+  static void parseRemoteParties(contacts_record_h *record, picojson::object& obj);
+  static void parseCallingParty(contacts_record_h *record, picojson::object& obj);
+  static unsigned int convertAttributeName(const std::string attribute_name);
+  static void createFilter(contacts_filter_h filter, const picojson::object filter_obj);
 };
 
 } // namespace callhistory