src/app/package/FAppPkg_PackageManagerImpl.cpp

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