src/application/application_manager.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 "application_manager.h"
  18
  19 #include <glib.h>
  20 #include <sys/stat.h>
  21 #include <unistd.h>
  22 #include <type_traits>
  23
  24 #include <app_control_internal.h>
  25 #include <app_info.h>
  26 #include <app_manager_extension.h>
  27 #include <appsvc.h>
  28 #include <aul.h>
  29 #include <bundle.h>
  30 #include <bundle_internal.h>
  31 #include <package_manager.h>
  32 #include <pkgmgr-info.h>
  33 #include <pkgmgr_installer.h>
  34
  35 #include "common/current_application.h"
  36 #include "common/logger.h"
  37 #include "common/platform_result.h"
  38 #include "common/scope_exit.h"
  39 #include "common/task-queue.h"
  40 #include "common/tools.h"
  41
  42 #include "application/application_instance.h"
  43 #include "application/application_utils.h"
  44
  45 using namespace common;
  46 using namespace tools;
  47
  48 namespace extension {
  49 namespace application {
  50
  51 namespace {
  52 const std::string kTizenApisFileScheme = "file://";
  53 const std::string kTizenApisAppSlash = "/";
  54 const std::string kTizenApisAppShared = "shared";
  55
  56 const char* kStartKey = PKGMGR_INSTALLER_START_KEY_STR;
  57 const char* kEndKey = PKGMGR_INSTALLER_END_KEY_STR;
  58 const char* kOkValue = PKGMGR_INSTALLER_OK_EVENT_STR;
  59 const char* kInstallEvent = PKGMGR_INSTALLER_INSTALL_EVENT_STR;
  60 const char* kUpdateEvent = PKGMGR_INSTALLER_UPGRADE_EVENT_STR;
  61 const char* kUninstallEvent = PKGMGR_INSTALLER_UNINSTALL_EVENT_STR;
  62
  63 const char* kAppidKey = "appid";
  64
  65 const std::string kAction = "action";
  66 const std::string kCallbackId = "callbackId";
  67 const std::string kOnInstalled = "oninstalled";
  68 const std::string kOnUpdated = "onupdated";
  69 const std::string kOnUninstalled = "onuninstalled";
  70 const std::string kData = "data";
  71 const std::string kStatusType = "statusType";
  72 const std::string kAppId = "appId";
  73 const std::string kListenerId = "listenerId";
  74 const std::string kAppStatusChangeListener = "AppStatusChangeListener";
  75 const std::string kAppUsageModeFrequently = "FREQUENTLY";
  76 const std::string kAppUsageModeRecently = "RECENTLY";
  77
  78 const std::map<std::string, std::string> event_map_ = {
  79     {SYSTEM_EVENT_BATTERY_CHARGER_STATUS, EVENT_KEY_BATTERY_CHARGER_STATUS},
  80     {SYSTEM_EVENT_BATTERY_LEVEL_STATUS, EVENT_KEY_BATTERY_LEVEL_STATUS},
  81     {SYSTEM_EVENT_USB_STATUS, EVENT_KEY_USB_STATUS},
  82     {SYSTEM_EVENT_EARJACK_STATUS, EVENT_KEY_EARJACK_STATUS},
  83     {SYSTEM_EVENT_DISPLAY_STATE, EVENT_KEY_DISPLAY_STATE},
  84     {SYSTEM_EVENT_LOW_MEMORY, EVENT_KEY_LOW_MEMORY},
  85     {SYSTEM_EVENT_WIFI_STATE, EVENT_KEY_WIFI_STATE},
  86     {SYSTEM_EVENT_BT_STATE, EVENT_KEY_BT_STATE},
  87     {SYSTEM_EVENT_LOCATION_ENABLE_STATE, EVENT_KEY_LOCATION_ENABLE_STATE},
  88     {SYSTEM_EVENT_GPS_ENABLE_STATE, EVENT_KEY_GPS_ENABLE_STATE},
  89     {SYSTEM_EVENT_NPS_ENABLE_STATE, EVENT_KEY_NPS_ENABLE_STATE},
  90     {SYSTEM_EVENT_INCOMING_MSG, EVENT_KEY_MSG_TYPE},
  91     {SYSTEM_EVENT_TIME_ZONE, EVENT_KEY_TIME_ZONE},
  92     {SYSTEM_EVENT_HOUR_FORMAT, EVENT_KEY_HOUR_FORMAT},
  93     {SYSTEM_EVENT_LANGUAGE_SET, EVENT_KEY_LANGUAGE_SET},
  94     {SYSTEM_EVENT_REGION_FORMAT, EVENT_KEY_REGION_FORMAT},
  95     {SYSTEM_EVENT_SILENT_MODE, EVENT_KEY_SILENT_MODE},
  96     {SYSTEM_EVENT_VIBRATION_STATE, EVENT_KEY_VIBRATION_STATE},
  97     {SYSTEM_EVENT_SCREEN_AUTOROTATE_STATE, EVENT_KEY_SCREEN_AUTOROTATE_STATE},
  98     {SYSTEM_EVENT_MOBILE_DATA_STATE, EVENT_KEY_MOBILE_DATA_STATE},
  99     {SYSTEM_EVENT_DATA_ROAMING_STATE, EVENT_KEY_DATA_ROAMING_STATE},
 100     {SYSTEM_EVENT_FONT_SET, EVENT_KEY_FONT_SET}};
 101
 102 #if defined(TIZEN_MOBILE) || defined(TIZEN_WEARABLE)
 103 const int kMaximumBatteryRetrievedObjects = 30;
 104 const int kMaximumAppsRetrievedObjects = 10;
 105 const int kDefaultPeriodOfTime = 30;
 106 #endif
 107 }
 108
 109 ApplicationManager::ApplicationManager(ApplicationInstance& instance)
 110     : pkgmgr_client_handle_(nullptr),
 111       pkgmgr_client_uninstall_handle_(nullptr),
 112       instance_(instance),
 113       app_status_handle_(nullptr) {
 114   ScopeLogger();
 115 }
 116
 117 ApplicationManager::~ApplicationManager() {
 118   ScopeLogger();
 119   StopAppInfoEventListener();
 120   StopStatusChangeListener();
 121
 122   for (auto it = event_handler_map_.begin(); it != event_handler_map_.end();) {
 123     int ret = event_remove_event_handler(it->second);
 124     if (EVENT_ERROR_NONE != ret) {
 125       LoggerE("event_remove_event_handler failed, error: %d (%s)", ret, get_error_message(ret));
 126     }
 127     it = event_handler_map_.erase(it);
 128   }
 129
 130   if (app_status_handle_) {
 131     int ret = app_manager_event_destroy(app_status_handle_);
 132     if (APP_MANAGER_ERROR_NONE != ret) {
 133       LoggerE("app_manager_event_destroy failed, error: %d", ret);
 134     }
 135   }
 136 }
 137
 138 void ApplicationManager::GetCurrentApplication(const std::string& app_id, picojson::object* out) {
 139   ScopeLogger();
 140
 141   // obtain handle to application info
 142   pkgmgrinfo_appinfo_h handle;
 143   int ret = pkgmgrinfo_appinfo_get_usr_appinfo(app_id.c_str(), getuid(), &handle);
 144   if (PMINFO_R_OK != ret) {
 145     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get app info."), out,
 146                       ("Failed to get app info: %d (%s)", ret, get_error_message(ret)));
 147     return;
 148   }
 149
 150   picojson::value app_info = picojson::value(picojson::object());
 151   picojson::object& app_info_obj = app_info.get<picojson::object>();
 152
 153   utils::CreateApplicationInformation(handle, &app_info_obj);
 154   pkgmgrinfo_appinfo_destroy_appinfo(handle);
 155
 156   picojson::value result = picojson::value(picojson::object());
 157   picojson::object& result_obj = result.get<picojson::object>();
 158
 159   result_obj.insert(std::make_pair(
 160       "contextId",
 161       picojson::value(std::to_string(CurrentApplication::GetInstance().GetProcessId()))));
 162   result_obj.insert(std::make_pair("appInfo", app_info));
 163
 164   ReportSuccess(result, *out);
 165 }
 166
 167 class TerminateHandler {
 168  public:
 169   TerminateHandler(int callback_id, ApplicationInstance* app_instance)
 170       : callback_handle_(callback_id), pid_(-1), timeout_id_(0), app_instance_(app_instance) {
 171   }
 172
 173   void set_pid(pid_t pid) {
 174     pid_ = pid;
 175   }
 176
 177   pid_t pid() const {
 178     return pid_;
 179   }
 180
 181   void Invoke(const std::shared_ptr<picojson::value>& response) {
 182     ScopeLogger();
 183
 184     if (timeout_id_ > 0) {
 185       // cancel terminate callback
 186       g_source_remove(timeout_id_);
 187       timeout_id_ = 0;
 188     }
 189
 190     ApplicationInstance* app_instance = this->app_instance_;
 191     int callback_id = this->callback_handle_;
 192     TaskQueue::GetInstance().Async<picojson::value>(
 193         [callback_id, app_instance](const std::shared_ptr<picojson::value>& response) {
 194           picojson::object& obj = response->get<picojson::object>();
 195           obj.insert(
 196               std::make_pair(kCallbackId, picojson::value(static_cast<double>(callback_id))));
 197           Instance::PostMessage(app_instance, response->serialize().c_str());
 198         },
 199         response);
 200   }
 201
 202  private:
 203   int callback_handle_;
 204   pid_t pid_;
 205   guint timeout_id_;
 206   ApplicationInstance* app_instance_;
 207 };
 208
 209 #define CHECK_RESULT(result, response, handler)                    \
 210   if (result.IsError()) {                                          \
 211     LogAndReportError(result, &response->get<picojson::object>()); \
 212     handler->Invoke(response);                                     \
 213     delete handler;                                                \
 214     return;                                                        \
 215   }
 216
 217 void ApplicationManager::AsyncResponse(const PlatformResult& result,
 218                                        std::shared_ptr<picojson::value>* response) {
 219   ScopeLogger();
 220   LogAndReportError(result, &(*response)->get<picojson::object>());
 221
 222   TaskQueue::GetInstance().Async<picojson::value>(
 223       [this](const std::shared_ptr<picojson::value>& response) {
 224         Instance::PostMessage(&this->instance_, response->serialize().c_str());
 225       },
 226       *response);
 227 }
 228
 229 void ApplicationManager::Kill(const picojson::value& args) {
 230   ScopeLogger();
 231
 232   PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
 233
 234   int callback_id = -1;
 235   const auto& callback = args.get(kCallbackId);
 236   if (callback.is<double>()) {
 237     callback_id = static_cast<int>(callback.get<double>());
 238   }
 239
 240   const auto& context = args.get("contextId");
 241   if (!context.is<std::string>()) {
 242     result = LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed.");
 243   }
 244
 245   const std::string& context_id = context.get<std::string>();
 246
 247   if (context_id.empty() && result.IsSuccess()) {
 248     result = LogAndCreateResult(ErrorCode::NOT_FOUND_ERR, "Context ID is empty.");
 249   }
 250
 251   std::shared_ptr<picojson::value> response(new picojson::value(picojson::object()));
 252   picojson::object& obj = response->get<picojson::object>();
 253   obj.insert(std::make_pair(kCallbackId, picojson::value(static_cast<double>(callback_id))));
 254
 255   if (result.IsError()) {
 256     LoggerE("Failed args.get");
 257     AsyncResponse(result, &response);
 258     return;
 259   }
 260
 261   auto kill = [this, callback_id, context_id]() -> void {
 262     ScopeLogger("Kill");
 263
 264     std::shared_ptr<picojson::value> response =
 265         std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
 266
 267     TerminateHandler* handler = new TerminateHandler(callback_id, &this->instance_);
 268     PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
 269
 270     pid_t pid = -1;
 271     try {
 272       pid = std::stoi(context_id);
 273     } catch (...) {
 274       result = LogAndCreateResult(ErrorCode::NOT_FOUND_ERR, "Failed to convert string to int.");
 275       CHECK_RESULT(result, response, handler)
 276     }
 277
 278     if (pid <= 0) {
 279       result = LogAndCreateResult(ErrorCode::NOT_FOUND_ERR, "Context ID cannot be negative value.");
 280       CHECK_RESULT(result, response, handler)
 281     }
 282
 283     // if kill request comes for current context, throw InvalidValuesException
 284     if (CurrentApplication::GetInstance().GetProcessId() == pid) {
 285       result =
 286           LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Cannot kill current application.");
 287       CHECK_RESULT(result, response, handler)
 288     }
 289
 290     LoggerD("Kill, pid: %d", pid);
 291
 292     char* app_id = nullptr;
 293     int ret = app_manager_get_app_id(pid, &app_id);
 294     // automatically release the memory
 295     std::unique_ptr<char, void (*)(void*)> app_id_ptr(app_id, &std::free);
 296
 297     if (APP_MANAGER_ERROR_NONE != ret) {
 298       result = LogAndCreateResult(
 299           ErrorCode::NOT_FOUND_ERR, "Failed to get application ID.",
 300           ("Failed to get application ID, error: %d (%s)", ret, get_error_message(ret)));
 301       CHECK_RESULT(result, response, handler)
 302     }
 303
 304     LoggerD("Kill, app ID: %s", app_id);
 305
 306     // acquire application context
 307     app_context_h app_context = nullptr;
 308
 309     ret = app_manager_get_app_context(app_id, &app_context);
 310     std::unique_ptr<std::remove_pointer<app_context_h>::type, int (*)(app_context_h)>
 311         app_context_ptr(app_context, &app_context_destroy);  // automatically release the memory
 312
 313     if (APP_MANAGER_ERROR_NONE != ret) {
 314       result = LogAndCreateResult(
 315           ErrorCode::NOT_FOUND_ERR, "Failed to get application ID.",
 316           ("Failed to get application context handle: %d (%s)", ret, get_error_message(ret)));
 317       CHECK_RESULT(result, response, handler)
 318     }
 319
 320     auto terminate_callback = [](app_context_h app_context, app_context_event_e event,
 321                                  void* user_data) {
 322       LoggerD("terminate_callback: %d", event);
 323
 324       if (APP_CONTEXT_EVENT_TERMINATED != event) {
 325         LoggerD("ignoring event");
 326         return;
 327       }
 328
 329       int pid = 0;
 330       int ret = app_context_get_pid(app_context, &pid);
 331
 332       if (APP_MANAGER_ERROR_NONE != ret) {
 333         LoggerE("Failed to get pid of terminated app: %d (%s)", ret, get_error_message(ret));
 334         return;
 335       }
 336
 337       TerminateHandler* handler = static_cast<TerminateHandler*>(user_data);
 338
 339       LoggerD("Expected PID: %d, got: %d", handler->pid(), pid);
 340
 341       if (handler->pid() == pid) {
 342         std::shared_ptr<picojson::value> response =
 343             std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
 344         ReportSuccess(response->get<picojson::object>());
 345         handler->Invoke(response);
 346         delete handler;
 347       }
 348     };
 349
 350     LoggerD("Kill, setting callback");
 351     handler->set_pid(pid);
 352     ret = app_manager_set_app_context_event_cb(terminate_callback, handler);
 353
 354     if (APP_MANAGER_ERROR_NONE != ret) {
 355       result = LogAndCreateResult(
 356           ErrorCode::UNKNOWN_ERR, "Failed to register termination callback.",
 357           ("Error while registering app context event: %d (%s)", ret, get_error_message(ret)));
 358       CHECK_RESULT(result, response, handler)
 359     }
 360
 361     LoggerD("Kill, calling native function");
 362
 363     // terminate application
 364     ret = app_manager_terminate_app(app_context);
 365
 366     if (APP_MANAGER_ERROR_NONE != ret) {
 367       result = LogAndCreateResult(
 368           ErrorCode::UNKNOWN_ERR, "Failed to terminate application.",
 369           ("Failed to terminate application: %d (%s)", ret, get_error_message(ret)));
 370       CHECK_RESULT(result, response, handler)
 371     }
 372
 373     LoggerD("Kill, end, waiting for notification");
 374   };
 375
 376   kill();
 377 }
 378
 379 namespace {
 380
 381 PlatformResult PrepareAppControlForLaunchAppControl(const picojson::value& args,
 382                                                     app_control_h* app_control) {
 383   ScopeLogger();
 384
 385   const auto& control = args.get("appControl");
 386   if (!control.is<picojson::object>()) {
 387     return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed.");
 388   }
 389   const picojson::object& app_control_obj = control.get<picojson::object>();
 390
 391   app_control_h tmp_app_control = nullptr;
 392   auto result = utils::ApplicationControlToService(app_control_obj, &tmp_app_control);
 393   std::unique_ptr<std::remove_pointer<app_control_h>::type, decltype(&app_control_destroy)>
 394       app_control_ptr(tmp_app_control, &app_control_destroy);
 395
 396   if (result.IsError()) {
 397     LoggerE("Application control to service failed.");
 398     return result;
 399   }
 400
 401   std::string app_id;
 402   const auto& id = args.get("id");
 403   if (id.is<std::string>()) {
 404     app_id = id.get<std::string>();
 405   }
 406
 407   if (!app_id.empty()) {
 408     LoggerD("app_id: %s", app_id.c_str());
 409
 410     int ret = app_control_set_app_id(app_control_ptr.get(), app_id.c_str());
 411
 412     if (APP_CONTROL_ERROR_NONE != ret) {
 413       LoggerE("Failed to set app id: %d (%s)", ret, get_error_message(ret));
 414       return PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed.");
 415     }
 416   }
 417
 418   *app_control = app_control_ptr.release();
 419
 420   return PlatformResult(ErrorCode::NO_ERROR);
 421 }
 422
 423 }  // namespace
 424
 425 void ApplicationManager::LaunchAppControl(const picojson::value& args) {
 426   ScopeLogger();
 427
 428   int callback_id = -1;
 429   const auto& callback = args.get(kCallbackId);
 430   if (callback.is<double>()) {
 431     callback_id = static_cast<int>(callback.get<double>());
 432   }
 433
 434   std::shared_ptr<picojson::value> response(new picojson::value(picojson::object()));
 435   picojson::object& response_obj = response->get<picojson::object>();
 436   response_obj.insert(
 437       std::make_pair(kCallbackId, picojson::value(static_cast<double>(callback_id))));
 438
 439   app_control_h app_control = nullptr;
 440   auto prepare_app_control_result = PrepareAppControlForLaunchAppControl(args, &app_control);
 441   if (prepare_app_control_result.IsError()) {
 442     AsyncResponse(LogAndCreateResult(prepare_app_control_result), &response);
 443     return;
 444   }
 445
 446   std::unique_ptr<std::remove_pointer<app_control_h>::type, decltype(&app_control_destroy)>
 447       app_control_ptr(app_control, &app_control_destroy);
 448
 449   std::string reply_callback_id;
 450   const auto& reply = args.get("replyCallback");
 451   if (reply.is<std::string>()) {
 452     reply_callback_id = reply.get<std::string>();
 453   }
 454
 455   struct LaunchAppControlCallbackData {
 456     ApplicationInstance* instance;
 457     std::shared_ptr<picojson::value> response;
 458     std::string reply_callback_id;
 459   }* launch_app_user_data = new (std::nothrow)
 460       LaunchAppControlCallbackData{&this->instance_, response, reply_callback_id};
 461
 462   if (!launch_app_user_data) {
 463     LoggerE("Memory allocation fail!");
 464     AsyncResponse(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error."), &response);
 465     return;
 466   }
 467
 468   app_control_reply_cb reply_callback = nullptr;
 469   if (!reply_callback_id.empty()) {
 470     launch_app_user_data->reply_callback_id = reply_callback_id;
 471
 472     reply_callback = [](app_control_h request, app_control_h reply, app_control_result_e result,
 473                         void* user_data) {
 474       ScopeLogger("reply_callback");
 475
 476       LaunchAppControlCallbackData* callback_data =
 477           static_cast<LaunchAppControlCallbackData*>(user_data);
 478       if (!callback_data) {
 479         LoggerD("reply_callback failed: user_data is nullptr");
 480         return;
 481       }
 482
 483       picojson::value return_value = picojson::value(picojson::object());
 484       picojson::object& return_value_obj = return_value.get<picojson::object>();
 485       return_value_obj.insert(
 486           std::make_pair(kListenerId, picojson::value(callback_data->reply_callback_id)));
 487
 488       if (APP_CONTROL_RESULT_SUCCEEDED == result) {
 489         LoggerD("App started");
 490         return_value_obj.insert(std::make_pair("data", picojson::value(picojson::array())));
 491         if (!utils::ServiceToApplicationControlDataArray(
 492                 reply, &return_value_obj.find("data")->second.get<picojson::array>())) {
 493           return_value_obj.erase("data");
 494         }
 495         ReportSuccess(return_value_obj);
 496       } else {
 497         ReportError(return_value_obj);
 498       }
 499
 500       Instance::PostMessage(callback_data->instance, return_value.serialize().c_str());
 501       delete callback_data;
 502     };
 503   }
 504
 505   app_control_result_cb result_callback = [](app_control_h launch_request,
 506                                              app_control_error_e launch_result, void* user_data) {
 507     ScopeLogger("LaunchAppControl result_callback");
 508
 509     LaunchAppControlCallbackData* callback_data =
 510         static_cast<LaunchAppControlCallbackData*>(user_data);
 511
 512     auto result = utils::TranslateAppControlError(launch_result);
 513
 514     if (result.IsError()) {
 515       LogAndReportError(result, &(callback_data->response->get<picojson::object>()));
 516     } else {
 517       ReportSuccess(callback_data->response->get<picojson::object>());
 518     }
 519
 520     Instance::PostMessage(callback_data->instance, callback_data->response->serialize().c_str());
 521
 522     if (result.IsError() || (callback_data->reply_callback_id).empty()) {
 523       delete callback_data;
 524     }
 525   };
 526
 527   /*
 528    * TODO: Observe how often app_control_send_launch_request_async tries to launch the application.
 529    * Previous implementation, using synchronous app_control_send_launch_request,
 530    * tries to launch the application 3 times, before reporting an error.
 531    * New implementation, using app_control_send_launch_request_async makes only one attempt.
 532    * If problems, such as failed application start occur, multiple attempts may solve the problem.
 533    */
 534   auto launch_result = utils::TranslateAppControlError(
 535       static_cast<app_control_error_e>(app_control_send_launch_request_async(
 536           app_control_ptr.get(), result_callback, reply_callback, launch_app_user_data)));
 537
 538   if (launch_result.IsError()) {
 539     delete launch_app_user_data;
 540     AsyncResponse(launch_result, &response);
 541   } else {
 542     LoggerD("App launched");
 543   }
 544 }
 545
 546 namespace {
 547
 548 PlatformResult TranslateLaunchError(app_control_error_e return_code) {
 549   ScopeLogger();
 550
 551   auto result = utils::TranslateAppControlError(return_code);
 552   if (ErrorCode::SECURITY_ERR == result.error_code()) {
 553     result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error.");
 554   }
 555
 556   return result;
 557 }
 558
 559 PlatformResult PrepareAppControlForLaunch(const picojson::value& args, app_control_h* app_control) {
 560   ScopeLogger();
 561
 562   const auto& app_id = args.get("id");
 563   if (!app_id.is<std::string>()) {
 564     return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed.");
 565   }
 566   const auto app_id_str = app_id.get<std::string>();
 567
 568   app_control_h tmp_app_control = nullptr;
 569   int result = app_control_create(&tmp_app_control);
 570   if (APP_CONTROL_ERROR_NONE != result) {
 571     LoggerD("app_control_create() failed: %d (%s)", result, get_error_message(result));
 572     return PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred.");
 573   }
 574
 575   std::unique_ptr<std::remove_pointer<app_control_h>::type, decltype(&app_control_destroy)>
 576       app_control_ptr(tmp_app_control, &app_control_destroy);
 577
 578   if (!app_id_str.empty()) {
 579     LoggerD("app_id: %s", app_id_str.c_str());
 580
 581     int ret = app_control_set_app_id(app_control_ptr.get(), app_id_str.c_str());
 582
 583     if (APP_CONTROL_ERROR_NONE != ret) {
 584       LoggerE("Failed to set app id: %d (%s)", ret, get_error_message(ret));
 585       return PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed.");
 586     }
 587   }
 588
 589   *app_control = app_control_ptr.release();
 590
 591   return PlatformResult(ErrorCode::NO_ERROR);
 592 }
 593
 594 }  // namespace
 595 void ApplicationManager::Launch(const picojson::value& args) {
 596   ScopeLogger();
 597
 598   int callback_id = -1;
 599   const auto& callback = args.get(kCallbackId);
 600   if (callback.is<double>()) {
 601     callback_id = static_cast<int>(callback.get<double>());
 602   }
 603
 604   std::shared_ptr<picojson::value> response(new picojson::value(picojson::object()));
 605   picojson::object& response_obj = response->get<picojson::object>();
 606   response_obj.insert(
 607       std::make_pair(kCallbackId, picojson::value(static_cast<double>(callback_id))));
 608
 609   app_control_h app_control = nullptr;
 610   auto prepare_app_control_result = PrepareAppControlForLaunch(args, &app_control);
 611   if (prepare_app_control_result.IsError()) {
 612     AsyncResponse(LogAndCreateResult(prepare_app_control_result), &response);
 613     return;
 614   }
 615
 616   std::unique_ptr<std::remove_pointer<app_control_h>::type, decltype(&app_control_destroy)>
 617       app_control_ptr(app_control, &app_control_destroy);
 618
 619   struct LaunchCallbackData {
 620     ApplicationInstance* instance;
 621     std::shared_ptr<picojson::value> response;
 622   }* launch_user_data = new (std::nothrow) LaunchCallbackData{&this->instance_, response};
 623
 624   app_control_result_cb result_callback = [](app_control_h launch_request,
 625                                              app_control_error_e launch_result, void* user_data) {
 626     ScopeLogger("Launch result_callback");
 627
 628     LaunchCallbackData* callback_data = static_cast<LaunchCallbackData*>(user_data);
 629
 630     auto result = TranslateLaunchError(launch_result);
 631
 632     if (result.IsError()) {
 633       LogAndReportError(result, &(callback_data->response->get<picojson::object>()));
 634     } else {
 635       ReportSuccess(callback_data->response->get<picojson::object>());
 636     }
 637
 638     Instance::PostMessage(callback_data->instance, callback_data->response->serialize().c_str());
 639
 640     delete callback_data;
 641   };
 642
 643   /*
 644    * TODO: Observe how often app_control_send_launch_request_async tries to launch the application.
 645    * Previous implementation, using synchronous app_control_send_launch_request,
 646    * tries to launch the application 3 times, before reporting an error.
 647    * New implementation, using app_control_send_launch_request_async makes only one attempt.
 648    * If problems, such as failed application start occur, multiple attempts may solve the problem.
 649    */
 650   auto launch_result =
 651       TranslateLaunchError(static_cast<app_control_error_e>(app_control_send_launch_request_async(
 652           app_control_ptr.get(), result_callback, nullptr, launch_user_data)));
 653
 654   if (launch_result.IsError()) {
 655     delete launch_user_data;
 656     AsyncResponse(launch_result, &response);
 657   } else {
 658     LoggerD("App launched");
 659   }
 660 }
 661
 662 // internal impl of app_control_foreach_app_matched() for handling APP_CONTROL_ERROR_APP_NOT_FOUND
 663 // public CAPI did not handling APP_CONTROL_ERROR_APP_NOT_FOUND
 664 int app_control_foreach_app_matched_internal(app_control_h app_control,
 665                                              app_control_app_matched_cb callback, void* user_data) {
 666   ScopeLogger();
 667   typedef struct {
 668     app_control_h app_control;
 669     app_control_app_matched_cb callback;
 670     void* user_data;
 671     bool foreach_break;
 672   } foreach_context_launchable_app_t_internal;
 673
 674   // internal impl of app_control_cb_broker_foreach_app_matched()
 675   auto app_control_cb_broker_foreach_app_matched_internal = [](const char* package,
 676                                                                void* data) -> int {
 677     ScopeLogger(
 678         "Entered into asynchronous function, app_control_cb_broker_foreach_app_matched_internal's "
 679         "argument");
 680     foreach_context_launchable_app_t_internal* foreach_context;
 681     app_control_app_matched_cb app_matched_cb;
 682
 683     if (package == NULL || data == NULL) {
 684       LoggerE("APP_CONTROL_ERROR_INVALID_PARAMETER");
 685       return -1;
 686     }
 687
 688     foreach_context = (foreach_context_launchable_app_t_internal*)data;
 689     if (foreach_context->foreach_break == true) return -1;
 690
 691     app_matched_cb = foreach_context->callback;
 692     if (app_matched_cb != NULL) {
 693       bool stop_foreach = false;
 694
 695       stop_foreach =
 696           !app_matched_cb(foreach_context->app_control, package, foreach_context->user_data);
 697
 698       foreach_context->foreach_break = stop_foreach;
 699     }
 700
 701     return 0;
 702   };
 703
 704   foreach_context_launchable_app_t_internal foreach_context = {.app_control = app_control,
 705                                                                .callback = callback,
 706                                                                .user_data = user_data,
 707                                                                .foreach_break = false};
 708
 709   bundle* bundle_data = NULL;
 710   app_control_to_bundle(app_control, &bundle_data);
 711
 712   int ret = appsvc_usr_get_list(bundle_data, app_control_cb_broker_foreach_app_matched_internal,
 713                                 &foreach_context, getuid());
 714
 715   if (ret < 0) {
 716     switch (ret) {
 717       case APPSVC_RET_EINVAL:
 718         return APP_CONTROL_ERROR_INVALID_PARAMETER;
 719
 720       case APPSVC_RET_ENOMATCH:
 721         return APP_CONTROL_ERROR_APP_NOT_FOUND;
 722
 723       default:
 724         return APP_CONTROL_ERROR_LAUNCH_FAILED;
 725     }
 726   }
 727
 728   return APP_CONTROL_ERROR_NONE;
 729 }
 730
 731 void ApplicationManager::FindAppControl(const picojson::value& args) {
 732   ScopeLogger();
 733
 734   int callback_id = -1;
 735   const auto& callback = args.get(kCallbackId);
 736   if (callback.is<double>()) {
 737     callback_id = static_cast<int>(callback.get<double>());
 738   }
 739
 740   std::shared_ptr<picojson::value> response(new picojson::value(picojson::object()));
 741   picojson::object& response_obj = response->get<picojson::object>();
 742   response_obj.insert(
 743       std::make_pair(kCallbackId, picojson::value(static_cast<double>(callback_id))));
 744
 745   PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
 746   const auto& control = args.get("appControl");
 747   if (!control.is<picojson::object>()) {
 748     result = LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed.");
 749     AsyncResponse(result, &response);
 750     return;
 751   }
 752
 753   const picojson::object& app_control_obj = control.get<picojson::object>();
 754
 755   app_control_h app_control = nullptr;
 756   result = utils::ApplicationControlToService(app_control_obj, &app_control);
 757   std::shared_ptr<std::remove_pointer<app_control_h>::type> app_control_ptr(
 758       app_control, &app_control_destroy);  // automatically release the memory
 759
 760   if (result.IsError()) {
 761     LoggerE("Application control to service failed.");
 762     AsyncResponse(result, &response);
 763     return;
 764   }
 765
 766   auto find = [app_control_ptr](const std::shared_ptr<picojson::value>& response) -> void {
 767     ScopeLogger("Entered into asynchronous function, find");
 768     auto app_control_matched = [](app_control_h app_control, const char* appid,
 769                                   void* user_data) -> bool {
 770       ScopeLogger("Entered into asynchronous function, app_control_matched");
 771       if (nullptr == appid) {
 772         LoggerD("appid is NULL");
 773         return false;
 774       }
 775
 776       pkgmgrinfo_appinfo_h handle;
 777       int ret = pkgmgrinfo_appinfo_get_usr_appinfo(appid, getuid(), &handle);
 778       if (PMINFO_R_OK != ret) {
 779         LoggerE("Failed to get appInfo: %d (%s)", ret, get_error_message(ret));
 780       } else {
 781         picojson::array* array = static_cast<picojson::array*>(user_data);
 782         array->push_back(picojson::value(picojson::object()));
 783
 784         utils::CreateApplicationInformation(handle, &array->back().get<picojson::object>());
 785         pkgmgrinfo_appinfo_destroy_appinfo(handle);
 786       }
 787
 788       return true;
 789     };
 790
 791     picojson::object& response_obj = response->get<picojson::object>();
 792     auto it_result = response_obj.find("result");
 793     picojson::object& result_obj = it_result->second.get<picojson::object>();
 794     auto array =
 795         result_obj.insert(std::make_pair("informationArray", picojson::value(picojson::array())));
 796
 797     int ret = app_control_foreach_app_matched_internal(app_control_ptr.get(), app_control_matched,
 798                                                        &array.first->second.get<picojson::array>());
 799
 800     if (APP_CONTROL_ERROR_NONE != ret) {
 801       if (APP_CONTROL_ERROR_APP_NOT_FOUND == ret) {
 802         LogAndReportError(PlatformResult(ErrorCode::NOT_FOUND_ERR, "Matched Application not found"),
 803                           &response_obj, ("app_control_foreach_app_matched error: %d (%s)", ret,
 804                                           get_error_message(ret)));
 805       } else if (APP_CONTROL_ERROR_LAUNCH_FAILED == ret) {
 806         LogAndReportError(
 807             PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error"), &response_obj,
 808             ("app_control_foreach_app_matched error: %d (%s)", ret, get_error_message(ret)));
 809       } else if (APP_CONTROL_ERROR_INVALID_PARAMETER == ret) {
 810         LogAndReportError(PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed"),
 811                           &response_obj, ("app_control_foreach_app_matched error: %d (%s)", ret,
 812                                           get_error_message(ret)));
 813       }
 814       // remove copied ApplicationControl from result
 815       response_obj.erase(it_result);
 816     } else {
 817       ReportSuccess(response_obj);
 818     }
 819   };
 820
 821   auto find_response = [this](const std::shared_ptr<picojson::value>& response) -> void {
 822     ScopeLogger("Entered into asynchronous function, find_response");
 823     Instance::PostMessage(&this->instance_, response->serialize().c_str());
 824   };
 825
 826   // prepare result object, we need to do that here, as input parameter is passed to result callback
 827   auto ret = response_obj.insert(std::make_pair("result", picojson::value(picojson::object())));
 828   // reinsert application control
 829   ret.first->second.get<picojson::object>().insert(
 830       std::make_pair("appControl", args.get("appControl")));
 831
 832   TaskQueue::GetInstance().Queue<picojson::value>(find, find_response, response);
 833 }
 834
 835 void ApplicationManager::GetAppsContext(const picojson::value& args) {
 836   ScopeLogger();
 837
 838   int callback_id = -1;
 839   const auto& callback = args.get(kCallbackId);
 840   if (callback.is<double>()) {
 841     callback_id = static_cast<int>(callback.get<double>());
 842   }
 843
 844   auto get_apps_context = [](const std::shared_ptr<picojson::value>& response) -> void {
 845     picojson::object& response_obj = response->get<picojson::object>();
 846     picojson::value result = picojson::value(picojson::object());
 847     picojson::object& result_obj = result.get<picojson::object>();
 848     picojson::array& array =
 849         result_obj.insert(std::make_pair("contexts", picojson::value(picojson::array())))
 850             .first->second.get<picojson::array>();
 851
 852     auto app_context_cb = [](app_context_h app_context, void* user_data) -> bool {
 853       if (nullptr == user_data) {
 854         return false;
 855       }
 856
 857       picojson::array* array = static_cast<picojson::array*>(user_data);
 858       array->push_back(picojson::value(picojson::object()));
 859
 860       if (!utils::CreateApplicationContext(app_context, &array->back().get<picojson::object>())) {
 861         array->pop_back();
 862         return false;
 863       }
 864
 865       return true;
 866     };
 867
 868     int ret = app_manager_foreach_app_context(app_context_cb, &array);
 869
 870     if (APP_MANAGER_ERROR_NONE != ret) {
 871       LogAndReportError(
 872           PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error."), &response_obj,
 873           ("app_manager_foreach_app_context error: %d (%s)", ret, get_error_message(ret)));
 874     } else {
 875       ReportSuccess(result, response_obj);
 876     }
 877   };
 878
 879   auto get_apps_context_response =
 880       [this, callback_id](const std::shared_ptr<picojson::value>& response) -> void {
 881     picojson::object& obj = response->get<picojson::object>();
 882     obj.insert(std::make_pair(kCallbackId, picojson::value(static_cast<double>(callback_id))));
 883     Instance::PostMessage(&this->instance_, response->serialize().c_str());
 884   };
 885
 886   auto data = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
 887
 888   TaskQueue::GetInstance().Queue<picojson::value>(get_apps_context, get_apps_context_response,
 889                                                   data);
 890 }
 891
 892 void ApplicationManager::GetAppContext(const picojson::value& args, picojson::object* out) {
 893   ScopeLogger();
 894   pid_t pid = 0;
 895
 896   const auto& context_id = args.get("contextId");
 897   if (context_id.is<std::string>()) {
 898     try {
 899       pid = std::stoi(context_id.get<std::string>());
 900     } catch (...) {
 901       LogAndReportError(PlatformResult(ErrorCode::NOT_FOUND_ERR, "Failed to convert context id."),
 902                         out);
 903       return;
 904     }
 905   } else {
 906     pid = CurrentApplication::GetInstance().GetProcessId();
 907   }
 908
 909   char* app_id = nullptr;
 910
 911   int ret = app_manager_get_app_id(pid, &app_id);
 912   // automatically release the memory
 913   std::unique_ptr<char, void (*)(void*)> app_id_ptr(app_id, &std::free);
 914
 915   if (APP_MANAGER_ERROR_NONE != ret || nullptr == app_id) {
 916     switch (ret) {
 917       case APP_MANAGER_ERROR_NO_SUCH_APP:
 918         LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "No such application exist."), out,
 919                           ("app_manager_get_app_id returned: APP_MANAGER_ERROR_NO_SUCH_APP"));
 920         return;
 921
 922       case APP_MANAGER_ERROR_INVALID_PARAMETER:
 923         LogAndReportError(PlatformResult(ErrorCode::NOT_FOUND_ERR, "Application not found."), out,
 924                           ("app_manager_get_app_id returned: APP_MANAGER_ERROR_INVALID_PARAMETER"));
 925         return;
 926
 927       default:
 928         LogAndReportError(
 929             PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error."), out,
 930             ("app_manager_get_app_id returned: %d (%s)", ret, get_error_message(ret)));
 931         return;
 932     }
 933   }
 934
 935   picojson::value result = picojson::value(picojson::object());
 936   utils::CreateApplicationContext(pid, app_id, &result.get<picojson::object>());
 937
 938   ReportSuccess(result, *out);
 939 }
 940
 941 void ApplicationManager::GetAppsInfo(const picojson::value& args) {
 942   ScopeLogger();
 943
 944   int callback_id = -1;
 945   const auto& callback = args.get(kCallbackId);
 946   if (callback.is<double>()) {
 947     callback_id = static_cast<int>(callback.get<double>());
 948   }
 949
 950   auto get_apps_info = [](const std::shared_ptr<picojson::value>& response) -> void {
 951     ScopeLogger("Entered into asynchronous function, get_apps_info");
 952     picojson::object& response_obj = response->get<picojson::object>();
 953     picojson::value result = picojson::value(picojson::object());
 954     picojson::object& result_obj = result.get<picojson::object>();
 955     picojson::array& array =
 956         result_obj.insert(std::make_pair("informationArray", picojson::value(picojson::array())))
 957             .first->second.get<picojson::array>();
 958
 959     auto app_info_cb = [](pkgmgrinfo_appinfo_h handle, void* user_data) -> int {
 960       ScopeLogger("Entered into asynchronous function, app_info_cb");
 961       if (nullptr == user_data) {
 962         return -1;
 963       }
 964
 965       picojson::array* array = static_cast<picojson::array*>(user_data);
 966       array->push_back(picojson::value(picojson::object()));
 967
 968       utils::CreateApplicationInformation(handle, &array->back().get<picojson::object>());
 969
 970       return 0;
 971     };
 972
 973     int ret = pkgmgrinfo_appinfo_get_usr_installed_list(app_info_cb, getuid(), &array);
 974
 975     if (APP_MANAGER_ERROR_NONE != ret) {
 976       LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error."), &response_obj,
 977                         ("pkgmgrinfo_appinfo_get_usr_installed_list error"));
 978     } else {
 979       ReportSuccess(result, response_obj);
 980     }
 981   };
 982
 983   auto get_apps_info_response =
 984       [this, callback_id](const std::shared_ptr<picojson::value>& response) -> void {
 985     ScopeLogger("Entered into asynchronous function, get_apps_info_response");
 986     picojson::object& obj = response->get<picojson::object>();
 987     obj.insert(std::make_pair(kCallbackId, picojson::value(static_cast<double>(callback_id))));
 988     Instance::PostMessage(&this->instance_, response->serialize().c_str());
 989   };
 990
 991   auto data = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
 992
 993   TaskQueue::GetInstance().Queue<picojson::value>(get_apps_info, get_apps_info_response, data);
 994 }
 995
 996 void ApplicationManager::GetAppInfo(const std::string& app_id, picojson::object* out) {
 997   ScopeLogger();
 998
 999   pkgmgrinfo_appinfo_h handle = nullptr;
1000
1001   if (PMINFO_R_OK != pkgmgrinfo_appinfo_get_usr_appinfo(app_id.c_str(), getuid(), &handle)) {
1002     LogAndReportError(PlatformResult(ErrorCode::NOT_FOUND_ERR, "Failed to get app info."), out);
1003     return;
1004   }
1005
1006   picojson::value result = picojson::value(picojson::object());
1007   utils::CreateApplicationInformation(handle, &result.get<picojson::object>());
1008   pkgmgrinfo_appinfo_destroy_appinfo(handle);
1009
1010   ReportSuccess(result, *out);
1011 }
1012
1013 char* ApplicationManager::GetPackageId(const std::string& app_id) {
1014   ScopeLogger();
1015   app_info_h handle;
1016   char* pkg_id = nullptr;
1017
1018   int ret = app_manager_get_app_info(app_id.c_str(), &handle);
1019   if (APP_MANAGER_ERROR_NONE != ret) {
1020     LoggerE("Failed to get app info: %d (%s)", ret, get_error_message(ret));
1021     return nullptr;
1022   }
1023
1024   ret = app_info_get_package(handle, &pkg_id);
1025   if (APP_MANAGER_ERROR_NONE != ret) {
1026     LoggerE("Failed to get package id: %d (%s)", ret, get_error_message(ret));
1027     pkg_id = nullptr;
1028   }
1029
1030   ret = app_info_destroy(handle);
1031   if (APP_MANAGER_ERROR_NONE != ret) {
1032     LoggerE("Failed to destroy app info: %d (%s)", ret, get_error_message(ret));
1033   }
1034
1035   return pkg_id;
1036 }
1037
1038 void ApplicationManager::GetAppCerts(const std::string& app_id, picojson::object* out) {
1039   ScopeLogger();
1040
1041   char* package_id = nullptr;
1042
1043   package_id = GetPackageId(app_id);
1044   // automatically release the memory
1045   std::unique_ptr<char, void (*)(void*)> package_id_ptr(package_id, &std::free);
1046
1047   if (!package_id) {
1048     LogAndReportError(PlatformResult(ErrorCode::NOT_FOUND_ERR, "Failed to get package."), out);
1049     return;
1050   }
1051
1052   package_info_h pkg_info = nullptr;
1053   int ret = package_info_create(package_id, &pkg_info);
1054
1055   std::unique_ptr<std::remove_pointer<package_info_h>::type, int (*)(package_info_h)> pkg_info_ptr(
1056       pkg_info, &package_info_destroy);  // automatically release the memory
1057
1058   if (PACKAGE_MANAGER_ERROR_NONE != ret) {
1059     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get package info."), out,
1060                       ("Failed to get package info: %d (%s)", ret, get_error_message(ret)));
1061     return;
1062   }
1063
1064   auto cert_info_cb = [](package_info_h handle, package_cert_type_e cert_type,
1065                          const char* cert_value, void* user_data) -> bool {
1066     const char* cert_name = nullptr;
1067
1068     switch (cert_type) {
1069       case PACKAGE_INFO_AUTHOR_ROOT_CERT:
1070         cert_name = "AUTHOR_ROOT";
1071         break;
1072       case PACKAGE_INFO_AUTHOR_INTERMEDIATE_CERT:
1073         cert_name = "AUTHOR_INTERMEDIATE";
1074         break;
1075       case PACKAGE_INFO_AUTHOR_SIGNER_CERT:
1076         cert_name = "AUTHOR_SIGNER";
1077         break;
1078       case PACKAGE_INFO_DISTRIBUTOR_ROOT_CERT:
1079         cert_name = "DISTRIBUTOR_ROOT";
1080         break;
1081       case PACKAGE_INFO_DISTRIBUTOR_INTERMEDIATE_CERT:
1082         cert_name = "DISTRIBUTOR_INTERMEDIATE";
1083         break;
1084       case PACKAGE_INFO_DISTRIBUTOR_SIGNER_CERT:
1085         cert_name = "DISTRIBUTOR_SIGNER";
1086         break;
1087       case PACKAGE_INFO_DISTRIBUTOR2_ROOT_CERT:
1088         cert_name = "DISTRIBUTOR2_ROOT";
1089         break;
1090       case PACKAGE_INFO_DISTRIBUTOR2_INTERMEDIATE_CERT:
1091         cert_name = "DISTRIBUTOR2_INTERMEDIATE";
1092         break;
1093       case PACKAGE_INFO_DISTRIBUTOR2_SIGNER_CERT:
1094         cert_name = "DISTRIBUTOR2_SIGNER";
1095         break;
1096       default:
1097         LoggerD("Unknown certificate type: %d", cert_type);
1098         break;
1099     }
1100
1101     picojson::array* array = static_cast<picojson::array*>(user_data);
1102     array->push_back(picojson::value(picojson::object()));
1103
1104     utils::CreateApplicationCertificate(cert_name, cert_value,
1105                                         &array->back().get<picojson::object>());
1106
1107     return true;
1108   };
1109
1110   picojson::value result = picojson::value(picojson::array());
1111
1112   ret = package_info_foreach_cert_info(pkg_info, cert_info_cb, &result.get<picojson::array>());
1113
1114   if ((PACKAGE_MANAGER_ERROR_NONE != ret) && (PACKAGE_MANAGER_ERROR_IO_ERROR != ret)) {
1115     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get certificates info."),
1116                       out,
1117                       ("Failed to get certificates info: %d (%s)", ret, get_error_message(ret)));
1118     return;
1119   }
1120
1121   ReportSuccess(result, *out);
1122 }
1123
1124 void ApplicationManager::GetAppSharedUri(const std::string& app_id, picojson::object* out) {
1125   ScopeLogger();
1126   // this implementation assumes that shared/trusted path is the obligatory member of application
1127   // and it is used to extract the parent directory 'shared'
1128   char* path = nullptr;
1129   int ret = app_manager_get_shared_trusted_path(app_id.c_str(), &path);
1130   if (APP_MANAGER_ERROR_NONE != ret) {
1131     // if the application does not exist, there is no need to check "res" directory
1132     if (APP_MANAGER_ERROR_NO_SUCH_APP == ret) {
1133       LogAndReportError(PlatformResult(ErrorCode::NOT_FOUND_ERR, "Failed to get shared URI."), out);
1134       return;
1135     }
1136
1137     // if the shared_trusted directory is not properly returned, gathering the shared/res path,
1138     // which is the obligatory member. The global path could be different then:
1139     // e.g. instead of path: /opt/usr/home/owner/apps_rw/org.example.basic/shared/
1140     // returned path is:     /opt/usr/globalapps/org.example.basic/shared/
1141     LoggerW(
1142         "app_manager_get_shared_trusted_path failed(), trying "
1143         "app_manager_get_shared_resource_path() to gather path");
1144     int ret = app_manager_get_shared_resource_path(app_id.c_str(), &path);
1145     if (APP_MANAGER_ERROR_NONE != ret) {
1146       LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get shared URI."), out);
1147       return;
1148     }
1149   }
1150
1151   std::string path_str = path;
1152   free(path);
1153
1154   std::string shared_path = path_str.substr(0, path_str.rfind("/", path_str.length() - 2));
1155
1156   // checking if path is valid
1157   struct stat stat_res;
1158   if (0 != stat(shared_path.c_str(), &stat_res)) {
1159     LoggerW("Path %s does not exist", shared_path.c_str());
1160     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get shared URI."), out);
1161     return;
1162   }
1163
1164   picojson::value result = picojson::value(kTizenApisFileScheme + shared_path);
1165   ReportSuccess(result, *out);
1166 }
1167
1168 #if defined(TIZEN_MOBILE) || defined(TIZEN_WEARABLE)
1169 PlatformResult ApplicationManager::BatteryUsageFilter(const picojson::value& args,
1170                                                       const context_history_filter_h filter,
1171                                                       context_history_data_e* data_type_out) {
1172   ScopeLogger();
1173   int ret = CONTEXT_HISTORY_ERROR_NONE;
1174   int limit = kMaximumBatteryRetrievedObjects;
1175   if (args.contains("limit")) {
1176     limit = static_cast<int>(args.get("limit").get<double>());
1177   }
1178
1179   ret = context_history_filter_set_int(filter, CONTEXT_HISTORY_FILTER_RESULT_SIZE, limit);
1180
1181   if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1182     return LogAndCreateResult(
1183         ErrorCode::INVALID_VALUES_ERR, "limit given with invalid value.",
1184         ("limit given with invalid value: %d (%s)", ret, get_error_message(ret)));
1185   }
1186
1187   context_history_data_e data_type_in = CONTEXT_HISTORY_RECENT_BATTERY_USAGE;
1188
1189   if (args.contains("days")) {
1190     const int days = static_cast<int>(args.get("days").get<double>());
1191     data_type_in = CONTEXT_HISTORY_BATTERY_USAGE;
1192     ret = context_history_filter_set_int(filter, CONTEXT_HISTORY_FILTER_TIME_SPAN, days);
1193
1194     if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1195       return LogAndCreateResult(
1196           ErrorCode::INVALID_VALUES_ERR, "days given with invalid value.",
1197           ("days given with invalid value: %d (%s)", ret, get_error_message(ret)));
1198     }
1199   }
1200
1201   *data_type_out = data_type_in;
1202
1203   return PlatformResult(ErrorCode::NO_ERROR);
1204 }
1205
1206 PlatformResult ApplicationManager::BatteryUsageAttributes(const context_history_record_h record,
1207                                                           picojson::object* object) {
1208   ScopeLogger();
1209
1210   int ret = CONTEXT_HISTORY_ERROR_NONE;
1211   double amount = 0.0;
1212   char* app_id = nullptr;
1213   SCOPE_EXIT {
1214     free(app_id);
1215   };
1216
1217   ret = context_history_record_get_string(record, CONTEXT_HISTORY_APP_ID, &app_id);
1218   if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1219     return LogAndCreateResult(ErrorCode::ABORT_ERR, "Failed to get string.",
1220                               ("Failed to get string: %d (%s)", ret, get_error_message(ret)));
1221   }
1222
1223   ret = context_history_record_get_double(record, CONTEXT_HISTORY_TOTAL_AMOUNT, &amount);
1224   if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1225     return LogAndCreateResult(ErrorCode::ABORT_ERR, "Failed to get amount.",
1226                               ("Failed to get amount: %d (%s)", ret, get_error_message(ret)));
1227   }
1228
1229   object->insert(std::make_pair("appId", picojson::value(app_id)));
1230   object->insert(std::make_pair("batteryUsage", picojson::value(amount)));
1231
1232   return PlatformResult(ErrorCode::NO_ERROR);
1233 }
1234
1235 PlatformResult ApplicationManager::AppsUsageFilter(const picojson::value& args,
1236                                                    const context_history_filter_h filter,
1237                                                    context_history_data_e* data_type_out) {
1238   ScopeLogger();
1239   int ret = CONTEXT_HISTORY_ERROR_NONE;
1240   int limit = kMaximumAppsRetrievedObjects;
1241   if (args.contains("limit")) {
1242     limit = static_cast<int>(args.get("limit").get<double>());
1243   }
1244
1245   ret = context_history_filter_set_int(filter, CONTEXT_HISTORY_FILTER_RESULT_SIZE, limit);
1246   if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1247     return LogAndCreateResult(
1248         ErrorCode::INVALID_VALUES_ERR, "limit given with invalid value.",
1249         ("limit given with invalid value: %d (%s)", ret, get_error_message(ret)));
1250   }
1251
1252   context_history_data_e data_type_in = CONTEXT_HISTORY_FREQUENTLY_USED_APP;
1253   if (args.contains("mode") && kAppUsageModeRecently == args.get("mode").get<std::string>()) {
1254     data_type_in = CONTEXT_HISTORY_RECENTLY_USED_APP;
1255   }
1256
1257   int time_span = kDefaultPeriodOfTime;
1258   const picojson::object& JS_filter = args.get("filter").get<picojson::object>();
1259   auto time_span_iter = JS_filter.find("timeSpan");
1260   if (JS_filter.end() != time_span_iter || (JS_filter.end() == JS_filter.find("startTime") &&
1261                                             JS_filter.end() == JS_filter.find("endTime"))) {
1262     // In the second case, we treat the filter object just like an empty object.
1263     // The default value of filter will be used instead.
1264     if (JS_filter.end() != time_span_iter) {
1265       time_span = static_cast<int>(time_span_iter->second.get<double>());
1266     }
1267     ret = context_history_filter_set_int(filter, CONTEXT_HISTORY_FILTER_TIME_SPAN, time_span);
1268     // context_history_filter_set_int may return only success or
1269     // CONTEXT_HISTORY_ERROR_INVALID_PARAMETER
1270     // Although this should never happen, it's better to check ret's value
1271     if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1272       return LogAndCreateResult(ErrorCode::ABORT_ERR,
1273                                 "Error while setting the default TIME_SPAN value.",
1274                                 ("Error while setting the default TIME_SPAN value: %d (%s)", ret,
1275                                  get_error_message(ret)));
1276     }
1277   } else {
1278     auto start_time_iter = JS_filter.find("startTime");
1279     auto end_time_iter = JS_filter.find("endTime");
1280     if (start_time_iter != JS_filter.end()) {
1281       int start_time = static_cast<int>(start_time_iter->second.get<double>());
1282       ret = context_history_filter_set_int(filter, CONTEXT_HISTORY_FILTER_START_TIME, start_time);
1283       if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1284         return LogAndCreateResult(
1285             ErrorCode::INVALID_VALUES_ERR, "startTime given with invalid value.",
1286             ("startTime given with invalid value: %d (%s)", ret, get_error_message(ret)));
1287       }
1288     }
1289     if (end_time_iter != JS_filter.end()) {
1290       int end_time = static_cast<int>(end_time_iter->second.get<double>());
1291       ret = context_history_filter_set_int(filter, CONTEXT_HISTORY_FILTER_END_TIME, end_time);
1292       if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1293         return LogAndCreateResult(
1294             ErrorCode::INVALID_VALUES_ERR, "endTime given with invalid value.",
1295             ("endTime given with invalid value: %d (%s)", ret, get_error_message(ret)));
1296       }
1297     }
1298   }
1299
1300   *data_type_out = data_type_in;
1301
1302   return PlatformResult(ErrorCode::NO_ERROR);
1303 }
1304
1305 PlatformResult ApplicationManager::AppsUsageAttributes(const context_history_record_h record,
1306                                                        picojson::object* object) {
1307   ScopeLogger();
1308
1309   int ret = CONTEXT_HISTORY_ERROR_NONE;
1310   int total_count = 0;
1311   int total_duration = 0;
1312   int last_time = 0;
1313   char* app_id = nullptr;
1314   SCOPE_EXIT {
1315     free(app_id);
1316   };
1317
1318   ret = context_history_record_get_string(record, CONTEXT_HISTORY_APP_ID, &app_id);
1319   if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1320     return LogAndCreateResult(ErrorCode::ABORT_ERR, "Failed to get string.",
1321                               ("Failed to get string: %d (%s)", ret, get_error_message(ret)));
1322   }
1323
1324   ret = context_history_record_get_int(record, CONTEXT_HISTORY_TOTAL_COUNT, &total_count);
1325   if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1326     return LogAndCreateResult(ErrorCode::ABORT_ERR, "Failed to get total count.",
1327                               ("Failed to get total count: %d (%s)", ret, get_error_message(ret)));
1328   }
1329
1330   ret = context_history_record_get_int(record, CONTEXT_HISTORY_TOTAL_DURATION, &total_duration);
1331   if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1332     return LogAndCreateResult(
1333         ErrorCode::ABORT_ERR, "Failed to get total duration.",
1334         ("Failed to get total duration: %d (%s)", ret, get_error_message(ret)));
1335   }
1336
1337   ret = context_history_record_get_int(record, CONTEXT_HISTORY_LAST_TIME, &last_time);
1338   if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1339     return LogAndCreateResult(ErrorCode::ABORT_ERR, "Failed to get last time.",
1340                               ("Failed to get last time: %d (%s)", ret, get_error_message(ret)));
1341   }
1342
1343   object->insert(std::make_pair("appId", picojson::value(app_id)));
1344   object->insert(std::make_pair("totalCount", picojson::value(static_cast<double>(total_count))));
1345   object->insert(
1346       std::make_pair("totalDuration", picojson::value(static_cast<double>(total_duration))));
1347   object->insert(std::make_pair("lastTime", picojson::value(static_cast<double>(last_time))));
1348
1349   return PlatformResult(ErrorCode::NO_ERROR);
1350 }
1351 #endif
1352
1353 void ApplicationManager::GetBatteryUsageInfo(const picojson::value& args, picojson::object* out) {
1354   ScopeLogger();
1355
1356 #if defined(TIZEN_MOBILE) || defined(TIZEN_WEARABLE)
1357   int callback_id = -1;
1358   const auto& callback = args.get(kCallbackId);
1359   if (callback.is<double>()) {
1360     callback_id = static_cast<int>(callback.get<double>());
1361   }
1362
1363   auto get_battery_usage = [args](const std::shared_ptr<picojson::value>& response) -> void {
1364     ScopeLogger();
1365     PlatformResult result = ApplicationManager::GetContextHistory(
1366         args, &response.get()->get<picojson::object>(), &ApplicationManager::BatteryUsageFilter,
1367         &ApplicationManager::BatteryUsageAttributes);
1368     if (!result) {
1369       LogAndReportError(result, &response.get()->get<picojson::object>());
1370     }
1371   };
1372
1373   auto get_battery_usage_response =
1374       [this, callback_id](const std::shared_ptr<picojson::value>& response) -> void {
1375     ScopeLogger();
1376     picojson::object& obj = response->get<picojson::object>();
1377     obj.insert(std::make_pair(kCallbackId, picojson::value(static_cast<double>(callback_id))));
1378     Instance::PostMessage(&this->instance_, response->serialize().c_str());
1379   };
1380
1381   auto data = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
1382
1383   TaskQueue::GetInstance().Queue<picojson::value>(get_battery_usage, get_battery_usage_response,
1384                                                   data);
1385 #else
1386   LogAndReportError(PlatformResult(ErrorCode::NOT_SUPPORTED_ERR,
1387                                    "This feature is not supported on this profile."),
1388                     out, ("NOT_SUPPORTED_ERR: This feature is not supported on this profile"));
1389 #endif
1390 }
1391
1392 void ApplicationManager::GetAppsUsageInfo(const picojson::value& args, picojson::object* out) {
1393   ScopeLogger();
1394
1395 #if defined(TIZEN_MOBILE) || defined(TIZEN_WEARABLE)
1396   int callback_id = static_cast<int>(args.get(kCallbackId).get<double>());
1397
1398   auto get_apps_usage = [args](const std::shared_ptr<picojson::value>& response) -> void {
1399     ScopeLogger();
1400     PlatformResult result = ApplicationManager::GetContextHistory(
1401         args, &response.get()->get<picojson::object>(), &ApplicationManager::AppsUsageFilter,
1402         &ApplicationManager::AppsUsageAttributes);
1403     if (!result) {
1404       LogAndReportError(result, &response.get()->get<picojson::object>());
1405     }
1406   };
1407
1408   auto get_apps_usage_response =
1409       [this, callback_id](const std::shared_ptr<picojson::value>& response) -> void {
1410     ScopeLogger();
1411     picojson::object& obj = response->get<picojson::object>();
1412     obj.insert(std::make_pair(kCallbackId, picojson::value(static_cast<double>(callback_id))));
1413     Instance::PostMessage(&this->instance_, response->serialize().c_str());
1414   };
1415
1416   auto data = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
1417
1418   TaskQueue::GetInstance().Queue<picojson::value>(get_apps_usage, get_apps_usage_response, data);
1419 #else
1420   LogAndReportError(PlatformResult(ErrorCode::NOT_SUPPORTED_ERR,
1421                                    "This feature is not supported on this profile."),
1422                     out, ("NOT_SUPPORTED_ERR: This feature is not supported on this profile"));
1423 #endif
1424 }
1425
1426 void ApplicationManager::GetAppMetaData(const std::string& app_id, picojson::object* out) {
1427   ScopeLogger();
1428
1429   pkgmgrinfo_appinfo_h handle = nullptr;
1430
1431   int ret = pkgmgrinfo_appinfo_get_usr_appinfo(app_id.c_str(), getuid(), &handle);
1432   std::unique_ptr<std::remove_pointer<pkgmgrinfo_appinfo_h>::type, int (*)(pkgmgrinfo_appinfo_h)>
1433       pkg_info_ptr(handle,
1434                    &pkgmgrinfo_appinfo_destroy_appinfo);  // automatically release the memory
1435
1436   if (PMINFO_R_OK != ret) {
1437     LogAndReportError(PlatformResult(ErrorCode::NOT_FOUND_ERR, "Failed to get app info."), out,
1438                       ("Failed to get app info: %d (%s)", ret, get_error_message(ret)));
1439     return;
1440   }
1441
1442   auto meta_data_cb = [](const char* meta_key, const char* meta_value, void* user_data) -> int {
1443     if (nullptr == meta_key || nullptr == meta_value) {
1444       LoggerE("meta_key or meta_value is null");
1445       return 0;
1446     }
1447
1448     picojson::array* array = static_cast<picojson::array*>(user_data);
1449     array->push_back(picojson::value(picojson::object()));
1450
1451     utils::CreateApplicationMetaData(meta_key, meta_value, &array->back().get<picojson::object>());
1452     return 0;
1453   };
1454
1455   picojson::value result = picojson::value(picojson::array());
1456   ret = pkgmgrinfo_appinfo_foreach_metadata(handle, meta_data_cb, &result.get<picojson::array>());
1457
1458   if (PMINFO_R_OK != ret) {
1459     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get metadata."), out,
1460                       ("Failed to get metadata: %d (%s)", ret, get_error_message(ret)));
1461     return;
1462   }
1463
1464   ReportSuccess(result, *out);
1465 }
1466
1467 class ApplicationListChangedBroker {
1468  public:
1469   ApplicationListChangedBroker() : event_type_() {
1470   }
1471   enum class Event {
1472     kInstalled,
1473     kUpdated,
1474     kUninstalled,
1475   };
1476
1477   static int ClientStatusListener(unsigned int target_uid, int id, const char* type,
1478                                   const char* package, const char* key, const char* val,
1479                                   const void* msg, void* data) {
1480     ScopeLogger();
1481     ApplicationListChangedBroker* that = static_cast<ApplicationListChangedBroker*>(data);
1482
1483     if (0 == strcasecmp(key, kStartKey)) {
1484       that->HandleStart(val, package);
1485     } else if (0 == strcasecmp(key, kEndKey) && 0 == strcasecmp(val, kOkValue)) {
1486       that->HandleEnd(package);
1487     } else {
1488       LoggerD("Ignored key: %s", key);
1489     }
1490
1491     return 0;
1492   }
1493
1494   static int AppUninstallListener(uid_t target_uid, int id, const char* type, const char* package,
1495                                   const char* key, const char* val, const void* msg, void* data) {
1496     ScopeLogger();
1497
1498     ApplicationListChangedBroker* that = static_cast<ApplicationListChangedBroker*>(data);
1499
1500     if (0 == strcasecmp(key, kStartKey)) {
1501       that->HandleUninstallStart();
1502     } else if (0 == strcasecmp(key, kAppidKey)) {
1503       that->AddUninstalledAppId(val);
1504     } else if (0 == strcasecmp(key, kEndKey)) {
1505       that->HandleUninstallEnd();
1506     } else {
1507       LoggerD("Ignored key: %s", key);
1508     }
1509
1510     return 0;
1511   }
1512
1513   void AddApplicationInstance(ApplicationInstance* app_instance) {
1514     ScopeLogger();
1515     app_instance_list_.push_back(app_instance);
1516   }
1517
1518   void RemoveApplicationInstance(ApplicationInstance* app_instance) {
1519     ScopeLogger();
1520     for (auto it = app_instance_list_.begin(); it != app_instance_list_.end(); it++) {
1521       if (*it == app_instance) {
1522         app_instance_list_.erase(it);
1523         return;
1524       }
1525     }
1526   }
1527
1528  private:
1529   void HandleStart(const char* event_type, const char* package) {
1530     ScopeLogger();
1531     app_list_.clear();
1532     set_event_type(event_type);
1533   }
1534
1535   void HandleEnd(const char* package) {
1536     ScopeLogger();
1537
1538     if (Event::kUninstalled == event_type_) {
1539       return;
1540     }
1541
1542     GetApplicationIdsFromPackage(package);
1543
1544     for (auto& app_id : app_list_) {
1545       picojson::value value = picojson::value(picojson::object());
1546       picojson::object& data_obj = value.get<picojson::object>();
1547
1548       switch (event_type_) {
1549         case Event::kInstalled:
1550           data_obj.insert(std::make_pair(kAction, picojson::value(kOnInstalled)));
1551           break;
1552
1553         case Event::kUpdated:
1554           data_obj.insert(std::make_pair(kAction, picojson::value(kOnUpdated)));
1555           break;
1556         case Event::kUninstalled:
1557           LoggerD("Uninstalled called");
1558           break;
1559       }
1560
1561       switch (event_type_) {
1562         case Event::kInstalled:
1563         case Event::kUpdated: {
1564           pkgmgrinfo_appinfo_h handle = nullptr;
1565           if (PMINFO_R_OK !=
1566               pkgmgrinfo_appinfo_get_usr_appinfo(app_id.c_str(), getuid(), &handle)) {
1567             LoggerE("Failed to get application information handle.");
1568             continue;
1569           }
1570           auto info = data_obj.insert(std::make_pair(kData, picojson::value(picojson::object())));
1571           utils::CreateApplicationInformation(handle, &info.first->second.get<picojson::object>());
1572           pkgmgrinfo_appinfo_destroy_appinfo(handle);
1573         } break;
1574         case Event::kUninstalled:
1575           LoggerD("Uninstalled called");
1576           break;
1577       }
1578
1579       data_obj["listenerId"] = picojson::value("ApplicationEventListener");
1580
1581       for (auto instance : app_instance_list_) {
1582         Instance::PostMessage(instance, value.serialize().c_str());
1583       }
1584     }
1585   }
1586
1587   void GetApplicationIdsFromPackage(const char* package) {
1588     ScopeLogger();
1589     package_info_h package_info = nullptr;
1590
1591     int ret = package_info_create(package, &package_info);
1592     if (PACKAGE_MANAGER_ERROR_NONE != ret) {
1593       LoggerE("Failed to create package info: %d (%s)", ret, get_error_message(ret));
1594       return;
1595     }
1596
1597     ret = package_info_foreach_app_from_package(package_info, PACKAGE_INFO_APP_COMPONENT_TYPE_ALL,
1598                                                 ApplicationIdCallback, this);
1599     if (PACKAGE_MANAGER_ERROR_NONE != ret) {
1600       LoggerE("Failed to get application IDs: %d (%s)", ret, get_error_message(ret));
1601     }
1602
1603     ret = package_info_destroy(package_info);
1604     if (PACKAGE_MANAGER_ERROR_NONE != ret) {
1605       LoggerE("Failed to destroy package info: %d (%s)", ret, get_error_message(ret));
1606     }
1607   }
1608
1609   void set_event_type(const char* type) {
1610     ScopeLogger();
1611     if (0 == strcasecmp(type, kInstallEvent)) {
1612       event_type_ = Event::kInstalled;
1613     } else if (0 == strcasecmp(type, kUpdateEvent)) {
1614       event_type_ = Event::kUpdated;
1615     } else if (0 == strcasecmp(type, kUninstallEvent)) {
1616       event_type_ = Event::kUninstalled;
1617     }
1618   }
1619
1620   static bool ApplicationIdCallback(package_info_app_component_type_e comp_type, const char* app_id,
1621                                     void* user_data) {
1622     ScopeLogger();
1623     if (nullptr != app_id) {
1624       static_cast<ApplicationListChangedBroker*>(user_data)->app_list_.push_back(app_id);
1625     }
1626     return true;
1627   }
1628
1629   void HandleUninstallStart() {
1630     ScopeLogger();
1631     app_list_.clear();
1632     set_event_type(kUninstallEvent);
1633   }
1634
1635   void AddUninstalledAppId(const char* app_id) {
1636     ScopeLogger();
1637     if (nullptr != app_id) {
1638       app_list_.push_back(app_id);
1639     }
1640   }
1641
1642   void HandleUninstallEnd() {
1643     ScopeLogger();
1644     for (auto& app_id : app_list_) {
1645       picojson::value value = picojson::value(picojson::object());
1646       picojson::object& data_obj = value.get<picojson::object>();
1647
1648       data_obj.insert(std::make_pair(kAction, picojson::value(kOnUninstalled)));
1649       data_obj.insert(std::make_pair(kData, picojson::value(app_id)));
1650
1651       data_obj["listenerId"] = picojson::value("ApplicationEventListener");
1652
1653       for (auto instance : app_instance_list_) {
1654         Instance::PostMessage(instance, value.serialize().c_str());
1655       }
1656     }
1657   }
1658
1659   Event event_type_;
1660   std::vector<std::string> app_list_;
1661   std::vector<ApplicationInstance*> app_instance_list_;
1662 };
1663
1664 static ApplicationListChangedBroker g_application_list_changed_broker;
1665
1666 void ApplicationManager::StartAppInfoEventListener(picojson::object* out) {
1667   ScopeLogger();
1668
1669   if (nullptr == pkgmgr_client_handle_ || nullptr == pkgmgr_client_uninstall_handle_) {
1670     if (nullptr == pkgmgr_client_handle_) {
1671       pkgmgr_client_handle_ = pkgmgr_client_new(PC_LISTENING);
1672     }
1673     if (nullptr == pkgmgr_client_uninstall_handle_) {
1674       pkgmgr_client_uninstall_handle_ = pkgmgr_client_new(PC_LISTENING);
1675     }
1676
1677     if (nullptr == pkgmgr_client_handle_ || nullptr == pkgmgr_client_uninstall_handle_) {
1678       if (nullptr != pkgmgr_client_handle_) {
1679         pkgmgr_client_free(pkgmgr_client_handle_);
1680         pkgmgr_client_handle_ = nullptr;
1681       }
1682       if (nullptr != pkgmgr_client_uninstall_handle_) {
1683         pkgmgr_client_free(pkgmgr_client_uninstall_handle_);
1684         pkgmgr_client_uninstall_handle_ = nullptr;
1685       }
1686       LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to register listener."),
1687                         out);
1688       return;
1689     }
1690
1691 #define CHECK_APPLICATION_EVENT_ERROR(result, function_name)                                \
1692   if (PKGMGR_R_OK > result) {                                                               \
1693     StopAppInfoEventListener();                                                             \
1694     LogAndReportError(                                                                      \
1695         PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to register listener."), out,        \
1696         ("Function %s failed: %s (%d)", function_name, get_error_message(result), result)); \
1697     return;                                                                                 \
1698   }
1699
1700     g_application_list_changed_broker.AddApplicationInstance(&instance_);
1701
1702     int result = pkgmgr_client_set_status_type(
1703         pkgmgr_client_handle_,
1704         PACKAGE_MANAGER_STATUS_TYPE_INSTALL | PACKAGE_MANAGER_STATUS_TYPE_UPGRADE);
1705     CHECK_APPLICATION_EVENT_ERROR(result, "pkgmgr_client_set_status_type")
1706
1707     result = pkgmgr_client_set_status_type(pkgmgr_client_uninstall_handle_,
1708                                            PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL);
1709     CHECK_APPLICATION_EVENT_ERROR(result, "pkgmgr_client_set_status_type")
1710
1711     result = pkgmgr_client_listen_status(pkgmgr_client_handle_,
1712                                          ApplicationListChangedBroker::ClientStatusListener,
1713                                          &g_application_list_changed_broker);
1714     CHECK_APPLICATION_EVENT_ERROR(result, "pkgmgr_client_listen_status")
1715
1716     result = pkgmgr_client_listen_status(pkgmgr_client_uninstall_handle_,
1717                                          ApplicationListChangedBroker::AppUninstallListener,
1718                                          &g_application_list_changed_broker);
1719     CHECK_APPLICATION_EVENT_ERROR(result, "pkgmgr_client_listen_status")
1720
1721 #undef CHECK_APPLICATION_EVENT_ERROR
1722   } else {
1723     LoggerD("Broker callback is already registered.");
1724   }
1725
1726   ReportSuccess(*out);
1727 }
1728
1729 void ApplicationManager::StopAppInfoEventListener() {
1730   ScopeLogger();
1731
1732   if (nullptr != pkgmgr_client_handle_ || nullptr != pkgmgr_client_uninstall_handle_) {
1733     if (nullptr != pkgmgr_client_handle_) {
1734       pkgmgr_client_free(pkgmgr_client_handle_);
1735       pkgmgr_client_handle_ = nullptr;
1736     }
1737     if (nullptr != pkgmgr_client_uninstall_handle_) {
1738       pkgmgr_client_free(pkgmgr_client_uninstall_handle_);
1739       pkgmgr_client_uninstall_handle_ = nullptr;
1740     }
1741     g_application_list_changed_broker.RemoveApplicationInstance(&instance_);
1742   } else {
1743     LoggerD("Broker callback is already unregistered.");
1744   }
1745 }
1746
1747 void ApplicationManager::GetApplicationInformationSize(const picojson::value& args,
1748                                                        picojson::object* out) {
1749   ScopeLogger();
1750
1751   const auto& package_id = args.get("packageId");
1752   if (!package_id.is<std::string>()) {
1753     LogAndReportError(PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed."),
1754                       out);
1755     return;
1756   }
1757
1758   const std::string& package_id_str = package_id.get<std::string>();
1759
1760   // get installed size from package server (to solve smack issue)
1761   pkgmgr_client* pc = pkgmgr_client_new(PC_REQUEST);
1762   int size = -1;
1763
1764   if (nullptr == pc) {
1765     LoggerE("Failed to create pkgmgr client");
1766   } else {
1767     size = pkgmgr_client_request_service(PM_REQUEST_GET_SIZE, PM_GET_TOTAL_SIZE, pc, NULL,
1768                                          package_id_str.c_str(), NULL, NULL, NULL);
1769
1770     if (size < 0) {
1771       LoggerE("Failed to get installed size: %d (%s)", size, get_error_message(size));
1772     }
1773
1774     pkgmgr_client_free(pc);
1775   }
1776
1777   picojson::value result = picojson::value(picojson::object());
1778   picojson::object& result_obj = result.get<picojson::object>();
1779   result_obj.insert(std::make_pair("size", picojson::value(static_cast<double>(size))));
1780
1781   ReportSuccess(result, *out);
1782 }
1783
1784 void ApplicationManager::BroadcastEventHelper(const picojson::value& args, picojson::object& out,
1785                                               bool trusted) {
1786   ScopeLogger();
1787
1788   int ret;
1789   std::string event_str = args.get("name").get<std::string>();
1790   const char* event_name = event_str.c_str();
1791
1792   bundle* data = bundle_create();
1793   SCOPE_EXIT {
1794     bundle_free(data);
1795   };
1796
1797   ret = bundle_add(data, "data", args.get("data").serialize().c_str());
1798
1799   if (ret != EVENT_ERROR_NONE) {
1800     LoggerE("bundle_add failed, error: %d (%s)", ret, get_error_message(ret));
1801     ReportError(out);
1802     return;
1803   }
1804
1805   if (trusted) {
1806     ret = event_publish_trusted_app_event(event_name, data);
1807   } else {
1808     ret = event_publish_app_event(event_name, data);
1809   }
1810
1811   if (ret == EVENT_ERROR_NONE) {
1812     ReportSuccess(out);
1813   } else {
1814     LoggerE("event_publish_app_event failed, error: %d (%s)", ret, get_error_message(ret));
1815     ReportError(out);
1816   }
1817 }
1818
1819 void ApplicationManager::OnEvent(const char* event_name, bundle* event_data, void* user_data) {
1820   ScopeLogger("Event name is: '%s'", event_name);
1821
1822   ApplicationManager* manager = static_cast<ApplicationManager*>(user_data);
1823
1824   if (!manager->event_callback_) {
1825     LoggerD("No event listener registered, skipping.");
1826     return;
1827   }
1828
1829   picojson::value event = picojson::value(picojson::object());
1830   picojson::object& event_o = event.get<picojson::object>();
1831
1832   int ret;
1833   char* val = nullptr;
1834
1835   if (event_map_.count(event_name)) {  // system event
1836     const std::string& key = event_map_.at(event_name);
1837     std::string state = "true";
1838     if (key != "") {
1839       ret = bundle_get_str(event_data, key.c_str(), &val);
1840       if (EVENT_ERROR_NONE != ret) {
1841         LoggerE("failed to read bundle data, error: %d (%s)", ret, get_error_message(ret));
1842         return;
1843       }
1844
1845       state = std::string(val);
1846     }
1847
1848     LoggerD("State is %s", state.c_str());
1849     event_o["value"] = picojson::value(state);
1850
1851   } else {  // user event
1852     ret = bundle_get_str(event_data, "data", &val);
1853     if (EVENT_ERROR_NONE != ret) {
1854       LoggerE("failed to read bundle data, error: %d (%s)", ret, get_error_message(ret));
1855       return;
1856     }
1857
1858     picojson::value data;
1859     std::string err;
1860     picojson::parse(data, val, val + strlen(val), &err);
1861     if (!err.empty()) {
1862       LoggerE("Failed to parse bundle data: %s", err.c_str());
1863       return;
1864     }
1865
1866     event_o["data"] = data;
1867   }
1868
1869   LoggerD("event_name is: %s", event_name);
1870   event_o["name"] = picojson::value(event_name);
1871
1872   manager->event_callback_(&event);
1873 }
1874
1875 PlatformResult ApplicationManager::StartEventListener(const std::string& event_name,
1876                                                       const JsonCallback& callback) {
1877   ScopeLogger();
1878
1879   int ret;
1880   event_handler_h event_handler;
1881
1882   ret = event_add_event_handler(event_name.c_str(), OnEvent, this, &event_handler);
1883   LoggerD("event_add_event_handler() result: %d (%s)", ret, get_error_message(ret));
1884   if (EVENT_ERROR_PERMISSION_DENIED == ret) {
1885     return LogAndCreateResult(ErrorCode::SECURITY_ERR, "The privilege is required",
1886                               ("event_add_event_handler failed, error: %d", ret));
1887   } else if (EVENT_ERROR_NONE != ret) {
1888     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error setting event listener",
1889                               ("event_add_event_handler failed, error: %d", ret));
1890   }
1891
1892   event_handler_map_[event_name] = event_handler;
1893
1894   event_callback_ = callback;
1895   LoggerD("event_add_event_handler success");
1896   return PlatformResult(ErrorCode::NO_ERROR);
1897 }
1898
1899 void ApplicationManager::StopEventListener(const std::string& event_name) {
1900   ScopeLogger();
1901
1902   int ret;
1903   event_handler_h event_handler;
1904
1905   if (event_handler_map_.find(event_name) != event_handler_map_.end()) {
1906     event_handler = event_handler_map_[event_name];
1907
1908     ret = event_remove_event_handler(event_handler);
1909     if (EVENT_ERROR_NONE != ret) {
1910       LoggerE("event_remove_event_handler failed, error: %d (%s)", ret, get_error_message(ret));
1911       return;
1912     }
1913
1914     event_handler_map_.erase(event_name);
1915   }
1916 }
1917
1918 void ApplicationManager::OnStatusEvent(const char* type, const char* app_id,
1919                                        app_manager_event_type_e event_type,
1920                                        app_manager_event_state_e event_state,
1921                                        app_manager_event_h handle, void* user_data) {
1922   ScopeLogger();
1923
1924   if (APP_MANAGER_EVENT_STATE_COMPLETED != event_state) {
1925     LoggerD("State different from completed");
1926     return;
1927   }
1928
1929   ApplicationManager* manager = static_cast<ApplicationManager*>(user_data);
1930
1931   if (!manager || !manager->status_callback_) {
1932     LoggerD("No event listener registered, skipping.");
1933     return;
1934   }
1935
1936   bool status_type;
1937   switch (event_type) {
1938     case APP_MANAGER_EVENT_ENABLE_APP:
1939       status_type = true;
1940       break;
1941     case APP_MANAGER_EVENT_DISABLE_APP:
1942       status_type = false;
1943       break;
1944     default:
1945       LoggerD("Uknown status type skipping.");
1946       return;
1947   }
1948
1949   picojson::value event = picojson::value(picojson::object());
1950   picojson::object& event_o = event.get<picojson::object>();
1951
1952   event_o[kStatusType] = picojson::value(status_type);
1953   event_o[kAppId] = picojson::value(app_id);
1954   event_o[kListenerId] = picojson::value(kAppStatusChangeListener);
1955
1956   manager->status_callback_(&event);
1957 }
1958
1959 #if defined(TIZEN_MOBILE) || defined(TIZEN_WEARABLE)
1960 PlatformResult ApplicationManager::GetContextHistory(
1961     const picojson::value& args, picojson::object* out,
1962     common::PlatformResult (*modify_filter_cb)(const picojson::value&,
1963                                                const context_history_filter_h,
1964                                                context_history_data_e* data_type),
1965     common::PlatformResult (*add_attributes_to_object)(const context_history_record_h,
1966                                                        picojson::object*)) {
1967   ScopeLogger();
1968   context_history_list_h list = nullptr;
1969   context_history_h handle = nullptr;
1970   context_history_filter_h filter = nullptr;
1971
1972   SCOPE_EXIT {
1973     context_history_list_destroy(list);
1974     context_history_destroy(handle);
1975     context_history_filter_destroy(filter);
1976   };
1977
1978   int ret = context_history_create(&handle);
1979   if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1980     return LogAndCreateResult(
1981         ErrorCode::ABORT_ERR, "Failed to create context handle.",
1982         ("Failed to create context handle: %d (%s)", ret, get_error_message(ret)));
1983   }
1984
1985   ret = context_history_filter_create(&filter);
1986   if (CONTEXT_HISTORY_ERROR_NONE != ret) {
1987     return LogAndCreateResult(
1988         ErrorCode::ABORT_ERR, "Failed to create filter handle.",
1989         ("Failed to create filter handle: %d (%s)", ret, get_error_message(ret)));
1990   }
1991
1992   context_history_data_e data_type;
1993
1994   PlatformResult result = modify_filter_cb(args, filter, &data_type);
1995   if (!result) {
1996     return result;
1997   }
1998
1999   picojson::value result_array = picojson::value(picojson::array());
2000   picojson::array& array_obj = result_array.get<picojson::array>();
2001
2002   ret = context_history_get_list(handle, data_type, filter, &list);
2003   if (CONTEXT_HISTORY_ERROR_NO_DATA == ret) {
2004     ReportSuccess(result_array, *out);
2005     return PlatformResult(ErrorCode::NO_ERROR);
2006   } else if (CONTEXT_HISTORY_ERROR_NONE != ret) {
2007     return LogAndCreateResult(ErrorCode::ABORT_ERR, "Failed to get list.",
2008                               ("Failed to get list: %d (%s)", ret, get_error_message(ret)));
2009   }
2010
2011   int size = 0;
2012   ret = context_history_list_get_count(list, &size);
2013   if (CONTEXT_HISTORY_ERROR_NONE != ret) {
2014     return LogAndCreateResult(ErrorCode::ABORT_ERR, "Failed to get list size.",
2015                               ("Failed to get list size: %d (%s)", ret, get_error_message(ret)));
2016   }
2017
2018   array_obj.resize(size, picojson::value(picojson::object()));
2019
2020   for (int i = 0; i < size; ++i) {
2021     context_history_record_h record = nullptr;
2022     SCOPE_EXIT {
2023       context_history_record_destroy(record);
2024     };
2025
2026     ret = context_history_list_get_current(list, &record);
2027     if (CONTEXT_HISTORY_ERROR_NONE != ret) {
2028       return LogAndCreateResult(
2029           ErrorCode::ABORT_ERR, "Failed to get current record.",
2030           ("Failed to get current record: %d (%s)", ret, get_error_message(ret)));
2031     }
2032
2033     result = add_attributes_to_object(record, &array_obj[i].get<picojson::object>());
2034     if (!result) {
2035       return result;
2036     }
2037
2038     ret = context_history_list_move_next(list);
2039     if (CONTEXT_HISTORY_ERROR_NONE != ret && CONTEXT_HISTORY_ERROR_NO_DATA != ret) {
2040       return LogAndCreateResult(ErrorCode::ABORT_ERR, "Failed to move iterator.",
2041                                 ("Failed to move iterator: %d (%s)", ret, get_error_message(ret)));
2042     }
2043   }
2044
2045   ReportSuccess(result_array, *out);
2046   return PlatformResult(ErrorCode::NO_ERROR);
2047 }
2048 #endif
2049
2050 PlatformResult ApplicationManager::StartStatusListener(const JsonCallback& callback) {
2051   ScopeLogger();
2052
2053   int ret = APP_MANAGER_ERROR_NONE;
2054
2055   if (!app_status_handle_) {
2056     ret = app_manager_event_create(&app_status_handle_);
2057     if (APP_MANAGER_ERROR_NONE != ret) {
2058       return LogAndCreateResult(ErrorCode::ABORT_ERR, "Error while creating event handle",
2059                                 ("app_manager_event_create failed, error: %d", ret));
2060     }
2061
2062     ret = app_manager_event_set_status(app_status_handle_, APP_MANAGER_EVENT_STATUS_TYPE_ALL);
2063     if (APP_MANAGER_ERROR_NONE != ret) {
2064       return LogAndCreateResult(ErrorCode::ABORT_ERR, "Error while setting status type",
2065                                 ("app_manager_event_set_status failed, error: %d", ret));
2066     }
2067   }
2068
2069   status_callback_ = callback;
2070   ret = app_manager_set_event_cb(app_status_handle_, OnStatusEvent, this);
2071   if (APP_MANAGER_ERROR_NONE != ret) {
2072     return LogAndCreateResult(ErrorCode::ABORT_ERR, "Error while setting status listener",
2073                               ("app_manager_set_event_cb failed, error: %d", ret));
2074   }
2075
2076   return PlatformResult(ErrorCode::NO_ERROR);
2077 }
2078
2079 PlatformResult ApplicationManager::StopStatusChangeListener() {
2080   ScopeLogger();
2081
2082   if (app_status_handle_) {
2083     int ret = app_manager_unset_event_cb(app_status_handle_);
2084     if (APP_MANAGER_ERROR_NONE != ret) {
2085       return LogAndCreateResult(ErrorCode::ABORT_ERR, "Error while removing status listener",
2086                                 ("app_manager_unset_event_cb failed, error: %d", ret));
2087     }
2088   }
2089
2090   return PlatformResult(ErrorCode::NO_ERROR);
2091 }
2092
2093 }  // namespace application
2094 }  // namespace extension