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