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_HOMEAPP || (*pKey) == PACKAGE_APP_FILTER_CATEGORY_LOCKAPP
 957                                                 || (*pKey) == PACKAGE_APP_FILTER_CATEGORY_MENUAPP)
 958                 {
 959                         definedKey = true;
 960
 961                         std::unique_ptr<char[]> pDefinedKey(_StringConverter::CopyToCharArrayN(*pKey));
 962                         SysTryCatch(NID_APP, pDefinedKey, , E_OUT_OF_MEMORY, "pDefinedKey is null.");
 963
 964                         Boolean* pVal = static_cast< Boolean* >(pEnum->GetValue());
 965                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 966
 967                         SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), pVal->ToBool());
 968                         SysTryCatch(NID_APP, pVal->ToBool() == true, , E_INVALID_ARG, "Value(false) is not allowed.");
 969
 970                         res = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_CATEGORY, pDefinedKey.get());
 971                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_add_string(CATEGORY, %s) is failed. [%d]", pDefinedKey.get(), res);
 972                 }
 973                 else
 974                 {
 975                         metadataKey = true;
 976
 977                         String* pVal = static_cast< String* >(pEnum->GetValue());
 978                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 979
 980                         SysLog(NID_APP, "Key[%ls], Value[%ls]", pKey->GetPointer(), pVal->GetPointer());
 981
 982                         std::unique_ptr<char[]> pMetaKey(_StringConverter::CopyToCharArrayN(*pKey));
 983                         SysTryCatch(NID_APP, pMetaKey, , E_OUT_OF_MEMORY, "pMetaKey is null.");
 984
 985                         std::unique_ptr<char[]> pValue(_StringConverter::CopyToCharArrayN(*pVal));
 986                         SysTryCatch(NID_APP, pValue, , E_OUT_OF_MEMORY, "pValue is null.");
 987
 988                         if ((*pVal) == L"*")
 989                         {
 990                                 res = pkgmgrinfo_appinfo_metadata_filter_add(metaHandle, pMetaKey.get(), null);
 991                                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_add(%s, null) is failed. [%d]", pMetaKey.get(), res);
 992                         }
 993                         else
 994                         {
 995                                 res = pkgmgrinfo_appinfo_metadata_filter_add(metaHandle, pMetaKey.get(), pValue.get());
 996                                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_add(%s, %s) is failed. [%d]", pMetaKey.get(), pValue.get(), res);
 997                         }
 998                 }
 999         }
