src/app/package/FAppPkg_PackageManagerImpl.cpp

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