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