src/app/package/FAppPkg_PackageManagerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file        FAppPkg_PackageManagerImpl.cpp
  19  * @brief       This is the implementation for the _PackageManagerImpl class.
  20  */
  21 #include <cstdio>
  22 #include <cstdlib>
  23 #include <new>
  24 #include <memory>
  25 #include <unistd.h>
  26 #include <dlog.h>
  27 #include <unique_ptr.h>
  28
  29 #include <package-manager-types.h>
  30
  31 #include <FAppPkgPackageManager.h>
  32 #include <FAppPkgPackageAppInfo.h>
  33 #include <FAppPkgPackageInfo.h>
  34 #include <FAppPkgIPackageInstallationEventListener.h>
  35 #include <FAppPkgIPackageInstallationResponseListener.h>
  36 #include <FAppPkgIPackageUninstallationResponseListener.h>
  37 #include <FBaseSysLog.h>
  38 #include <FIo.h>
  39 #include <FIoRegistry.h>
  40 #include <FSysSystemTime.h>
  41 #include <FBase_StringConverter.h>
  42
  43 #include "FAppPkg_PackageManagerImpl.h"
  44 #include "FAppPkg_PackageInfoImpl.h"
  45 #include "FAppPkg_PackageAppInfoImpl.h"
  46 #include "FAppPkg_PackageParser.h"
  47 #include "FApp_AppInfo.h"
  48 #include "FApp_PackageManagerProxy.h"
  49
  50 using namespace Tizen::Base;
  51 using namespace Tizen::Base::Runtime;
  52 using namespace Tizen::Base::Collection;
  53 using namespace Tizen::Io;
  54 using namespace Tizen::System;
  55
  56 namespace Tizen { namespace App { namespace Package
  57 {
  58
  59 PackageManager* pPackageManagerInstance = null;
  60
  61 Tizen::Base::Collection::HashMap _PackageManagerImpl::__installationList;
  62
  63 void
  64 _PackageManagerEvent::FireImpl(IEventListener& listener, const IEventArg& arg)
  65 {
  66         IPackageInstallationEventListener* pListener = dynamic_cast<IPackageInstallationEventListener*> (&listener);
  67         SysTryReturnVoidResult(NID_APP, pListener != null, E_OUT_OF_MEMORY, "pListener instance must not be null.");
  68
  69         const _PackageManagerEventArg* pArg = dynamic_cast<const _PackageManagerEventArg*>(&arg);
  70         SysTryReturnVoidResult(NID_APP, pArg != null, E_OUT_OF_MEMORY, "pArg instance must not be null.");
  71
  72         if (pArg->__eventKey == L"end")
  73         {
  74                 if (pArg->__eventValue == L"ok")
  75                 {
  76                         if (pArg->__install)
  77                         {
  78                                 SysLog(NID_APP, "Installation is Completed. [PackageId = %ls]", pArg->__packageId.GetPointer());
  79                                 pListener->OnPackageInstallationCompleted(pArg->__packageId, PACKAGE_INSTALLATION_RESULT_SUCCESS);
  80                         }
  81                         else
  82                         {
  83                                 SysLog(NID_APP, "Uninstallation is Completed. [PackageId = %ls]", pArg->__packageId.GetPointer());
  84                                 pListener->OnPackageUninstallationCompleted(pArg->__packageId, true);
  85                         }
  86                 }
  87                 else
  88                 {
  89                         if (pArg->__install)
  90                         {
  91                                 SysLog(NID_APP, "Installation is Completed(Error). [PackageId = %ls]", pArg->__packageId.GetPointer());
  92                                 pListener->OnPackageInstallationCompleted(pArg->__packageId, PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE);
  93                         }
  94                         else
  95                         {
  96                                 SysLog(NID_APP, "Uninstallation is Completed(Error). [PackageId = %ls]", pArg->__packageId.GetPointer());
  97                                 pListener->OnPackageUninstallationCompleted(pArg->__packageId, false);
  98                         }
  99                 }
 100         }
 101         else if (pArg->__eventKey == L"install_percent")
 102         {
 103                 std::unique_ptr<char[]> pProgress(_StringConverter::CopyToCharArrayN(pArg->__eventValue));
 104
 105                 int progress = 0;
 106                 sscanf(pProgress.get(), "%d", &progress);
 107
 108                 SysLog(NID_APP, "InstallationInProgress [%d]", progress);
 109                 pListener->OnPackageInstallationInProgress(pArg->__packageId, progress);
 110         }
 111 }
 112
 113 PackageId
 114 _PackageManagerImpl::GetPackageIdByAppId(const AppId& appId)
 115 {
 116         SysTryReturn(NID_APP, appId.IsEmpty() == false, L"", E_INVALID_ARG, "appId is empty");
 117
 118         String packageId;
 119
 120         if (appId.StartsWith(L".", 10) == true)
 121         {
 122                 appId.SubString(0, 10, packageId);
 123         }
 124         else
 125         {
 126                 int result = 0;
 127                 char* pPackageId = null;
 128                 pkgmgrinfo_appinfo_h pAppInfoHandle = null;
 129
 130                 std::unique_ptr<char[]> pAppId(_StringConverter::CopyToCharArrayN(appId));
 131                 SysTryReturn(NID_APP, pAppId, L"", E_OUT_OF_MEMORY, "pAppId is null");
 132
 133                 result = pkgmgrinfo_appinfo_get_appinfo(pAppId.get(), &pAppInfoHandle);
 134                 SysTryReturn(NID_APP, result == 0, L"", E_PKG_NOT_INSTALLED, "pkgmgrinfo_appinfo_get_appinfo() failed. result=[%d], appId=[%s]", result, pAppId.get());
 135
 136                 result = pkgmgrinfo_appinfo_get_pkgname(pAppInfoHandle, &pPackageId);
 137
 138                 packageId.Append(pPackageId);
 139
 140                 if(pAppInfoHandle)
 141                 {
 142                         pkgmgrinfo_appinfo_destroy_appinfo(pAppInfoHandle);
 143                 }
 144         }
 145
 146         SysLog(NID_APP, "appId = [%ls], packageId = [%ls]", appId.GetPointer(), packageId.GetPointer());
 147
 148         return packageId;
 149 }
 150
 151 result
 152 _PackageManagerImpl::AddEventListener(IPackageInstallationEventListener* pListener, int priority)
 153 {
 154         SysTryReturnResult(NID_APP, (priority < 3) && (priority >= 0), E_INVALID_ARG, "priority is invalid.");
 155
 156         result r = E_SUCCESS;
 157         int res = 0;
 158
 159         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
 160         SysTryReturnResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
 161
 162         while (pEnum->MoveNext() == E_SUCCESS)
 163         {
 164                 _PackageManagerEvent*   pEvent = null;
 165                 pEnum->GetCurrent(pEvent);
 166                 if (pEvent)
 167                 {
 168                         if (pEvent->__pListener == pListener)
 169                         {
 170                                 SysLog(NID_APP, "The event listener already exist. listener = [0x%x]", pListener);
 171                                 return E_OBJ_ALREADY_EXIST;
 172                         }
 173                 }
 174         }
 175
 176         if (__pListeningClient == null)
 177         {
 178                 __pListeningClient = pkgmgr_client_new(PC_LISTENING);
 179                 SysTryReturnResult(NID_APP, __pListeningClient != null, E_SYSTEM, "pkgmgr_client_new(PC_LISTENING) failed");
 180
 181                 res = pkgmgr_client_listen_status(__pListeningClient, PackageEventHandler, this);
 182                 if (res < PKGMGR_R_OK)
 183                 {
 184                         pkgmgr_client_free(__pListeningClient);
 185                         __pListeningClient = null;
 186
 187                         if (res == PKGMGR_R_EINVAL)
 188                         {
 189                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns ARGV error");
 190                                 return E_INVALID_ARG;
 191                         }
 192                         else if (res == PKGMGR_R_ECOMM)
 193                         {
 194                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns COMM error");
 195                         }
 196                         else if (res == PKGMGR_R_ETIMEOUT)
 197                         {
 198                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns TIME_OUT error");
 199                         }
 200                         else if (res == PKGMGR_R_ERROR)
 201                         {
 202                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns Unknown error");
 203                         }
 204                         else
 205                         {
 206                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns Unknown error, res = %d", res);
 207                         }
 208
 209                         return E_SYSTEM;
 210                 }
 211         }
 212
 213         _PackageManagerEvent* pEvent = new (std::nothrow) _PackageManagerEvent();
 214         SysTryReturnResult(NID_APP, pEvent != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 215
 216         r = pEvent->Construct();
 217         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "pEvent->Construct() failed.");
 218
 219         pEvent->__pListener = pListener;
 220
 221         r = pEvent->AddListener(*pListener, true);
 222         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "pEvent->AddListener() failed. [%s]", GetErrorMessage(r));
 223
 224         r = __packageEventListenerList.Add(pEvent);
 225         SysTryReturnResult(NID_APP, !IsFailed(r), r, "[%s] Propagating.", GetErrorMessage(r));
 226
 227         SysLog(NID_APP, "Add PackageInstallationEventListener = [0x%x]", pListener);
 228         return E_SUCCESS;
 229 }
 230
 231 result
 232 _PackageManagerImpl::RemoveEventListener(IPackageInstallationEventListener* pListener)
 233 {
 234         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
 235         SysTryReturnResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
 236
 237         result r = E_SUCCESS;
 238
 239         while (pEnum->MoveNext() == E_SUCCESS)
 240         {
 241                 _PackageManagerEvent*   pEvent = null;
 242                 pEnum->GetCurrent(pEvent);
 243                 if (pEvent)
 244                 {
 245                         if (pEvent->__pListener == pListener)
 246                         {
 247                                 r = __packageEventListenerList.Remove(pEvent);
 248                                 SysTryReturnResult(NID_APP, !IsFailed(r), r, "[%s] Propagating.", GetErrorMessage(r));
 249
 250                                 delete pEvent;
 251
 252                                 SysLog(NID_APP, "Remove PackageInstallationEventListener = [0x%x]", pListener);
 253                                 return E_SUCCESS;
 254                         }
 255                 }
 256         }
 257
 258         return E_OBJ_NOT_FOUND;
 259 }
 260
 261 PackageInfo*
 262 _PackageManagerImpl::GetPackageInfoN(const PackageId& packageId) const
 263 {
 264         SysTryReturn(NID_APP, packageId.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] packageId is empty.");
 265         SysTryReturn(NID_APP, packageId.GetLength() < NATIVE_APP_MAX_APPID_LENGTH, null, E_INVALID_ARG, "packageId is invalid.(length)");
 266
 267         result r = E_SUCCESS;
 268         PackageInfo* pPackageInfo = null;
 269
 270         pPackageInfo = new (std::nothrow) PackageInfo;
 271         SysTryReturn(NID_APP, pPackageInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
 272
 273         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
 274         r = pPackageInfoImpl->Construct(packageId);
 275         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[E_PKG_NOT_INSTALLED] packageId (%ls) is not found.", packageId.GetPointer());
 276
 277         return pPackageInfo;
 278
 279 CATCH:
 280         delete pPackageInfo;
 281         return null;
 282 }
 283
 284 PackageAppInfo*
 285 _PackageManagerImpl::GetPackageAppInfoN(const AppId& appId) const
 286 {
 287         SysTryReturn(NID_APP, appId.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] appId is empty.");
 288
 289         result r = E_SUCCESS;
 290         PackageAppInfo* pPackageAppInfo = null;
 291
 292         pPackageAppInfo = new (std::nothrow) PackageAppInfo;
 293         SysTryReturn(NID_APP, pPackageAppInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageAppInfo instance must not be null.");
 294
 295         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo);
 296         r = pPackageAppInfoImpl->Construct(appId);
 297         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[E_PKG_NOT_INSTALLED] appId (%ls) is not found.", appId.GetPointer());
 298
 299         return pPackageAppInfo;
 300
 301 CATCH:
 302         delete pPackageAppInfo;
 303         return null;
 304 }
 305
 306 IList*
 307 _PackageManagerImpl::GetPackageInfoListN(void) const
 308 {
 309         result r = E_SUCCESS;
 310         int res = 0;
 311         ArrayList* pList = null;
 312
 313         pList = new (std::nothrow) ArrayList();
 314         SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
 315         pList->Construct();
 316
 317         res = pkgmgrinfo_pkginfo_get_list(PackageInfoEventHandler, pList);
 318         if (res != 0)
 319         {
 320                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_list() is failed. result = [%d]", res);
 321
 322                 pList->RemoveAll(true);
 323                 pList = null;
 324         }
 325
 326         SetLastResult(r);
 327         return pList;
 328 }
 329
 330 bool
 331 _PackageManagerImpl::IsPackageInstalled(const PackageId& packageId) const
 332 {
 333         SysTryReturn(NID_APP, packageId.IsEmpty() == false, false, E_INVALID_ARG, "packageId is empty");
 334
 335         int result = 0;
 336         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
 337
 338         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 339         SysTryReturn(NID_APP, pPackageId, false, E_OUT_OF_MEMORY, "pPackageId is null");
 340
 341         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
 342         if (result != 0)
 343         {
 344                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", result, pPackageId.get());
 345                 return false;
 346         }
 347
 348         if(pPackageInfoHandle)
 349         {
 350                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
 351         }
 352
 353         SysLog(NID_APP, "packageId = [%ls] is installed.", packageId.GetPointer());
 354
 355         return true;
 356 }
 357
 358 result
 359 _PackageManagerImpl::InstallPackage(const PackageId& packageId, const String& packagePath, IPackageInstallationResponseListener* pListener)
 360 {
 361         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty.");
 362         SysTryReturnResult(NID_APP, packagePath.IsEmpty() == false, E_INVALID_ARG, "packagePath is empty.");
 363         SysTryReturnResult(NID_APP, File::IsFileExist(packagePath) == true, E_INVALID_ARG, "packagePath is not existed.");
 364
 365         String extension = File::GetFileExtension(packagePath);
 366         SysTryReturnResult(NID_APP, extension.IsEmpty() == false, E_INVALID_ARG, "extension is empty.");
 367
 368         std::unique_ptr<char[]> pPackagePath(_StringConverter::CopyToCharArrayN(packagePath));
 369         SysTryReturnResult(NID_APP, pPackagePath, E_OUT_OF_MEMORY, "pPackagePath is null");
 370
 371         std::unique_ptr<char[]> pExtension(_StringConverter::CopyToCharArrayN(extension));
 372         SysTryReturnResult(NID_APP, pExtension, E_OUT_OF_MEMORY, "pExtension is null");
 373
 374         if ((strcasecmp(pExtension.get(), "tpk") == 0) || (strcasecmp(pExtension.get(), "wgt") == 0))
 375         {
 376                 SysLog(NID_APP, "packageId = [%ls], packagePath = [%s], extension = [%s]", packageId.GetPointer(), pPackagePath.get(), pExtension.get());
 377         }
 378         else
 379         {
 380                 SysLog(NID_APP, "invalid extension! - packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 381                 return E_SYSTEM;
 382         }
 383
 384         result r = E_SUCCESS;
 385         _PackageManagerProxy packageManagerProxy;
 386         r = packageManagerProxy.Construct();
 387         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "packageManagerProxy.Construct() failed.");
 388
 389         r = packageManagerProxy.InstallPackage(packageId, packagePath, null);
 390         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "packageManagerProxy.InstallPackage() failed.");
 391
 392         if (__pRequestClient == null)
 393         {
 394                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 395                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 396         }
 397
 398         int res = pkgmgr_client_install(__pRequestClient, pExtension.get(), null, pPackagePath.get(), null, PM_QUIET, InstallationEventHandler, pListener);
 399
 400         if (res < PKGMGR_R_OK)
 401         {
 402                 pkgmgr_client_free(__pRequestClient);
 403                 __pRequestClient = null;
 404
 405                 if (res == PKGMGR_R_EINVAL)
 406                 {
 407                         SysLog(NID_APP, "pkgmgr_client_install() returns ARGV error");
 408                         return E_INVALID_ARG;
 409                 }
 410                 else if (res == PKGMGR_R_ECOMM)
 411                 {
 412                         SysLog(NID_APP, "pkgmgr_client_install() returns COMM error");
 413                 }
 414                 else if (res == PKGMGR_R_ETIMEOUT)
 415                 {
 416                         SysLog(NID_APP, "pkgmgr_client_install() returns TIME_OUT error");
 417                 }
 418                 else if (res == PKGMGR_R_ERROR)
 419                 {
 420                         SysLog(NID_APP, "pkgmgr_client_install() returns Unknown error");
 421                 }
 422                 else
 423                 {
 424                         SysLog(NID_APP, "pkgmgr_client_install() returns Unknown error, res = %d", res);
 425                 }
 426
 427                 return E_SYSTEM;
 428         }
 429
 430         return E_SUCCESS;
 431 }
 432
 433 result
 434 _PackageManagerImpl::UninstallPackage(const PackageId& packageId, IPackageUninstallationResponseListener* pListener)
 435 {
 436         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty.");
 437         SysTryReturnResult(NID_APP, packageId.GetLength() < NATIVE_APP_MAX_APPID_LENGTH, E_INVALID_ARG, "The packageId is invalid.(length)");
 438         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 439
 440         result r = E_SUCCESS;
 441         int res = 0;
 442         char* pType = null;
 443         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
 444
 445         _PackageManagerProxy packageManagerProxy;
 446         r = packageManagerProxy.Construct();
 447         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "packageManagerProxy.Construct() failed.");
 448
 449         r = packageManagerProxy.UninstallPackage(packageId, pListener);
 450         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "packageManagerProxy.UninstallPackage() failed.");
 451
 452         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 453         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 454
 455         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
 456         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 457
 458         res = pkgmgrinfo_pkginfo_get_type(pPackageInfoHandle, &pType);
 459         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 460
 461         if (__pRequestClient == null)
 462         {
 463                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 464                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 465         }
 466
 467         res = pkgmgr_client_uninstall(__pRequestClient, pType, pPackageId.get(), PM_QUIET, UninstallationEventHandler, pListener);
 468         SysLog(NID_APP, "pkgmgr_client_uninstall - req_id=[%d], packageId=[%s], type=[%s]", res, pPackageId.get(), pType);
 469
 470         if(pPackageInfoHandle)
 471         {
 472                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
 473         }
 474
 475         if (res < PKGMGR_R_OK)
 476         {
 477                 pkgmgr_client_free(__pRequestClient);
 478                 __pRequestClient = null;
 479
 480                 if (res == PKGMGR_R_EINVAL)
 481                 {
 482                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns ARGV error");
 483                         return E_INVALID_ARG;
 484                 }
 485                 else if (res == PKGMGR_R_ECOMM)
 486                 {
 487                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns COMM error");
 488                 }
 489                 else if (res == PKGMGR_R_ETIMEOUT)
 490                 {
 491                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns TIME_OUT error");
 492                 }
 493                 else if (res == PKGMGR_R_ERROR)
 494                 {
 495                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns Unknown error");
 496                 }
 497                 else
 498                 {
 499                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns Unknown error, res = %d", res);
 500                 }
 501
 502                 return E_SYSTEM;
 503         }
 504
 505         return E_SUCCESS;
 506 }
 507
 508 result
 509 _PackageManagerImpl::MoveToExternalStorage(const PackageId& packageId)
 510 {
 511         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty");
 512         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 513
 514         int res = 0;
 515         char* pType = null;
 516         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
 517         pkgmgrinfo_pkginfo_h packageInfoHandle = null;
 518
 519         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 520         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 521
 522         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &packageInfoHandle);
 523         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 524
 525         res = pkgmgrinfo_pkginfo_get_type(packageInfoHandle, &pType);
 526         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 527
 528         res = pkgmgrinfo_pkginfo_get_installed_storage(packageInfoHandle, &storage);
 529         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_installed_storage() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 530
 531         if (storage == PMINFO_EXTERNAL_STORAGE)
 532         {
 533                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage(): storage = [%d][E_INVALID_OPERATION]", storage);
 534                 return E_INVALID_OPERATION;
 535         }
 536
 537         if (__pRequestClient == null)
 538         {
 539                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 540                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 541         }
 542
 543         res = pkgmgr_client_move(__pRequestClient, pType, pPackageId.get(), PM_MOVE_TO_SDCARD, PM_QUIET);
 544
 545         if(packageInfoHandle)
 546         {
 547                 pkgmgrinfo_pkginfo_destroy_pkginfo(packageInfoHandle);
 548         }
 549
 550         if (res < PKGMGR_R_OK)
 551         {
 552                 pkgmgr_client_free(__pRequestClient);
 553                 __pRequestClient = null;
 554
 555                 if (res == PKGMGR_R_EINVAL)
 556                 {
 557                         SysLog(NID_APP, "pkgmgr_client_move() returns ARGV error");
 558                         return E_INVALID_ARG;
 559                 }
 560                 else if (res == PKGMGR_R_ERROR)
 561                 {
 562                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error");
 563                 }
 564                 else
 565                 {
 566                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error, res = %d", res);
 567                 }
 568
 569                 return E_SYSTEM;
 570         }
 571
 572         return E_SUCCESS;
 573 }
 574
 575 result
 576 _PackageManagerImpl::MoveToInternalStorage(const PackageId& packageId)
 577 {
 578         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty");
 579         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 580
 581         int res = 0;
 582         char* pType = null;
 583         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
 584         pkgmgrinfo_pkginfo_h packageInfoHandle = null;
 585
 586         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 587         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 588
 589         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &packageInfoHandle);
 590         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 591
 592         res = pkgmgrinfo_pkginfo_get_type(packageInfoHandle, &pType);
 593         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 594
 595         res = pkgmgrinfo_pkginfo_get_installed_storage(packageInfoHandle, &storage);
 596         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_installed_storage() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 597
 598         if (storage == PMINFO_INTERNAL_STORAGE)
 599         {
 600                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage(): storage = [%d][E_INVALID_OPERATION]", storage);
 601                 return E_INVALID_OPERATION;
 602         }
 603
 604         if (__pRequestClient == null)
 605         {
 606                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 607                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 608         }
 609
 610         res = pkgmgr_client_move(__pRequestClient, pType, pPackageId.get(), PM_MOVE_TO_INTERNAL, PM_QUIET);
 611
 612         if(packageInfoHandle)
 613         {
 614                 pkgmgrinfo_pkginfo_destroy_pkginfo(packageInfoHandle);
 615         }
 616
 617         if (res < PKGMGR_R_OK)
 618         {
 619                 pkgmgr_client_free(__pRequestClient);
 620                 __pRequestClient = null;
 621
 622                 if (res == PKGMGR_R_EINVAL)
 623                 {
 624                         SysLog(NID_APP, "pkgmgr_client_move() returns ARGV error");
 625                         return E_INVALID_ARG;
 626                 }
 627                 else if (res == PKGMGR_R_ERROR)
 628                 {
 629                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error");
 630                 }
 631                 else
 632                 {
 633                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error, res = %d", res);
 634                 }
 635
 636                 return E_SYSTEM;
 637         }
 638
 639         return E_SUCCESS;
 640 }
 641
 642 int
 643 _PackageManagerImpl::InstallationEventHandler(int reqId, const char* pType, const char* pPackageId, const char* pKey, const char* pVal, const void* pMsg, void* pData)
 644 {
 645         SysLog(NID_APP, "reqId[%d], Type[%s], PackageId[%s], Key[%s], Val[%s]", reqId, pType, pPackageId, pKey, pVal);
 646
 647         if (pData)
 648         {
 649                 IPackageInstallationResponseListener* pListener = (IPackageInstallationResponseListener*) pData;
 650
 651                 if (strcmp(pKey, "end") == 0)
 652                 {
 653                         if (strcmp(pVal, "ok") == 0)
 654                         {
 655                                 pListener->OnPackageInstallationResponseReceived(pPackageId, PACKAGE_INSTALLATION_RESULT_SUCCESS);
 656                                 SysLog(NID_APP, "OnPackageInstallationResponseReceived(PACKAGE_INSTALLATION_RESULT_SUCCESS)");
 657                         }
 658                         else
 659                         {
 660                                 pListener->OnPackageInstallationResponseReceived(pPackageId, PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE);
 661                                 SysLog(NID_APP, "OnPackageInstallationResponseReceived(PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE)");
 662                         }
 663
 664                         delete pListener;
 665                 }
 666                 else if (strcmp(pKey, "install_percent") == 0)
 667                 {
 668                         int progress = 0;
 669                         sscanf(pVal, "%d", &progress);
 670
 671                         pListener->OnPackageInstallationInProgressResponseReceived(pPackageId, progress);
 672                         SysLog(NID_APP, "OnPackageInstallationInProgressResponseReceived(%s, %d)", pPackageId, progress);
 673                 }
 674         }
 675
 676         return 0;
 677 }
 678
 679 int
 680 _PackageManagerImpl::UninstallationEventHandler(int reqId, const char* pType, const char* pPackageId, const char* pKey, const char* pVal, const void* pMsg, void* pData)
 681 {
 682         SysLog(NID_APP, "reqId[%d], Type[%s], PackageId[%s], Key[%s], Val[%s]", reqId, pType, pPackageId, pKey, pVal);
 683
 684         if (pData)
 685         {
 686                 if (strcmp(pKey, "end") == 0)
 687                 {
 688                         IPackageUninstallationResponseListener* pListener = (IPackageUninstallationResponseListener*) pData;
 689
 690                         if (strcmp(pVal, "ok") == 0)
 691                         {
 692                                 SysLog(NID_APP, "OnPackageUninstallationResponseReceived(true)");
 693                                 pListener->OnPackageUninstallationResponseReceived(pPackageId, true);
 694                         }
 695                         else
 696                         {
 697                                 SysLog(NID_APP, "OnPackageUninstallationResponseReceived(false)");
 698                                 pListener->OnPackageUninstallationResponseReceived(pPackageId, false);
 699                         }
 700
 701                         delete pListener;
 702                 }
 703         }
 704
 705         return 0;
 706 }
 707
 708 PackageInfo*
 709 _PackageManagerImpl::GetPackageInfoFromFileN(const String& filePath) const
 710 {
 711         SysTryReturn(NID_APP, filePath.IsEmpty() == false, null, E_INVALID_ARG, "filePath is empty.");
 712         SysTryReturn(NID_APP, File::IsFileExist(filePath) == true, null, E_FILE_NOT_FOUND, "package is not existed.");
 713
 714         String extension = File::GetFileExtension(filePath);
 715         SysTryReturn(NID_APP, extension.IsEmpty() == false, null, E_INVALID_ARG, "extension is empty.");
 716
 717         std::unique_ptr<char[]> pPackagePath(_StringConverter::CopyToCharArrayN(filePath));
 718         SysTryReturn(NID_APP, pPackagePath, null, E_OUT_OF_MEMORY, "pPackagePath is null.");
 719
 720         std::unique_ptr<char[]> pExtension(_StringConverter::CopyToCharArrayN(extension));
 721         SysTryReturn(NID_APP, pExtension, null, E_OUT_OF_MEMORY, "pExtension is null.");
 722
 723         std::unique_ptr< PackageInfo > pPackageInfo(new (std::nothrow) PackageInfo);
 724         SysTryReturn(NID_APP, pPackageInfo, null, E_OUT_OF_MEMORY, "pPackageInfo instance must not be null.");
 725
 726         SysLog(NID_APP, "packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 727
 728         bool res = true;
 729
 730         if (strcasecmp(pExtension.get(), "tpk") == 0)
 731         {
 732                 _PackageParser packageParser;
 733
 734                 res = packageParser.Construct(pPackageInfo.get());
 735                 SysTryReturn(NID_APP, res, null, E_PARSING_FAILED, "Construct() is failed. [%s]", pPackagePath.get());
 736
 737                 res = packageParser.Parse(filePath);
 738                 SysTryReturn(NID_APP, res, null, E_PARSING_FAILED, "Parse() is failed. [%s]", pPackagePath.get());
 739         }
 740         else if (strcasecmp(pExtension.get(), "wgt") == 0)
 741         {
 742                 pkgmgr_info* pPkgmgrInfo = null;
 743
 744                 pPkgmgrInfo = pkgmgr_client_check_pkginfo_from_file(pPackagePath.get());
 745                 SysTryReturn(NID_APP, pPkgmgrInfo, null, E_PARSING_FAILED, "pkgmgr_client_check_pkginfo_from_file(%s) is failed.", pPackagePath.get());
 746
 747                 _package_manager_pkg_detail_info_t* pPkgInfo = (_package_manager_pkg_detail_info_t*) pPkgmgrInfo;
 748                 _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
 749
 750                 SysLog(NID_APP, "id(%s), version(%s), label(%s), description(%s), author(%s), icon_size(%d), pkgname(%s)", pPkgInfo->pkgid, pPkgInfo->version, pPkgInfo->label,
 751                                 pPkgInfo->pkg_description, pPkgInfo->author, pPkgInfo->icon_size, pPkgInfo->pkg_name);
 752
 753                 pPackageInfoImpl->SetType(PACKAGE_TYPE_WGT);
 754                 pPackageInfoImpl->SetId(pPkgInfo->pkgid);
 755                 pPackageInfoImpl->SetVersion(pPkgInfo->version);
 756                 pPackageInfoImpl->SetDisplayName(pPkgInfo->label);
 757                 pPackageInfoImpl->SetDescription(pPkgInfo->pkg_description);
 758                 pPackageInfoImpl->SetAuthor(pPkgInfo->author);
 759                 pPackageInfoImpl->SetMainAppId(pPkgInfo->pkg_name);
 760
 761                 if (pPkgInfo->privilege_list)
 762                 {
 763                         GList* pList = null;
 764                         pList = g_list_first(pPkgInfo->privilege_list);
 765                         while (pList)
 766                         {
 767                                 char* pPrivilege = (char*)pList->data;
 768                                 if (pPrivilege)
 769                                 {
 770                                         pPackageInfoImpl->AddPrivilege(*new (std::nothrow) String(pPrivilege));
 771                                         free(pPrivilege);
 772                                 }
 773                                 pList = g_list_next(pList);
 774                         }
 775                         g_list_free(pPkgInfo->privilege_list);
 776                 }
 777
 778                 std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
 779                 SysTryReturn(NID_APP, pPackageAppInfo, null, E_OUT_OF_MEMORY, "pPackageAppInfo instance must not be null.");
 780
 781                 _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
 782
 783                 pPackageAppInfoImpl->SetAppId(pPkgInfo->pkg_name);
 784                 pPackageAppInfoImpl->SetAppName(pPkgInfo->label);
 785                 pPackageAppInfoImpl->SetAppDisplayName(pPkgInfo->label);
 786                 pPackageAppInfoImpl->SetMainApp(true);
 787                 if ((pPkgInfo->icon_buf) && (pPkgInfo->icon_size > 0))
 788                 {
 789                         String iconPath("/tmp/icon.png");
 790                         File file;
 791                         file.Construct(iconPath, "w+");
 792                         file.Write(pPkgInfo->icon_buf, pPkgInfo->icon_size);
 793
 794                         pPackageAppInfoImpl->SetAppTempIconPath(iconPath);
 795                 }
 796
 797                 pPackageInfoImpl->AddPackageAppInfo(*pPackageAppInfo.release());
 798
 799                 pkgmgr_client_free_pkginfo(pPkgmgrInfo);
 800         }
 801         else
 802         {
 803                 SysTryReturn(NID_APP, false, null, E_UNSUPPORTED_FORMAT, "invalid extension! - packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 804         }
 805
 806         return pPackageInfo.release();
 807 }
 808
 809 IList*
 810 _PackageManagerImpl::GetPackageInfoListN(const IMap& packageFilterMap) const
 811 {
 812         SysTryReturn(NID_APP, packageFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageFilterMap.GetCount() is invalid.");
 813
 814         std::unique_ptr<IMapEnumerator> pEnum(packageFilterMap.GetMapEnumeratorN());
 815         SysTryReturn(NID_APP, pEnum, null, E_INVALID_ARG, "GetMapEnumeratorN() is failed.");
 816
 817         int res = 0;
 818         ArrayList* pList = null;
 819         pkgmgrinfo_pkginfo_filter_h handle = null;
 820
 821         res = pkgmgrinfo_pkginfo_filter_create(&handle);
 822         SysTryReturn(NID_APP, res == PMINFO_R_OK, null, E_SYSTEM, "pkgmgrinfo_pkginfo_filter_create() is failed. [%d]", res);
 823
 824         while(pEnum->MoveNext() == E_SUCCESS)
 825         {
 826                 String* pKey = static_cast< String* >(pEnum->GetKey());
 827                 SysTryCatch(NID_APP, pKey, , E_INVALID_ARG, "GetKey() is failed.");
 828
 829                 Boolean* pVal = static_cast< Boolean* >(pEnum->GetValue());
 830                 SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 831
 832                 bool value = pVal->ToBool();
 833
 834                 SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), value);
 835
 836                 if ((*pKey) == PACKAGE_FILTER_UNINSTALLABLE)
 837                 {
 838                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_REMOVABLE, value);
 839                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(REMOVABLE, %d) is failed. [%d]", value, res);
 840                 }
 841                 else if ((*pKey) == PACKAGE_FILTER_DOWNLOADED)
 842                 {
 843                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_PRELOAD, !value);
 844                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(PRELOAD, %d) is failed. [%d]", !value, res);
 845                 }
 846                 else if ((*pKey) == PACKAGE_FILTER_APP_SETTING)
 847                 {
 848                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_APPSETTING, value);
 849                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(APPSETTING, %d) is failed. [%d]", value, res);
 850                 }
 851                 else if ((*pKey) == PACKAGE_FILTER_EXTERNAL_STORAGE)
 852                 {
 853                         String installedStorage;
 854                         if (value == true)
 855                         {
 856                                 installedStorage = L"installed_external";
 857                         }
 858                         else
 859                         {
 860                                 installedStorage = L"installed_internal";
 861                         }
 862
 863                         std::unique_ptr<char[]> pInstalledStorage(_StringConverter::CopyToCharArrayN(installedStorage));
 864                         SysTryCatch(NID_APP, pInstalledStorage, , E_OUT_OF_MEMORY, "pInstalledStorage is null.");
 865
 866                         SysLog(NID_APP, "Value[%d]->[%s]", value, pInstalledStorage.get());
 867
 868                         res = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_INSTALLED_STORAGE, pInstalledStorage.get());
 869                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_string(STORAGE, %s) is failed. [%d]", pInstalledStorage.get(), res);
 870                 }
 871                 else
 872                 {
 873                         SysTryCatch(NID_APP, false, , E_INVALID_ARG, "Invalid key(%ls)", pKey->GetPointer());
 874                 }
 875         }
 876
 877         pList = new (std::nothrow) ArrayList();
 878         SysTryCatch(NID_APP, pList, , E_OUT_OF_MEMORY, "ArrayList creation failure.");
 879         pList->Construct();
 880
 881         res = pkgmgrinfo_pkginfo_filter_foreach_pkginfo(handle, PackageInfoHandler, pList);
 882         if (res != 0)
 883         {
 884                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_filter_foreach_pkginfo() is failed. result = [%d]", res);
 885
 886                 pList->RemoveAll(true);
 887                 pList = null;
 888         }
 889
 890 CATCH:
 891         if (handle)
 892         {
 893                 pkgmgrinfo_pkginfo_filter_destroy(handle);
 894         }
 895
 896         return pList;
 897 }
 898
 899 IList*
 900 _PackageManagerImpl::GetPackageAppInfoListN(const IMap& packageAppFilterMap) const
 901 {
 902         SysTryReturn(NID_APP, packageAppFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageAppFilterMap.GetCount() is invalid.");
 903
 904         std::unique_ptr<IMapEnumerator> pEnum(packageAppFilterMap.GetMapEnumeratorN());
 905         SysTryReturn(NID_APP, pEnum, null, E_INVALID_ARG, "GetMapEnumeratorN() is failed.");
 906
 907         int res = 0;
 908         bool definedKey = false;
 909         bool metadataKey = false;
 910         ArrayList* pList = null;
 911         ArrayList list;
 912         ArrayList metadataList;
 913         ArrayList appIdList;
 914         pkgmgrinfo_appinfo_filter_h handle = null;
 915         pkgmgrinfo_appinfo_metadata_filter_h metaHandle = null;
 916
 917         res = pkgmgrinfo_appinfo_filter_create(&handle);
 918         SysTryReturn(NID_APP, res == PMINFO_R_OK, null, E_SYSTEM, "pkgmgrinfo_appinfo_filter_create() is failed. [%d]", res);
 919
 920         res = pkgmgrinfo_appinfo_metadata_filter_create(&metaHandle);
 921         SysTryReturn(NID_APP, res == PMINFO_R_OK, null, E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_create() is failed. [%d]", res);
 922
 923         while(pEnum->MoveNext() == E_SUCCESS)
 924         {
 925                 String* pKey = static_cast< String* >(pEnum->GetKey());
 926                 SysTryCatch(NID_APP, pKey, , E_INVALID_ARG, "GetKey() is failed.");
 927
 928                 if ((*pKey) == PACKAGE_APP_FILTER_MENUICON_VISIBLE)
 929                 {
 930                         definedKey = true;
 931
 932                         Boolean* pVal = static_cast< Boolean* >(pEnum->GetValue());
 933                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 934
 935                         bool nodisplay = !(pVal->ToBool());
 936                         SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), nodisplay);
 937
 938                         res = pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_NODISPLAY, nodisplay);
 939                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(NODISPLAY, %d) is failed. [%d]", nodisplay, res);
 940                 }
 941                 else if ((*pKey) == PACKAGE_APP_FILTER_CATEGORY)
 942                 {
 943                         definedKey = true;
 944
 945                         String* pVal = static_cast< String* >(pEnum->GetValue());
 946                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 947
 948                         SysLog(NID_APP, "Key[%ls], Value[%ls]", pKey->GetPointer(), pVal->GetPointer());
 949
 950                         std::unique_ptr<char[]> pValue(_StringConverter::CopyToCharArrayN(*pVal));
 951                         SysTryCatch(NID_APP, pValue, , E_OUT_OF_MEMORY, "pValue is null.");
 952
 953                         res = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_CATEGORY, pValue.get());
 954                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_add_string(CATEGORY, %s) is failed. [%d]", pValue.get(), res);
 955                 }
 956                 else
 957                 {
 958                         metadataKey = true;
 959
 960                         String* pVal = static_cast< String* >(pEnum->GetValue());
 961                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 962
 963                         SysLog(NID_APP, "Key[%ls], Value[%ls]", pKey->GetPointer(), pVal->GetPointer());
 964
 965                         std::unique_ptr<char[]> pMetaKey(_StringConverter::CopyToCharArrayN(*pKey));
 966                         SysTryCatch(NID_APP, pMetaKey, , E_OUT_OF_MEMORY, "pMetaKey is null.");
 967
 968                         std::unique_ptr<char[]> pValue(_StringConverter::CopyToCharArrayN(*pVal));
 969                         SysTryCatch(NID_APP, pValue, , E_OUT_OF_MEMORY, "pValue is null.");
 970
 971                         res = pkgmgrinfo_appinfo_metadata_filter_add(metaHandle, pMetaKey.get(), pValue.get());
 972                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_add(%s, %s) is failed. [%d]", pMetaKey.get(), pValue.get(), res);
 973                 }
 974         }
 975
 976         if ((definedKey == true) && (metadataKey == false))
 977         {
 978                 pList = new (std::nothrow) ArrayList();
 979                 SysTryCatch(NID_APP, pList, , E_OUT_OF_MEMORY, "ArrayList creation failure.");
 980                 pList->Construct();
 981
 982                 res = pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, PackageAppInfoHandler, pList);
 983                 if (res != PMINFO_R_OK)
 984                 {
 985                         SysLog(NID_APP, "pkgmgrinfo_appinfo_filter_foreach_appinfo() is failed. result = [%d]", res);
 986
 987                         pList->RemoveAll(true);
 988                         pList = null;
 989                 }
 990         }
 991         else if ((definedKey == false) && (metadataKey == true))
 992         {
 993                 pList = new (std::nothrow) ArrayList();
 994                 SysTryCatch(NID_APP, pList, , E_OUT_OF_MEMORY, "ArrayList creation failure.");
 995                 pList->Construct();
 996
 997                 res = pkgmgrinfo_appinfo_metadata_filter_foreach(metaHandle, PackageAppInfoMetadataHandler, pList);
 998                 if (res != PMINFO_R_OK)
 999                 {
1000                         SysLog(NID_APP, "pkgmgrinfo_appinfo_metadata_filter_foreach() is failed. result = [%d]", res);
1001
1002                         pList->RemoveAll(true);
1003                         pList = null;
1004                 }
1005         }
1006         else
1007         {
1008                 list.Construct();
1009
1010                 res = pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, PackageAppInfoHandler, &list);
1011                 if (res != PMINFO_R_OK)
1012                 {
1013                         SysLog(NID_APP, "pkgmgrinfo_appinfo_filter_foreach_appinfo() is failed. result = [%d]", res);
1014                         goto CATCH;
1015                 }
1016
1017                 metadataList.Construct();
1018
1019                 res = pkgmgrinfo_appinfo_metadata_filter_foreach(metaHandle, PackageAppInfoMetadataHandler, &metadataList);
1020                 if (res != PMINFO_R_OK)
1021                 {
1022                         SysLog(NID_APP, "pkgmgrinfo_appinfo_metadata_filter_foreach() is failed. result = [%d]", res);
1023                         goto CATCH;
1024                 }
1025
1026                 for (int i = 0; i < list.GetCount(); i++)
1027                 {
1028                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(list.GetAt(i));
1029                         if (pPackageAppInfo)
1030                         {
1031                                 AppLog("PackageAppFilter - AppId [%ls]", pPackageAppInfo->GetAppId().GetPointer());
1032
1033                                 std::unique_ptr< AppId > pAppId(new (std::nothrow) AppId(pPackageAppInfo->GetAppId()));
1034                                 appIdList.Add(pAppId.release());
1035                         }
1036                 }
1037
1038                 pList = new (std::nothrow) ArrayList();
1039                 SysTryCatch(NID_APP, pList, , E_OUT_OF_MEMORY, "ArrayList creation failure.");
1040                 pList->Construct();
1041
1042                 for (int j = 0; j < metadataList.GetCount(); j++)
1043                 {
1044                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(metadataList.GetAt(j));
1045                         if (pPackageAppInfo)
1046                         {
1047                                 if (appIdList.Contains(pPackageAppInfo->GetAppId()) == true)
1048                                 {
1049                                         AppLog("AppId [%ls] is matched.", pPackageAppInfo->GetAppId().GetPointer());
1050
1051                                         std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1052                                         SysTryCatch(NID_APP, pPackageAppInfo, , E_OUT_OF_MEMORY, "PackageAppInfo is null.");
1053
1054                                         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1055                                         pPackageAppInfoImpl->Construct(pPackageAppInfo->GetAppId());
1056
1057                                         pList->Add(pPackageAppInfo.release());
1058                                 }
1059                                 else
1060                                 {
1061                                         AppLog("AppId [%ls] is not matched.", pPackageAppInfo->GetAppId().GetPointer());
1062                                 }
1063                         }
1064                 }
1065         }
1066
1067 CATCH:
1068         if (handle)
1069         {
1070                 pkgmgrinfo_appinfo_filter_destroy(handle);
1071         }
1072
1073         if (metaHandle)
1074         {
1075                 pkgmgrinfo_appinfo_metadata_filter_destroy(metaHandle);
1076         }
1077         return pList;
1078 }
1079
1080 IList*
1081 _PackageManagerImpl::GetPackageAppInfoListN(const IMap& packageFilterMap, const IMap& packageAppFilterMap) const
1082 {
1083         SysTryReturn(NID_APP, packageFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageFilterMap Count is invalid.");
1084         SysTryReturn(NID_APP, packageAppFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageAppFilterMap Count is invalid.");
1085
1086         ArrayList appIdList;
1087
1088         std::unique_ptr< IList > pPackageFilterList(GetPackageInfoListN(packageFilterMap));
1089         if (pPackageFilterList == null)
1090         {
1091                 SysLog(NID_APP, "GetPackageInfoListN(packageFilterMap) is null.");
1092                 return null;
1093         }
1094
1095         for (int i = 0; i < pPackageFilterList->GetCount(); i++)
1096         {
1097                 PackageInfo* pPackageInfo = dynamic_cast < PackageInfo* >(pPackageFilterList->GetAt(i));
1098                 if (pPackageInfo)
1099                 {
1100                         std::unique_ptr< IList > pPackageAppInfoList(pPackageInfo->GetPackageAppInfoListN());
1101                         if (pPackageAppInfoList)
1102                         {
1103                                 for (int j = 0; j < pPackageAppInfoList->GetCount(); j++)
1104                                 {
1105                                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(pPackageAppInfoList->GetAt(j));
1106                                         if (pPackageAppInfo)
1107                                         {
1108                                                 AppLog("PackageFilter - AppId [%ls]", pPackageAppInfo->GetAppId().GetPointer());
1109
1110                                                 std::unique_ptr< AppId > pAppId(new (std::nothrow) AppId(pPackageAppInfo->GetAppId()));
1111                                                 appIdList.Add(pAppId.release());
1112                                         }
1113                                 }
1114                         }
1115                 }
1116         }
1117
1118         std::unique_ptr< ArrayList > pList(new (std::nothrow) ArrayList);
1119         SysTryReturn(NID_APP, pList, null, E_OUT_OF_MEMORY, "pList is null.");
1120
1121         std::unique_ptr< IList > pAppFilterList(GetPackageAppInfoListN(packageAppFilterMap));
1122         if (pAppFilterList == null)
1123         {
1124                 SysLog(NID_APP, "GetPackageAppInfoListN(packageAppFilterMap) is null.");
1125                 return null;
1126         }
1127
1128         for (int k = 0; k < pAppFilterList->GetCount(); k++)
1129         {
1130                 PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(pAppFilterList->GetAt(k));
1131                 if (pPackageAppInfo)
1132                 {
1133                         AppId appId = pPackageAppInfo->GetAppId();
1134                         AppLog("AppFilter - AppId [%ls]", appId.GetPointer());
1135
1136                         if (appIdList.Contains(appId) == true)
1137                         {
1138                                 AppLog("AppId [%ls] is matched.", appId.GetPointer());
1139
1140                                 std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1141                                 SysTryReturn(NID_APP, pPackageAppInfo, null, E_OUT_OF_MEMORY, "PackageAppInfo is null.");
1142
1143                                 _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1144                                 pPackageAppInfoImpl->Construct(appId);
1145
1146                                 pList->Add(pPackageAppInfo.release());
1147                         }
1148                         else
1149                         {
1150                                 AppLog("AppId [%ls] is not matched.", pPackageAppInfo->GetAppId().GetPointer());
1151                         }
1152                 }
1153         }
1154
1155         if (pList->GetCount() <= 0)
1156         {
1157                 AppLog("pList's count is 0.");
1158                 return null;
1159         }
1160
1161         return pList.release();
1162 }
1163
1164 int
1165 _PackageManagerImpl::PackageInfoHandler(const pkgmgrinfo_pkginfo_h handle, void* pUserData)
1166 {
1167         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
1168         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
1169
1170         result r = E_SUCCESS;
1171         int res = PMINFO_R_OK;
1172         char* pPackageId = null;
1173         ArrayList* pList = (ArrayList*)pUserData;
1174
1175         res = pkgmgrinfo_pkginfo_get_pkgname(handle, &pPackageId);
1176         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkgname() is failed. [%d]", res);
1177
1178         std::unique_ptr<PackageInfo> pPackageInfo(new (std::nothrow) PackageInfo);
1179         SysTryReturn(NID_APP, pPackageInfo, 0, E_OUT_OF_MEMORY, "pPackageInfo instance must not be null.");
1180
1181         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
1182         r = pPackageInfoImpl->Construct(pPackageId);
1183         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pPackageId);
1184
1185         pList->Add(*pPackageInfo.release());
1186
1187         return 0;
1188 }
1189
1190 int
1191 _PackageManagerImpl::PackageAppInfoHandler(const pkgmgrinfo_appinfo_h handle, void* pUserData)
1192 {
1193         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
1194         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
1195
1196         result r = E_SUCCESS;
1197         int res = PMINFO_R_OK;
1198         char* pAppId = null;
1199         ArrayList* pList = (ArrayList*)pUserData;
1200
1201         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
1202         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_appinfo_get_appid is failed. [%d]", res);
1203
1204         std::unique_ptr<PackageAppInfo> pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1205         SysTryReturn(NID_APP, pPackageAppInfo, 0, E_OUT_OF_MEMORY, "pPackageAppInfo instance must not be null.");
1206
1207         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1208         r = pPackageAppInfoImpl->Construct(pAppId);
1209         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pAppId);
1210
1211         pList->Add(*pPackageAppInfo.release());
1212
1213         return 0;
1214 }
1215
1216 int
1217 _PackageManagerImpl::PackageAppInfoMetadataHandler(const pkgmgrinfo_appinfo_h handle, void* pUserData)
1218 {
1219         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
1220         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
1221
1222         result r = E_SUCCESS;
1223         int res = PMINFO_R_OK;
1224         char* pAppId = null;
1225         ArrayList* pList = (ArrayList*)pUserData;
1226
1227         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
1228         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_appinfo_get_appid is failed. [%d]", res);
1229
1230         std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1231         SysTryReturn(NID_APP, pPackageAppInfo, 0, E_OUT_OF_MEMORY, "pPackageAppInfo instance must not be null.");
1232
1233         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1234         r = pPackageAppInfoImpl->Construct(pAppId);
1235         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pAppId);
1236
1237         pList->Add(*pPackageAppInfo.release());
1238
1239         return 0;
1240 }
1241
1242 _PackageManagerImpl*
1243 _PackageManagerImpl::GetInstance(void)
1244 {
1245         return PackageManager::GetInstance()->__pPackageManagerImpl;
1246 }
1247
1248 result
1249 _PackageManagerImpl::Construct(void)
1250 {
1251         ClearLastResult();
1252
1253         result r = __installationList.Construct();
1254         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "The memory is insufficient.");
1255
1256         return E_SUCCESS;
1257 }
1258
1259 _PackageManagerImpl::_PackageManagerImpl(void)
1260 :__pRequestClient(null),
1261 __pListeningClient(null)
1262 {
1263 }
1264
1265 _PackageManagerImpl::~_PackageManagerImpl(void)
1266 {
1267 }
1268
1269 void
1270 _PackageManagerImpl::SendPackageEvent(PackageType type, const PackageId& packageId, const char* pEventKey, const char* pEventValue)
1271 {
1272         result r = E_SUCCESS;
1273         bool install = true;
1274
1275         if (strcmp(pEventKey, "start") == 0)
1276         {
1277                 if ((strcmp(pEventValue, "install") == 0) || (strcmp(pEventValue, "uninstall") == 0))
1278                 {
1279                         String* pAppId = new (std::nothrow) String(packageId);
1280                         SysTryReturnVoidResult(NID_APP, pAppId != null, E_OUT_OF_MEMORY, "pAppId instance must not be null.");
1281
1282                         String* pOperation = new (std::nothrow) String(pEventValue);
1283                         SysTryReturnVoidResult(NID_APP, pOperation != null, E_OUT_OF_MEMORY, "pOperation instance must not be null.");
1284
1285                         r = __installationList.Add(*pAppId, *pOperation);
1286                         if (IsFailed(r))
1287                         {
1288                                 delete pAppId;
1289                                 delete pOperation;
1290                                 SysLog(NID_APP, "Failed to add installation condition.");
1291                                 SetLastResult(E_SYSTEM);
1292                                 return;
1293                         }
1294                 }
1295         }
1296         else if (strcmp(pEventKey, "end") == 0)
1297         {
1298                 String* pOperation = static_cast <String*>(__installationList.GetValue(packageId));
1299                 if (pOperation)
1300                 {
1301                         if (pOperation->Equals("uninstall", true) == true)
1302                         {
1303                                 install = false;
1304                         }
1305
1306                         r = __installationList.Remove(packageId, true);
1307                         if (IsFailed(r))
1308                         {
1309                                 SysLogException(NID_APP, r, "[%s] Remove Element [%ls] is failed from installing list.", GetErrorMessage(r), packageId.GetPointer());
1310                         }
1311                 }
1312         }
1313
1314         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
1315         SysTryReturnVoidResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
1316
1317         while (pEnum->MoveNext() == E_SUCCESS)
1318         {
1319                 _PackageManagerEvent*   pEvent = null;
1320                 pEnum->GetCurrent(pEvent);
1321                 if (pEvent)
1322                 {
1323                         _PackageManagerEventArg* pEventArg= new (std::nothrow) _PackageManagerEventArg();
1324                         SysTryReturnVoidResult(NID_APP, pEventArg, E_OUT_OF_MEMORY, "The memory is insufficient.");
1325
1326                         String eventKey(pEventKey);
1327                         String eventValue(pEventValue);
1328
1329                         pEventArg->__packageId = packageId;
1330                         pEventArg->__eventKey = eventKey;
1331                         pEventArg->__eventValue = eventValue;
1332                         pEventArg->__install = install;
1333
1334                         r = pEvent->Fire(*pEventArg);
1335                         if (r != E_SUCCESS)
1336                         {
1337                                 SysLog(NID_APP, "pEvent->Fire(*pEventArg) failed. [%s]", GetErrorMessage(r));
1338                         }
1339
1340                         SysLog(NID_APP, "PackageId = [%ls], Key = [%ls], Value = [%ls], install = [%d]", pEventArg->__packageId.GetPointer(), pEventArg->__eventKey.GetPointer(), pEventArg->__eventValue.GetPointer(), pEventArg->__install);
1341                 }
1342                 else
1343                 {
1344                         SysLog(NID_APP, "pEvent is null.");
1345                 }
1346         }
1347 }
1348
1349 PackageInfo*
1350 _PackageManagerImpl::GetPackageInfoN(PackageType packageType, const String& packageName) const
1351 {
1352         SysTryReturn(NID_APP, packageName.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] packageName is empty.");
1353
1354         result r = E_SUCCESS;
1355         Database db;
1356         DbStatement* pStmt = null;
1357         DbEnumerator* pEnum = null;
1358         String query;
1359         PackageInfo *pPackageInfo = null;
1360
1361         query.Format(   1024, L"SELECT PkgInfo.*, AppInfo.APP_MAINMENU_ICON FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.PACKAGE_NAME = '%ls'", packageName.GetPointer());
1362
1363         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1364         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1365
1366         pStmt = CreateStatementN(db, query);
1367
1368         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1369
1370         pEnum = ExecuteStatementN(db, pStmt);
1371         if (pEnum != null)
1372         {
1373                 if (pEnum->MoveNext() == E_SUCCESS)
1374                 {
1375                         pPackageInfo = new (std::nothrow) PackageInfo;
1376                         SysTryReturn(NID_APP, pPackageInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
1377
1378                         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
1379
1380                         String id;
1381                         String appVersion;
1382                         String appType;
1383                         String appMimeType;
1384                         String appApiVersion;
1385                         String appName;
1386                         String appVendor;
1387                         String appDescription;
1388                         String appUrl;
1389                         String appCid;
1390                         String appRootPath;
1391                         int appStorageType = 0;
1392                         DateTime appInstallationTime;
1393                         String appIconPath;
1394
1395                         pEnum->GetStringAt(1, id);
1396                         pEnum->GetStringAt(3, appVersion);
1397                         pEnum->GetStringAt(4, appType);
1398                         pEnum->GetStringAt(5, appMimeType);
1399                         pEnum->GetStringAt(6, appApiVersion);
1400                         pEnum->GetStringAt(7, appName);
1401                         pEnum->GetStringAt(8, appVendor);
1402                         pEnum->GetStringAt(9, appDescription);
1403                         pEnum->GetStringAt(10, appUrl);
1404                         pEnum->GetStringAt(11, appCid);
1405                         pEnum->GetStringAt(16, appRootPath);
1406                         pEnum->GetIntAt(17, appStorageType);
1407                         pEnum->GetDateTimeAt(18, appInstallationTime);
1408                         pEnum->GetStringAt(21, appIconPath);
1409
1410                         pPackageInfoImpl->SetAppId(id);
1411                         pPackageInfoImpl->SetAppVersion(appVersion);
1412                         pPackageInfoImpl->SetAppMimeType(appMimeType);
1413                         pPackageInfoImpl->SetAppApiVersion(appApiVersion);
1414                         pPackageInfoImpl->SetAppName(appName);
1415                         pPackageInfoImpl->SetAppVendor(appVendor);
1416                         pPackageInfoImpl->SetAppDescription(appDescription);
1417                         pPackageInfoImpl->SetAppUrl(appUrl);
1418                         pPackageInfoImpl->SetAppCid(appCid);
1419                         pPackageInfoImpl->SetAppRootPath(appRootPath);
1420                         pPackageInfoImpl->SetAppStorageType(appStorageType);
1421                         pPackageInfoImpl->SetAppInstallationTime(appInstallationTime);
1422                         pPackageInfoImpl->SetAppIconPath(appIconPath);
1423                 }
1424
1425                 delete pEnum;
1426         }
1427         else
1428         {
1429                 r = E_OBJ_NOT_FOUND;
1430         }
1431
1432 CATCH:
1433         delete pStmt;
1434         return pPackageInfo;
1435 }
1436
1437 int
1438 _PackageManagerImpl::PackageInfoEventHandler(const pkgmgrinfo_pkginfo_h handle, void* pUserData)
1439 {
1440         SysTryReturn(NID_APP, handle != null, 0, E_SYSTEM, "[E_SYSTEM] handle must not be null.");
1441
1442         int result = 0;
1443         char* pPackage = null;
1444         ArrayList* pList = (ArrayList*)pUserData;
1445
1446         PackageInfo *pPackageInfo = new (std::nothrow) PackageInfo;
1447         SysTryReturn(NID_APP, pPackageInfo != null, 0, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
1448
1449         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
1450
1451         result = pkgmgrinfo_pkginfo_get_pkgname(handle, &pPackage);
1452         if (result == 0)
1453         {
1454                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname(): package = [%s]", pPackage);
1455         }
1456         else
1457         {
1458                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname() is failed. result = [%d]", result);
1459         }
1460
1461         pPackageInfoImpl->Construct(pPackage);
1462         pList->Add(*pPackageInfo);
1463
1464         return result;
1465 }
1466
1467 IList*
1468 _PackageManagerImpl::GetFilteredAppIdListN(const String& feature, const String& value) const
1469 {
1470         result r = E_SUCCESS;
1471         Database db;
1472         DbStatement* pStmt = null;
1473         DbEnumerator* pEnum = null;
1474         String query;
1475         ArrayList* pList = null;
1476
1477         query.Format(1024, L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, AppFeature WHERE AppFeature.ID = AppInfo.UNIQUE_ID and AppFeature.NAME = '%ls' and AppFeature.VALUE = '%ls' COLLATE NOCASE", feature.GetPointer(), value.GetPointer());
1478
1479         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1480         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1481
1482         pStmt = CreateStatementN(db, query);
1483         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1484
1485         pEnum = ExecuteStatementN(db, pStmt);
1486
1487         if (pEnum != null)
1488         {
1489                 pList = new (std::nothrow) ArrayList();
1490                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1491                 pList->Construct();
1492
1493                 while (pEnum->MoveNext() == E_SUCCESS)
1494                 {
1495                         String* pPackageName = new (std::nothrow) String;
1496                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1497
1498                         pEnum->GetStringAt(0, *pPackageName);
1499
1500                         pList->Add(*pPackageName);
1501                 }
1502
1503                 delete pEnum;
1504
1505         }
1506         else
1507         {
1508                 r = E_OBJ_NOT_FOUND;
1509         }
1510
1511 CATCH:
1512         delete pStmt;
1513         return pList;
1514 }
1515
1516 IList*
1517 _PackageManagerImpl::GetDataControlInfoN(const String& providerId, const String& type) const
1518 {
1519         result r = E_SUCCESS;
1520         Database db;
1521         DbStatement* pStmt = null;
1522         DbEnumerator* pEnum = null;
1523         String query;
1524         ArrayList* pList = null;
1525
1526         query.Format(1024, L"SELECT AppInfo.PACKAGE_NAME, DataControl.ACCESS FROM AppInfo, DataControl WHERE DataControl.ID = AppInfo.UNIQUE_ID and DataControl.PROVIDER_ID = '%ls' and DataControl.TYPE = '%ls' COLLATE NOCASE", providerId.GetPointer(), type.GetPointer());
1527
1528         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1529         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1530
1531         pStmt = CreateStatementN(db, query);
1532         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1533
1534         pEnum = ExecuteStatementN(db, pStmt);
1535
1536         if (pEnum != null)
1537         {
1538                 pList = new (std::nothrow) ArrayList();
1539                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1540                 pList->Construct();
1541
1542                 while (pEnum->MoveNext() == E_SUCCESS)
1543                 {
1544                         String* pPackageName = new (std::nothrow) String;
1545                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1546
1547                         String* pAccess = new (std::nothrow) String;
1548                         SysTryReturn(NID_APP, pAccess != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pAccess instance must not be null.");
1549
1550                         pEnum->GetStringAt(0, *pPackageName);
1551                         pList->Add(*pPackageName);
1552
1553                         pEnum->GetStringAt(1, *pAccess);
1554                         pList->Add(*pAccess);
1555                 }
1556
1557                 delete pEnum;
1558
1559         }
1560         else
1561         {
1562                 r = E_OBJ_NOT_FOUND;
1563         }
1564
1565 CATCH:
1566         delete pStmt;
1567         return pList;
1568 }
1569
1570 IMap*
1571 _PackageManagerImpl::GetUiThemeListN(const PackageId& packageId) const
1572 {
1573         result r = E_SUCCESS;
1574         Database db;
1575         DbStatement* pStmt = null;
1576         DbEnumerator* pEnum = null;
1577         String query;
1578         HashMap* pList = null;
1579
1580         query.Format(1024, L"SELECT AppFeature.NAME, AppFeature.VALUE FROM PkgInfo, AppInfo, AppFeature WHERE (AppFeature.ID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID and PkgInfo.PKG_ID = '%ls') and (AppFeature.NAME = 'SystemTheme' or AppFeature.NAME = 'UserDefinedTheme')"
1581                         , packageId.GetPointer());
1582
1583         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1584         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1585
1586         pStmt = CreateStatementN(db, query);
1587         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1588
1589         pEnum = ExecuteStatementN(db, pStmt);
1590
1591         if (pEnum != null)
1592         {
1593                 pList = new (std::nothrow) HashMap();
1594                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "HashMap creation failure.");
1595                 pList->Construct();
1596
1597                 while (pEnum->MoveNext() == E_SUCCESS)
1598                 {
1599                         String* pName = new (std::nothrow) String;
1600                         SysTryCatch(NID_APP, pName != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pName instance must not be null.");
1601
1602                         String* pValue = new (std::nothrow) String;
1603                         SysTryCatch(NID_APP, pValue != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pValue instance must not be null.");
1604
1605                         pEnum->GetStringAt(0, *pName);
1606                         pEnum->GetStringAt(1, *pValue);
1607
1608                         pList->Add(*pName, *pValue);
1609                 }
1610
1611                 delete pEnum;
1612
1613         }
1614         else
1615         {
1616                 r = E_OBJ_NOT_FOUND;
1617         }
1618
1619 CATCH:
1620         delete pStmt;
1621         return pList;
1622 }
1623
1624 bool
1625 _PackageManagerImpl::IsAppInstalled(const AppId& appId)
1626 {
1627         if (appId == _AppInfo::GetPackageId())
1628         {
1629                 return true;
1630         }
1631
1632         int result = 0;
1633         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
1634
1635         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(appId));
1636         SysTryReturn(NID_APP, pPackageId, false, E_OUT_OF_MEMORY, "pPackageId is null");
1637
1638         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
1639         SysTryReturn(NID_APP, result == 0, false, E_APP_NOT_INSTALLED, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", result, pPackageId.get());
1640
1641         if(pPackageInfoHandle)
1642         {
1643                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
1644         }
1645
1646         return true;
1647 }
1648
1649 int
1650 _PackageManagerImpl::PackageEventHandler(int req_id, const char* pkg_type, const char* pkg_name,
1651                                                                                 const char* key, const char* val, const void* pmsg, void* data)
1652 {
1653         SysLog(NID_APP, "PackageEventHandler - req_id: %d, pkg_type: %s, pkg_name: %s, key: %s, val: %s", req_id, pkg_type,
1654                                 pkg_name, key, val);
1655
1656         PackageType type = PACKAGE_TYPE_TPK;
1657         PackageId packageId(pkg_name);
1658
1659         if (strcmp(pkg_type, "tpk") == 0)
1660         {
1661                 type = PACKAGE_TYPE_TPK;
1662         }
1663         else if (strcmp(pkg_type, "wgt") == 0)
1664         {
1665                 type = PACKAGE_TYPE_WGT;
1666         }
1667         else
1668         {
1669                 SysLog(NID_APP, "Invalid type - pkg_type: %s", pkg_type);
1670                 return 0;
1671         }
1672
1673         _PackageManagerImpl* pThis = _PackageManagerImpl::GetInstance();
1674         pThis->SendPackageEvent(type, packageId, key, val);
1675
1676         return 0;
1677 }
1678
1679 String*
1680 _PackageManagerImpl::GetAppIdOfDataControlN(const String& providerId)
1681 {
1682         result r = E_SUCCESS;
1683         Database db;
1684         DbStatement* pStmt = null;
1685         DbEnumerator* pEnum = null;
1686         String query;
1687         String* pAppId = null;
1688
1689         query.Format(1024, L"SELECT PkgInfo.PKG_ID FROM PkgInfo, AppInfo, DataControl WHERE DataControl.PROVIDER_ID = '%ls' and DataControl.ID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID",
1690                         providerId.GetPointer());
1691
1692         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1693         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1694
1695         pStmt = CreateStatementN(db, query);
1696         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1697
1698         pEnum = ExecuteStatementN(db, pStmt);
1699
1700         if (pEnum != null)
1701         {
1702                 if (pEnum->MoveNext() == E_SUCCESS)
1703                 {
1704                         pAppId = new (std::nothrow) String;
1705                         SysTryReturn(NID_APP, pAppId != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
1706
1707                         pEnum->GetStringAt(0, *pAppId);
1708                 }
1709
1710                 delete pEnum;
1711         }
1712
1713 CATCH:
1714         delete pStmt;
1715         return pAppId;
1716 }
1717
1718 PackageInfo*
1719 _PackageManagerImpl::GetPackageInfoN(const String& providerId, const String& operationId) const
1720 {
1721         result r = E_SUCCESS;
1722         PackageInfo* pPkgInfo = null;
1723         Database db;
1724         DbStatement* pStmt = null;
1725         DbEnumerator* pEnum = null;
1726         String query;
1727
1728         query.Format(1024, L"SELECT PkgInfo.PKG_ID FROM PkgInfo, AppInfo, AppInfoLookup, AppControl, Capability "
1729                         "WHERE AppControl.PROVIDER_ID ='%ls' and Capability.OPERATION_ID ='%ls' and AppControl.ID = AppInfoLookup.AppControlID "
1730                         "and Capability.ID = AppInfoLookup.CapabilityID and AppInfoLookup.AppInfoID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID "
1731                         "GROUP BY AppInfoID"
1732                         , providerId.GetPointer(), operationId.GetPointer());
1733
1734         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1735         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1736
1737         pStmt = CreateStatementN(db, query);
1738         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1739
1740         pEnum = ExecuteStatementN(db, pStmt);
1741         if (pEnum != null)
1742         {
1743                 if (pEnum->MoveNext() == E_SUCCESS)
1744                 {
1745                         PackageId packageId;
1746                         pEnum->GetStringAt(0, packageId);
1747
1748                         pPkgInfo = GetPackageInfoN(packageId);
1749                 }
1750
1751                 delete pEnum;
1752         }
1753         else
1754         {
1755                 r = E_OBJ_NOT_FOUND;
1756         }
1757
1758 CATCH:
1759         delete pStmt;
1760         return pPkgInfo;
1761 }
1762
1763 ArrayList*
1764 _PackageManagerImpl::GetPackageAppInfoImplListN(const String& packageId) const
1765 {
1766         result r = E_SUCCESS;
1767         Database db;
1768         DbStatement* pStmt = null;
1769         DbEnumerator* pEnum = null;
1770         String query;
1771         //int id = 0;
1772         PackageInfo* pPkgInfo = null;
1773         _PackageInfoImpl* pPackageInfoImpl = null;
1774         ArrayList* pList = null;
1775
1776         pPkgInfo = GetPackageInfoN(packageId);
1777         SysTryCatch(NID_APP, pPkgInfo != null, , r, "[%s] GetPackageInfoN() is failed", GetErrorMessage(r));
1778
1779         pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPkgInfo);
1780         query.Format(1024, L"SELECT * FROM AppInfo WHERE ID = %d", pPackageInfoImpl->GetUniqueId());
1781
1782         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1783         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1784
1785         pStmt = CreateStatementN(db, query);
1786         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1787                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1788
1789         pEnum = ExecuteStatementN(db, pStmt);
1790
1791         if (pEnum != null)
1792         {
1793                 pList = new (std::nothrow) ArrayList;
1794                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
1795
1796                 pList->Construct();
1797
1798                 while (pEnum->MoveNext() == E_SUCCESS)
1799                 {
1800                         _PackageAppInfoImpl* pPackageAppInfoImpl = new (std::nothrow) _PackageAppInfoImpl;
1801                         SysTryReturn(NID_APP, pPackageAppInfoImpl != null, null, E_OUT_OF_MEMORY, "pPackageAppInfoImpl instance must not be null.");
1802
1803                         int uniqueId = 0;
1804                         int pkgId = 0;
1805                         String name;
1806                         String defaultapp;
1807                         String mainmenuIcon;
1808                         String settingIcon;
1809                         String quickpanelIcon;
1810                         int appFeature = 0;
1811                         String packageName;
1812
1813                         pEnum->GetIntAt(0, uniqueId);
1814                         pEnum->GetIntAt(1, pkgId);
1815                         pEnum->GetStringAt(2, name);
1816                         pEnum->GetStringAt(3, defaultapp);
1817                         pEnum->GetStringAt(4, mainmenuIcon);
1818                         pEnum->GetStringAt(5, settingIcon);
1819                         pEnum->GetStringAt(7, quickpanelIcon);
1820                         pEnum->GetIntAt(9, appFeature);
1821                         pEnum->GetStringAt(10, packageName);
1822
1823                         pPackageAppInfoImpl->SetUniqueId(uniqueId);
1824                         pPackageAppInfoImpl->SetPkgId(pkgId);
1825                         pPackageAppInfoImpl->SetName(name);
1826                         pPackageAppInfoImpl->SetDefault(defaultapp);
1827                         pPackageAppInfoImpl->SetMainmenuIcon(mainmenuIcon);
1828                         pPackageAppInfoImpl->SetSettingIcon(settingIcon);
1829                         pPackageAppInfoImpl->SetQuickpanelIcon(quickpanelIcon);
1830                         pPackageAppInfoImpl->SetAppFeature(appFeature);
1831                         pPackageAppInfoImpl->SetPackageName(packageName);
1832
1833                         pList->Add(*pPackageAppInfoImpl);
1834                 }
1835
1836                 delete pEnum;
1837         }
1838
1839 CATCH:
1840         delete pPkgInfo;
1841         delete pStmt;
1842         return pList;
1843 }
1844
1845 ArrayList*
1846 _PackageManagerImpl::GetPackageAppFeatureListN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
1847 {
1848         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
1849         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
1850
1851         ArrayList* pResult = null;
1852
1853         for (int i = 0; i < pAppInfoList->GetCount(); i++)
1854         {
1855                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pAppInfoList->GetAt(i));
1856                 if (pAppInfoImpl == null)
1857                 {
1858                         continue;
1859                 }
1860
1861                 if (pAppInfoImpl->GetName() == appExecutableName)
1862                 {
1863                         pResult = pAppInfoImpl->GetAppFeatureListN();
1864                         goto OUT;
1865                 }
1866         }
1867
1868 OUT:
1869         pAppInfoList->RemoveAll(true);
1870         delete pAppInfoList;
1871
1872         return pResult;
1873 }
1874
1875 HashMapT<String, _AppFeatureInfoImpl*>*
1876 _PackageManagerImpl::GetPackageAppFeatureMapN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
1877 {
1878         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
1879         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
1880
1881         HashMapT<String, _AppFeatureInfoImpl*>* pResult = null;
1882
1883         std::auto_ptr<IEnumerator> pEnum(pAppInfoList->GetEnumeratorN());
1884
1885         while (pEnum->MoveNext() == E_SUCCESS)
1886         {
1887                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pEnum->GetCurrent());
1888                 if (pAppInfoImpl == null)
1889                 {
1890                         continue;
1891                 }
1892
1893                 if (pAppInfoImpl->GetName() == appExecutableName)
1894                 {
1895                         pResult = pAppInfoImpl->GetAppFeatureMapN();
1896                         goto OUT;
1897                 }
1898         }
1899
1900 OUT:
1901         pAppInfoList->RemoveAll(true);
1902         delete pAppInfoList;
1903
1904         return pResult;
1905 }
1906
1907 ArrayList*
1908 _PackageManagerImpl::GetAppLaunchConditionListN(const String& packageName) const
1909 {
1910         result r = E_SUCCESS;
1911         Database db;
1912         DbStatement* pStmt = null;
1913         DbEnumerator* pEnum = null;
1914         String query;
1915         ArrayList* pList = null;
1916
1917         query.Format(1024, L"SELECT LaunchCondition.* FROM LaunchCondition, AppInfo WHERE AppInfo.UNIQUE_ID = LaunchCondition.ID and AppInfo.PACKAGE_NAME = '%ls'", packageName.GetPointer());
1918
1919         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1920         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1921
1922         pStmt = CreateStatementN(db, query);
1923         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1924                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1925
1926         pEnum = ExecuteStatementN(db, pStmt);
1927         if (pEnum != null)
1928         {
1929                 pList = new (std::nothrow) ArrayList;
1930                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
1931
1932                 pList->Construct();
1933
1934                 while (pEnum->MoveNext() == E_SUCCESS)
1935                 {
1936                         _LaunchConditionInfoImpl* pLaunchCondtion = new (std::nothrow) _LaunchConditionInfoImpl;
1937                         SysTryReturn(NID_APP, pLaunchCondtion != null, null, E_OUT_OF_MEMORY, "pLaunchCondtion instance must not be null.");
1938
1939                         String name;
1940                         String value;
1941
1942                         pEnum->GetStringAt(1, name);
1943                         pEnum->GetStringAt(2, value);
1944
1945                         pLaunchCondtion->SetName(name);
1946                         pLaunchCondtion->SetValue(value);
1947
1948                         pList->Add(*pLaunchCondtion);
1949
1950                         SysLog(NID_APP, "Name[%ls], Value[%ls]", name.GetPointer(), value.GetPointer());
1951                 }
1952
1953                 delete pEnum;
1954         }
1955
1956 CATCH:
1957         delete pStmt;
1958         return pList;
1959 }
1960
1961 result
1962 _PackageManagerImpl::GetPackageName(const PackageId& packageId, const String* pName, char* pPackageName, int bufferSize)
1963 {
1964         result r = E_SUCCESS;
1965         Database db;
1966         DbStatement* pStmt = null;
1967         DbEnumerator* pEnum = null;
1968         String query;
1969         Tizen::Base::String packageName;
1970
1971         if (pName == null)
1972         {
1973                 query.Format(
1974                         1024,
1975                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
1976                         "True", packageId.GetPointer());
1977         }
1978         else
1979         {
1980                 query.Format(
1981                         1024,
1982                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and APP_NAME = '%ls' and PkgInfo.PKG_ID = '%ls'",
1983                         pName->GetPointer(), packageId.GetPointer());
1984         }
1985
1986         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1987         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1988
1989         pStmt = CreateStatementN(db, query);
1990         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1991                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1992
1993         pEnum = ExecuteStatementN(db, pStmt);
1994         if (pEnum != null)
1995         {
1996                 if (pEnum->MoveNext() == E_SUCCESS)
1997                 {
1998                         pEnum->GetStringAt(0, packageName);
1999                         snprintf(pPackageName, bufferSize, "%ls", packageName.GetPointer());
2000                 }
2001                 delete pEnum;
2002         }
2003         else
2004         {
2005                 r = E_OBJ_NOT_FOUND;
2006         }
2007
2008 CATCH:
2009         delete pStmt;
2010
2011         return r;
2012 }
2013
2014 String
2015 _PackageManagerImpl::GetDefaultAppExecutableName(const PackageId& packageId)
2016 {
2017         result r = E_SUCCESS;
2018         Database db;
2019         DbStatement* pStmt = null;
2020         DbEnumerator* pEnum = null;
2021         String query;
2022         String executableName;
2023
2024         query.Format(
2025                 1024,
2026                 L"SELECT AppInfo.APP_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
2027                 "True", packageId.GetPointer());
2028
2029         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2030         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2031
2032         pStmt = CreateStatementN(db, query);
2033         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2034                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2035
2036         pEnum = ExecuteStatementN(db, pStmt);
2037         if (pEnum != null)
2038         {
2039                 if (pEnum->MoveNext() == E_SUCCESS)
2040                 {
2041                         pEnum->GetStringAt(0, executableName);
2042                 }
2043                 delete pEnum;
2044         }
2045         else
2046         {
2047                 r = E_OBJ_NOT_FOUND;
2048                 SetLastResult(r);
2049         }
2050
2051 CATCH:
2052         delete pStmt;
2053
2054         return executableName;
2055 }
2056
2057 DbStatement*
2058 _PackageManagerImpl::CreateStatementN(Database& db, const String& query)
2059 {
2060         result r = E_SUCCESS;
2061         DbStatement* pStmt = null;
2062
2063         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2064         {
2065                 pStmt = db.CreateStatementN(query);
2066                 r = GetLastResult();
2067
2068                 if (r != E_OBJECT_LOCKED)
2069                 {
2070                         break;
2071                 }
2072                 else
2073                 {
2074                         SysLog(NID_APP, "RetryCount[%d] CreateStatementN - E_OBJECT_LOCKED", i);
2075                         delete pStmt;
2076                         pStmt = null;
2077                         usleep(50000);
2078                 }
2079         }
2080
2081         return pStmt;
2082 }
2083
2084 DbEnumerator*
2085 _PackageManagerImpl::ExecuteStatementN(Database& db, const DbStatement* pStmt)
2086 {
2087         result r = E_SUCCESS;
2088         DbEnumerator* pEnum = null;
2089
2090         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2091         {
2092                 pEnum = db.ExecuteStatementN(*pStmt);
2093                 r = GetLastResult();
2094
2095                 if (r != E_OBJECT_LOCKED)
2096                 {
2097                         break;
2098                 }
2099                 else
2100                 {
2101                         SysLog(NID_APP, "RetryCount[%d] ExecuteStatementN - E_OBJECT_LOCKED", i);
2102                         delete pEnum;
2103                         pEnum = null;
2104                         usleep(50000);
2105                 }
2106         }
2107
2108         return pEnum;
2109 }
2110
2111 } } } // Tizen::App::Package