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         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 375         SysTryReturnResult(NID_APP, pPackageId, E_OUT_OF_MEMORY, "pPackageId is null.");
 376
 377         if ((strcasecmp(pExtension.get(), "tpk") == 0) || (strcasecmp(pExtension.get(), "wgt") == 0))
 378         {
 379                 SysLog(NID_APP, "packageId = [%ls], packagePath = [%s], extension = [%s]", packageId.GetPointer(), pPackagePath.get(), pExtension.get());
 380         }
 381         else
 382         {
 383                 SysLog(NID_APP, "invalid extension! - packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 384                 return E_SYSTEM;
 385         }
 386
 387         result r = E_SUCCESS;
 388         _PackageManagerProxy packageManagerProxy;
 389         r = packageManagerProxy.Construct();
 390         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "packageManagerProxy.Construct() failed.");
 391
 392         r = packageManagerProxy.InstallPackage(packageId, packagePath, null);
 393         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "packageManagerProxy.InstallPackage() failed.");
 394
 395         if (__pRequestClient == null)
 396         {
 397                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 398                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 399         }
 400
 401         int res = pkgmgr_client_install(__pRequestClient, pExtension.get(), null, pPackagePath.get(), pPackageId.get(), PM_QUIET, InstallationEventHandler, pListener);
 402
 403         if (res < PKGMGR_R_OK)
 404         {
 405                 pkgmgr_client_free(__pRequestClient);
 406                 __pRequestClient = null;
 407
 408                 if (res == PKGMGR_R_EINVAL)
 409                 {
 410                         SysLog(NID_APP, "pkgmgr_client_install() returns ARGV error");
 411                         return E_INVALID_ARG;
 412                 }
 413                 else if (res == PKGMGR_R_ECOMM)
 414                 {
 415                         SysLog(NID_APP, "pkgmgr_client_install() returns COMM error");
 416                 }
 417                 else if (res == PKGMGR_R_ETIMEOUT)
 418                 {
 419                         SysLog(NID_APP, "pkgmgr_client_install() returns TIME_OUT error");
 420                 }
 421                 else if (res == PKGMGR_R_ERROR)
 422                 {
 423                         SysLog(NID_APP, "pkgmgr_client_install() returns Unknown error");
 424                 }
 425                 else
 426                 {
 427                         SysLog(NID_APP, "pkgmgr_client_install() returns Unknown error, res = %d", res);
 428                 }
 429
 430                 return E_SYSTEM;
 431         }
 432
 433         return E_SUCCESS;
 434 }
 435
 436 result
 437 _PackageManagerImpl::UninstallPackage(const PackageId& packageId, IPackageUninstallationResponseListener* pListener)
 438 {
 439         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty.");
 440         SysTryReturnResult(NID_APP, packageId.GetLength() < NATIVE_APP_MAX_APPID_LENGTH, E_INVALID_ARG, "The packageId is invalid.(length)");
 441         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 442
 443         result r = E_SUCCESS;
 444         int res = 0;
 445         char* pType = null;
 446         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
 447
 448         _PackageManagerProxy packageManagerProxy;
 449         r = packageManagerProxy.Construct();
 450         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "packageManagerProxy.Construct() failed.");
 451
 452         r = packageManagerProxy.UninstallPackage(packageId, pListener);
 453         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "packageManagerProxy.UninstallPackage() failed.");
 454
 455         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 456         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 457
 458         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
 459         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 460
 461         res = pkgmgrinfo_pkginfo_get_type(pPackageInfoHandle, &pType);
 462         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 463
 464         if (__pRequestClient == null)
 465         {
 466                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 467                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 468         }
 469
 470         res = pkgmgr_client_uninstall(__pRequestClient, pType, pPackageId.get(), PM_QUIET, UninstallationEventHandler, pListener);
 471         SysLog(NID_APP, "pkgmgr_client_uninstall - req_id=[%d], packageId=[%s], type=[%s]", res, pPackageId.get(), pType);
 472
 473         if(pPackageInfoHandle)
 474         {
 475                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
 476         }
 477
 478         if (res < PKGMGR_R_OK)
 479         {
 480                 pkgmgr_client_free(__pRequestClient);
 481                 __pRequestClient = null;
 482
 483                 if (res == PKGMGR_R_EINVAL)
 484                 {
 485                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns ARGV error");
 486                         return E_INVALID_ARG;
 487                 }
 488                 else if (res == PKGMGR_R_ECOMM)
 489                 {
 490                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns COMM error");
 491                 }
 492                 else if (res == PKGMGR_R_ETIMEOUT)
 493                 {
 494                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns TIME_OUT error");
 495                 }
 496                 else if (res == PKGMGR_R_ERROR)
 497                 {
 498                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns Unknown error");
 499                 }
 500                 else
 501                 {
 502                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns Unknown error, res = %d", res);
 503                 }
 504
 505                 return E_SYSTEM;
 506         }
 507
 508         return E_SUCCESS;
 509 }
 510
 511 result
 512 _PackageManagerImpl::MoveToExternalStorage(const PackageId& packageId)
 513 {
 514         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty");
 515         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 516
 517         int res = 0;
 518         char* pType = null;
 519         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
 520         pkgmgrinfo_pkginfo_h packageInfoHandle = null;
 521
 522         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 523         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 524
 525         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &packageInfoHandle);
 526         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 527
 528         res = pkgmgrinfo_pkginfo_get_type(packageInfoHandle, &pType);
 529         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 530
 531         res = pkgmgrinfo_pkginfo_get_installed_storage(packageInfoHandle, &storage);
 532         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_installed_storage() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 533
 534         if (storage == PMINFO_EXTERNAL_STORAGE)
 535         {
 536                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage(): storage = [%d][E_INVALID_OPERATION]", storage);
 537                 return E_INVALID_OPERATION;
 538         }
 539
 540         if (__pRequestClient == null)
 541         {
 542                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 543                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 544         }
 545
 546         res = pkgmgr_client_move(__pRequestClient, pType, pPackageId.get(), PM_MOVE_TO_SDCARD, PM_QUIET);
 547
 548         if(packageInfoHandle)
 549         {
 550                 pkgmgrinfo_pkginfo_destroy_pkginfo(packageInfoHandle);
 551         }
 552
 553         if (res < PKGMGR_R_OK)
 554         {
 555                 pkgmgr_client_free(__pRequestClient);
 556                 __pRequestClient = null;
 557
 558                 if (res == PKGMGR_R_EINVAL)
 559                 {
 560                         SysLog(NID_APP, "pkgmgr_client_move() returns ARGV error");
 561                         return E_INVALID_ARG;
 562                 }
 563                 else if (res == PKGMGR_R_ERROR)
 564                 {
 565                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error");
 566                 }
 567                 else
 568                 {
 569                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error, res = %d", res);
 570                 }
 571
 572                 return E_SYSTEM;
 573         }
 574
 575         return E_SUCCESS;
 576 }
 577
 578 result
 579 _PackageManagerImpl::MoveToInternalStorage(const PackageId& packageId)
 580 {
 581         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty");
 582         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 583
 584         int res = 0;
 585         char* pType = null;
 586         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
 587         pkgmgrinfo_pkginfo_h packageInfoHandle = null;
 588
 589         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 590         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 591
 592         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &packageInfoHandle);
 593         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 594
 595         res = pkgmgrinfo_pkginfo_get_type(packageInfoHandle, &pType);
 596         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 597
 598         res = pkgmgrinfo_pkginfo_get_installed_storage(packageInfoHandle, &storage);
 599         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_installed_storage() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 600
 601         if (storage == PMINFO_INTERNAL_STORAGE)
 602         {
 603                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage(): storage = [%d][E_INVALID_OPERATION]", storage);
 604                 return E_INVALID_OPERATION;
 605         }
 606
 607         if (__pRequestClient == null)
 608         {
 609                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 610                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 611         }
 612
 613         res = pkgmgr_client_move(__pRequestClient, pType, pPackageId.get(), PM_MOVE_TO_INTERNAL, PM_QUIET);
 614
 615         if(packageInfoHandle)
 616         {
 617                 pkgmgrinfo_pkginfo_destroy_pkginfo(packageInfoHandle);
 618         }
 619
 620         if (res < PKGMGR_R_OK)
 621         {
 622                 pkgmgr_client_free(__pRequestClient);
 623                 __pRequestClient = null;
 624
 625                 if (res == PKGMGR_R_EINVAL)
 626                 {
 627                         SysLog(NID_APP, "pkgmgr_client_move() returns ARGV error");
 628                         return E_INVALID_ARG;
 629                 }
 630                 else if (res == PKGMGR_R_ERROR)
 631                 {
 632                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error");
 633                 }
 634                 else
 635                 {
 636                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error, res = %d", res);
 637                 }
 638
 639                 return E_SYSTEM;
 640         }
 641
 642         return E_SUCCESS;
 643 }
 644
 645 int
 646 _PackageManagerImpl::InstallationEventHandler(int reqId, const char* pType, const char* pPackageId, const char* pKey, const char* pVal, const void* pMsg, void* pData)
 647 {
 648         SysLog(NID_APP, "reqId[%d], Type[%s], PackageId[%s], Key[%s], Val[%s]", reqId, pType, pPackageId, pKey, pVal);
 649
 650         if (pData)
 651         {
 652                 IPackageInstallationResponseListener* pListener = (IPackageInstallationResponseListener*) pData;
 653
 654                 if (strcmp(pKey, "end") == 0)
 655                 {
 656                         if (strcmp(pVal, "ok") == 0)
 657                         {
 658                                 pListener->OnPackageInstallationResponseReceived(pPackageId, PACKAGE_INSTALLATION_RESULT_SUCCESS);
 659                                 SysLog(NID_APP, "OnPackageInstallationResponseReceived(PACKAGE_INSTALLATION_RESULT_SUCCESS)");
 660                         }
 661                         else
 662                         {
 663                                 pListener->OnPackageInstallationResponseReceived(pPackageId, PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE);
 664                                 SysLog(NID_APP, "OnPackageInstallationResponseReceived(PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE)");
 665                         }
 666
 667                         delete pListener;
 668                 }
 669                 else if (strcmp(pKey, "install_percent") == 0)
 670                 {
 671                         int progress = 0;
 672                         sscanf(pVal, "%d", &progress);
 673
 674                         pListener->OnPackageInstallationInProgressResponseReceived(pPackageId, progress);
 675                         SysLog(NID_APP, "OnPackageInstallationInProgressResponseReceived(%s, %d)", pPackageId, progress);
 676                 }
 677         }
 678
 679         return 0;
 680 }
 681
 682 int
 683 _PackageManagerImpl::UninstallationEventHandler(int reqId, const char* pType, const char* pPackageId, const char* pKey, const char* pVal, const void* pMsg, void* pData)
 684 {
 685         SysLog(NID_APP, "reqId[%d], Type[%s], PackageId[%s], Key[%s], Val[%s]", reqId, pType, pPackageId, pKey, pVal);
 686
 687         if (pData)
 688         {
 689                 if (strcmp(pKey, "end") == 0)
 690                 {
 691                         IPackageUninstallationResponseListener* pListener = (IPackageUninstallationResponseListener*) pData;
 692
 693                         if (strcmp(pVal, "ok") == 0)
 694                         {
 695                                 SysLog(NID_APP, "OnPackageUninstallationResponseReceived(true)");
 696                                 pListener->OnPackageUninstallationResponseReceived(pPackageId, true);
 697                         }
 698                         else
 699                         {
 700                                 SysLog(NID_APP, "OnPackageUninstallationResponseReceived(false)");
 701                                 pListener->OnPackageUninstallationResponseReceived(pPackageId, false);
 702                         }
 703
 704                         delete pListener;
 705                 }
 706         }
 707
 708         return 0;
 709 }
 710
 711 PackageInfo*
 712 _PackageManagerImpl::GetPackageInfoFromFileN(const String& filePath) const
 713 {
 714         SysTryReturn(NID_APP, filePath.IsEmpty() == false, null, E_INVALID_ARG, "filePath is empty.");
 715         SysTryReturn(NID_APP, File::IsFileExist(filePath) == true, null, E_FILE_NOT_FOUND, "package is not existed.");
 716
 717         String extension = File::GetFileExtension(filePath);
 718         SysTryReturn(NID_APP, extension.IsEmpty() == false, null, E_INVALID_ARG, "extension is empty.");
 719
 720         std::unique_ptr<char[]> pPackagePath(_StringConverter::CopyToCharArrayN(filePath));
 721         SysTryReturn(NID_APP, pPackagePath, null, E_OUT_OF_MEMORY, "pPackagePath is null.");
 722
 723         std::unique_ptr<char[]> pExtension(_StringConverter::CopyToCharArrayN(extension));
 724         SysTryReturn(NID_APP, pExtension, null, E_OUT_OF_MEMORY, "pExtension is null.");
 725
 726         std::unique_ptr< PackageInfo > pPackageInfo(new (std::nothrow) PackageInfo);
 727         SysTryReturn(NID_APP, pPackageInfo, null, E_OUT_OF_MEMORY, "pPackageInfo instance must not be null.");
 728
 729         SysLog(NID_APP, "packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 730
 731         bool res = true;
 732         result r = E_SUCCESS;
 733
 734         if (strcasecmp(pExtension.get(), "tpk") == 0)
 735         {
 736                 _PackageParser packageParser;
 737
 738                 res = packageParser.Construct(pPackageInfo.get());
 739                 SysTryReturn(NID_APP, res, null, E_PARSING_FAILED, "Construct() is failed. [%s]", pPackagePath.get());
 740
 741                 res = packageParser.Parse(filePath);
 742                 SysTryReturn(NID_APP, res, null, E_PARSING_FAILED, "Parse() is failed. [%s]", pPackagePath.get());
 743         }
 744         else if (strcasecmp(pExtension.get(), "wgt") == 0)
 745         {
 746                 pkgmgr_info* pPkgmgrInfo = null;
 747
 748                 pPkgmgrInfo = pkgmgr_client_check_pkginfo_from_file(pPackagePath.get());
 749                 SysTryReturn(NID_APP, pPkgmgrInfo, null, E_PARSING_FAILED, "pkgmgr_client_check_pkginfo_from_file(%s) is failed.", pPackagePath.get());
 750
 751                 _package_manager_pkg_detail_info_t* pPkgInfo = (_package_manager_pkg_detail_info_t*) pPkgmgrInfo;
 752                 _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
 753
 754                 SysLog(NID_APP, "id(%s), version(%s), label(%s), description(%s), author(%s), icon_size(%d), pkgname(%s)", pPkgInfo->pkgid, pPkgInfo->version, pPkgInfo->label,
 755                                 pPkgInfo->pkg_description, pPkgInfo->author, pPkgInfo->icon_size, pPkgInfo->pkg_name);
 756
 757                 pPackageInfoImpl->SetType(PACKAGE_TYPE_WGT);
 758                 pPackageInfoImpl->SetId(pPkgInfo->pkgid);
 759                 pPackageInfoImpl->SetVersion(pPkgInfo->version);
 760                 pPackageInfoImpl->SetDisplayName(pPkgInfo->label);
 761                 pPackageInfoImpl->SetDescription(pPkgInfo->pkg_description);
 762                 pPackageInfoImpl->SetAuthor(pPkgInfo->author);
 763                 pPackageInfoImpl->SetMainAppId(pPkgInfo->pkg_name);
 764
 765                 if (pPkgInfo->privilege_list)
 766                 {
 767                         GList* pList = null;
 768                         pList = g_list_first(pPkgInfo->privilege_list);
 769                         while (pList)
 770                         {
 771                                 char* pPrivilege = (char*)pList->data;
 772                                 if (pPrivilege)
 773                                 {
 774                                         pPackageInfoImpl->AddPrivilege(*new (std::nothrow) String(pPrivilege));
 775                                         free(pPrivilege);
 776                                 }
 777                                 pList = g_list_next(pList);
 778                         }
 779                         g_list_free(pPkgInfo->privilege_list);
 780                 }
 781
 782                 std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
 783                 if (pPackageAppInfo)
 784                 {
 785                         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
 786
 787                         pPackageAppInfoImpl->SetAppId(pPkgInfo->pkg_name);
 788                         pPackageAppInfoImpl->SetAppName(pPkgInfo->label);
 789                         pPackageAppInfoImpl->SetAppDisplayName(pPkgInfo->label);
 790                         pPackageAppInfoImpl->SetMainApp(true);
 791                         if ((pPkgInfo->icon_buf) && (pPkgInfo->icon_size > 0))
 792                         {
 793                                 String iconPath("/tmp/icon.png");
 794                                 File file;
 795                                 r = file.Construct(iconPath, "w+");
 796                                 r = file.Write(pPkgInfo->icon_buf, pPkgInfo->icon_size);
 797
 798                                 pPackageAppInfoImpl->SetAppTempIconPath(iconPath);
 799                         }
 800
 801                         pPackageInfoImpl->AddPackageAppInfo(*pPackageAppInfo.release());
 802                 }
 803                 else
 804                 {
 805                         SysLog(NID_APP, "pPackageAppInfo instance must not be null.");
 806                         pkgmgr_client_free_pkginfo(pPkgmgrInfo);
 807                         return null;
 808                 }
 809
 810                 pkgmgr_client_free_pkginfo(pPkgmgrInfo);
 811         }
 812         else
 813         {
 814                 SysTryReturn(NID_APP, false, null, E_UNSUPPORTED_FORMAT, "invalid extension! - packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 815         }
 816
 817         return pPackageInfo.release();
 818 }
 819
 820 IList*
 821 _PackageManagerImpl::GetPackageInfoListN(const IMap& packageFilterMap) const
 822 {
 823         SysTryReturn(NID_APP, packageFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageFilterMap.GetCount() is invalid.");
 824
 825         std::unique_ptr<IMapEnumerator> pEnum(packageFilterMap.GetMapEnumeratorN());
 826         SysTryReturn(NID_APP, pEnum, null, E_INVALID_ARG, "GetMapEnumeratorN() is failed.");
 827
 828         std::unique_ptr< ArrayList > pList(new (std::nothrow) ArrayList());
 829         SysTryReturn(NID_APP, pList, null, E_OUT_OF_MEMORY, "pList is null.");
 830
 831         pList->Construct();
 832
 833         int res = PMINFO_R_OK;
 834         pkgmgrinfo_pkginfo_filter_h handle = null;
 835
 836         res = pkgmgrinfo_pkginfo_filter_create(&handle);
 837         SysTryReturn(NID_APP, res == PMINFO_R_OK, null, E_SYSTEM, "pkgmgrinfo_pkginfo_filter_create() is failed. [%d]", res);
 838
 839         while(pEnum->MoveNext() == E_SUCCESS)
 840         {
 841                 String* pKey = static_cast< String* >(pEnum->GetKey());
 842                 SysTryCatch(NID_APP, pKey, , E_INVALID_ARG, "GetKey() is failed.");
 843
 844                 Boolean* pVal = static_cast< Boolean* >(pEnum->GetValue());
 845                 SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 846
 847                 bool value = pVal->ToBool();
 848
 849                 SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), value);
 850
 851                 if ((*pKey) == PACKAGE_FILTER_UNINSTALLABLE)
 852                 {
 853                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_REMOVABLE, value);
 854                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(REMOVABLE, %d) is failed. [%d]", value, res);
 855                 }
 856                 else if ((*pKey) == PACKAGE_FILTER_DOWNLOADED)
 857                 {
 858                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_PRELOAD, !value);
 859                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(PRELOAD, %d) is failed. [%d]", !value, res);
 860                 }
 861                 else if ((*pKey) == PACKAGE_FILTER_APP_SETTING)
 862                 {
 863                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_APPSETTING, value);
 864                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(APPSETTING, %d) is failed. [%d]", value, res);
 865                 }
 866                 else if ((*pKey) == PACKAGE_FILTER_EXTERNAL_STORAGE)
 867                 {
 868                         String installedStorage;
 869                         if (value == true)
 870                         {
 871                                 installedStorage = L"installed_external";
 872                         }
 873                         else
 874                         {
 875                                 installedStorage = L"installed_internal";
 876                         }
 877
 878                         std::unique_ptr<char[]> pInstalledStorage(_StringConverter::CopyToCharArrayN(installedStorage));
 879                         SysTryCatch(NID_APP, pInstalledStorage, , E_OUT_OF_MEMORY, "pInstalledStorage is null.");
 880
 881                         SysLog(NID_APP, "Value[%d]->[%s]", value, pInstalledStorage.get());
 882
 883                         res = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_INSTALLED_STORAGE, pInstalledStorage.get());
 884                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_string(STORAGE, %s) is failed. [%d]", pInstalledStorage.get(), res);
 885                 }
 886                 else
 887                 {
 888                         SysTryCatch(NID_APP, false, , E_INVALID_ARG, "Invalid key(%ls)", pKey->GetPointer());
 889                 }
 890         }
 891
 892         res = pkgmgrinfo_pkginfo_filter_foreach_pkginfo(handle, PackageInfoHandler, pList.get());
 893         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_foreach_pkginfo() failed. [%d]", res);
 894
 895 CATCH:
 896         if (handle)
 897         {
 898                 pkgmgrinfo_pkginfo_filter_destroy(handle);
 899         }
 900
 901         if (pList->GetCount() <= 0)
 902         {
 903                 AppLog("pList's count is 0.");
 904                 return null;
 905         }
 906
 907         return pList.release();
 908 }
 909
 910 IList*
 911 _PackageManagerImpl::GetPackageAppInfoListN(const IMap& packageAppFilterMap) const
 912 {
 913         SysTryReturn(NID_APP, packageAppFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageAppFilterMap.GetCount() is invalid.");
 914
 915         std::unique_ptr< IMapEnumerator > pEnum(packageAppFilterMap.GetMapEnumeratorN());
 916         SysTryReturn(NID_APP, pEnum, null, E_INVALID_ARG, "GetMapEnumeratorN() is failed.");
 917
 918         std::unique_ptr< ArrayList > pList(new (std::nothrow) ArrayList());
 919         SysTryReturn(NID_APP, pList, null, E_OUT_OF_MEMORY, "pList is null.");
 920
 921         pList->Construct();
 922
 923         int res = 0;
 924         bool definedKey = false;
 925         bool metadataKey = false;
 926         ArrayList list;
 927         ArrayList metadataList;
 928         ArrayList appIdList;
 929         pkgmgrinfo_appinfo_filter_h handle = null;
 930         pkgmgrinfo_appinfo_metadata_filter_h metaHandle = null;
 931
 932         res = pkgmgrinfo_appinfo_filter_create(&handle);
 933         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_create() is failed. [%d]", res);
 934
 935         res = pkgmgrinfo_appinfo_metadata_filter_create(&metaHandle);
 936         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_create() is failed. [%d]", res);
 937
 938         while(pEnum->MoveNext() == E_SUCCESS)
 939         {
 940                 String* pKey = static_cast< String* >(pEnum->GetKey());
 941                 SysTryCatch(NID_APP, pKey, , E_INVALID_ARG, "GetKey() is failed.");
 942
 943                 if ((*pKey) == PACKAGE_APP_FILTER_MENUICON_VISIBLE)
 944                 {
 945                         definedKey = true;
 946
 947                         Boolean* pVal = static_cast< Boolean* >(pEnum->GetValue());
 948                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 949
 950                         bool nodisplay = !(pVal->ToBool());
 951                         SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), nodisplay);
 952
 953                         res = pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_NODISPLAY, nodisplay);
 954                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(NODISPLAY, %d) is failed. [%d]", nodisplay, res);
 955                 }
 956                 else if ((*pKey) == PACKAGE_APP_FILTER_CATEGORY)
 957                 {
 958                         definedKey = 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[]> pValue(_StringConverter::CopyToCharArrayN(*pVal));
 966                         SysTryCatch(NID_APP, pValue, , E_OUT_OF_MEMORY, "pValue is null.");
 967
 968                         res = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_CATEGORY, pValue.get());
 969                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_add_string(CATEGORY, %s) is failed. [%d]", pValue.get(), res);
 970                 }
 971                 else
 972                 {
 973                         metadataKey = true;
 974
 975                         String* pVal = static_cast< String* >(pEnum->GetValue());
 976                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 977
 978                         SysLog(NID_APP, "Key[%ls], Value[%ls]", pKey->GetPointer(), pVal->GetPointer());
 979
 980                         std::unique_ptr<char[]> pMetaKey(_StringConverter::CopyToCharArrayN(*pKey));
 981                         SysTryCatch(NID_APP, pMetaKey, , E_OUT_OF_MEMORY, "pMetaKey is null.");
 982
 983                         std::unique_ptr<char[]> pValue(_StringConverter::CopyToCharArrayN(*pVal));
 984                         SysTryCatch(NID_APP, pValue, , E_OUT_OF_MEMORY, "pValue is null.");
 985
 986                         res = pkgmgrinfo_appinfo_metadata_filter_add(metaHandle, pMetaKey.get(), pValue.get());
 987                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_add(%s, %s) is failed. [%d]", pMetaKey.get(), pValue.get(), res);
 988                 }
 989         }
 990
 991         if ((definedKey == true) && (metadataKey == false))
 992         {
 993                 res = pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, PackageAppInfoHandler, pList.get());
 994                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_foreach_appinfo() failed. [%d]", res);
 995         }
 996         else if ((definedKey == false) && (metadataKey == true))
 997         {
 998                 res = pkgmgrinfo_appinfo_metadata_filter_foreach(metaHandle, PackageAppInfoMetadataHandler, pList.get());
 999                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_foreach() failed. [%d]", res);
1000         }
1001         else
1002         {
1003                 list.Construct();
1004
1005                 res = pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, PackageAppInfoHandler, &list);
1006                 if (res != PMINFO_R_OK)
1007                 {
1008                         SysLog(NID_APP, "pkgmgrinfo_appinfo_filter_foreach_appinfo() is failed. result = [%d]", res);
1009                         goto CATCH;
1010                 }
1011
1012                 metadataList.Construct();
1013
1014                 res = pkgmgrinfo_appinfo_metadata_filter_foreach(metaHandle, PackageAppInfoMetadataHandler, &metadataList);
1015                 if (res != PMINFO_R_OK)
1016                 {
1017                         SysLog(NID_APP, "pkgmgrinfo_appinfo_metadata_filter_foreach() is failed. result = [%d]", res);
1018                         goto CATCH;
1019                 }
1020
1021                 for (int i = 0; i < list.GetCount(); i++)
1022                 {
1023                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(list.GetAt(i));
1024                         if (pPackageAppInfo)
1025                         {
1026                                 AppLog("PackageAppFilter - AppId [%ls]", pPackageAppInfo->GetAppId().GetPointer());
1027
1028                                 std::unique_ptr< AppId > pAppId(new (std::nothrow) AppId(pPackageAppInfo->GetAppId()));
1029                                 appIdList.Add(pAppId.release());
1030                         }
1031                 }
1032
1033                 for (int j = 0; j < metadataList.GetCount(); j++)
1034                 {
1035                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(metadataList.GetAt(j));
1036                         if (pPackageAppInfo)
1037                         {
1038                                 AppId appId = pPackageAppInfo->GetAppId();
1039
1040                                 if (appIdList.Contains(appId) == true)
1041                                 {
1042                                         AppLog("AppId [%ls] is matched.", appId.GetPointer());
1043
1044                                         std::unique_ptr< PackageAppInfo > pAppInfo(new (std::nothrow) PackageAppInfo);
1045                                         SysTryCatch(NID_APP, pAppInfo, , E_OUT_OF_MEMORY, "pAppInfo is null.");
1046
1047                                         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pAppInfo.get());
1048                                         pPackageAppInfoImpl->Construct(appId);
1049
1050                                         pList->Add(pAppInfo.release());
1051                                 }
1052                                 else
1053                                 {
1054                                         AppLog("AppId [%ls] is not matched.", pPackageAppInfo->GetAppId().GetPointer());
1055                                 }
1056                         }
1057                 }
1058         }
1059
1060 CATCH:
1061         if (handle)
1062         {
1063                 pkgmgrinfo_appinfo_filter_destroy(handle);
1064         }
1065
1066         if (metaHandle)
1067         {
1068                 pkgmgrinfo_appinfo_metadata_filter_destroy(metaHandle);
1069         }
1070
1071         if (pList->GetCount() <= 0)
1072         {
1073                 AppLog("pList's count is 0.");
1074                 return null;
1075         }
1076
1077         return pList.release();
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         SysLog(NID_APP, "appId = [%s]", pAppId);
1205
1206         std::unique_ptr<PackageAppInfo> pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1207         SysTryReturn(NID_APP, pPackageAppInfo, 0, E_OUT_OF_MEMORY, "pPackageAppInfo instance must not be null.");
1208
1209         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1210         r = pPackageAppInfoImpl->Construct(pAppId);
1211         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pAppId);
1212
1213         pList->Add(*pPackageAppInfo.release());
1214
1215         return 0;
1216 }
1217
1218 int
1219 _PackageManagerImpl::PackageAppInfoMetadataHandler(const pkgmgrinfo_appinfo_h handle, void* pUserData)
1220 {
1221         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
1222         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
1223
1224         result r = E_SUCCESS;
1225         int res = PMINFO_R_OK;
1226         char* pAppId = null;
1227         ArrayList* pList = (ArrayList*)pUserData;
1228
1229         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
1230         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_appinfo_get_appid is failed. [%d]", res);
1231
1232         SysLog(NID_APP, "appId = [%s]", pAppId);
1233
1234         std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1235         SysTryReturn(NID_APP, pPackageAppInfo, 0, E_OUT_OF_MEMORY, "pPackageAppInfo instance must not be null.");
1236
1237         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1238         r = pPackageAppInfoImpl->Construct(pAppId);
1239         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pAppId);
1240
1241         pList->Add(*pPackageAppInfo.release());
1242
1243         return 0;
1244 }
1245
1246 _PackageManagerImpl*
1247 _PackageManagerImpl::GetInstance(void)
1248 {
1249         return PackageManager::GetInstance()->__pPackageManagerImpl;
1250 }
1251
1252 result
1253 _PackageManagerImpl::Construct(void)
1254 {
1255         ClearLastResult();
1256
1257         result r = __installationList.Construct();
1258         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "The memory is insufficient.");
1259
1260         return E_SUCCESS;
1261 }
1262
1263 _PackageManagerImpl::_PackageManagerImpl(void)
1264 :__pRequestClient(null),
1265 __pListeningClient(null)
1266 {
1267 }
1268
1269 _PackageManagerImpl::~_PackageManagerImpl(void)
1270 {
1271 }
1272
1273 void
1274 _PackageManagerImpl::SendPackageEvent(PackageType type, const PackageId& packageId, const char* pEventKey, const char* pEventValue)
1275 {
1276         result r = E_SUCCESS;
1277         bool install = true;
1278
1279         if (strcmp(pEventKey, "start") == 0)
1280         {
1281                 if ((strcmp(pEventValue, "install") == 0) || (strcmp(pEventValue, "uninstall") == 0))
1282                 {
1283                         String* pAppId = new (std::nothrow) String(packageId);
1284                         SysTryReturnVoidResult(NID_APP, pAppId != null, E_OUT_OF_MEMORY, "pAppId instance must not be null.");
1285
1286                         String* pOperation = new (std::nothrow) String(pEventValue);
1287                         SysTryReturnVoidResult(NID_APP, pOperation != null, E_OUT_OF_MEMORY, "pOperation instance must not be null.");
1288
1289                         r = __installationList.Add(*pAppId, *pOperation);
1290                         if (IsFailed(r))
1291                         {
1292                                 delete pAppId;
1293                                 delete pOperation;
1294                                 SysLog(NID_APP, "Failed to add installation condition.");
1295                                 SetLastResult(E_SYSTEM);
1296                                 return;
1297                         }
1298                 }
1299         }
1300         else if (strcmp(pEventKey, "end") == 0)
1301         {
1302                 String* pOperation = static_cast <String*>(__installationList.GetValue(packageId));
1303                 if (pOperation)
1304                 {
1305                         if (pOperation->Equals("uninstall", true) == true)
1306                         {
1307                                 install = false;
1308                         }
1309
1310                         r = __installationList.Remove(packageId, true);
1311                         if (IsFailed(r))
1312                         {
1313                                 SysLogException(NID_APP, r, "[%s] Remove Element [%ls] is failed from installing list.", GetErrorMessage(r), packageId.GetPointer());
1314                         }
1315                 }
1316         }
1317
1318         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
1319         SysTryReturnVoidResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
1320
1321         while (pEnum->MoveNext() == E_SUCCESS)
1322         {
1323                 _PackageManagerEvent*   pEvent = null;
1324                 pEnum->GetCurrent(pEvent);
1325                 if (pEvent)
1326                 {
1327                         _PackageManagerEventArg* pEventArg= new (std::nothrow) _PackageManagerEventArg();
1328                         SysTryReturnVoidResult(NID_APP, pEventArg, E_OUT_OF_MEMORY, "The memory is insufficient.");
1329
1330                         String eventKey(pEventKey);
1331                         String eventValue(pEventValue);
1332
1333                         pEventArg->__packageId = packageId;
1334                         pEventArg->__eventKey = eventKey;
1335                         pEventArg->__eventValue = eventValue;
1336                         pEventArg->__install = install;
1337
1338                         r = pEvent->Fire(*pEventArg);
1339                         if (r != E_SUCCESS)
1340                         {
1341                                 SysLog(NID_APP, "pEvent->Fire(*pEventArg) failed. [%s]", GetErrorMessage(r));
1342                         }
1343
1344                         SysLog(NID_APP, "PackageId = [%ls], Key = [%ls], Value = [%ls], install = [%d]", pEventArg->__packageId.GetPointer(), pEventArg->__eventKey.GetPointer(), pEventArg->__eventValue.GetPointer(), pEventArg->__install);
1345                 }
1346                 else
1347                 {
1348                         SysLog(NID_APP, "pEvent is null.");
1349                 }
1350         }
1351 }
1352
1353 PackageInfo*
1354 _PackageManagerImpl::GetPackageInfoN(PackageType packageType, const String& packageName) const
1355 {
1356         SysTryReturn(NID_APP, packageName.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] packageName is empty.");
1357
1358         result r = E_SUCCESS;
1359         Database db;
1360         DbStatement* pStmt = null;
1361         DbEnumerator* pEnum = null;
1362         String query;
1363         PackageInfo *pPackageInfo = null;
1364
1365         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());
1366
1367         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1368         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1369
1370         pStmt = CreateStatementN(db, query);
1371
1372         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1373
1374         pEnum = ExecuteStatementN(db, pStmt);
1375         if (pEnum != null)
1376         {
1377                 if (pEnum->MoveNext() == E_SUCCESS)
1378                 {
1379                         pPackageInfo = new (std::nothrow) PackageInfo;
1380                         SysTryReturn(NID_APP, pPackageInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
1381
1382                         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
1383
1384                         String id;
1385                         String appVersion;
1386                         String appType;
1387                         String appMimeType;
1388                         String appApiVersion;
1389                         String appName;
1390                         String appVendor;
1391                         String appDescription;
1392                         String appUrl;
1393                         String appCid;
1394                         String appRootPath;
1395                         int appStorageType = 0;
1396                         DateTime appInstallationTime;
1397                         String appIconPath;
1398
1399                         pEnum->GetStringAt(1, id);
1400                         pEnum->GetStringAt(3, appVersion);
1401                         pEnum->GetStringAt(4, appType);
1402                         pEnum->GetStringAt(5, appMimeType);
1403                         pEnum->GetStringAt(6, appApiVersion);
1404                         pEnum->GetStringAt(7, appName);
1405                         pEnum->GetStringAt(8, appVendor);
1406                         pEnum->GetStringAt(9, appDescription);
1407                         pEnum->GetStringAt(10, appUrl);
1408                         pEnum->GetStringAt(11, appCid);
1409                         pEnum->GetStringAt(16, appRootPath);
1410                         pEnum->GetIntAt(17, appStorageType);
1411                         pEnum->GetDateTimeAt(18, appInstallationTime);
1412                         pEnum->GetStringAt(21, appIconPath);
1413
1414                         pPackageInfoImpl->SetAppId(id);
1415                         pPackageInfoImpl->SetAppVersion(appVersion);
1416                         pPackageInfoImpl->SetAppMimeType(appMimeType);
1417                         pPackageInfoImpl->SetAppApiVersion(appApiVersion);
1418                         pPackageInfoImpl->SetAppName(appName);
1419                         pPackageInfoImpl->SetAppVendor(appVendor);
1420                         pPackageInfoImpl->SetAppDescription(appDescription);
1421                         pPackageInfoImpl->SetAppUrl(appUrl);
1422                         pPackageInfoImpl->SetAppCid(appCid);
1423                         pPackageInfoImpl->SetAppRootPath(appRootPath);
1424                         pPackageInfoImpl->SetAppStorageType(appStorageType);
1425                         pPackageInfoImpl->SetAppInstallationTime(appInstallationTime);
1426                         pPackageInfoImpl->SetAppIconPath(appIconPath);
1427                 }
1428
1429                 delete pEnum;
1430         }
1431         else
1432         {
1433                 r = E_OBJ_NOT_FOUND;
1434         }
1435
1436 CATCH:
1437         delete pStmt;
1438         return pPackageInfo;
1439 }
1440
1441 int
1442 _PackageManagerImpl::PackageInfoEventHandler(const pkgmgrinfo_pkginfo_h handle, void* pUserData)
1443 {
1444         SysTryReturn(NID_APP, handle != null, 0, E_SYSTEM, "[E_SYSTEM] handle must not be null.");
1445
1446         result r = E_SUCCESS;
1447         int result = 0;
1448         char* pPackage = null;
1449         ArrayList* pList = (ArrayList*)pUserData;
1450
1451         std::unique_ptr< PackageInfo > pPackageInfo(new (std::nothrow) PackageInfo);
1452         SysTryReturn(NID_APP, pPackageInfo, null, E_OUT_OF_MEMORY, "pPackageInfo instance must not be null.");
1453
1454         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
1455
1456         result = pkgmgrinfo_pkginfo_get_pkgname(handle, &pPackage);
1457         if (result == 0)
1458         {
1459                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname(): package = [%s]", pPackage);
1460         }
1461         else
1462         {
1463                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname() is failed. result = [%d]", result);
1464         }
1465
1466         r = pPackageInfoImpl->Construct(pPackage);
1467         SysTryReturn(NID_APP, r == E_SUCCESS, -1, E_SYSTEM, "pPackageInfoImpl->Construct() failed.");
1468
1469         r = pList->Add(*pPackageInfo.release());
1470         SysTryReturn(NID_APP, r == E_SUCCESS, -1, E_SYSTEM, "pList->Add() failed.");
1471
1472         return result;
1473 }
1474
1475 IList*
1476 _PackageManagerImpl::GetFilteredAppIdListN(const String& feature, const String& value) const
1477 {
1478         result r = E_SUCCESS;
1479         Database db;
1480         DbStatement* pStmt = null;
1481         DbEnumerator* pEnum = null;
1482         String query;
1483         ArrayList* pList = null;
1484
1485         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());
1486
1487         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1488         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1489
1490         pStmt = CreateStatementN(db, query);
1491         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1492
1493         pEnum = ExecuteStatementN(db, pStmt);
1494
1495         if (pEnum != null)
1496         {
1497                 pList = new (std::nothrow) ArrayList();
1498                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1499                 pList->Construct();
1500
1501                 while (pEnum->MoveNext() == E_SUCCESS)
1502                 {
1503                         String* pPackageName = new (std::nothrow) String;
1504                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1505
1506                         pEnum->GetStringAt(0, *pPackageName);
1507
1508                         pList->Add(*pPackageName);
1509                 }
1510
1511                 delete pEnum;
1512
1513         }
1514         else
1515         {
1516                 r = E_OBJ_NOT_FOUND;
1517         }
1518
1519 CATCH:
1520         delete pStmt;
1521         return pList;
1522 }
1523
1524 IList*
1525 _PackageManagerImpl::GetDataControlInfoN(const String& providerId, const String& type) const
1526 {
1527         result r = E_SUCCESS;
1528         Database db;
1529         DbStatement* pStmt = null;
1530         DbEnumerator* pEnum = null;
1531         String query;
1532         ArrayList* pList = null;
1533
1534         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());
1535
1536         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1537         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1538
1539         pStmt = CreateStatementN(db, query);
1540         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1541
1542         pEnum = ExecuteStatementN(db, pStmt);
1543
1544         if (pEnum != null)
1545         {
1546                 pList = new (std::nothrow) ArrayList();
1547                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1548                 pList->Construct();
1549
1550                 while (pEnum->MoveNext() == E_SUCCESS)
1551                 {
1552                         String* pPackageName = new (std::nothrow) String;
1553                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1554
1555                         String* pAccess = new (std::nothrow) String;
1556                         SysTryReturn(NID_APP, pAccess != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pAccess instance must not be null.");
1557
1558                         pEnum->GetStringAt(0, *pPackageName);
1559                         pList->Add(*pPackageName);
1560
1561                         pEnum->GetStringAt(1, *pAccess);
1562                         pList->Add(*pAccess);
1563                 }
1564
1565                 delete pEnum;
1566
1567         }
1568         else
1569         {
1570                 r = E_OBJ_NOT_FOUND;
1571         }
1572
1573 CATCH:
1574         delete pStmt;
1575         return pList;
1576 }
1577
1578 IMap*
1579 _PackageManagerImpl::GetUiThemeListN(const PackageId& packageId) const
1580 {
1581         result r = E_SUCCESS;
1582         Database db;
1583         DbStatement* pStmt = null;
1584         DbEnumerator* pEnum = null;
1585         String query;
1586         HashMap* pList = null;
1587
1588         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')"
1589                         , packageId.GetPointer());
1590
1591         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1592         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1593
1594         pStmt = CreateStatementN(db, query);
1595         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1596
1597         pEnum = ExecuteStatementN(db, pStmt);
1598
1599         if (pEnum != null)
1600         {
1601                 pList = new (std::nothrow) HashMap();
1602                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "HashMap creation failure.");
1603                 pList->Construct();
1604
1605                 while (pEnum->MoveNext() == E_SUCCESS)
1606                 {
1607                         String* pName = new (std::nothrow) String;
1608                         SysTryCatch(NID_APP, pName != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pName instance must not be null.");
1609
1610                         String* pValue = new (std::nothrow) String;
1611                         SysTryCatch(NID_APP, pValue != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pValue instance must not be null.");
1612
1613                         pEnum->GetStringAt(0, *pName);
1614                         pEnum->GetStringAt(1, *pValue);
1615
1616                         pList->Add(*pName, *pValue);
1617                 }
1618
1619                 delete pEnum;
1620
1621         }
1622         else
1623         {
1624                 r = E_OBJ_NOT_FOUND;
1625         }
1626
1627 CATCH:
1628         delete pStmt;
1629         return pList;
1630 }
1631
1632 bool
1633 _PackageManagerImpl::IsAppInstalled(const AppId& appId)
1634 {
1635         if (appId == _AppInfo::GetPackageId())
1636         {
1637                 return true;
1638         }
1639
1640         int result = 0;
1641         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
1642
1643         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(appId));
1644         SysTryReturn(NID_APP, pPackageId, false, E_OUT_OF_MEMORY, "pPackageId is null");
1645
1646         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
1647         SysTryReturn(NID_APP, result == 0, false, E_APP_NOT_INSTALLED, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", result, pPackageId.get());
1648
1649         if(pPackageInfoHandle)
1650         {
1651                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
1652         }
1653
1654         return true;
1655 }
1656
1657 int
1658 _PackageManagerImpl::PackageEventHandler(int req_id, const char* pkg_type, const char* pkg_name,
1659                                                                                 const char* key, const char* val, const void* pmsg, void* data)
1660 {
1661         SysLog(NID_APP, "PackageEventHandler - req_id: %d, pkg_type: %s, pkg_name: %s, key: %s, val: %s", req_id, pkg_type,
1662                                 pkg_name, key, val);
1663
1664         PackageType type = PACKAGE_TYPE_TPK;
1665         PackageId packageId(pkg_name);
1666
1667         if (strcmp(pkg_type, "tpk") == 0)
1668         {
1669                 type = PACKAGE_TYPE_TPK;
1670         }
1671         else if (strcmp(pkg_type, "wgt") == 0)
1672         {
1673                 type = PACKAGE_TYPE_WGT;
1674         }
1675         else
1676         {
1677                 SysLog(NID_APP, "Invalid type - pkg_type: %s", pkg_type);
1678                 return 0;
1679         }
1680
1681         _PackageManagerImpl* pThis = _PackageManagerImpl::GetInstance();
1682         pThis->SendPackageEvent(type, packageId, key, val);
1683
1684         return 0;
1685 }
1686
1687 String*
1688 _PackageManagerImpl::GetAppIdOfDataControlN(const String& providerId)
1689 {
1690         result r = E_SUCCESS;
1691         Database db;
1692         DbStatement* pStmt = null;
1693         DbEnumerator* pEnum = null;
1694         String query;
1695         String* pAppId = null;
1696
1697         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",
1698                         providerId.GetPointer());
1699
1700         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1701         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1702
1703         pStmt = CreateStatementN(db, query);
1704         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1705
1706         pEnum = ExecuteStatementN(db, pStmt);
1707
1708         if (pEnum != null)
1709         {
1710                 if (pEnum->MoveNext() == E_SUCCESS)
1711                 {
1712                         pAppId = new (std::nothrow) String;
1713                         SysTryReturn(NID_APP, pAppId != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
1714
1715                         pEnum->GetStringAt(0, *pAppId);
1716                 }
1717
1718                 delete pEnum;
1719         }
1720
1721 CATCH:
1722         delete pStmt;
1723         return pAppId;
1724 }
1725
1726 PackageInfo*
1727 _PackageManagerImpl::GetPackageInfoN(const String& providerId, const String& operationId) const
1728 {
1729         result r = E_SUCCESS;
1730         PackageInfo* pPkgInfo = null;
1731         Database db;
1732         DbStatement* pStmt = null;
1733         DbEnumerator* pEnum = null;
1734         String query;
1735
1736         query.Format(1024, L"SELECT PkgInfo.PKG_ID FROM PkgInfo, AppInfo, AppInfoLookup, AppControl, Capability "
1737                         "WHERE AppControl.PROVIDER_ID ='%ls' and Capability.OPERATION_ID ='%ls' and AppControl.ID = AppInfoLookup.AppControlID "
1738                         "and Capability.ID = AppInfoLookup.CapabilityID and AppInfoLookup.AppInfoID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID "
1739                         "GROUP BY AppInfoID"
1740                         , providerId.GetPointer(), operationId.GetPointer());
1741
1742         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1743         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1744
1745         pStmt = CreateStatementN(db, query);
1746         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1747
1748         pEnum = ExecuteStatementN(db, pStmt);
1749         if (pEnum != null)
1750         {
1751                 if (pEnum->MoveNext() == E_SUCCESS)
1752                 {
1753                         PackageId packageId;
1754                         pEnum->GetStringAt(0, packageId);
1755
1756                         pPkgInfo = GetPackageInfoN(packageId);
1757                 }
1758
1759                 delete pEnum;
1760         }
1761         else
1762         {
1763                 r = E_OBJ_NOT_FOUND;
1764         }
1765
1766 CATCH:
1767         delete pStmt;
1768         return pPkgInfo;
1769 }
1770
1771 ArrayList*
1772 _PackageManagerImpl::GetPackageAppInfoImplListN(const String& packageId) const
1773 {
1774         result r = E_SUCCESS;
1775         Database db;
1776         DbStatement* pStmt = null;
1777         DbEnumerator* pEnum = null;
1778         String query;
1779         //int id = 0;
1780         PackageInfo* pPkgInfo = null;
1781         _PackageInfoImpl* pPackageInfoImpl = null;
1782         ArrayList* pList = null;
1783
1784         pPkgInfo = GetPackageInfoN(packageId);
1785         SysTryCatch(NID_APP, pPkgInfo != null, , r, "[%s] GetPackageInfoN() is failed", GetErrorMessage(r));
1786
1787         pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPkgInfo);
1788         query.Format(1024, L"SELECT * FROM AppInfo WHERE ID = %d", pPackageInfoImpl->GetUniqueId());
1789
1790         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1791         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1792
1793         pStmt = CreateStatementN(db, query);
1794         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1795                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1796
1797         pEnum = ExecuteStatementN(db, pStmt);
1798
1799         if (pEnum != null)
1800         {
1801                 pList = new (std::nothrow) ArrayList;
1802                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
1803
1804                 pList->Construct();
1805
1806                 while (pEnum->MoveNext() == E_SUCCESS)
1807                 {
1808                         _PackageAppInfoImpl* pPackageAppInfoImpl = new (std::nothrow) _PackageAppInfoImpl;
1809                         SysTryReturn(NID_APP, pPackageAppInfoImpl != null, null, E_OUT_OF_MEMORY, "pPackageAppInfoImpl instance must not be null.");
1810
1811                         int uniqueId = 0;
1812                         int pkgId = 0;
1813                         String name;
1814                         String defaultapp;
1815                         String mainmenuIcon;
1816                         String settingIcon;
1817                         String quickpanelIcon;
1818                         int appFeature = 0;
1819                         String packageName;
1820
1821                         pEnum->GetIntAt(0, uniqueId);
1822                         pEnum->GetIntAt(1, pkgId);
1823                         pEnum->GetStringAt(2, name);
1824                         pEnum->GetStringAt(3, defaultapp);
1825                         pEnum->GetStringAt(4, mainmenuIcon);
1826                         pEnum->GetStringAt(5, settingIcon);
1827                         pEnum->GetStringAt(7, quickpanelIcon);
1828                         pEnum->GetIntAt(9, appFeature);
1829                         pEnum->GetStringAt(10, packageName);
1830
1831                         pPackageAppInfoImpl->SetUniqueId(uniqueId);
1832                         pPackageAppInfoImpl->SetPkgId(pkgId);
1833                         pPackageAppInfoImpl->SetName(name);
1834                         pPackageAppInfoImpl->SetDefault(defaultapp);
1835                         pPackageAppInfoImpl->SetMainmenuIcon(mainmenuIcon);
1836                         pPackageAppInfoImpl->SetSettingIcon(settingIcon);
1837                         pPackageAppInfoImpl->SetQuickpanelIcon(quickpanelIcon);
1838                         pPackageAppInfoImpl->SetAppFeature(appFeature);
1839                         pPackageAppInfoImpl->SetPackageName(packageName);
1840
1841                         pList->Add(*pPackageAppInfoImpl);
1842                 }
1843
1844                 delete pEnum;
1845         }
1846
1847 CATCH:
1848         delete pPkgInfo;
1849         delete pStmt;
1850         return pList;
1851 }
1852
1853 ArrayList*
1854 _PackageManagerImpl::GetPackageAppFeatureListN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
1855 {
1856         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
1857         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
1858
1859         ArrayList* pResult = null;
1860
1861         for (int i = 0; i < pAppInfoList->GetCount(); i++)
1862         {
1863                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pAppInfoList->GetAt(i));
1864                 if (pAppInfoImpl == null)
1865                 {
1866                         continue;
1867                 }
1868
1869                 if (pAppInfoImpl->GetName() == appExecutableName)
1870                 {
1871                         pResult = pAppInfoImpl->GetAppFeatureListN();
1872                         goto OUT;
1873                 }
1874         }
1875
1876 OUT:
1877         pAppInfoList->RemoveAll(true);
1878         delete pAppInfoList;
1879
1880         return pResult;
1881 }
1882
1883 HashMapT<String, _AppFeatureInfoImpl*>*
1884 _PackageManagerImpl::GetPackageAppFeatureMapN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
1885 {
1886         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
1887         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
1888
1889         HashMapT<String, _AppFeatureInfoImpl*>* pResult = null;
1890
1891         std::auto_ptr<IEnumerator> pEnum(pAppInfoList->GetEnumeratorN());
1892
1893         while (pEnum->MoveNext() == E_SUCCESS)
1894         {
1895                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pEnum->GetCurrent());
1896                 if (pAppInfoImpl == null)
1897                 {
1898                         continue;
1899                 }
1900
1901                 if (pAppInfoImpl->GetName() == appExecutableName)
1902                 {
1903                         pResult = pAppInfoImpl->GetAppFeatureMapN();
1904                         goto OUT;
1905                 }
1906         }
1907
1908 OUT:
1909         pAppInfoList->RemoveAll(true);
1910         delete pAppInfoList;
1911
1912         return pResult;
1913 }
1914
1915 ArrayList*
1916 _PackageManagerImpl::GetAppLaunchConditionListN(const String& packageName) const
1917 {
1918         result r = E_SUCCESS;
1919         Database db;
1920         DbStatement* pStmt = null;
1921         DbEnumerator* pEnum = null;
1922         String query;
1923         ArrayList* pList = null;
1924
1925         query.Format(1024, L"SELECT LaunchCondition.* FROM LaunchCondition, AppInfo WHERE AppInfo.UNIQUE_ID = LaunchCondition.ID and AppInfo.PACKAGE_NAME = '%ls'", packageName.GetPointer());
1926
1927         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1928         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1929
1930         pStmt = CreateStatementN(db, query);
1931         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1932                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1933
1934         pEnum = ExecuteStatementN(db, pStmt);
1935         if (pEnum != null)
1936         {
1937                 pList = new (std::nothrow) ArrayList;
1938                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
1939
1940                 pList->Construct();
1941
1942                 while (pEnum->MoveNext() == E_SUCCESS)
1943                 {
1944                         _LaunchConditionInfoImpl* pLaunchCondtion = new (std::nothrow) _LaunchConditionInfoImpl;
1945                         SysTryReturn(NID_APP, pLaunchCondtion != null, null, E_OUT_OF_MEMORY, "pLaunchCondtion instance must not be null.");
1946
1947                         String name;
1948                         String value;
1949
1950                         pEnum->GetStringAt(1, name);
1951                         pEnum->GetStringAt(2, value);
1952
1953                         pLaunchCondtion->SetName(name);
1954                         pLaunchCondtion->SetValue(value);
1955
1956                         pList->Add(*pLaunchCondtion);
1957
1958                         SysLog(NID_APP, "Name[%ls], Value[%ls]", name.GetPointer(), value.GetPointer());
1959                 }
1960
1961                 delete pEnum;
1962         }
1963
1964 CATCH:
1965         delete pStmt;
1966         return pList;
1967 }
1968
1969 result
1970 _PackageManagerImpl::GetPackageName(const PackageId& packageId, const String* pName, char* pPackageName, int bufferSize)
1971 {
1972         result r = E_SUCCESS;
1973         Database db;
1974         DbStatement* pStmt = null;
1975         DbEnumerator* pEnum = null;
1976         String query;
1977         Tizen::Base::String packageName;
1978
1979         if (pName == null)
1980         {
1981                 query.Format(
1982                         1024,
1983                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
1984                         "True", packageId.GetPointer());
1985         }
1986         else
1987         {
1988                 query.Format(
1989                         1024,
1990                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and APP_NAME = '%ls' and PkgInfo.PKG_ID = '%ls'",
1991                         pName->GetPointer(), packageId.GetPointer());
1992         }
1993
1994         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1995         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1996
1997         pStmt = CreateStatementN(db, query);
1998         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1999                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2000
2001         pEnum = ExecuteStatementN(db, pStmt);
2002         if (pEnum != null)
2003         {
2004                 if (pEnum->MoveNext() == E_SUCCESS)
2005                 {
2006                         pEnum->GetStringAt(0, packageName);
2007                         snprintf(pPackageName, bufferSize, "%ls", packageName.GetPointer());
2008                 }
2009                 delete pEnum;
2010         }
2011         else
2012         {
2013                 r = E_OBJ_NOT_FOUND;
2014         }
2015
2016 CATCH:
2017         delete pStmt;
2018
2019         return r;
2020 }
2021
2022 String
2023 _PackageManagerImpl::GetDefaultAppExecutableName(const PackageId& packageId)
2024 {
2025         result r = E_SUCCESS;
2026         Database db;
2027         DbStatement* pStmt = null;
2028         DbEnumerator* pEnum = null;
2029         String query;
2030         String executableName;
2031
2032         query.Format(
2033                 1024,
2034                 L"SELECT AppInfo.APP_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
2035                 "True", packageId.GetPointer());
2036
2037         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2038         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2039
2040         pStmt = CreateStatementN(db, query);
2041         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2042                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2043
2044         pEnum = ExecuteStatementN(db, pStmt);
2045         if (pEnum != null)
2046         {
2047                 if (pEnum->MoveNext() == E_SUCCESS)
2048                 {
2049                         pEnum->GetStringAt(0, executableName);
2050                 }
2051                 delete pEnum;
2052         }
2053         else
2054         {
2055                 r = E_OBJ_NOT_FOUND;
2056                 SetLastResult(r);
2057         }
2058
2059 CATCH:
2060         delete pStmt;
2061
2062         return executableName;
2063 }
2064
2065 DbStatement*
2066 _PackageManagerImpl::CreateStatementN(Database& db, const String& query)
2067 {
2068         result r = E_SUCCESS;
2069         DbStatement* pStmt = null;
2070
2071         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2072         {
2073                 pStmt = db.CreateStatementN(query);
2074                 r = GetLastResult();
2075
2076                 if (r != E_OBJECT_LOCKED)
2077                 {
2078                         break;
2079                 }
2080                 else
2081                 {
2082                         SysLog(NID_APP, "RetryCount[%d] CreateStatementN - E_OBJECT_LOCKED", i);
2083                         delete pStmt;
2084                         pStmt = null;
2085                         usleep(50000);
2086                 }
2087         }
2088
2089         return pStmt;
2090 }
2091
2092 DbEnumerator*
2093 _PackageManagerImpl::ExecuteStatementN(Database& db, const DbStatement* pStmt)
2094 {
2095         result r = E_SUCCESS;
2096         DbEnumerator* pEnum = null;
2097
2098         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2099         {
2100                 pEnum = db.ExecuteStatementN(*pStmt);
2101                 r = GetLastResult();
2102
2103                 if (r != E_OBJECT_LOCKED)
2104                 {
2105                         break;
2106                 }
2107                 else
2108                 {
2109                         SysLog(NID_APP, "RetryCount[%d] ExecuteStatementN - E_OBJECT_LOCKED", i);
2110                         delete pEnum;
2111                         pEnum = null;
2112                         usleep(50000);
2113                 }
2114         }
2115
2116         return pEnum;
2117 }
2118
2119 } } } // Tizen::App::Package