1000
1001         if ((definedKey == true) && (metadataKey == false))
1002         {
1003                 res = pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, PackageAppInfoHandler, pList.get());
1004                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_foreach_appinfo() failed. [%d]", res);
1005         }
1006         else if ((definedKey == false) && (metadataKey == true))
1007         {
1008                 res = pkgmgrinfo_appinfo_metadata_filter_foreach(metaHandle, PackageAppInfoMetadataHandler, pList.get());
1009                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_foreach() failed. [%d]", res);
1010         }
1011         else
1012         {
1013                 list.Construct();
1014
1015                 res = pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, PackageAppInfoHandler, &list);
1016                 if (res != PMINFO_R_OK)
1017                 {
1018                         SysLog(NID_APP, "pkgmgrinfo_appinfo_filter_foreach_appinfo() is failed. result = [%d]", res);
1019                         goto CATCH;
1020                 }
1021
1022                 metadataList.Construct();
1023
1024                 res = pkgmgrinfo_appinfo_metadata_filter_foreach(metaHandle, PackageAppInfoMetadataHandler, &metadataList);
1025                 if (res != PMINFO_R_OK)
1026                 {
1027                         SysLog(NID_APP, "pkgmgrinfo_appinfo_metadata_filter_foreach() is failed. result = [%d]", res);
1028                         goto CATCH;
1029                 }
1030
1031                 for (int i = 0; i < list.GetCount(); i++)
1032                 {
1033                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(list.GetAt(i));
1034                         if (pPackageAppInfo)
1035                         {
1036                                 AppLog("PackageAppFilter - AppId [%ls]", pPackageAppInfo->GetAppId().GetPointer());
1037
1038                                 std::unique_ptr< AppId > pAppId(new (std::nothrow) AppId(pPackageAppInfo->GetAppId()));
1039                                 appIdList.Add(pAppId.release());
1040                         }
1041                 }
1042
1043                 for (int j = 0; j < metadataList.GetCount(); j++)
1044                 {
1045                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(metadataList.GetAt(j));
1046                         if (pPackageAppInfo)
1047                         {
1048                                 AppId appId = pPackageAppInfo->GetAppId();
1049
1050                                 if (appIdList.Contains(appId) == true)
1051                                 {
1052                                         AppLog("AppId [%ls] is matched.", appId.GetPointer());
1053
1054                                         std::unique_ptr< PackageAppInfo > pAppInfo(new (std::nothrow) PackageAppInfo);
1055                                         SysTryCatch(NID_APP, pAppInfo, , E_OUT_OF_MEMORY, "pAppInfo is null.");
1056
1057                                         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pAppInfo.get());
1058                                         pPackageAppInfoImpl->Construct(appId);
1059
1060                                         pList->Add(pAppInfo.release());
1061                                 }
1062                                 else
1063                                 {
1064                                         AppLog("AppId [%ls] is not matched.", pPackageAppInfo->GetAppId().GetPointer());
1065                                 }
1066                         }
1067                 }
1068         }
1069
1070 CATCH:
1071         if (handle)
1072         {
1073                 pkgmgrinfo_appinfo_filter_destroy(handle);
1074         }
1075
1076         if (metaHandle)
1077         {
1078                 pkgmgrinfo_appinfo_metadata_filter_destroy(metaHandle);
1079         }
1080
1081         if (pList->GetCount() <= 0)
1082         {
1083                 AppLog("pList's count is 0.");
1084                 return null;
1085         }
1086
1087         return pList.release();
1088 }
1089
1090 IList*
1091 _PackageManagerImpl::GetPackageAppInfoListN(const IMap& packageFilterMap, const IMap& packageAppFilterMap) const
1092 {
1093         SysTryReturn(NID_APP, packageFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageFilterMap Count is invalid.");
1094         SysTryReturn(NID_APP, packageAppFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageAppFilterMap Count is invalid.");
1095
1096         ArrayList appIdList;
1097
1098         std::unique_ptr< IList > pPackageFilterList(GetPackageInfoListN(packageFilterMap));
1099         if (pPackageFilterList == null)
1100         {
1101                 SysLog(NID_APP, "GetPackageInfoListN(packageFilterMap) is null.");
1102                 return null;
1103         }
1104
1105         for (int i = 0; i < pPackageFilterList->GetCount(); i++)
1106         {
1107                 PackageInfo* pPackageInfo = dynamic_cast < PackageInfo* >(pPackageFilterList->GetAt(i));
1108                 if (pPackageInfo)
1109                 {
1110                         std::unique_ptr< IList > pPackageAppInfoList(pPackageInfo->GetPackageAppInfoListN());
1111                         if (pPackageAppInfoList)
1112                         {
1113                                 for (int j = 0; j < pPackageAppInfoList->GetCount(); j++)
1114                                 {
1115                                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(pPackageAppInfoList->GetAt(j));
1116                                         if (pPackageAppInfo)
1117                                         {
1118                                                 AppLog("PackageFilter - AppId [%ls]", pPackageAppInfo->GetAppId().GetPointer());
1119
1120                                                 std::unique_ptr< AppId > pAppId(new (std::nothrow) AppId(pPackageAppInfo->GetAppId()));
1121                                                 appIdList.Add(pAppId.release());
1122                                         }
1123                                 }
1124                         }
1125                 }
1126         }
1127
1128         std::unique_ptr< ArrayList > pList(new (std::nothrow) ArrayList);
1129         SysTryReturn(NID_APP, pList, null, E_OUT_OF_MEMORY, "pList is null.");
1130
1131         std::unique_ptr< IList > pAppFilterList(GetPackageAppInfoListN(packageAppFilterMap));
1132         if (pAppFilterList == null)
1133         {
1134                 SysLog(NID_APP, "GetPackageAppInfoListN(packageAppFilterMap) is null.");
1135                 return null;
1136         }
1137
1138         for (int k = 0; k < pAppFilterList->GetCount(); k++)
1139         {
1140                 PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(pAppFilterList->GetAt(k));
1141                 if (pPackageAppInfo)
1142                 {
1143                         AppId appId = pPackageAppInfo->GetAppId();
1144                         AppLog("AppFilter - AppId [%ls]", appId.GetPointer());
1145
1146                         if (appIdList.Contains(appId) == true)
1147                         {
1148                                 AppLog("AppId [%ls] is matched.", appId.GetPointer());
1149
1150                                 std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1151                                 SysTryReturn(NID_APP, pPackageAppInfo, null, E_OUT_OF_MEMORY, "PackageAppInfo is null.");
1152
1153                                 _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1154                                 pPackageAppInfoImpl->Construct(appId);
1155
1156                                 pList->Add(pPackageAppInfo.release());
1157                         }
1158                         else
1159                         {
1160                                 AppLog("AppId [%ls] is not matched.", pPackageAppInfo->GetAppId().GetPointer());
1161                         }
1162                 }
1163         }
1164
1165         if (pList->GetCount() <= 0)
1166         {
1167                 AppLog("pList's count is 0.");
1168                 return null;
1169         }
1170
1171         return pList.release();
1172 }
1173
1174 int
1175 _PackageManagerImpl::PackageInfoHandler(const pkgmgrinfo_pkginfo_h handle, void* pUserData)
1176 {
1177         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
1178         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
1179
1180         result r = E_SUCCESS;
1181         int res = PMINFO_R_OK;
1182         char* pPackageId = null;
1183         ArrayList* pList = (ArrayList*)pUserData;
1184
1185         res = pkgmgrinfo_pkginfo_get_pkgname(handle, &pPackageId);
1186         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkgname() is failed. [%d]", res);
1187
1188         std::unique_ptr<PackageInfo> pPackageInfo(new (std::nothrow) PackageInfo);
1189         SysTryReturn(NID_APP, pPackageInfo, 0, E_OUT_OF_MEMORY, "pPackageInfo instance must not be null.");
1190
1191         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
1192         r = pPackageInfoImpl->Construct(pPackageId);
1193         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pPackageId);
1194
1195         pList->Add(*pPackageInfo.release());
1196
1197         return 0;
1198 }
1199
1200 int
1201 _PackageManagerImpl::PackageAppInfoHandler(const pkgmgrinfo_appinfo_h handle, void* pUserData)
1202 {
1203         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
1204         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
1205
1206         result r = E_SUCCESS;
1207         int res = PMINFO_R_OK;
1208         char* pAppId = null;
1209         ArrayList* pList = (ArrayList*)pUserData;
1210
1211         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
1212         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_appinfo_get_appid is failed. [%d]", res);
1213
1214         SysLog(NID_APP, "appId = [%s]", pAppId);
1215
1216         std::unique_ptr<PackageAppInfo> pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1217         SysTryReturn(NID_APP, pPackageAppInfo, 0, E_OUT_OF_MEMORY, "pPackageAppInfo instance must not be null.");
1218
1219         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1220         r = pPackageAppInfoImpl->Construct(pAppId);
1221         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pAppId);
1222
1223         pList->Add(*pPackageAppInfo.release());
1224
1225         return 0;
1226 }
1227
1228 int
1229 _PackageManagerImpl::PackageAppInfoMetadataHandler(const pkgmgrinfo_appinfo_h handle, void* pUserData)
1230 {
1231         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
1232         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
1233
1234         result r = E_SUCCESS;
1235         int res = PMINFO_R_OK;
1236         char* pAppId = null;
1237         ArrayList* pList = (ArrayList*)pUserData;
1238
1239         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
1240         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_appinfo_get_appid is failed. [%d]", res);
1241
1242         SysLog(NID_APP, "appId = [%s]", pAppId);
1243
1244         std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1245         SysTryReturn(NID_APP, pPackageAppInfo, 0, E_OUT_OF_MEMORY, "pPackageAppInfo instance must not be null.");
1246
1247         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1248         r = pPackageAppInfoImpl->Construct(pAppId);
1249         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pAppId);
1250
1251         pList->Add(*pPackageAppInfo.release());
1252
1253         return 0;
1254 }
1255
1256 _PackageManagerImpl*
1257 _PackageManagerImpl::GetInstance(void)
1258 {
1259         return PackageManager::GetInstance()->__pPackageManagerImpl;
1260 }
1261
1262 result
1263 _PackageManagerImpl::Construct(void)
1264 {
1265         ClearLastResult();
1266
1267         result r = __installationList.Construct();
1268         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "The memory is insufficient.");
1269
1270         return E_SUCCESS;
1271 }
1272
1273 _PackageManagerImpl::_PackageManagerImpl(void)
1274 :__pRequestClient(null),
1275 __pListeningClient(null)
1276 {
1277 }
1278
1279 _PackageManagerImpl::~_PackageManagerImpl(void)
1280 {
1281 }
1282
1283 void
1284 _PackageManagerImpl::SendPackageEvent(PackageType type, const PackageId& packageId, const char* pEventKey, const char* pEventValue)
1285 {
1286         result r = E_SUCCESS;
1287         bool install = true;
1288
1289         if (strcmp(pEventKey, "start") == 0)
1290         {
1291                 if ((strcmp(pEventValue, "install") == 0) || (strcmp(pEventValue, "uninstall") == 0))
1292                 {
1293                         String* pAppId = new (std::nothrow) String(packageId);
1294                         SysTryReturnVoidResult(NID_APP, pAppId != null, E_OUT_OF_MEMORY, "pAppId instance must not be null.");
1295
1296                         String* pOperation = new (std::nothrow) String(pEventValue);
1297                         SysTryReturnVoidResult(NID_APP, pOperation != null, E_OUT_OF_MEMORY, "pOperation instance must not be null.");
1298
1299                         r = __installationList.Add(*pAppId, *pOperation);
1300                         if (IsFailed(r))
1301                         {
1302                                 delete pAppId;
1303                                 delete pOperation;
1304                                 SysLog(NID_APP, "Failed to add installation condition.");
1305                                 SetLastResult(E_SYSTEM);
1306                                 return;
1307                         }
1308                 }
1309         }
1310         else if (strcmp(pEventKey, "end") == 0)
1311         {
1312                 String* pOperation = static_cast <String*>(__installationList.GetValue(packageId));
1313                 if (pOperation)
1314                 {
1315                         if (pOperation->Equals("uninstall", true) == true)
1316                         {
1317                                 install = false;
1318                         }
1319
1320                         r = __installationList.Remove(packageId, true);
1321                         if (IsFailed(r))
1322                         {
1323                                 SysLogException(NID_APP, r, "[%s] Remove Element [%ls] is failed from installing list.", GetErrorMessage(r), packageId.GetPointer());
1324                         }
1325                 }
1326         }
1327
1328         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
1329         SysTryReturnVoidResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
1330
1331         while (pEnum->MoveNext() == E_SUCCESS)
1332         {
1333                 _PackageManagerEvent*   pEvent = null;
1334                 pEnum->GetCurrent(pEvent);
1335                 if (pEvent)
1336                 {
1337                         _PackageManagerEventArg* pEventArg= new (std::nothrow) _PackageManagerEventArg();
1338                         SysTryReturnVoidResult(NID_APP, pEventArg, E_OUT_OF_MEMORY, "The memory is insufficient.");
1339
1340                         String eventKey(pEventKey);
1341                         String eventValue(pEventValue);
1342
1343                         pEventArg->__packageId = packageId;
1344                         pEventArg->__eventKey = eventKey;
1345                         pEventArg->__eventValue = eventValue;
1346                         pEventArg->__install = install;
1347
1348                         r = pEvent->Fire(*pEventArg);
1349                         if (r != E_SUCCESS)
1350                         {
1351                                 SysLog(NID_APP, "pEvent->Fire(*pEventArg) failed. [%s]", GetErrorMessage(r));
1352                         }
1353
1354                         SysLog(NID_APP, "PackageId = [%ls], Key = [%ls], Value = [%ls], install = [%d]", pEventArg->__packageId.GetPointer(), pEventArg->__eventKey.GetPointer(), pEventArg->__eventValue.GetPointer(), pEventArg->__install);
1355                 }
1356                 else
1357                 {
1358                         SysLog(NID_APP, "pEvent is null.");
1359                 }
1360         }
1361 }
1362
1363 PackageInfo*
1364 _PackageManagerImpl::GetPackageInfoN(PackageType packageType, const String& packageName) const
1365 {
1366         SysTryReturn(NID_APP, packageName.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] packageName is empty.");
1367
1368         result r = E_SUCCESS;
1369         Database db;
1370         DbStatement* pStmt = null;
1371         DbEnumerator* pEnum = null;
1372         String query;
1373         PackageInfo *pPackageInfo = null;
1374
1375         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());
1376
1377         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1378         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1379
1380         pStmt = CreateStatementN(db, query);
1381
1382         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1383
1384         pEnum = ExecuteStatementN(db, pStmt);
1385         if (pEnum != null)
1386         {
1387                 if (pEnum->MoveNext() == E_SUCCESS)
1388                 {
1389                         pPackageInfo = new (std::nothrow) PackageInfo;
1390                         SysTryReturn(NID_APP, pPackageInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
1391
1392                         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
1393
1394                         String id;
1395                         String appVersion;
1396                         String appType;
1397                         String appMimeType;
1398                         String appApiVersion;
1399                         String appName;
1400                         String appVendor;
1401                         String appDescription;
1402                         String appUrl;
1403                         String appCid;
1404                         String appRootPath;
1405                         int appStorageType = 0;
1406                         DateTime appInstallationTime;
1407                         String appIconPath;
1408
1409                         pEnum->GetStringAt(1, id);
1410                         pEnum->GetStringAt(3, appVersion);
1411                         pEnum->GetStringAt(4, appType);
1412                         pEnum->GetStringAt(5, appMimeType);
1413                         pEnum->GetStringAt(6, appApiVersion);
1414                         pEnum->GetStringAt(7, appName);
1415                         pEnum->GetStringAt(8, appVendor);
1416                         pEnum->GetStringAt(9, appDescription);
1417                         pEnum->GetStringAt(10, appUrl);
1418                         pEnum->GetStringAt(11, appCid);
1419                         pEnum->GetStringAt(16, appRootPath);
1420                         pEnum->GetIntAt(17, appStorageType);
1421                         pEnum->GetDateTimeAt(18, appInstallationTime);
1422                         pEnum->GetStringAt(21, appIconPath);
1423
1424                         pPackageInfoImpl->SetAppId(id);
1425                         pPackageInfoImpl->SetAppVersion(appVersion);
1426                         pPackageInfoImpl->SetAppMimeType(appMimeType);
1427                         pPackageInfoImpl->SetAppApiVersion(appApiVersion);
1428                         pPackageInfoImpl->SetAppName(appName);
1429                         pPackageInfoImpl->SetAppVendor(appVendor);
1430                         pPackageInfoImpl->SetAppDescription(appDescription);
1431                         pPackageInfoImpl->SetAppUrl(appUrl);
1432                         pPackageInfoImpl->SetAppCid(appCid);
1433                         pPackageInfoImpl->SetAppRootPath(appRootPath);
1434                         pPackageInfoImpl->SetAppStorageType(appStorageType);
1435                         pPackageInfoImpl->SetAppInstallationTime(appInstallationTime);
1436                         pPackageInfoImpl->SetAppIconPath(appIconPath);
1437                 }
1438
1439                 delete pEnum;
1440         }
1441         else
1442         {
1443                 r = E_OBJ_NOT_FOUND;
1444         }
1445
1446 CATCH:
1447         delete pStmt;
1448         return pPackageInfo;
1449 }
1450
1451 int
1452 _PackageManagerImpl::PackageInfoEventHandler(const pkgmgrinfo_pkginfo_h handle, void* pUserData)
1453 {
1454         SysTryReturn(NID_APP, handle != null, 0, E_SYSTEM, "[E_SYSTEM] handle must not be null.");
1455
1456         result r = E_SUCCESS;
1457         int result = 0;
1458         char* pPackage = null;
1459         ArrayList* pList = (ArrayList*)pUserData;
1460
1461         std::unique_ptr< PackageInfo > pPackageInfo(new (std::nothrow) PackageInfo);
1462         SysTryReturn(NID_APP, pPackageInfo, null, E_OUT_OF_MEMORY, "pPackageInfo instance must not be null.");
1463
1464         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
1465
1466         result = pkgmgrinfo_pkginfo_get_pkgname(handle, &pPackage);
1467         if (result == 0)
1468         {
1469                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname(): package = [%s]", pPackage);
1470         }
1471         else
1472         {
1473                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname() is failed. result = [%d]", result);
1474         }
1475
1476         r = pPackageInfoImpl->Construct(pPackage);
1477         SysTryReturn(NID_APP, r == E_SUCCESS, -1, E_SYSTEM, "pPackageInfoImpl->Construct() failed.");
1478
1479         r = pList->Add(*pPackageInfo.release());
1480         SysTryReturn(NID_APP, r == E_SUCCESS, -1, E_SYSTEM, "pList->Add() failed.");
1481
1482         return result;
1483 }
1484
1485 IList*
1486 _PackageManagerImpl::GetFilteredAppIdListN(const String& feature, const String& value) const
1487 {
1488         result r = E_SUCCESS;
1489         Database db;
1490         DbStatement* pStmt = null;
1491         DbEnumerator* pEnum = null;
1492         String query;
1493         ArrayList* pList = null;
1494
1495         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());
1496
1497         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1498         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1499
1500         pStmt = CreateStatementN(db, query);
1501         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1502
1503         pEnum = ExecuteStatementN(db, pStmt);
1504
1505         if (pEnum != null)
1506         {
1507                 pList = new (std::nothrow) ArrayList();
1508                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1509                 pList->Construct();
1510
1511                 while (pEnum->MoveNext() == E_SUCCESS)
1512                 {
1513                         String* pPackageName = new (std::nothrow) String;
1514                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1515
1516                         pEnum->GetStringAt(0, *pPackageName);
1517
1518                         pList->Add(*pPackageName);
1519                 }
1520
1521                 delete pEnum;
1522
1523         }
1524         else
1525         {
1526                 r = E_OBJ_NOT_FOUND;
1527         }
1528
1529 CATCH:
1530         delete pStmt;
1531         return pList;
1532 }
1533
1534 IList*
1535 _PackageManagerImpl::GetDataControlInfoN(const String& providerId, const String& type) const
1536 {
1537         result r = E_SUCCESS;
1538         Database db;
1539         DbStatement* pStmt = null;
1540         DbEnumerator* pEnum = null;
1541         String query;
1542         ArrayList* pList = null;
1543
1544         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());
1545
1546         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1547         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1548
1549         pStmt = CreateStatementN(db, query);
1550         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1551
1552         pEnum = ExecuteStatementN(db, pStmt);
1553
1554         if (pEnum != null)
1555         {
1556                 pList = new (std::nothrow) ArrayList();
1557                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1558                 pList->Construct();
1559
1560                 while (pEnum->MoveNext() == E_SUCCESS)
1561                 {
1562                         String* pPackageName = new (std::nothrow) String;
1563                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1564
1565                         String* pAccess = new (std::nothrow) String;
1566                         SysTryReturn(NID_APP, pAccess != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pAccess instance must not be null.");
1567
1568                         pEnum->GetStringAt(0, *pPackageName);
1569                         pList->Add(*pPackageName);
1570
1571                         pEnum->GetStringAt(1, *pAccess);
1572                         pList->Add(*pAccess);
1573                 }
1574
1575                 delete pEnum;
1576
1577         }
1578         else
1579         {
1580                 r = E_OBJ_NOT_FOUND;
1581         }
1582
1583 CATCH:
1584         delete pStmt;
1585         return pList;
1586 }
1587
1588 IMap*
1589 _PackageManagerImpl::GetUiThemeListN(const PackageId& packageId) const
1590 {
1591         result r = E_SUCCESS;
1592         Database db;
1593         DbStatement* pStmt = null;
1594         DbEnumerator* pEnum = null;
1595         String query;
1596         HashMap* pList = null;
1597
1598         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')"
1599                         , packageId.GetPointer());
1600
1601         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1602         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1603
1604         pStmt = CreateStatementN(db, query);
1605         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1606
1607         pEnum = ExecuteStatementN(db, pStmt);
1608
1609         if (pEnum != null)
1610         {
1611                 pList = new (std::nothrow) HashMap();
1612                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "HashMap creation failure.");
1613                 pList->Construct();
1614
1615                 while (pEnum->MoveNext() == E_SUCCESS)
1616                 {
1617                         String* pName = new (std::nothrow) String;
1618                         SysTryCatch(NID_APP, pName != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pName instance must not be null.");
1619
1620                         String* pValue = new (std::nothrow) String;
1621                         SysTryCatch(NID_APP, pValue != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pValue instance must not be null.");
1622
1623                         pEnum->GetStringAt(0, *pName);
1624                         pEnum->GetStringAt(1, *pValue);
1625
1626                         pList->Add(*pName, *pValue);
1627                 }
1628
1629                 delete pEnum;
1630
1631         }
1632         else
1633         {
1634                 r = E_OBJ_NOT_FOUND;
1635         }
1636
1637 CATCH:
1638         delete pStmt;
1639         return pList;
1640 }
1641
1642 bool
1643 _PackageManagerImpl::IsAppInstalled(const AppId& appId)
1644 {
1645         if (appId == _AppInfo::GetPackageId())
1646         {
1647                 return true;
1648         }
1649
1650         int result = 0;
1651         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
1652
1653         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(appId));
1654         SysTryReturn(NID_APP, pPackageId, false, E_OUT_OF_MEMORY, "pPackageId is null");
1655
1656         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
1657         SysTryReturn(NID_APP, result == 0, false, E_APP_NOT_INSTALLED, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", result, pPackageId.get());
1658
1659         if(pPackageInfoHandle)
1660         {
1661                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
1662         }
1663
1664         return true;
1665 }
1666
1667 int
1668 _PackageManagerImpl::PackageEventHandler(int req_id, const char* pkg_type, const char* pkg_name,
1669                                                                                 const char* key, const char* val, const void* pmsg, void* data)
1670 {
1671         SysLog(NID_APP, "PackageEventHandler - req_id: %d, pkg_type: %s, pkg_name: %s, key: %s, val: %s", req_id, pkg_type,
1672                                 pkg_name, key, val);
1673
1674         PackageType type = PACKAGE_TYPE_TPK;
1675         PackageId packageId(pkg_name);
1676
1677         if (strcmp(pkg_type, "tpk") == 0)
1678         {
1679                 type = PACKAGE_TYPE_TPK;
1680         }
1681         else if (strcmp(pkg_type, "wgt") == 0)
1682         {
1683                 type = PACKAGE_TYPE_WGT;
1684         }
1685         else
1686         {
1687                 SysLog(NID_APP, "Invalid type - pkg_type: %s", pkg_type);
1688                 return 0;
1689         }
1690
1691         _PackageManagerImpl* pThis = _PackageManagerImpl::GetInstance();
1692         pThis->SendPackageEvent(type, packageId, key, val);
1693
1694         return 0;
1695 }
1696
1697 String*
1698 _PackageManagerImpl::GetAppIdOfDataControlN(const String& providerId)
1699 {
1700         result r = E_SUCCESS;
1701         Database db;
1702         DbStatement* pStmt = null;
1703         DbEnumerator* pEnum = null;
1704         String query;
1705         String* pAppId = null;
1706
1707         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",
1708                         providerId.GetPointer());
1709
1710         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1711         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1712
1713         pStmt = CreateStatementN(db, query);
1714         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1715
1716         pEnum = ExecuteStatementN(db, pStmt);
1717
1718         if (pEnum != null)
1719         {
1720                 if (pEnum->MoveNext() == E_SUCCESS)
1721                 {
1722                         pAppId = new (std::nothrow) String;
1723                         SysTryReturn(NID_APP, pAppId != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
1724
1725                         pEnum->GetStringAt(0, *pAppId);
1726                 }
1727
1728                 delete pEnum;
1729         }
1730
1731 CATCH:
1732         delete pStmt;
1733         return pAppId;
1734 }
1735
1736 PackageInfo*
1737 _PackageManagerImpl::GetPackageInfoN(const String& providerId, const String& operationId) const
1738 {
1739         result r = E_SUCCESS;
1740         PackageInfo* pPkgInfo = null;
1741         Database db;
1742         DbStatement* pStmt = null;
1743         DbEnumerator* pEnum = null;
1744         String query;
1745
1746         query.Format(1024, L"SELECT PkgInfo.PKG_ID FROM PkgInfo, AppInfo, AppInfoLookup, AppControl, Capability "
1747                         "WHERE AppControl.PROVIDER_ID ='%ls' and Capability.OPERATION_ID ='%ls' and AppControl.ID = AppInfoLookup.AppControlID "
1748                         "and Capability.ID = AppInfoLookup.CapabilityID and AppInfoLookup.AppInfoID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID "
1749                         "GROUP BY AppInfoID"
1750                         , providerId.GetPointer(), operationId.GetPointer());
1751
1752         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1753         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1754
1755         pStmt = CreateStatementN(db, query);
1756         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1757
1758         pEnum = ExecuteStatementN(db, pStmt);
1759         if (pEnum != null)
1760         {
1761                 if (pEnum->MoveNext() == E_SUCCESS)
1762                 {
1763                         PackageId packageId;
1764                         pEnum->GetStringAt(0, packageId);
1765
1766                         pPkgInfo = GetPackageInfoN(packageId);
1767                 }
1768
1769                 delete pEnum;
1770         }
1771         else
1772         {
1773                 r = E_OBJ_NOT_FOUND;
1774         }
1775
1776 CATCH:
1777         delete pStmt;
1778         return pPkgInfo;
1779 }
1780
1781 ArrayList*
1782 _PackageManagerImpl::GetPackageAppInfoImplListN(const String& packageId) const
1783 {
1784         result r = E_SUCCESS;
1785         Database db;
1786         DbStatement* pStmt = null;
1787         DbEnumerator* pEnum = null;
1788         String query;
1789         //int id = 0;
1790         PackageInfo* pPkgInfo = null;
1791         _PackageInfoImpl* pPackageInfoImpl = null;
1792         ArrayList* pList = null;
1793
1794         pPkgInfo = GetPackageInfoN(packageId);
1795         SysTryCatch(NID_APP, pPkgInfo != null, , r, "[%s] GetPackageInfoN() is failed", GetErrorMessage(r));
1796
1797         pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPkgInfo);
1798         query.Format(1024, L"SELECT * FROM AppInfo WHERE ID = %d", pPackageInfoImpl->GetUniqueId());
1799
1800         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1801         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1802
1803         pStmt = CreateStatementN(db, query);
1804         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1805                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1806
1807         pEnum = ExecuteStatementN(db, pStmt);
1808
1809         if (pEnum != null)
1810         {
1811                 pList = new (std::nothrow) ArrayList;
1812                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
1813
1814                 pList->Construct();
1815
1816                 while (pEnum->MoveNext() == E_SUCCESS)
1817                 {
1818                         _PackageAppInfoImpl* pPackageAppInfoImpl = new (std::nothrow) _PackageAppInfoImpl;
1819                         SysTryReturn(NID_APP, pPackageAppInfoImpl != null, null, E_OUT_OF_MEMORY, "pPackageAppInfoImpl instance must not be null.");
1820
1821                         int uniqueId = 0;
1822                         int pkgId = 0;
1823                         String name;
1824                         String defaultapp;
1825                         String mainmenuIcon;
1826                         String settingIcon;
1827                         String quickpanelIcon;
1828                         int appFeature = 0;
1829                         String packageName;
1830
1831                         pEnum->GetIntAt(0, uniqueId);
1832                         pEnum->GetIntAt(1, pkgId);
1833                         pEnum->GetStringAt(2, name);
1834                         pEnum->GetStringAt(3, defaultapp);
1835                         pEnum->GetStringAt(4, mainmenuIcon);
1836                         pEnum->GetStringAt(5, settingIcon);
1837                         pEnum->GetStringAt(7, quickpanelIcon);
1838                         pEnum->GetIntAt(9, appFeature);
1839                         pEnum->GetStringAt(10, packageName);
1840
1841                         pPackageAppInfoImpl->SetUniqueId(uniqueId);
1842                         pPackageAppInfoImpl->SetPkgId(pkgId);
1843                         pPackageAppInfoImpl->SetName(name);
1844                         pPackageAppInfoImpl->SetDefault(defaultapp);
1845                         pPackageAppInfoImpl->SetMainmenuIcon(mainmenuIcon);
1846                         pPackageAppInfoImpl->SetSettingIcon(settingIcon);
1847                         pPackageAppInfoImpl->SetQuickpanelIcon(quickpanelIcon);
1848                         pPackageAppInfoImpl->SetAppFeature(appFeature);
1849                         pPackageAppInfoImpl->SetPackageName(packageName);
1850
1851                         pList->Add(*pPackageAppInfoImpl);
1852                 }
1853
1854                 delete pEnum;
1855         }
1856
1857 CATCH:
1858         delete pPkgInfo;
1859         delete pStmt;
1860         return pList;
1861 }
1862
1863 ArrayList*
1864 _PackageManagerImpl::GetPackageAppFeatureListN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
1865 {
1866         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
1867         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
1868
1869         ArrayList* pResult = null;
1870
1871         for (int i = 0; i < pAppInfoList->GetCount(); i++)
1872         {
1873                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pAppInfoList->GetAt(i));
1874                 if (pAppInfoImpl == null)
1875                 {
1876                         continue;
1877                 }
1878
1879                 if (pAppInfoImpl->GetName() == appExecutableName)
1880                 {
1881                         pResult = pAppInfoImpl->GetAppFeatureListN();
1882                         goto OUT;
1883                 }
1884         }
1885
1886 OUT:
1887         pAppInfoList->RemoveAll(true);
1888         delete pAppInfoList;
1889
1890         return pResult;
1891 }
1892
1893 HashMapT<String, _AppFeatureInfoImpl*>*
1894 _PackageManagerImpl::GetPackageAppFeatureMapN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
1895 {
1896         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
1897         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
1898
1899         HashMapT<String, _AppFeatureInfoImpl*>* pResult = null;
1900
1901         std::auto_ptr<IEnumerator> pEnum(pAppInfoList->GetEnumeratorN());
1902
1903         while (pEnum->MoveNext() == E_SUCCESS)
1904         {
1905                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pEnum->GetCurrent());
1906                 if (pAppInfoImpl == null)
1907                 {
1908                         continue;
1909                 }
1910
1911                 if (pAppInfoImpl->GetName() == appExecutableName)
1912                 {
1913                         pResult = pAppInfoImpl->GetAppFeatureMapN();
1914                         goto OUT;
1915                 }
1916         }
1917
1918 OUT:
1919         pAppInfoList->RemoveAll(true);
1920         delete pAppInfoList;
1921
1922         return pResult;
1923 }
1924
1925 ArrayList*
1926 _PackageManagerImpl::GetAppLaunchConditionListN(const String& packageName) const
1927 {
1928         result r = E_SUCCESS;
1929         Database db;
1930         DbStatement* pStmt = null;
1931         DbEnumerator* pEnum = null;
1932         String query;
1933         ArrayList* pList = null;
1934
1935         query.Format(1024, L"SELECT LaunchCondition.* FROM LaunchCondition, AppInfo WHERE AppInfo.UNIQUE_ID = LaunchCondition.ID and AppInfo.PACKAGE_NAME = '%ls'", packageName.GetPointer());
1936
1937         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1938         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1939
1940         pStmt = CreateStatementN(db, query);
1941         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1942                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1943
1944         pEnum = ExecuteStatementN(db, pStmt);
1945         if (pEnum != null)
1946         {
1947                 pList = new (std::nothrow) ArrayList;
1948                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
1949
1950                 pList->Construct();
1951
1952                 while (pEnum->MoveNext() == E_SUCCESS)
1953                 {
1954                         _LaunchConditionInfoImpl* pLaunchCondtion = new (std::nothrow) _LaunchConditionInfoImpl;
1955                         SysTryReturn(NID_APP, pLaunchCondtion != null, null, E_OUT_OF_MEMORY, "pLaunchCondtion instance must not be null.");
1956
1957                         String name;
1958                         String value;
1959
1960                         pEnum->GetStringAt(1, name);
1961                         pEnum->GetStringAt(2, value);
1962
1963                         pLaunchCondtion->SetName(name);
1964                         pLaunchCondtion->SetValue(value);
1965
1966                         pList->Add(*pLaunchCondtion);
1967
1968                         SysLog(NID_APP, "Name[%ls], Value[%ls]", name.GetPointer(), value.GetPointer());
1969                 }
1970
1971                 delete pEnum;
1972         }
1973
1974 CATCH:
1975         delete pStmt;
1976         return pList;
1977 }
1978
1979 result
1980 _PackageManagerImpl::GetPackageName(const PackageId& packageId, const String* pName, char* pPackageName, int bufferSize)
1981 {
1982         result r = E_SUCCESS;
1983         Database db;
1984         DbStatement* pStmt = null;
1985         DbEnumerator* pEnum = null;
1986         String query;
1987         Tizen::Base::String packageName;
1988
1989         if (pName == null)
1990         {
1991                 query.Format(
1992                         1024,
1993                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
1994                         "True", packageId.GetPointer());
1995         }
1996         else
1997         {
1998                 query.Format(
1999                         1024,
2000                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and APP_NAME = '%ls' and PkgInfo.PKG_ID = '%ls'",
2001                         pName->GetPointer(), packageId.GetPointer());
2002         }
2003
2004         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2005         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2006
2007         pStmt = CreateStatementN(db, query);
2008         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2009                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2010
2011         pEnum = ExecuteStatementN(db, pStmt);
2012         if (pEnum != null)
2013         {
2014                 if (pEnum->MoveNext() == E_SUCCESS)
2015                 {
2016                         pEnum->GetStringAt(0, packageName);
2017                         snprintf(pPackageName, bufferSize, "%ls", packageName.GetPointer());
2018                 }
2019                 delete pEnum;
2020         }
2021         else
2022         {
2023                 r = E_OBJ_NOT_FOUND;
2024         }
2025
2026 CATCH:
2027         delete pStmt;
2028
2029         return r;
2030 }
2031
2032 String
2033 _PackageManagerImpl::GetDefaultAppExecutableName(const PackageId& packageId)
2034 {
2035         result r = E_SUCCESS;
2036         Database db;
2037         DbStatement* pStmt = null;
2038         DbEnumerator* pEnum = null;
2039         String query;
2040         String executableName;
2041
2042         query.Format(
2043                 1024,
2044                 L"SELECT AppInfo.APP_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
2045                 "True", packageId.GetPointer());
2046
2047         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2048         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2049
2050         pStmt = CreateStatementN(db, query);
2051         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2052                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2053
2054         pEnum = ExecuteStatementN(db, pStmt);
2055         if (pEnum != null)
2056         {
2057                 if (pEnum->MoveNext() == E_SUCCESS)
2058                 {
2059                         pEnum->GetStringAt(0, executableName);
2060                 }
2061                 delete pEnum;
2062         }
2063         else
2064         {
2065                 r = E_OBJ_NOT_FOUND;
2066                 SetLastResult(r);
2067         }
2068
2069 CATCH:
2070         delete pStmt;
2071
2072         return executableName;
2073 }
2074
2075 DbStatement*
2076 _PackageManagerImpl::CreateStatementN(Database& db, const String& query)
2077 {
2078         result r = E_SUCCESS;
2079         DbStatement* pStmt = null;
2080
2081         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2082         {
2083                 pStmt = db.CreateStatementN(query);
2084                 r = GetLastResult();
2085
2086                 if (r != E_OBJECT_LOCKED)
2087                 {
2088                         break;
2089                 }
2090                 else
2091                 {
2092                         SysLog(NID_APP, "RetryCount[%d] CreateStatementN - E_OBJECT_LOCKED", i);
2093                         delete pStmt;
2094                         pStmt = null;
2095                         usleep(50000);
2096                 }
2097         }
2098
2099         return pStmt;
2100 }
2101
2102 DbEnumerator*
2103 _PackageManagerImpl::ExecuteStatementN(Database& db, const DbStatement* pStmt)
2104 {
2105         result r = E_SUCCESS;
2106         DbEnumerator* pEnum = null;
2107
2108         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2109         {
2110                 pEnum = db.ExecuteStatementN(*pStmt);
2111                 r = GetLastResult();
2112
2113                 if (r != E_OBJECT_LOCKED)
2114                 {
2115                         break;
2116                 }
2117                 else
2118                 {
2119                         SysLog(NID_APP, "RetryCount[%d] ExecuteStatementN - E_OBJECT_LOCKED", i);
2120                         delete pEnum;
2121                         pEnum = null;
2122                         usleep(50000);
2123                 }
2124         }
2125
2126         return pEnum;
2127 }
2128
2129 } } } // Tizen::App::Package