src/contact/contact_instance.cc

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16
  17 #include "contact/contact_instance.h"
  18
  19 #include "common/converter.h"
  20 #include "common/filesystem/filesystem_provider.h"
  21 #include "common/logger.h"
  22 #include "common/platform_exception.h"
  23 #include "common/task-queue.h"
  24 #include "common/tools.h"
  25
  26 #include "contact/addressbook.h"
  27 #include "contact/contact_manager.h"
  28 #include "contact/person.h"
  29
  30 namespace extension {
  31 namespace contact {
  32
  33 namespace {
  34 const std::string kPrivilegeContactRead = "http://tizen.org/privilege/contact.read";
  35 const std::string kPrivilegeContactWrite = "http://tizen.org/privilege/contact.write";
  36 const std::vector<const char*> kContactURIs = {"photoURI", "ringtoneURI", "vibrationURI",
  37                                                "messageAlertURI"};
  38 const std::vector<const char*> kPersonGroupURIs = {"photoURI", "ringtoneURI"};
  39 const std::vector<const char*> kOrganizationURIs = {"logoURI"};
  40 }
  41
  42 #define CHECK_CONTACT_ATTRIBUTES_STORAGE(in, to_check, out)                                    \
  43   do {                                                                                         \
  44     for (auto& attr : to_check) {                                                              \
  45       if (!IsNull(in, attr)) {                                                                 \
  46         const std::string& real_path =                                                         \
  47             common::FilesystemProvider::Create().GetRealPath(FromJson<std::string>(in, attr)); \
  48         CHECK_STORAGE_ACCESS(real_path, out);                                                  \
  49       }                                                                                        \
  50     }                                                                                          \
  51   } while (0);
  52
  53 #define CHECK_CONTACT_ATTRIBUTES_ARRAY(in, attribute, to_check, out) \
  54   do {                                                               \
  55     JsonArray array = FromJson<JsonArray>(in, attribute);            \
  56     for (auto& el : array) {                                         \
  57       JsonObject element = common::JsonCast<JsonObject>(el);         \
  58       CHECK_CONTACT_ATTRIBUTES_STORAGE(element, to_check, out);      \
  59     }                                                                \
  60   } while (0);
  61
  62 using namespace common;
  63
  64 ContactInstance::ContactInstance() : current_state_(0), is_listening_(false) {
  65   ScopeLogger();
  66   using std::placeholders::_1;
  67   using std::placeholders::_2;
  68
  69 #define REGISTER_METHOD(M) \
  70     RegisterSyncHandler(#M, std::bind(&ContactInstance::M, this, _1, _2))
  71
  72   REGISTER_METHOD(ContactManagerGetAddressBooks);
  73   REGISTER_METHOD(ContactManagerGetAddressBook);
  74   REGISTER_METHOD(ContactManagerAddAddressBook);
  75   REGISTER_METHOD(ContactManagerRemoveAddressBook);
  76   REGISTER_METHOD(ContactManagerGet);
  77   REGISTER_METHOD(ContactManagerUpdate);
  78   REGISTER_METHOD(ContactManagerUpdateBatch);
  79   REGISTER_METHOD(ContactManagerRemove);
  80   REGISTER_METHOD(ContactManagerRemoveBatch);
  81   REGISTER_METHOD(ContactManagerFind);
  82   REGISTER_METHOD(ContactManagerFindByUsageCount);
  83   REGISTER_METHOD(ContactManagerImportFromVCard);
  84   REGISTER_METHOD(ContactManagerStartListening);
  85   REGISTER_METHOD(ContactManagerStopListening);
  86
  87   REGISTER_METHOD(AddressBookAddBatch);
  88   REGISTER_METHOD(AddressBookUpdateBatch);
  89   REGISTER_METHOD(AddressBookRemoveBatch);
  90   REGISTER_METHOD(AddressBookGet);
  91   REGISTER_METHOD(AddressBookAdd);
  92   REGISTER_METHOD(AddressBookUpdate);
  93   REGISTER_METHOD(AddressBookRemove);
  94   REGISTER_METHOD(AddressBookFind);
  95   REGISTER_METHOD(AddressBookAddGroup);
  96   REGISTER_METHOD(AddressBookGetGroup);
  97   REGISTER_METHOD(AddressBookUpdateGroup);
  98   REGISTER_METHOD(AddressBookRemoveGroup);
  99   REGISTER_METHOD(AddressBookGetGroups);
 100   REGISTER_METHOD(AddressBookStartListening);
 101   REGISTER_METHOD(AddressBookStopListening);
 102
 103   REGISTER_METHOD(PersonLink);
 104   REGISTER_METHOD(PersonUnlink);
 105   REGISTER_METHOD(PersonGetUsageCount);
 106   REGISTER_METHOD(PersonResetUsageCount);
 107
 108 #undef REGISTER_METHOD
 109 }
 110
 111 ContactInstance::~ContactInstance() {
 112   ScopeLogger();
 113   if (is_listening_) {
 114     AddressBook::AddressBookStopListening(*this);
 115     set_is_listening(false);
 116   }
 117 }
 118
 119 void ContactInstance::AddressBookGet(const JsonValue& args, JsonObject& out) {
 120   ScopeLogger();
 121   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 122   JsonValue val{JsonObject{}};
 123   PlatformResult status =
 124       AddressBook::AddressBookGet(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 125   if (status.IsSuccess())
 126     ReportSuccess(val, out);
 127   else
 128     LogAndReportError(status, &out);
 129 }
 130
 131 void ContactInstance::AddressBookAdd(const JsonValue& args, JsonObject& out) {
 132   ScopeLogger();
 133   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 134
 135   const auto& contact = args.get("contact").get<JsonObject>();
 136   CHECK_CONTACT_ATTRIBUTES_STORAGE(contact, kContactURIs, &out);
 137   CHECK_CONTACT_ATTRIBUTES_ARRAY(contact, "organizations", kOrganizationURIs, &out);
 138
 139   JsonValue val{JsonObject{}};
 140   PlatformResult status =
 141       AddressBook::AddressBookAdd(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 142   if (status.IsSuccess())
 143     ReportSuccess(val, out);
 144   else
 145     LogAndReportError(status, &out);
 146 }
 147
 148 void ContactInstance::AddressBookAddBatch(const JsonValue& args, JsonObject& out) {
 149   ScopeLogger();
 150   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 151
 152   const auto& batch_args = args.get("batchArgs").get<JsonArray>();
 153   for (auto& item : batch_args) {
 154     JsonObject contact = common::JsonCast<JsonObject>(item);
 155     CHECK_CONTACT_ATTRIBUTES_STORAGE(contact, kContactURIs, &out);
 156     CHECK_CONTACT_ATTRIBUTES_ARRAY(contact, "organizations", kOrganizationURIs, &out);
 157   }
 158
 159   const double callback_id = args.get("callbackId").get<double>();
 160
 161   auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
 162     ScopeLogger("Entered into asynchronous function, get");
 163     JsonValue result = JsonValue(JsonArray());
 164     PlatformResult status = AddressBook::AddressBookAddBatch(common::JsonCast<JsonObject>(args),
 165                                                              result.get<JsonArray>());
 166     if (status.IsSuccess())
 167       ReportSuccess(result, response->get<JsonObject>());
 168     else
 169       LogAndReportError(status, &response->get<JsonObject>());
 170   };
 171
 172   auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
 173     ScopeLogger("Entered into asynchronous function, get_response");
 174     JsonObject& obj = response->get<JsonObject>();
 175     obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
 176     Instance::PostMessage(this, response->serialize().c_str());
 177   };
 178
 179   auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
 180
 181   TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
 182 }
 183
 184 void ContactInstance::AddressBookRemoveBatch(const JsonValue& args, JsonObject& out) {
 185   ScopeLogger();
 186   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 187
 188   const double callback_id = args.get("callbackId").get<double>();
 189
 190   auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
 191     ScopeLogger("Entered into asynchronous function, get");
 192     PlatformResult status = AddressBook::AddressBookRemoveBatch(common::JsonCast<JsonObject>(args));
 193
 194     if (status.IsSuccess())
 195       ReportSuccess(response->get<JsonObject>());
 196     else
 197       LogAndReportError(status, &response->get<JsonObject>());
 198   };
 199
 200   auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
 201     ScopeLogger("Entered into asynchronous function, get_response");
 202     JsonObject& obj = response->get<JsonObject>();
 203     obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
 204     Instance::PostMessage(this, response->serialize().c_str());
 205   };
 206
 207   auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
 208
 209   TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
 210 }
 211
 212 void ContactInstance::AddressBookUpdateBatch(const JsonValue& args, JsonObject& out) {
 213   ScopeLogger();
 214   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 215
 216   const auto& batch_args = args.get("batchArgs").get<JsonArray>();
 217   for (auto& item : batch_args) {
 218     JsonObject contact = common::JsonCast<JsonObject>(item);
 219     CHECK_CONTACT_ATTRIBUTES_STORAGE(contact, kContactURIs, &out);
 220     CHECK_CONTACT_ATTRIBUTES_ARRAY(contact, "organizations", kOrganizationURIs, &out);
 221   }
 222
 223   const double callback_id = args.get("callbackId").get<double>();
 224
 225   auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
 226     ScopeLogger("Entered into asynchronous function, get");
 227     JsonValue result = JsonValue(JsonArray());
 228     PlatformResult status = AddressBook::AddressBookUpdateBatch(common::JsonCast<JsonObject>(args),
 229                                                                 result.get<JsonArray>());
 230     if (status.IsSuccess())
 231       ReportSuccess(result, response->get<JsonObject>());
 232     else
 233       LogAndReportError(status, &response->get<JsonObject>());
 234   };
 235
 236   auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
 237     ScopeLogger("Entered into asynchronous function, get_response");
 238     JsonObject& obj = response->get<JsonObject>();
 239     obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
 240     Instance::PostMessage(this, response->serialize().c_str());
 241   };
 242
 243   auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
 244
 245   TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
 246 }
 247
 248 void ContactInstance::AddressBookUpdate(const JsonValue& args, JsonObject& out) {
 249   ScopeLogger();
 250   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 251
 252   const auto& contact = args.get("contact").get<JsonObject>();
 253   CHECK_CONTACT_ATTRIBUTES_STORAGE(contact, kContactURIs, &out);
 254   CHECK_CONTACT_ATTRIBUTES_ARRAY(contact, "organizations", kOrganizationURIs, &out);
 255
 256   JsonValue val{JsonObject{}};
 257   PlatformResult status =
 258       AddressBook::AddressBookUpdate(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 259   if (status.IsSuccess())
 260     ReportSuccess(val, out);
 261   else
 262     LogAndReportError(status, &out);
 263 }
 264
 265 void ContactInstance::AddressBookRemove(const JsonValue& args, JsonObject& out) {
 266   ScopeLogger();
 267   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 268   JsonValue val{JsonObject{}};
 269   PlatformResult status =
 270       AddressBook::AddressBookRemove(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 271   if (status.IsSuccess())
 272     ReportSuccess(out);
 273   else
 274     LogAndReportError(status, &out);
 275 }
 276
 277 void ContactInstance::AddressBookFind(const JsonValue& args, JsonObject& out) {
 278   ScopeLogger();
 279   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 280   const double callback_id = args.get("callbackId").get<double>();
 281
 282   auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
 283     ScopeLogger("Entered into asynchronous function, get");
 284     JsonValue result = JsonValue(JsonArray());
 285     PlatformResult status =
 286         AddressBook::AddressBookFind(JsonCast<JsonObject>(args), result.get<JsonArray>());
 287     if (status.IsSuccess())
 288       ReportSuccess(result, response->get<JsonObject>());
 289     else
 290       LogAndReportError(status, &response->get<JsonObject>());
 291   };
 292
 293   auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
 294     ScopeLogger("Entered into asynchronous function, get_response");
 295     JsonObject& obj = response->get<JsonObject>();
 296     obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
 297     Instance::PostMessage(this, response->serialize().c_str());
 298   };
 299
 300   auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
 301
 302   TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
 303 }
 304
 305 void ContactInstance::AddressBookAddGroup(const JsonValue& args, JsonObject& out) {
 306   ScopeLogger();
 307   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 308
 309   const auto& group = args.get("group").get<JsonObject>();
 310   CHECK_CONTACT_ATTRIBUTES_STORAGE(group, kPersonGroupURIs, &out);
 311
 312   JsonValue val{JsonObject{}};
 313   PlatformResult status =
 314       AddressBook::AddressBookAddGroup(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 315   if (status.IsSuccess())
 316     ReportSuccess(val, out);
 317   else
 318     LogAndReportError(status, &out);
 319 }
 320
 321 void ContactInstance::AddressBookGetGroup(const JsonValue& args, JsonObject& out) {
 322   ScopeLogger();
 323   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 324   JsonValue val{JsonObject{}};
 325   PlatformResult status =
 326       AddressBook::AddressBookGetGroup(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 327   if (status.IsSuccess())
 328     ReportSuccess(val, out);
 329   else
 330     LogAndReportError(status, &out);
 331 }
 332
 333 void ContactInstance::AddressBookUpdateGroup(const JsonValue& args, JsonObject& out) {
 334   ScopeLogger();
 335
 336   const auto& group = args.get("group").get<JsonObject>();
 337   CHECK_CONTACT_ATTRIBUTES_STORAGE(group, kPersonGroupURIs, &out);
 338
 339   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 340   JsonValue val{JsonObject{}};
 341   PlatformResult status = AddressBook::AddressBookUpdateGroup(common::JsonCast<JsonObject>(args),
 342                                                               val.get<JsonObject>());
 343   if (status.IsSuccess())
 344     ReportSuccess(out);
 345   else
 346     LogAndReportError(status, &out);
 347 }
 348
 349 void ContactInstance::AddressBookRemoveGroup(const JsonValue& args, JsonObject& out) {
 350   ScopeLogger();
 351   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 352   JsonValue val{JsonObject{}};
 353   PlatformResult status = AddressBook::AddressBookRemoveGroup(common::JsonCast<JsonObject>(args),
 354                                                               val.get<JsonObject>());
 355   if (status.IsSuccess())
 356     ReportSuccess(out);
 357   else
 358     LogAndReportError(status, &out);
 359 }
 360
 361 void ContactInstance::AddressBookGetGroups(const JsonValue& args, JsonObject& out) {
 362   ScopeLogger();
 363   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 364   JsonValue val{JsonArray{}};
 365   PlatformResult status =
 366       AddressBook::AddressBookGetGroups(common::JsonCast<JsonObject>(args), val.get<JsonArray>());
 367   if (status.IsSuccess())
 368     ReportSuccess(val, out);
 369   else
 370     LogAndReportError(status, &out);
 371 }
 372
 373 void ContactInstance::ContactManagerGetAddressBooks(const JsonValue& args, JsonObject& out) {
 374   ScopeLogger();
 375   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 376
 377   const double callback_id = args.get("callbackId").get<double>();
 378
 379   auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
 380     ScopeLogger("Entered into asynchronous function, get");
 381     JsonValue result = JsonValue(JsonArray());
 382     PlatformResult status = ContactManager::ContactManagerGetAddressBooks(
 383         common::JsonCast<JsonObject>(args), result.get<JsonArray>());
 384
 385     if (status.IsSuccess())
 386       ReportSuccess(result, response->get<JsonObject>());
 387     else
 388       LogAndReportError(status, &response->get<JsonObject>());
 389   };
 390
 391   auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
 392     ScopeLogger("Entered into asynchronous function, get_response");
 393     JsonObject& obj = response->get<JsonObject>();
 394     obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
 395     Instance::PostMessage(this, response->serialize().c_str());
 396   };
 397
 398   auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
 399
 400   TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
 401 }
 402
 403 void ContactInstance::ContactManagerGetAddressBook(const JsonValue& args, JsonObject& out) {
 404   ScopeLogger();
 405   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 406   JsonValue val{JsonObject{}};
 407   PlatformResult status = ContactManager::ContactManagerGetAddressBook(
 408       common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 409   if (status.IsSuccess())
 410     ReportSuccess(val, out);
 411   else
 412     LogAndReportError(status, &out);
 413 }
 414
 415 void ContactInstance::ContactManagerAddAddressBook(const JsonValue& args, JsonObject& out) {
 416   ScopeLogger();
 417   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 418   JsonValue val{JsonObject{}};
 419   PlatformResult status = ContactManager::ContactManagerAddAddressBook(
 420       common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 421   if (status.IsSuccess())
 422     ReportSuccess(val, out);
 423   else
 424     LogAndReportError(status, &out);
 425 }
 426
 427 void ContactInstance::ContactManagerRemoveAddressBook(const JsonValue& args, JsonObject& out) {
 428   ScopeLogger();
 429   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 430   JsonValue val{JsonObject{}};
 431   PlatformResult status = ContactManager::ContactManagerRemoveAddressBook(
 432       common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 433   if (status.IsSuccess())
 434     ReportSuccess(val, out);
 435   else
 436     LogAndReportError(status, &out);
 437 }
 438
 439 void ContactInstance::AddressBookStartListening(const JsonValue& args, JsonObject& out) {
 440   ScopeLogger();
 441   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 442   JsonValue val{JsonObject{}};
 443   PlatformResult status = AddressBook::AddressBookStartListening(
 444       *this, common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 445   if (status.IsSuccess())
 446     ReportSuccess(val, out);
 447   else
 448     LogAndReportError(status, &out);
 449 }
 450
 451 void ContactInstance::AddressBookStopListening(const JsonValue& args, JsonObject& out) {
 452   ScopeLogger();
 453   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 454   JsonValue val{JsonObject{}};
 455   PlatformResult status = AddressBook::AddressBookStopListening(*this);
 456   if (status.IsSuccess())
 457     ReportSuccess(val, out);
 458   else
 459     LogAndReportError(status, &out);
 460 }
 461
 462 void ContactInstance::ContactManagerGet(const JsonValue& args, JsonObject& out) {
 463   ScopeLogger();
 464   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 465   JsonValue val{JsonObject{}};
 466   PlatformResult status =
 467       ContactManager::ContactManagerGet(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 468   if (status.IsSuccess())
 469     ReportSuccess(val, out);
 470   else
 471     LogAndReportError(status, &out);
 472 }
 473
 474 void ContactInstance::ContactManagerUpdate(const JsonValue& args, JsonObject& out) {
 475   ScopeLogger();
 476   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 477
 478   const auto& group = args.get("person").get<JsonObject>();
 479   CHECK_CONTACT_ATTRIBUTES_STORAGE(group, kPersonGroupURIs, &out);
 480
 481   JsonValue val{JsonObject{}};
 482   PlatformResult status = ContactManager::ContactManagerUpdate(common::JsonCast<JsonObject>(args),
 483                                                                val.get<JsonObject>());
 484   if (status.IsSuccess())
 485     ReportSuccess(out);
 486   else
 487     LogAndReportError(status, &out);
 488 }
 489
 490 void ContactInstance::ContactManagerUpdateBatch(const JsonValue& args, JsonObject& out) {
 491   ScopeLogger();
 492   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 493
 494   const auto& batch_args = args.get("batchArgs").get<JsonArray>();
 495   for (auto& item : batch_args) {
 496     JsonObject contact = common::JsonCast<JsonObject>(item);
 497     CHECK_CONTACT_ATTRIBUTES_STORAGE(contact, kPersonGroupURIs, &out);
 498   }
 499
 500   const double callback_id = args.get("callbackId").get<double>();
 501
 502   auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
 503     ScopeLogger("Entered into asynchronous function, get");
 504     PlatformResult status =
 505         ContactManager::ContactManagerUpdateBatch(common::JsonCast<JsonObject>(args));
 506
 507     if (status.IsSuccess())
 508       ReportSuccess(response->get<JsonObject>());
 509     else
 510       LogAndReportError(status, &response->get<JsonObject>());
 511   };
 512
 513   auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
 514     ScopeLogger("Entered into asynchronous function, get_response");
 515     JsonObject& obj = response->get<JsonObject>();
 516     obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
 517     Instance::PostMessage(this, response->serialize().c_str());
 518   };
 519
 520   auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
 521
 522   TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
 523 }
 524
 525 void ContactInstance::ContactManagerRemove(const JsonValue& args, JsonObject& out) {
 526   ScopeLogger();
 527   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 528   JsonValue val{JsonObject{}};
 529   PlatformResult status = ContactManager::ContactManagerRemove(common::JsonCast<JsonObject>(args),
 530                                                                val.get<JsonObject>());
 531   if (status.IsSuccess())
 532     ReportSuccess(out);
 533   else
 534     LogAndReportError(status, &out);
 535 }
 536
 537 void ContactInstance::ContactManagerRemoveBatch(const JsonValue& args, JsonObject& out) {
 538   ScopeLogger();
 539   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 540
 541   const double callback_id = args.get("callbackId").get<double>();
 542
 543   auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
 544     ScopeLogger("Entered into asynchronous function, get");
 545     PlatformResult status =
 546         ContactManager::ContactManagerRemoveBatch(common::JsonCast<JsonObject>(args));
 547
 548     if (status.IsSuccess())
 549       ReportSuccess(response->get<JsonObject>());
 550     else
 551       LogAndReportError(status, &response->get<JsonObject>());
 552   };
 553
 554   auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
 555     ScopeLogger("Entered into asynchronous function, get_response");
 556     JsonObject& obj = response->get<JsonObject>();
 557     obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
 558     Instance::PostMessage(this, response->serialize().c_str());
 559   };
 560
 561   auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
 562
 563   TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
 564 }
 565
 566 void ContactInstance::ContactManagerFind(const JsonValue& args, JsonObject& out) {
 567   ScopeLogger();
 568   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 569   const double callback_id = args.get("callbackId").get<double>();
 570
 571   auto get = [this, args](const std::shared_ptr<JsonValue>& response) -> void {
 572     ScopeLogger("Entered into asynchronous function, get");
 573     JsonValue result = JsonValue(JsonArray());
 574
 575     PlatformResult status = ContactManager::ContactManagerFind(common::JsonCast<JsonObject>(args),
 576                                                                result.get<JsonArray>());
 577     if (status.IsSuccess()) {
 578       ReportSuccess(result, response->get<JsonObject>());
 579     } else {
 580       LogAndReportError(status, &response->get<JsonObject>());
 581     }
 582   };
 583
 584   auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
 585     ScopeLogger("Entered into asynchronous function, get_response");
 586     JsonObject& obj = response->get<JsonObject>();
 587     obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
 588     Instance::PostMessage(this, response->serialize().c_str());
 589   };
 590
 591   auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
 592
 593   TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
 594 }
 595
 596 void ContactInstance::ContactManagerFindByUsageCount(const JsonValue& args, JsonObject& out) {
 597   ScopeLogger();
 598   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 599   const double callback_id = args.get("callbackId").get<double>();
 600
 601   auto get = [this, args](const std::shared_ptr<JsonValue>& response) -> void {
 602     ScopeLogger("Entered into asynchronous function, get");
 603     JsonValue result = JsonValue(JsonArray());
 604
 605     PlatformResult status = ContactManager::ContactManagerFindByUsageCount(
 606         common::JsonCast<JsonObject>(args), result.get<JsonArray>());
 607     if (status.IsSuccess()) {
 608       ReportSuccess(result, response->get<JsonObject>());
 609     } else {
 610       LogAndReportError(status, &response->get<JsonObject>());
 611     }
 612   };
 613
 614   auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
 615     ScopeLogger("Entered into asynchronous function, get_response");
 616     JsonObject& obj = response->get<JsonObject>();
 617     obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
 618     Instance::PostMessage(this, response->serialize().c_str());
 619   };
 620
 621   auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
 622
 623   TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
 624 }
 625
 626 void ContactInstance::ContactManagerImportFromVCard(const JsonValue& args, JsonObject& out) {
 627   ScopeLogger();
 628   JsonValue val{JsonObject{}};
 629   PlatformResult status = ContactManager::ContactManagerImportFromVCard(
 630       common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 631   if (status.IsSuccess())
 632     ReportSuccess(val, out);
 633   else
 634     LogAndReportError(status, &out);
 635 }
 636
 637 void ContactInstance::ContactManagerStartListening(const JsonValue& args, JsonObject& out) {
 638   ScopeLogger();
 639   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 640   JsonValue val{JsonObject{}};
 641   PlatformResult status = ContactManager::ContactManagerStartListening(
 642       *this, common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 643   if (status.IsSuccess())
 644     ReportSuccess(val, out);
 645   else
 646     LogAndReportError(status, &out);
 647 }
 648
 649 void ContactInstance::ContactManagerStopListening(const JsonValue& args, JsonObject& out) {
 650   ScopeLogger();
 651   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 652   JsonValue val{JsonObject{}};
 653   PlatformResult status = ContactManager::ContactManagerStopListening(
 654       *this, common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 655   if (status.IsSuccess())
 656     ReportSuccess(val, out);
 657   else
 658     LogAndReportError(status, &out);
 659 }
 660
 661 void ContactInstance::PersonLink(const JsonValue& args, JsonObject& out) {
 662   ScopeLogger();
 663   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 664   JsonValue val{JsonObject{}};
 665   PlatformResult status =
 666       Person::PersonLink(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 667   if (status.IsSuccess())
 668     ReportSuccess(out);
 669   else
 670     LogAndReportError(status, &out);
 671 }
 672
 673 void ContactInstance::PersonUnlink(const JsonValue& args, JsonObject& out) {
 674   ScopeLogger();
 675   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 676   JsonValue val{JsonObject{}};
 677   PlatformResult status =
 678       Person::PersonUnlink(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 679   if (status.IsSuccess())
 680     ReportSuccess(val, out);
 681   else
 682     LogAndReportError(status, &out);
 683 }
 684
 685 void ContactInstance::PersonGetUsageCount(const JsonValue& args, JsonObject& out) {
 686   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
 687   JsonValue val{JsonObject{}};
 688   PlatformResult status =
 689       Person::GetUsageCount(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
 690   if (status.IsSuccess()) {
 691     ReportSuccess(val, out);
 692   } else {
 693     LogAndReportError(status, &out);
 694   }
 695 }
 696
 697 void ContactInstance::PersonResetUsageCount(const JsonValue& args, JsonObject& out) {
 698   ScopeLogger();
 699   CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
 700   PlatformResult status = Person::PersonResetUsageCount(common::JsonCast<JsonObject>(args));
 701   if (status.IsSuccess()) {
 702     ReportSuccess(out);
 703   } else {
 704     LogAndReportError(status, &out);
 705   }
 706 #undef CHECK_CONTACT_ATTRIBUTES_STORAGE
 707 #undef CHECK_CONTACT_ATTRIBUTES_ARRAY
 708 }
 709
 710 }  // namespace contact
 711 }  // namespace extension