src/app/package/FAppPkg_PackageManagerImpl.cpp

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