src/app/package/FAppPkg_PackageManagerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file        FAppPkg_PackageManagerImpl.cpp
  19  * @brief       This is the implementation for the _PackageManagerImpl class.
  20  */
  21 #include <cstdio>
  22 #include <cstdlib>
  23 #include <new>
  24 #include <memory>
  25 #include <unistd.h>
  26 #include <dlog.h>
  27 #include <unique_ptr.h>
  28
  29 #include <FSysSystemTime.h>
  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 <FIo.h>
  37 #include <FIoRegistry.h>
  38
  39 #include <FBaseSysLog.h>
  40 #include <FBase_StringConverter.h>
  41
  42 #include "FAppPkg_PackageManagerImpl.h"
  43 #include "FAppPkg_PackageInfoImpl.h"
  44 #include "FAppPkg_PackageAppInfoImpl.h"
  45 #include "FApp_AppInfo.h"
  46 #include "FApp_PackageManagerProxy.h"
  47
  48 using namespace Tizen::Base;
  49 using namespace Tizen::Base::Runtime;
  50 using namespace Tizen::Base::Collection;
  51 using namespace Tizen::Io;
  52 using namespace Tizen::System;
  53
  54 namespace Tizen { namespace App { namespace Package
  55 {
  56
  57 PackageManager* pPackageManagerInstance = null;
  58
  59 Tizen::Base::Collection::HashMap _PackageManagerImpl::__installationList;
  60
  61 const wchar_t PACKAGE_DATABASE_FILE_NAME[] = L"/opt/usr/dbspace/.app-package.db";
  62
  63 void
  64 _PackageManagerEvent::FireImpl(IEventListener& listener, const IEventArg& arg)
  65 {
  66         IPackageInstallationEventListener* pListener = dynamic_cast<IPackageInstallationEventListener*> (&listener);
  67         SysTryReturnVoidResult(NID_APP, pListener != null, E_OUT_OF_MEMORY, "pListener instance must not be null.");
  68
  69         const _PackageManagerEventArg* pArg = dynamic_cast<const _PackageManagerEventArg*>(&arg);
  70         SysTryReturnVoidResult(NID_APP, pArg != null, E_OUT_OF_MEMORY, "pArg instance must not be null.");
  71
  72         if (pArg->__eventKey == L"end")
  73         {
  74                 if (pArg->__eventValue == L"ok")
  75                 {
  76                         if (pArg->__install)
  77                         {
  78                                 SysLog(NID_APP, "Installation is Completed. [PackageId = %ls]", pArg->__packageId.GetPointer());
  79                                 pListener->OnPackageInstallationCompleted(pArg->__packageId, PACKAGE_INSTALLATION_RESULT_SUCCESS);
  80                         }
  81                         else
  82                         {
  83                                 SysLog(NID_APP, "Uninstallation is Completed. [PackageId = %ls]", pArg->__packageId.GetPointer());
  84                                 pListener->OnPackageUninstallationCompleted(pArg->__packageId, true);
  85                         }
  86                 }
  87                 else
  88                 {
  89                         if (pArg->__install)
  90                         {
  91                                 SysLog(NID_APP, "Installation is Completed(Error). [PackageId = %ls]", pArg->__packageId.GetPointer());
  92                                 pListener->OnPackageInstallationCompleted(pArg->__packageId, PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE);
  93                         }
  94                         else
  95                         {
  96                                 SysLog(NID_APP, "Uninstallation is Completed(Error). [PackageId = %ls]", pArg->__packageId.GetPointer());
  97                                 pListener->OnPackageUninstallationCompleted(pArg->__packageId, false);
  98                         }
  99                 }
 100         }
 101         else if (pArg->__eventKey == L"install_percent")
 102         {
 103                 std::unique_ptr<char[]> pProgress(_StringConverter::CopyToCharArrayN(pArg->__eventValue));
 104
 105                 int progress = 0;
 106                 sscanf(pProgress.get(), "%d", &progress);
 107
 108                 SysLog(NID_APP, "InstallationInProgress [%d]", progress);
 109                 pListener->OnPackageInstallationInProgress(pArg->__packageId, progress);
 110         }
 111 }
 112
 113 PackageId
 114 _PackageManagerImpl::GetPackageIdByAppId(const AppId& appId)
 115 {
 116         SysTryReturn(NID_APP, appId.IsEmpty() == false, L"", E_INVALID_ARG, "appId is empty");
 117
 118         String packageId;
 119
 120         if (appId.StartsWith(L".", 10) == true)
 121         {
 122                 appId.SubString(0, 10, packageId);
 123         }
 124         else
 125         {
 126                 int result = 0;
 127                 char* pPackageId = null;
 128                 pkgmgrinfo_appinfo_h pAppInfoHandle = null;
 129
 130                 std::unique_ptr<char[]> pAppId(_StringConverter::CopyToCharArrayN(appId));
 131                 SysTryReturn(NID_APP, pAppId, L"", E_OUT_OF_MEMORY, "pAppId is null");
 132
 133                 result = pkgmgrinfo_appinfo_get_appinfo(pAppId.get(), &pAppInfoHandle);
 134                 SysTryReturn(NID_APP, result == 0, L"", E_PKG_NOT_INSTALLED, "pkgmgrinfo_appinfo_get_appinfo() failed. result=[%d], appId=[%s]", result, pAppId.get());
 135
 136                 result = pkgmgrinfo_appinfo_get_pkgname(pAppInfoHandle, &pPackageId);
 137
 138                 packageId.Append(pPackageId);
 139
 140                 if(pAppInfoHandle)
 141                 {
 142                         pkgmgrinfo_appinfo_destroy_appinfo(pAppInfoHandle);
 143                 }
 144         }
 145
 146         SysLog(NID_APP, "appId = [%ls], packageId = [%ls]", appId.GetPointer(), packageId.GetPointer());
 147
 148         return packageId;
 149 }
 150
 151 result
 152 _PackageManagerImpl::AddEventListener(IPackageInstallationEventListener* pListener, int priority)
 153 {
 154         SysTryReturnResult(NID_APP, (priority < 3) && (priority >= 0), E_INVALID_ARG, "priority is invalid.");
 155
 156         result r = E_SUCCESS;
 157         int res = 0;
 158
 159         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
 160         SysTryReturnResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
 161
 162         while (pEnum->MoveNext() == E_SUCCESS)
 163         {
 164                 _PackageManagerEvent*   pEvent = null;
 165                 pEnum->GetCurrent(pEvent);
 166                 if (pEvent)
 167                 {
 168                         if (pEvent->__pListener == pListener)
 169                         {
 170                                 SysLog(NID_APP, "The event listener already exist. listener = [0x%x]", pListener);
 171                                 return E_OBJ_ALREADY_EXIST;
 172                         }
 173                 }
 174         }
 175
 176         if (__pListeningClient == null)
 177         {
 178                 __pListeningClient = pkgmgr_client_new(PC_LISTENING);
 179                 SysTryReturnResult(NID_APP, __pListeningClient != null, E_SYSTEM, "pkgmgr_client_new(PC_LISTENING) failed");
 180
 181                 res = pkgmgr_client_listen_status(__pListeningClient, PackageEventHandler, this);
 182                 if (res < PKGMGR_R_OK)
 183                 {
 184                         pkgmgr_client_free(__pListeningClient);
 185                         __pListeningClient = null;
 186
 187                         if (res == PKGMGR_R_EINVAL)
 188                         {
 189                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns ARGV error");
 190                                 return E_INVALID_ARG;
 191                         }
 192                         else if (res == PKGMGR_R_ECOMM)
 193                         {
 194                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns COMM error");
 195                         }
 196                         else if (res == PKGMGR_R_ETIMEOUT)
 197                         {
 198                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns TIME_OUT error");
 199                         }
 200                         else if (res == PKGMGR_R_ERROR)
 201                         {
 202                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns Unknown error");
 203                         }
 204                         else
 205                         {
 206                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns Unknown error, res = %d", res);
 207                         }
 208
 209                         return E_SYSTEM;
 210                 }
 211         }
 212
 213         _PackageManagerEvent* pEvent = new (std::nothrow) _PackageManagerEvent();
 214         SysTryReturnResult(NID_APP, pEvent != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 215
 216         r = pEvent->Construct();
 217         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "pEvent->Construct() failed.");
 218
 219         pEvent->__pListener = pListener;
 220
 221         r = pEvent->AddListener(*pListener, true);
 222         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "pEvent->AddListener() failed. [%s]", GetErrorMessage(r));
 223
 224         r = __packageEventListenerList.Add(pEvent);
 225         SysTryReturnResult(NID_APP, !IsFailed(r), r, "[%s] Propagating.", GetErrorMessage(r));
 226
 227         SysLog(NID_APP, "Add PackageInstallationEventListener = [0x%x]", pListener);
 228         return E_SUCCESS;
 229 }
 230
 231 result
 232 _PackageManagerImpl::RemoveEventListener(IPackageInstallationEventListener* pListener)
 233 {
 234         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
 235         SysTryReturnResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
 236
 237         result r = E_SUCCESS;
 238
 239         while (pEnum->MoveNext() == E_SUCCESS)
 240         {
 241                 _PackageManagerEvent*   pEvent = null;
 242                 pEnum->GetCurrent(pEvent);
 243                 if (pEvent)
 244                 {
 245                         if (pEvent->__pListener == pListener)
 246                         {
 247                                 r = __packageEventListenerList.Remove(pEvent);
 248                                 SysTryReturnResult(NID_APP, !IsFailed(r), r, "[%s] Propagating.", GetErrorMessage(r));
 249
 250                                 delete pEvent;
 251
 252                                 SysLog(NID_APP, "Remove PackageInstallationEventListener = [0x%x]", pListener);
 253                                 return E_SUCCESS;
 254                         }
 255                 }
 256         }
 257
 258         return E_OBJ_NOT_FOUND;
 259 }
 260
 261 PackageInfo*
 262 _PackageManagerImpl::GetPackageInfoN(const PackageId& packageId) const
 263 {
 264         SysTryReturn(NID_APP, packageId.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] packageId is empty.");
 265         SysTryReturn(NID_APP, packageId.GetLength() < NATIVE_APP_MAX_APPID_LENGTH, null, E_INVALID_ARG, "packageId is invalid.(length)");
 266
 267         result r = E_SUCCESS;
 268         PackageInfo* pPackageInfo = null;
 269
 270         pPackageInfo = new (std::nothrow) PackageInfo;
 271         SysTryReturn(NID_APP, pPackageInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
 272
 273         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
 274         r = pPackageInfoImpl->Construct(packageId);
 275         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[E_PKG_NOT_INSTALLED] packageId (%ls) is not found.", packageId.GetPointer());
 276
 277         return pPackageInfo;
 278
 279 CATCH:
 280         delete pPackageInfo;
 281         return null;
 282 }
 283
 284 PackageAppInfo*
 285 _PackageManagerImpl::GetPackageAppInfoN(const AppId& appId) const
 286 {
 287         SysTryReturn(NID_APP, appId.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] appId is empty.");
 288
 289         result r = E_SUCCESS;
 290         PackageAppInfo* pPackageAppInfo = null;
 291
 292         pPackageAppInfo = new (std::nothrow) PackageAppInfo;
 293         SysTryReturn(NID_APP, pPackageAppInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageAppInfo instance must not be null.");
 294
 295         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo);
 296         r = pPackageAppInfoImpl->Construct(appId);
 297         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[E_PKG_NOT_INSTALLED] appId (%ls) is not found.", appId.GetPointer());
 298
 299         return pPackageAppInfo;
 300
 301 CATCH:
 302         delete pPackageAppInfo;
 303         return null;
 304 }
 305
 306 IList*
 307 _PackageManagerImpl::GetPackageInfoListN(void) const
 308 {
 309         result r = E_SUCCESS;
 310         int res = 0;
 311         ArrayList* pList = null;
 312
 313         pList = new (std::nothrow) ArrayList();
 314         SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
 315         pList->Construct();
 316
 317         res = pkgmgrinfo_pkginfo_get_list(PackageInfoEventHandler, pList);
 318         if (res != 0)
 319         {
 320                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_list() is failed. result = [%d]", res);
 321
 322                 pList->RemoveAll(true);
 323                 pList = null;
 324         }
 325
 326         SetLastResult(r);
 327         return pList;
 328 }
 329
 330 bool
 331 _PackageManagerImpl::IsPackageInstalled(const PackageId& packageId) const
 332 {
 333         SysTryReturn(NID_APP, packageId.IsEmpty() == false, false, E_INVALID_ARG, "packageId is empty");
 334
 335         int result = 0;
 336         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
 337
 338         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 339         SysTryReturn(NID_APP, pPackageId, false, E_OUT_OF_MEMORY, "pPackageId is null");
 340
 341         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
 342         if (result != 0)
 343         {
 344                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", result, pPackageId.get());
 345                 return false;
 346         }
 347
 348         if(pPackageInfoHandle)
 349         {
 350                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
 351         }
 352
 353         SysLog(NID_APP, "packageId = [%ls] is installed.", packageId.GetPointer());
 354
 355         return true;
 356 }
 357
 358 result
 359 _PackageManagerImpl::InstallPackage(const PackageId& packageId, const String& packagePath, IPackageInstallationResponseListener* pListener)
 360 {
 361         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty.");
 362         SysTryReturnResult(NID_APP, packagePath.IsEmpty() == false, E_INVALID_ARG, "packagePath is empty.");
 363         SysTryReturnResult(NID_APP, File::IsFileExist(packagePath) == true, E_FILE_NOT_FOUND, "packagePath is not existed.");
 364
 365         String extension = File::GetFileExtension(packagePath);
 366         SysTryReturnResult(NID_APP, extension.IsEmpty() == false, E_INVALID_ARG, "extension is empty.");
 367
 368         std::unique_ptr<char[]> pPackagePath(_StringConverter::CopyToCharArrayN(packagePath));
 369         SysTryReturnResult(NID_APP, pPackagePath, E_OUT_OF_MEMORY, "pPackagePath is null");
 370
 371         std::unique_ptr<char[]> pExtension(_StringConverter::CopyToCharArrayN(extension));
 372         SysTryReturnResult(NID_APP, pExtension, E_OUT_OF_MEMORY, "pExtension is null");
 373
 374         if ((strcasecmp(pExtension.get(), "tpk") == 0) || (strcasecmp(pExtension.get(), "wgt") == 0))
 375         {
 376                 SysLog(NID_APP, "packageId = [%ls], packagePath = [%s], extension = [%s]", packageId.GetPointer(), pPackagePath.get(), pExtension.get());
 377         }
 378         else
 379         {
 380                 SysLog(NID_APP, "invalid extension! - packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 381                 return E_SYSTEM;
 382         }
 383
 384         result r = E_SUCCESS;
 385         _PackageManagerProxy packageManagerProxy;
 386         r = packageManagerProxy.Construct();
 387         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "packageManagerProxy.Construct() failed.");
 388
 389         r = packageManagerProxy.InstallPackage(packageId, packagePath, null);
 390         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "packageManagerProxy.InstallPackage() failed.");
 391
 392         if (__pRequestClient == null)
 393         {
 394                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 395                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 396         }
 397
 398         int res = pkgmgr_client_install(__pRequestClient, pExtension.get(), null, pPackagePath.get(), null, PM_QUIET, InstallationEventHandler, pListener);
 399
 400         if (res < PKGMGR_R_OK)
 401         {
 402                 pkgmgr_client_free(__pRequestClient);
 403                 __pRequestClient = null;
 404
 405                 if (res == PKGMGR_R_EINVAL)
 406                 {
 407                         SysLog(NID_APP, "pkgmgr_client_install() returns ARGV error");
 408                         return E_INVALID_ARG;
 409                 }
 410                 else if (res == PKGMGR_R_ECOMM)
 411                 {
 412                         SysLog(NID_APP, "pkgmgr_client_install() returns COMM error");
 413                 }
 414                 else if (res == PKGMGR_R_ETIMEOUT)
 415                 {
 416                         SysLog(NID_APP, "pkgmgr_client_install() returns TIME_OUT error");
 417                 }
 418                 else if (res == PKGMGR_R_ERROR)
 419                 {
 420                         SysLog(NID_APP, "pkgmgr_client_install() returns Unknown error");
 421                 }
 422                 else
 423                 {
 424                         SysLog(NID_APP, "pkgmgr_client_install() returns Unknown error, res = %d", res);
 425                 }
 426
 427                 return E_SYSTEM;
 428         }
 429
 430         return E_SUCCESS;
 431 }
 432
 433 result
 434 _PackageManagerImpl::UninstallPackage(const PackageId& packageId, IPackageUninstallationResponseListener* pListener)
 435 {
 436         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty.");
 437         SysTryReturnResult(NID_APP, packageId.GetLength() < NATIVE_APP_MAX_APPID_LENGTH, E_INVALID_ARG, "The packageId is invalid.(length)");
 438         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 439
 440         result r = E_SUCCESS;
 441         int res = 0;
 442         char* pType = null;
 443         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
 444
 445         _PackageManagerProxy packageManagerProxy;
 446         r = packageManagerProxy.Construct();
 447         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "packageManagerProxy.Construct() failed.");
 448
 449         r = packageManagerProxy.UninstallPackage(packageId, pListener);
 450         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "packageManagerProxy.UninstallPackage() failed.");
 451
 452         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 453         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 454
 455         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
 456         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 457
 458         res = pkgmgrinfo_pkginfo_get_type(pPackageInfoHandle, &pType);
 459         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 460
 461         if (__pRequestClient == null)
 462         {
 463                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 464                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 465         }
 466
 467         res = pkgmgr_client_uninstall(__pRequestClient, pType, pPackageId.get(), PM_QUIET, UninstallationEventHandler, pListener);
 468         SysLog(NID_APP, "pkgmgr_client_uninstall - req_id=[%d], packageId=[%s], type=[%s]", res, pPackageId.get(), pType);
 469
 470         if(pPackageInfoHandle)
 471         {
 472                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
 473         }
 474
 475         if (res < PKGMGR_R_OK)
 476         {
 477                 pkgmgr_client_free(__pRequestClient);
 478                 __pRequestClient = null;
 479
 480                 if (res == PKGMGR_R_EINVAL)
 481                 {
 482                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns ARGV error");
 483                         return E_INVALID_ARG;
 484                 }
 485                 else if (res == PKGMGR_R_ECOMM)
 486                 {
 487                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns COMM error");
 488                 }
 489                 else if (res == PKGMGR_R_ETIMEOUT)
 490                 {
 491                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns TIME_OUT error");
 492                 }
 493                 else if (res == PKGMGR_R_ERROR)
 494                 {
 495                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns Unknown error");
 496                 }
 497                 else
 498                 {
 499                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns Unknown error, res = %d", res);
 500                 }
 501
 502                 return E_SYSTEM;
 503         }
 504
 505         return E_SUCCESS;
 506 }
 507
 508 result
 509 _PackageManagerImpl::MoveToExternalStorage(const PackageId& packageId)
 510 {
 511         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty");
 512         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 513
 514 #if defined(_OSP_EMUL_)
 515         SysLog(NID_APP, "MoveToExternalStorage() is unavailable on the emulator.");
 516         return E_SYSTEM;
 517 #else
 518         int res = 0;
 519         char* pType = null;
 520         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
 521         pkgmgrinfo_pkginfo_h packageInfoHandle = null;
 522
 523         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 524         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 525
 526         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &packageInfoHandle);
 527         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 528
 529         res = pkgmgrinfo_pkginfo_get_type(packageInfoHandle, &pType);
 530         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 531
 532         res = pkgmgrinfo_pkginfo_get_installed_storage(packageInfoHandle, &storage);
 533         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_installed_storage() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 534
 535         if (storage == PMINFO_EXTERNAL_STORAGE)
 536         {
 537                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage(): storage = [%d][E_INVALID_OPERATION]", storage);
 538                 return E_INVALID_OPERATION;
 539         }
 540
 541         if (__pRequestClient == null)
 542         {
 543                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 544                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 545         }
 546
 547         res = pkgmgr_client_move(__pRequestClient, pType, pPackageId.get(), PM_MOVE_TO_SDCARD, PM_QUIET);
 548
 549         if(packageInfoHandle)
 550         {
 551                 pkgmgrinfo_pkginfo_destroy_pkginfo(packageInfoHandle);
 552         }
 553
 554         if (res < PKGMGR_R_OK)
 555         {
 556                 pkgmgr_client_free(__pRequestClient);
 557                 __pRequestClient = null;
 558
 559                 if (res == PKGMGR_R_EINVAL)
 560                 {
 561                         SysLog(NID_APP, "pkgmgr_client_move() returns ARGV error");
 562                         return E_INVALID_ARG;
 563                 }
 564                 else if (res == PKGMGR_R_ERROR)
 565                 {
 566                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error");
 567                 }
 568                 else
 569                 {
 570                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error, res = %d", res);
 571                 }
 572
 573                 return E_SYSTEM;
 574         }
 575
 576         return E_SUCCESS;
 577 #endif
 578 }
 579
 580 result
 581 _PackageManagerImpl::MoveToInternalStorage(const PackageId& packageId)
 582 {
 583         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty");
 584         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 585
 586 #if defined(_OSP_EMUL_)
 587         SysLog(NID_APP, "MoveToInternalStorage() is unavailable on the emulator.");
 588         return E_SYSTEM;
 589 #else
 590         int res = 0;
 591         char* pType = null;
 592         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
 593         pkgmgrinfo_pkginfo_h packageInfoHandle = null;
 594
 595         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 596         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 597
 598         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &packageInfoHandle);
 599         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 600
 601         res = pkgmgrinfo_pkginfo_get_type(packageInfoHandle, &pType);
 602         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 603
 604         res = pkgmgrinfo_pkginfo_get_installed_storage(packageInfoHandle, &storage);
 605         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_installed_storage() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 606
 607         if (storage == PMINFO_INTERNAL_STORAGE)
 608         {
 609                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage(): storage = [%d][E_INVALID_OPERATION]", storage);
 610                 return E_INVALID_OPERATION;
 611         }
 612
 613         if (__pRequestClient == null)
 614         {
 615                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 616                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 617         }
 618
 619         res = pkgmgr_client_move(__pRequestClient, pType, pPackageId.get(), PM_MOVE_TO_INTERNAL, PM_QUIET);
 620
 621         if(packageInfoHandle)
 622         {
 623                 pkgmgrinfo_pkginfo_destroy_pkginfo(packageInfoHandle);
 624         }
 625
 626         if (res < PKGMGR_R_OK)
 627         {
 628                 pkgmgr_client_free(__pRequestClient);
 629                 __pRequestClient = null;
 630
 631                 if (res == PKGMGR_R_EINVAL)
 632                 {
 633                         SysLog(NID_APP, "pkgmgr_client_move() returns ARGV error");
 634                         return E_INVALID_ARG;
 635                 }
 636                 else if (res == PKGMGR_R_ERROR)
 637                 {
 638                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error");
 639                 }
 640                 else
 641                 {
 642                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error, res = %d", res);
 643                 }
 644
 645                 return E_SYSTEM;
 646         }
 647
 648         return E_SUCCESS;
 649 #endif
 650 }
 651
 652 int
 653 _PackageManagerImpl::InstallationEventHandler(int reqId, const char* pType, const char* pPackageId, const char* pKey, const char* pVal, const void* pMsg, void* pData)
 654 {
 655         SysLog(NID_APP, "reqId[%d], Type[%s], PackageId[%s], Key[%s], Val[%s]", reqId, pType, pPackageId, pKey, pVal);
 656
 657         if (pData)
 658         {
 659                 if (strcmp(pKey, "end") == 0)
 660                 {
 661                         IPackageInstallationResponseListener* pListener = (IPackageInstallationResponseListener*) pData;
 662
 663                         if (strcmp(pVal, "ok") == 0)
 664                         {
 665                                 pListener->OnPackageInstallationResponseReceived(pPackageId, PACKAGE_INSTALLATION_RESULT_SUCCESS);
 666                                 SysLog(NID_APP, "OnPackageInstallationResponseReceived(PACKAGE_INSTALLATION_RESULT_SUCCESS)");
 667                         }
 668                         else
 669                         {
 670                                 pListener->OnPackageInstallationResponseReceived(pPackageId, PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE);
 671                                 SysLog(NID_APP, "OnPackageInstallationResponseReceived(PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE)");
 672                         }
 673
 674                         delete pListener;
 675                 }
 676         }
 677
 678         return 0;
 679 }
 680
 681 int
 682 _PackageManagerImpl::UninstallationEventHandler(int reqId, const char* pType, const char* pPackageId, const char* pKey, const char* pVal, const void* pMsg, void* pData)
 683 {
 684         SysLog(NID_APP, "reqId[%d], Type[%s], PackageId[%s], Key[%s], Val[%s]", reqId, pType, pPackageId, pKey, pVal);
 685
 686         if (pData)
 687         {
 688                 if (strcmp(pKey, "end") == 0)
 689                 {
 690                         IPackageUninstallationResponseListener* pListener = (IPackageUninstallationResponseListener*) pData;
 691
 692                         if (strcmp(pVal, "ok") == 0)
 693                         {
 694                                 SysLog(NID_APP, "OnPackageUninstallationResponseReceived(true)");
 695                                 pListener->OnPackageUninstallationResponseReceived(pPackageId, true);
 696                         }
 697                         else
 698                         {
 699                                 SysLog(NID_APP, "OnPackageUninstallationResponseReceived(false)");
 700                                 pListener->OnPackageUninstallationResponseReceived(pPackageId, false);
 701                         }
 702
 703                         delete pListener;
 704                 }
 705         }
 706
 707         return 0;
 708 }
 709
 710 _PackageManagerImpl*
 711 _PackageManagerImpl::GetInstance(void)
 712 {
 713         return PackageManager::GetInstance()->__pPackageManagerImpl;
 714 }
 715
 716 result
 717 _PackageManagerImpl::Construct(void)
 718 {
 719         ClearLastResult();
 720
 721         result r = __installationList.Construct();
 722         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "The memory is insufficient.");
 723
 724         return E_SUCCESS;
 725 }
 726
 727 _PackageManagerImpl::_PackageManagerImpl(void)
 728 :__pRequestClient(null),
 729 __pListeningClient(null),
 730 __pDb(null)
 731 {
 732         CreatePackageTables();
 733 }
 734
 735 _PackageManagerImpl::~_PackageManagerImpl(void)
 736 {
 737 }
 738
 739 void
 740 _PackageManagerImpl::SendPackageEvent(PackageType type, const PackageId& packageId, const char* pEventKey, const char* pEventValue)
 741 {
 742         result r = E_SUCCESS;
 743         bool install = true;
 744
 745         if (strcmp(pEventKey, "start") == 0)
 746         {
 747                 if ((strcmp(pEventValue, "install") == 0) || (strcmp(pEventValue, "uninstall") == 0))
 748                 {
 749                         String* pAppId = new (std::nothrow) String(packageId);
 750                         SysTryReturnVoidResult(NID_APP, pAppId != null, E_OUT_OF_MEMORY, "pAppId instance must not be null.");
 751
 752                         String* pOperation = new (std::nothrow) String(pEventValue);
 753                         SysTryReturnVoidResult(NID_APP, pOperation != null, E_OUT_OF_MEMORY, "pOperation instance must not be null.");
 754
 755                         r = __installationList.Add(*pAppId, *pOperation);
 756                         if (IsFailed(r))
 757                         {
 758                                 delete pAppId;
 759                                 delete pOperation;
 760                                 SysLog(NID_APP, "Failed to add installation condition.");
 761                                 SetLastResult(E_SYSTEM);
 762                                 return;
 763                         }
 764                 }
 765         }
 766         else if (strcmp(pEventKey, "end") == 0)
 767         {
 768                 String* pOperation = static_cast <String*>(__installationList.GetValue(packageId));
 769                 if (pOperation)
 770                 {
 771                         if (pOperation->Equals("uninstall", true) == true)
 772                         {
 773                                 install = false;
 774                         }
 775
 776                         r = __installationList.Remove(packageId, true);
 777                         if (IsFailed(r))
 778                         {
 779                                 SysLogException(NID_APP, r, "[%s] Remove Element [%ls] is failed from installing list.", GetErrorMessage(r), packageId.GetPointer());
 780                         }
 781                 }
 782         }
 783
 784         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
 785         SysTryReturnVoidResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
 786
 787         while (pEnum->MoveNext() == E_SUCCESS)
 788         {
 789                 _PackageManagerEvent*   pEvent = null;
 790                 pEnum->GetCurrent(pEvent);
 791                 if (pEvent)
 792                 {
 793                         _PackageManagerEventArg* pEventArg= new (std::nothrow) _PackageManagerEventArg();
 794                         SysTryReturnVoidResult(NID_APP, pEventArg, E_OUT_OF_MEMORY, "The memory is insufficient.");
 795
 796                         String eventKey(pEventKey);
 797                         String eventValue(pEventValue);
 798
 799                         pEventArg->__packageId = packageId;
 800                         pEventArg->__eventKey = eventKey;
 801                         pEventArg->__eventValue = eventValue;
 802                         pEventArg->__install = install;
 803
 804                         r = pEvent->Fire(*pEventArg);
 805                         if (r != E_SUCCESS)
 806                         {
 807                                 SysLog(NID_APP, "pEvent->Fire(*pEventArg) failed. [%s]", GetErrorMessage(r));
 808                         }
 809
 810                         SysLog(NID_APP, "PackageId = [%ls], Key = [%ls], Value = [%ls], install = [%d]", pEventArg->__packageId.GetPointer(), pEventArg->__eventKey.GetPointer(), pEventArg->__eventValue.GetPointer(), pEventArg->__install);
 811                 }
 812                 else
 813                 {
 814                         SysLog(NID_APP, "pEvent is null.");
 815                 }
 816         }
 817 }
 818
 819 PackageInfo*
 820 _PackageManagerImpl::GetPackageInfoN(PackageType packageType, const String& packageName) const
 821 {
 822         SysTryReturn(NID_APP, packageName.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] packageName is empty.");
 823
 824         result r = E_SUCCESS;
 825         Database db;
 826         DbStatement* pStmt = null;
 827         DbEnumerator* pEnum = null;
 828         String query;
 829         PackageInfo *pPackageInfo = null;
 830
 831         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());
 832
 833         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
 834         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
 835
 836         pStmt = CreateStatementN(db, query);
 837
 838         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
 839
 840         pEnum = ExecuteStatementN(db, pStmt);
 841         if (pEnum != null)
 842         {
 843                 if (pEnum->MoveNext() == E_SUCCESS)
 844                 {
 845                         pPackageInfo = new (std::nothrow) PackageInfo;
 846                         SysTryReturn(NID_APP, pPackageInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
 847
 848                         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
 849
 850                         String id;
 851                         String appVersion;
 852                         String appType;
 853                         String appMimeType;
 854                         String appApiVersion;
 855                         String appName;
 856                         String appVendor;
 857                         String appDescription;
 858                         String appUrl;
 859                         String appCid;
 860                         String appRootPath;
 861                         int appStorageType = 0;
 862                         DateTime appInstallationTime;
 863                         String appIconPath;
 864
 865                         pEnum->GetStringAt(1, id);
 866                         pEnum->GetStringAt(3, appVersion);
 867                         pEnum->GetStringAt(4, appType);
 868                         pEnum->GetStringAt(5, appMimeType);
 869                         pEnum->GetStringAt(6, appApiVersion);
 870                         pEnum->GetStringAt(7, appName);
 871                         pEnum->GetStringAt(8, appVendor);
 872                         pEnum->GetStringAt(9, appDescription);
 873                         pEnum->GetStringAt(10, appUrl);
 874                         pEnum->GetStringAt(11, appCid);
 875                         pEnum->GetStringAt(16, appRootPath);
 876                         pEnum->GetIntAt(17, appStorageType);
 877                         pEnum->GetDateTimeAt(18, appInstallationTime);
 878                         pEnum->GetStringAt(21, appIconPath);
 879
 880                         pPackageInfoImpl->SetAppId(id);
 881                         pPackageInfoImpl->SetAppVersion(appVersion);
 882                         pPackageInfoImpl->SetAppMimeType(appMimeType);
 883                         pPackageInfoImpl->SetAppApiVersion(appApiVersion);
 884                         pPackageInfoImpl->SetAppName(appName);
 885                         pPackageInfoImpl->SetAppVendor(appVendor);
 886                         pPackageInfoImpl->SetAppDescription(appDescription);
 887                         pPackageInfoImpl->SetAppUrl(appUrl);
 888                         pPackageInfoImpl->SetAppCid(appCid);
 889                         pPackageInfoImpl->SetAppRootPath(appRootPath);
 890                         pPackageInfoImpl->SetAppStorageType(appStorageType);
 891                         pPackageInfoImpl->SetAppInstallationTime(appInstallationTime);
 892                         pPackageInfoImpl->SetAppIconPath(appIconPath);
 893                 }
 894
 895                 delete pEnum;
 896         }
 897         else
 898         {
 899                 r = E_OBJ_NOT_FOUND;
 900         }
 901
 902 CATCH:
 903         delete pStmt;
 904         return pPackageInfo;
 905 }
 906
 907 int
 908 _PackageManagerImpl::PackageInfoEventHandler(const pkgmgrinfo_pkginfo_h handle, void* pUserData)
 909 {
 910         SysTryReturn(NID_APP, handle != null, 0, E_SYSTEM, "[E_SYSTEM] handle must not be null.");
 911
 912         int result = 0;
 913         char* pPackage = null;
 914         ArrayList* pList = (ArrayList*)pUserData;
 915
 916         PackageInfo *pPackageInfo = new (std::nothrow) PackageInfo;
 917         SysTryReturn(NID_APP, pPackageInfo != null, 0, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
 918
 919         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
 920
 921         result = pkgmgrinfo_pkginfo_get_pkgname(handle, &pPackage);
 922         if (result == 0)
 923         {
 924                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname(): package = [%s]", pPackage);
 925         }
 926         else
 927         {
 928                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname() is failed. result = [%d]", result);
 929         }
 930
 931         pPackageInfoImpl->Construct(pPackage);
 932         pList->Add(*pPackageInfo);
 933
 934         return result;
 935 }
 936
 937 IList*
 938 _PackageManagerImpl::GetFilteredAppIdListN(const String& feature, const String& value) const
 939 {
 940         result r = E_SUCCESS;
 941         Database db;
 942         DbStatement* pStmt = null;
 943         DbEnumerator* pEnum = null;
 944         String query;
 945         ArrayList* pList = null;
 946
 947         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());
 948
 949         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
 950         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
 951
 952         pStmt = CreateStatementN(db, query);
 953         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
 954
 955         pEnum = ExecuteStatementN(db, pStmt);
 956
 957         if (pEnum != null)
 958         {
 959                 pList = new (std::nothrow) ArrayList();
 960                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
 961                 pList->Construct();
 962
 963                 while (pEnum->MoveNext() == E_SUCCESS)
 964                 {
 965                         String* pPackageName = new (std::nothrow) String;
 966                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
 967
 968                         pEnum->GetStringAt(0, *pPackageName);
 969
 970                         pList->Add(*pPackageName);
 971                 }
 972
 973                 delete pEnum;
 974
 975         }
 976         else
 977         {
 978                 r = E_OBJ_NOT_FOUND;
 979         }
 980
 981 CATCH:
 982         delete pStmt;
 983         return pList;
 984 }
 985
 986 IList*
 987 _PackageManagerImpl::GetDataControlInfoN(const String& providerId, const String& type) const
 988 {
 989         result r = E_SUCCESS;
 990         Database db;
 991         DbStatement* pStmt = null;
 992         DbEnumerator* pEnum = null;
 993         String query;
 994         ArrayList* pList = null;
 995
 996         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());
 997
 998         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
 999         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1000
1001         pStmt = CreateStatementN(db, query);
1002         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1003
1004         pEnum = ExecuteStatementN(db, pStmt);
1005
1006         if (pEnum != null)
1007         {
1008                 pList = new (std::nothrow) ArrayList();
1009                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1010                 pList->Construct();
1011
1012                 while (pEnum->MoveNext() == E_SUCCESS)
1013                 {
1014                         String* pPackageName = new (std::nothrow) String;
1015                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1016
1017                         String* pAccess = new (std::nothrow) String;
1018                         SysTryReturn(NID_APP, pAccess != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pAccess instance must not be null.");
1019
1020                         pEnum->GetStringAt(0, *pPackageName);
1021                         pList->Add(*pPackageName);
1022
1023                         pEnum->GetStringAt(1, *pAccess);
1024                         pList->Add(*pAccess);
1025                 }
1026
1027                 delete pEnum;
1028
1029         }
1030         else
1031         {
1032                 r = E_OBJ_NOT_FOUND;
1033         }
1034
1035 CATCH:
1036         delete pStmt;
1037         return pList;
1038 }
1039
1040 IMap*
1041 _PackageManagerImpl::GetUiThemeListN(const PackageId& packageId) const
1042 {
1043         result r = E_SUCCESS;
1044         Database db;
1045         DbStatement* pStmt = null;
1046         DbEnumerator* pEnum = null;
1047         String query;
1048         HashMap* pList = null;
1049
1050         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')"
1051                         , packageId.GetPointer());
1052
1053         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
1054         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1055
1056         pStmt = CreateStatementN(db, query);
1057         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1058
1059         pEnum = ExecuteStatementN(db, pStmt);
1060
1061         if (pEnum != null)
1062         {
1063                 pList = new (std::nothrow) HashMap();
1064                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "HashMap creation failure.");
1065                 pList->Construct();
1066
1067                 while (pEnum->MoveNext() == E_SUCCESS)
1068                 {
1069                         String* pName = new (std::nothrow) String;
1070                         SysTryCatch(NID_APP, pName != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pName instance must not be null.");
1071
1072                         String* pValue = new (std::nothrow) String;
1073                         SysTryCatch(NID_APP, pValue != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pValue instance must not be null.");
1074
1075                         pEnum->GetStringAt(0, *pName);
1076                         pEnum->GetStringAt(1, *pValue);
1077
1078                         pList->Add(*pName, *pValue);
1079                 }
1080
1081                 delete pEnum;
1082
1083         }
1084         else
1085         {
1086                 r = E_OBJ_NOT_FOUND;
1087         }
1088
1089 CATCH:
1090         delete pStmt;
1091         return pList;
1092 }
1093
1094 bool
1095 _PackageManagerImpl::IsAppInstalled(const AppId& appId)
1096 {
1097         if (appId == _AppInfo::GetPackageId())
1098         {
1099                 return true;
1100         }
1101
1102         int result = 0;
1103         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
1104
1105         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(appId));
1106         SysTryReturn(NID_APP, pPackageId, false, E_OUT_OF_MEMORY, "pPackageId is null");
1107
1108         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
1109         SysTryReturn(NID_APP, result == 0, false, E_APP_NOT_INSTALLED, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", result, pPackageId.get());
1110
1111         if(pPackageInfoHandle)
1112         {
1113                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
1114         }
1115
1116         return true;
1117 }
1118
1119 int
1120 _PackageManagerImpl::PackageEventHandler(int req_id, const char* pkg_type, const char* pkg_name,
1121                                                                                 const char* key, const char* val, const void* pmsg, void* data)
1122 {
1123         SysLog(NID_APP, "PackageEventHandler - req_id: %d, pkg_type: %s, pkg_name: %s, key: %s, val: %s", req_id, pkg_type,
1124                                 pkg_name, key, val);
1125
1126         PackageType type = PACKAGE_TYPE_TPK;
1127         PackageId packageId(pkg_name);
1128
1129         if (strcmp(pkg_type, "tpk") == 0)
1130         {
1131                 type = PACKAGE_TYPE_TPK;
1132         }
1133         else if (strcmp(pkg_type, "wgt") == 0)
1134         {
1135                 type = PACKAGE_TYPE_WGT;
1136         }
1137         else
1138         {
1139                 SysLog(NID_APP, "Invalid type - pkg_type: %s", pkg_type);
1140                 return 0;
1141         }
1142
1143         _PackageManagerImpl* pThis = _PackageManagerImpl::GetInstance();
1144         pThis->SendPackageEvent(type, packageId, key, val);
1145
1146         return 0;
1147 }
1148
1149 String*
1150 _PackageManagerImpl::GetAppIdOfDataControlN(const String& providerId)
1151 {
1152         result r = E_SUCCESS;
1153         Database db;
1154         DbStatement* pStmt = null;
1155         DbEnumerator* pEnum = null;
1156         String query;
1157         String* pAppId = null;
1158
1159         query.Format(1024, L"SELECT PkgInfo.PKG_ID FROM PkgInfo, AppInfo, DataControl WHERE DataControl.PROVIDER_ID = '%ls' and DataControl.ID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID",
1160                         providerId.GetPointer());
1161
1162         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
1163         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1164
1165         pStmt = CreateStatementN(db, query);
1166         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1167
1168         pEnum = ExecuteStatementN(db, pStmt);
1169
1170         if (pEnum != null)
1171         {
1172                 if (pEnum->MoveNext() == E_SUCCESS)
1173                 {
1174                         pAppId = new (std::nothrow) String;
1175                         SysTryReturn(NID_APP, pAppId != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
1176
1177                         pEnum->GetStringAt(0, *pAppId);
1178                 }
1179
1180                 delete pEnum;
1181         }
1182
1183 CATCH:
1184         delete pStmt;
1185         return pAppId;
1186 }
1187
1188 result
1189 _PackageManagerImpl::CreatePackageTables(void)
1190 {
1191         result r = E_SUCCESS;
1192         Database db;
1193         String createQuery;
1194
1195         if (File::IsFileExist(PACKAGE_DATABASE_FILE_NAME) == true)
1196         {
1197                 SysLog(NID_APP, ".app-package.db is already existed!");
1198                 return r;
1199         }
1200
1201         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, true);
1202         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.Construct is failed. [%s]", GetErrorMessage(r));
1203
1204         // PkgInfo
1205         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS PkgInfo"
1206                                                          "( UNIQUE_ID                                   INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1207                                                          "PKG_ID                        TEXT,"
1208                                                          "PKG_SECRET                    TEXT,"
1209                                                          "PKG_VERSION                   TEXT,"
1210                                                          "PKG_TYPE                  TEXT,"
1211                                                          "PKG_MIMETYPE              TEXT,"
1212                                                          "PKG_APIVERSION                TEXT,"
1213                                                          "PKG_NAME                  TEXT,"
1214                                                          "PKG_VENDOR                    TEXT,"
1215                                                          "PKG_DESCRIPTION           TEXT,"
1216                                                          "PKG_URL                       TEXT,"
1217                                                          "PKG_CID                       TEXT,"
1218                                                          "PKG_READONLY_SIZE             INTEGER,"
1219                                                          "PKG_DATA_SIZE                 INTEGER,"
1220                                                          "PKG_PARENT_ID                         TEXT,"
1221                                                          "PKG_ATTRIBUTE                         INTEGER,"
1222                                                          "PKG_ROOTPATH              TEXT,"
1223                                                          "PKG_STORAGE_TYPE          INTEGER,"
1224                                                          "PKG_INSTALLATION_DATE         TEXT,"
1225                                                          "PKG_STATE                     INTEGER,"
1226                                                          "PKG_INITIATOR                 INTEGER )");
1227         r = db.ExecuteSql(createQuery, true);
1228         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1229         createQuery.Clear();
1230
1231         // PkgPrivileges
1232         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS PkgPrivileges"
1233                                                          "( ID                          INTEGER,"
1234                                                          "PRIVILEGES                                    TEXT,"
1235                                                          "HMAC_PPRIVILEGES                      TEXT,"
1236                                                          "CERTIFICATE_TYPE              INTEGER )");
1237         r = db.ExecuteSql(createQuery, true);
1238         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1239         createQuery.Clear();
1240
1241         // PkgIntegrity
1242         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS PkgIntegrity"
1243                                                          "( ID                          INTEGER,"
1244                                                          "HMAC_APPID                                    TEXT,"
1245                                                          "HMAC_APPSECRET                                TEXT,"
1246                                                          "HMAC_HTB                                              TEXT,"
1247                                                          "SLOT_NUM                              INTEGER )");
1248         r = db.ExecuteSql(createQuery, true);
1249         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1250         createQuery.Clear();
1251
1252         // AppInfo
1253         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS AppInfo"
1254                                                          "( UNIQUE_ID                                   INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1255                                                          "ID                            INTEGER,"
1256                                                          "APP_NAME                  TEXT,"
1257                                                          "APP_TYPE                  TEXT,"
1258                                                          "APP_DEFAULT                   TEXT,"
1259                                                          "APP_MAINMENU_ICON             TEXT,"
1260                                                          "APP_SETTING_ICON          TEXT,"
1261                                                          "APP_TICKER_ICON                               TEXT,"
1262                                                          "APP_QUICKPANEL_ICON                   TEXT,"
1263                                                          "APP_LAUNCHIMAGE_ICON      TEXT,"
1264                                                          "APP_FEATURE               INTEGER,"
1265                                                          "PACKAGE_NAME              TEXT )");
1266         r = db.ExecuteSql(createQuery, true);
1267         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1268         createQuery.Clear();
1269
1270         // Notification
1271         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS Notification"
1272                                                          "( ID                          INTEGER,"
1273                                                          "NAME                      TEXT,"
1274                                                          "VALUE                     TEXT )");
1275         r = db.ExecuteSql(createQuery, true);
1276         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1277         createQuery.Clear();
1278
1279         // AppFeature
1280         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS AppFeature"
1281                                                          "( ID                          INTEGER,"
1282                                                          "NAME                      TEXT,"
1283                                                          "VALUE                     TEXT )");
1284         r = db.ExecuteSql(createQuery, true);
1285         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1286         createQuery.Clear();
1287
1288         // LaunchCondition
1289         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS LaunchCondition"
1290                                                          "( ID                          INTEGER,"
1291                                                          "NAME                      TEXT,"
1292                                                          "VALUE                     TEXT )");
1293         r = db.ExecuteSql(createQuery, true);
1294         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1295         createQuery.Clear();
1296
1297         // DataControl
1298         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS DataControl"
1299                                                          "( ID INTEGER,"
1300                                                          "PROVIDER_ID TEXT,"
1301                                                          "TYPE TEXT,"
1302                                                          "ACCESS TEXT )");
1303         r = db.ExecuteSql(createQuery, true);
1304         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1305         createQuery.Clear();
1306
1307         // Capability
1308         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS Capability"
1309                                                          "( ID                          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1310                                                          "OPERATION_ID                          TEXT )");
1311         r = db.ExecuteSql(createQuery, true);
1312         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1313         createQuery.Clear();
1314
1315         // ResolutionUriScheme
1316         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS ResolutionUriScheme"
1317                                                          "( ID                          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1318                                                          "URI_SCHEME                            TEXT )");
1319         r = db.ExecuteSql(createQuery, true);
1320         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1321         createQuery.Clear();
1322
1323         // ResolutionMimeType
1324         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS ResolutionMimeType"
1325                                                          "( ID                          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1326                                                          "MIME_TYPE                             TEXT )");
1327         r = db.ExecuteSql(createQuery, true);
1328         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1329         createQuery.Clear();
1330
1331         // AppControl
1332         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS AppControl"
1333                                                          "( ID                          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1334                                                          "PROVIDER_ID                   TEXT,"
1335                                                          "CATEGORY                                      TEXT )");
1336         r = db.ExecuteSql(createQuery, true);
1337         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1338         createQuery.Clear();
1339
1340         // AppInfoLookup
1341         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS AppInfoLookup"
1342                                                          "( AppInfoID                   INTEGER,"
1343                                                          "CapabilityID              INTEGER,"
1344                                                          "ResolutionUriSchemeID         INTEGER,"
1345                                                          "ResolutionMimeTypeID      INTEGER,"
1346                                                          "AppControlID                              INTEGER )");
1347         r = db.ExecuteSql(createQuery, true);
1348         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1349         createQuery.Clear();
1350
1351         return r;
1352 }
1353
1354 result
1355 _PackageManagerImpl::RegisterPackageInfo(_PackageInfoImpl& pkgInfoImpl)
1356 {
1357         result r = E_SUCCESS;
1358         Database db;
1359         DbStatement* pStmt = null;
1360         DbEnumerator* pEnum = null;
1361         String query;
1362         String privileges;
1363         String hmacPrivileges;
1364         PackageInfo packageInfo;
1365         int uniqueId = 0;
1366
1367         SysLog(NID_APP, "_PackageManagerImpl::RegisterPackageInfo()");
1368
1369         query.Format(
1370                 1024, L"INSERT INTO PkgInfo "
1371                           "(PKG_ID, PKG_SECRET, PKG_VERSION, PKG_TYPE, PKG_MIMETYPE, PKG_APIVERSION, PKG_NAME, PKG_VENDOR, PKG_DESCRIPTION, PKG_URL, PKG_CID, PKG_READONLY_SIZE, PKG_DATA_SIZE, PKG_PARENT_ID,"
1372                           " PKG_ATTRIBUTE, PKG_ROOTPATH, PKG_STORAGE_TYPE, PKG_INSTALLATION_DATE, PKG_STATE, PKG_INITIATOR) "
1373                           "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
1374
1375         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
1376         //SysTryCatch(NID_APP, r == E_SUCCESS, r, r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1377
1378         pStmt = CreateStatementN(db, query);
1379         //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1380
1381         PackageId packageId = pkgInfoImpl.GetAppId();
1382         String appVersion = pkgInfoImpl.GetAppVersion();
1383         String type = pkgInfoImpl.GetAppType();
1384         String appMimeType = pkgInfoImpl.GetAppMimeType();
1385         String appApiVersion = pkgInfoImpl.GetAppApiVersion();
1386         String appName = pkgInfoImpl.GetAppName();
1387         String appVendor = pkgInfoImpl.GetAppVendor();
1388         String appDescription = pkgInfoImpl.GetAppDescription();
1389         String appUrl = pkgInfoImpl.GetAppUrl();
1390         String appCid = pkgInfoImpl.GetAppCid();
1391
1392         pkgInfoImpl.GetPrivilegesValue(privileges, hmacPrivileges);
1393         String appRootPath = pkgInfoImpl.GetAppRootPath();
1394         int appStorageType = pkgInfoImpl.GetAppStorageType();
1395         int certType = pkgInfoImpl.GetCertType();
1396         ArrayList* pAppInfoImplList = pkgInfoImpl.GetAppInfoList();
1397
1398         DateTime time;
1399         r = SystemTime::GetCurrentTime(time);
1400         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "An error occurs while getting a current time.");
1401
1402         if (!packageId.IsEmpty())
1403         {
1404                 r = pStmt->BindString(0, packageId);
1405                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1406         }
1407
1408         if (!appVersion.IsEmpty())
1409         {
1410                 r = pStmt->BindString(2, appVersion);
1411                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1412         }
1413
1414         if (!type.IsEmpty())
1415         {
1416                 r = pStmt->BindString(3, type);
1417                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1418         }
1419
1420         if (!appMimeType.IsEmpty())
1421         {
1422                 r = pStmt->BindString(4, appMimeType);
1423                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1424         }
1425
1426         if (!appApiVersion.IsEmpty())
1427         {
1428                 r = pStmt->BindString(5, appApiVersion);
1429                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1430         }
1431
1432         if (!appName.IsEmpty())
1433         {
1434                 r = pStmt->BindString(6, appName);
1435                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1436         }
1437
1438         if (!appVendor.IsEmpty())
1439         {
1440                 r = pStmt->BindString(7, appVendor);
1441                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1442         }
1443
1444         if (!appDescription.IsEmpty())
1445         {
1446                 r = pStmt->BindString(8, appDescription);
1447                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1448         }
1449
1450         if (!appUrl.IsEmpty())
1451         {
1452                 r = pStmt->BindString(9, appUrl);
1453                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1454         }
1455
1456         if (!appCid.IsEmpty())
1457         {
1458                 r = pStmt->BindString(10, appCid);
1459                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1460         }
1461
1462         if (!appRootPath.IsEmpty())
1463         {
1464                 r = pStmt->BindString(15, appRootPath);
1465                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1466         }
1467
1468         if (appStorageType != 0)
1469         {
1470                 r = pStmt->BindInt(16, appStorageType);
1471                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1472         }
1473
1474         r = pStmt->BindDateTime(17, time);
1475         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1476
1477         pEnum = ExecuteStatementN(db, pStmt);
1478
1479         r = GetLastResult();
1480
1481         uniqueId = pkgInfoImpl.GetUniqueId();
1482
1483         SysLog(NID_APP, "_PackageManagerImpl::RegisterPackageInfo()-GetUniqueId(%d)", uniqueId);
1484
1485         __pDb = &db;
1486
1487         // AppInfo
1488         RegisterAppInfoList(uniqueId, pAppInfoImplList);
1489
1490         // PkgPrivileges
1491         RegisterPrivileges(uniqueId, privileges, hmacPrivileges, certType);
1492
1493 CATCH:
1494         __pDb = null;
1495         delete pEnum;
1496         delete pStmt;
1497         return r;
1498 }
1499
1500 result
1501 _PackageManagerImpl::UnregisterPackageInfo(const PackageId& packageId)
1502 {
1503         SysLog(NID_APP, "packageId = [%ls]", packageId.GetPointer());
1504
1505         result r = E_SUCCESS;
1506         Database db;
1507         String query;
1508         int id = 0;
1509         PackageInfo* pPkgInfo;
1510         _PackageInfoImpl* pPackageInfoImpl = null;
1511         ArrayList* pList = null;
1512
1513         pPkgInfo = GetPackageInfoN(packageId);
1514         SysTryReturn(NID_APP, pPkgInfo != null, r, r, "UnregisterPackageInfo: GetUniqueId() is invalid. [%d]", id);
1515
1516         pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPkgInfo);
1517         pPackageInfoImpl->SetAppId(packageId);
1518         id = pPackageInfoImpl->GetUniqueId();
1519         SysTryReturn(NID_APP, id > 0, r, r, "UnregisterPackageInfo: GetUniqueId() is invalid. [%d]", id);
1520
1521         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
1522         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.Construct is failed. [%s]", GetErrorMessage(r));
1523
1524         // AppInfoLookup
1525         pList = pPackageInfoImpl->GetAppInfoListN();
1526         if (pList != null)
1527         {
1528                 for (int i = 0; i < pList->GetCount(); i++)
1529                 {
1530                         _PackageAppInfoImpl* pAppInfoImpl = dynamic_cast <_PackageAppInfoImpl*>(pList->GetAt(i));
1531
1532                         if (pAppInfoImpl != null)
1533                         {
1534                                 int uniqueId = 0;
1535                                 uniqueId = pAppInfoImpl->GetUniqueId();
1536
1537                                 query.Format(1024, L"DELETE FROM AppInfoLookup WHERE AppInfoID = %d", uniqueId);
1538                                 r = db.ExecuteSql(query, true);
1539                                 SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1540                                 query.Clear();
1541                         }
1542                 }
1543                 delete pList;
1544         }
1545
1546         // PkgInfo
1547         query.Format(1024, L"DELETE FROM PkgInfo WHERE PKG_ID = '%ls'", packageId.GetPointer());
1548         r = db.ExecuteSql(query, true);
1549         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1550         query.Clear();
1551
1552         // AppInfo
1553         query.Format(1024, L"DELETE FROM AppInfo WHERE ID = %d", id);
1554         r = db.ExecuteSql(query, true);
1555         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1556         query.Clear();
1557
1558         // PkgPrivileges
1559         query.Format(1024, L"DELETE FROM PkgPrivileges WHERE ID = %d", id);
1560         r = db.ExecuteSql(query, true);
1561         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1562         query.Clear();
1563
1564         // DataControl
1565         query.Format(1024, L"DELETE FROM DataControl WHERE ID = %d", id);
1566         r = db.ExecuteSql(query, true);
1567         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1568         query.Clear();
1569
1570         delete pPkgInfo;
1571         return r;
1572 }
1573
1574 PackageInfo*
1575 _PackageManagerImpl::GetPackageInfoN(const String& providerId, const String& operationId) const
1576 {
1577         result r = E_SUCCESS;
1578         PackageInfo* pPkgInfo = null;
1579         Database db;
1580         DbStatement* pStmt = null;
1581         DbEnumerator* pEnum = null;
1582         String query;
1583
1584         query.Format(1024, L"SELECT PkgInfo.PKG_ID FROM PkgInfo, AppInfo, AppInfoLookup, AppControl, Capability "
1585                         "WHERE AppControl.PROVIDER_ID ='%ls' and Capability.OPERATION_ID ='%ls' and AppControl.ID = AppInfoLookup.AppControlID "
1586                         "and Capability.ID = AppInfoLookup.CapabilityID and AppInfoLookup.AppInfoID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID "
1587                         "GROUP BY AppInfoID"
1588                         , providerId.GetPointer(), operationId.GetPointer());
1589
1590         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
1591         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1592
1593         pStmt = CreateStatementN(db, query);
1594         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1595
1596         pEnum = ExecuteStatementN(db, pStmt);
1597         if (pEnum != null)
1598         {
1599                 if (pEnum->MoveNext() == E_SUCCESS)
1600                 {
1601                         PackageId packageId;
1602                         pEnum->GetStringAt(0, packageId);
1603
1604                         pPkgInfo = GetPackageInfoN(packageId);
1605                 }
1606
1607                 delete pEnum;
1608         }
1609         else
1610         {
1611                 r = E_OBJ_NOT_FOUND;
1612         }
1613
1614 CATCH:
1615         delete pStmt;
1616         return pPkgInfo;
1617 }
1618
1619 result
1620 _PackageManagerImpl::GetAppInfo(int uniqueId, _PackageAppInfoImpl& appInfo) const
1621 {
1622         result r = E_SUCCESS;
1623         Database db;
1624         DbStatement* pStmt = null;
1625         DbEnumerator* pEnum = null;
1626         String query;
1627
1628         query.Format(1024, L"SELECT * FROM AppInfo WHERE UNIQUE_ID = %d", uniqueId);
1629
1630         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
1631         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1632
1633         pStmt = CreateStatementN(db, query);
1634         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1635
1636         pEnum = ExecuteStatementN(db, pStmt);
1637         if (pEnum != null)
1638         {
1639                 if (pEnum->MoveNext() == E_SUCCESS)
1640                 {
1641                         int uniqueId = 0;
1642                         int pkgId = 0;
1643                         String name;
1644                         String defaultapp;
1645                         String mainmenuIcon;
1646                         String settingIcon;
1647                         String tickerIcon;
1648                         String quickpanelIcon;
1649                         String launchImageIcon;
1650                         int appFeature = 0;
1651                         String packageName;
1652
1653                         pEnum->GetIntAt(0, uniqueId);
1654                         pEnum->GetIntAt(1, pkgId);
1655                         pEnum->GetStringAt(2, name);
1656                         pEnum->GetStringAt(3, defaultapp);
1657                         pEnum->GetStringAt(4, mainmenuIcon);
1658                         pEnum->GetStringAt(5, settingIcon);
1659                         pEnum->GetStringAt(7, quickpanelIcon);
1660                         pEnum->GetIntAt(9, appFeature);
1661                         pEnum->GetStringAt(10, packageName);
1662
1663                         appInfo.SetUniqueId(uniqueId);
1664                         appInfo.SetPkgId(pkgId);
1665                         appInfo.SetName(name);
1666                         appInfo.SetDefault(defaultapp);
1667                         appInfo.SetMainmenuIcon(mainmenuIcon);
1668                         appInfo.SetSettingIcon(settingIcon);
1669                         appInfo.SetQuickpanelIcon(quickpanelIcon);
1670                         appInfo.SetAppFeature(appFeature);
1671                         appInfo.SetPackageName(packageName);
1672                 }
1673
1674                 delete pEnum;
1675         }
1676         else
1677         {
1678                 r = E_OBJ_NOT_FOUND;
1679         }
1680
1681 CATCH:
1682         delete pStmt;
1683         return r;
1684 }
1685
1686 ArrayList*
1687 _PackageManagerImpl::GetPackageAppInfoImplListN(const String& packageId) const
1688 {
1689         result r = E_SUCCESS;
1690         Database db;
1691         DbStatement* pStmt = null;
1692         DbEnumerator* pEnum = null;
1693         String query;
1694         //int id = 0;
1695         PackageInfo* pPkgInfo = null;
1696         _PackageInfoImpl* pPackageInfoImpl = null;
1697         ArrayList* pList = null;
1698
1699         pPkgInfo = GetPackageInfoN(packageId);
1700         SysTryCatch(NID_APP, pPkgInfo != null, , r, "[%s] GetPackageInfoN() is failed", GetErrorMessage(r));
1701
1702         pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPkgInfo);
1703         query.Format(1024, L"SELECT * FROM AppInfo WHERE ID = %d", pPackageInfoImpl->GetUniqueId());
1704
1705         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
1706         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1707
1708         pStmt = CreateStatementN(db, query);
1709         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1710                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1711
1712         pEnum = ExecuteStatementN(db, pStmt);
1713
1714         if (pEnum != null)
1715         {
1716                 pList = new (std::nothrow) ArrayList;
1717                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
1718
1719                 pList->Construct();
1720
1721                 while (pEnum->MoveNext() == E_SUCCESS)
1722                 {
1723                         _PackageAppInfoImpl* pPackageAppInfoImpl = new (std::nothrow) _PackageAppInfoImpl;
1724                         SysTryReturn(NID_APP, pPackageAppInfoImpl != null, null, E_OUT_OF_MEMORY, "pPackageAppInfoImpl instance must not be null.");
1725
1726                         int uniqueId = 0;
1727                         int pkgId = 0;
1728                         String name;
1729                         String defaultapp;
1730                         String mainmenuIcon;
1731                         String settingIcon;
1732                         String quickpanelIcon;
1733                         int appFeature = 0;
1734                         String packageName;
1735
1736                         pEnum->GetIntAt(0, uniqueId);
1737                         pEnum->GetIntAt(1, pkgId);
1738                         pEnum->GetStringAt(2, name);
1739                         pEnum->GetStringAt(3, defaultapp);
1740                         pEnum->GetStringAt(4, mainmenuIcon);
1741                         pEnum->GetStringAt(5, settingIcon);
1742                         pEnum->GetStringAt(7, quickpanelIcon);
1743                         pEnum->GetIntAt(9, appFeature);
1744                         pEnum->GetStringAt(10, packageName);
1745
1746                         pPackageAppInfoImpl->SetUniqueId(uniqueId);
1747                         pPackageAppInfoImpl->SetPkgId(pkgId);
1748                         pPackageAppInfoImpl->SetName(name);
1749                         pPackageAppInfoImpl->SetDefault(defaultapp);
1750                         pPackageAppInfoImpl->SetMainmenuIcon(mainmenuIcon);
1751                         pPackageAppInfoImpl->SetSettingIcon(settingIcon);
1752                         pPackageAppInfoImpl->SetQuickpanelIcon(quickpanelIcon);
1753                         pPackageAppInfoImpl->SetAppFeature(appFeature);
1754                         pPackageAppInfoImpl->SetPackageName(packageName);
1755
1756                         pList->Add(*pPackageAppInfoImpl);
1757                 }
1758
1759                 delete pEnum;
1760         }
1761
1762 CATCH:
1763         delete pPkgInfo;
1764         delete pStmt;
1765         return pList;
1766 }
1767
1768 ArrayList*
1769 _PackageManagerImpl::GetPackageAppFeatureListN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
1770 {
1771         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
1772         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
1773
1774         ArrayList* pResult = null;
1775
1776         for (int i = 0; i < pAppInfoList->GetCount(); i++)
1777         {
1778                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pAppInfoList->GetAt(i));
1779                 if (pAppInfoImpl == null)
1780                 {
1781                         continue;
1782                 }
1783
1784                 if (pAppInfoImpl->GetName() == appExecutableName)
1785                 {
1786                         pResult = pAppInfoImpl->GetAppFeatureListN();
1787                         goto OUT;
1788                 }
1789         }
1790
1791 OUT:
1792         pAppInfoList->RemoveAll(true);
1793         delete pAppInfoList;
1794
1795         return pResult;
1796 }
1797
1798 HashMapT<String, _AppFeatureInfoImpl*>*
1799 _PackageManagerImpl::GetPackageAppFeatureMapN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
1800 {
1801         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
1802         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
1803
1804         HashMapT<String, _AppFeatureInfoImpl*>* pResult = null;
1805
1806         std::auto_ptr<IEnumerator> pEnum(pAppInfoList->GetEnumeratorN());
1807
1808         while (pEnum->MoveNext() == E_SUCCESS)
1809         {
1810                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pEnum->GetCurrent());
1811                 if (pAppInfoImpl == null)
1812                 {
1813                         continue;
1814                 }
1815
1816                 if (pAppInfoImpl->GetName() == appExecutableName)
1817                 {
1818                         pResult = pAppInfoImpl->GetAppFeatureMapN();
1819                         goto OUT;
1820                 }
1821         }
1822
1823 OUT:
1824         pAppInfoList->RemoveAll(true);
1825         delete pAppInfoList;
1826
1827         return pResult;
1828 }
1829
1830 ArrayList*
1831 _PackageManagerImpl::GetAppLaunchConditionListN(const String& packageName) const
1832 {
1833         result r = E_SUCCESS;
1834         Database db;
1835         DbStatement* pStmt = null;
1836         DbEnumerator* pEnum = null;
1837         String query;
1838         ArrayList* pList = null;
1839
1840         query.Format(1024, L"SELECT LaunchCondition.* FROM LaunchCondition, AppInfo WHERE AppInfo.UNIQUE_ID = LaunchCondition.ID and AppInfo.PACKAGE_NAME = '%ls'", packageName.GetPointer());
1841
1842         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
1843         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1844
1845         pStmt = CreateStatementN(db, query);
1846         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1847                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1848
1849         pEnum = ExecuteStatementN(db, pStmt);
1850         if (pEnum != null)
1851         {
1852                 pList = new (std::nothrow) ArrayList;
1853                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
1854
1855                 pList->Construct();
1856
1857                 while (pEnum->MoveNext() == E_SUCCESS)
1858                 {
1859                         _LaunchConditionInfoImpl* pLaunchCondtion = new (std::nothrow) _LaunchConditionInfoImpl;
1860                         SysTryReturn(NID_APP, pLaunchCondtion != null, null, E_OUT_OF_MEMORY, "pLaunchCondtion instance must not be null.");
1861
1862                         String name;
1863                         String value;
1864
1865                         pEnum->GetStringAt(1, name);
1866                         pEnum->GetStringAt(2, value);
1867
1868                         pLaunchCondtion->SetName(name);
1869                         pLaunchCondtion->SetValue(value);
1870
1871                         pList->Add(*pLaunchCondtion);
1872
1873                         SysLog(NID_APP, "Name[%ls], Value[%ls]", name.GetPointer(), value.GetPointer());
1874                 }
1875
1876                 delete pEnum;
1877         }
1878
1879 CATCH:
1880         delete pStmt;
1881         return pList;
1882 }
1883
1884 result
1885 _PackageManagerImpl::RegisterAppInfoList(int id, ArrayList* pList)
1886 {
1887         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
1888
1889         result r = E_SUCCESS;
1890         String query;
1891         DbStatement* pStmt = null;
1892
1893         if (pList != null)
1894         {
1895                 for (int i = 0; i < pList->GetCount(); i++)
1896                 {
1897                         _PackageAppInfoImpl* pAppInfoImpl = dynamic_cast <_PackageAppInfoImpl*>(pList->GetAt(i));
1898
1899                         if (pAppInfoImpl != null)
1900                         {
1901                                 DbEnumerator* pEnum = null;
1902                                 int uniqueId = 0;
1903
1904                                 String name = pAppInfoImpl->GetName();
1905                                 String defaultapp = pAppInfoImpl->GetDefault();
1906                                 String mainmenuIcon = pAppInfoImpl->GetMainmenuIcon();
1907                                 String settingIcon = pAppInfoImpl->GetSettingIcon();
1908                                 String quickpanelIcon = pAppInfoImpl->GetQuickpanelIcon();
1909                                 int appFeature = pAppInfoImpl->GetAppFeature();
1910                                 String packageName = pAppInfoImpl->GetPackageName();
1911                                 String type = pAppInfoImpl->GetType();
1912
1913                                 ArrayList* pLaunchConditionImplList = pAppInfoImpl->GetLaunchConditionList();
1914                                 ArrayList* pNotificationImplList = pAppInfoImpl->GetNotificationList();
1915                                 ArrayList* pAppFeatureImplList = pAppInfoImpl->GetAppFeatureList();
1916                                 ArrayList* pDataControlImplList = pAppInfoImpl->GetDataControlList();
1917
1918                                 query.Format(
1919                                         1024, L"INSERT INTO AppInfo "
1920                                                   "(ID, APP_NAME, APP_DEFAULT, APP_MAINMENU_ICON, APP_SETTING_ICON, APP_TICKER_ICON, APP_QUICKPANEL_ICON, APP_LAUNCHIMAGE_ICON, APP_FEATURE, PACKAGE_NAME, APP_TYPE) "
1921                                                   "VALUES (?,?,?,?,?,?,?,?,?,?,?)");
1922
1923                                 pStmt = CreateStatementN(*__pDb, query);
1924                                 //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1925
1926                                 if (id != 0)
1927                                 {
1928                                         r = pStmt->BindInt(0, id);
1929                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1930                                 }
1931
1932                                 if (!name.IsEmpty())
1933                                 {
1934                                         r = pStmt->BindString(1, name);
1935                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1936                                 }
1937
1938                                 if (!defaultapp.IsEmpty())
1939                                 {
1940                                         r = pStmt->BindString(2, defaultapp);
1941                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1942                                 }
1943
1944                                 if (!mainmenuIcon.IsEmpty())
1945                                 {
1946                                         r = pStmt->BindString(3, mainmenuIcon);
1947                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1948                                 }
1949
1950                                 if (!settingIcon.IsEmpty())
1951                                 {
1952                                         r = pStmt->BindString(4, settingIcon);
1953                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1954                                 }
1955
1956                                 if (!quickpanelIcon.IsEmpty())
1957                                 {
1958                                         r = pStmt->BindString(6, quickpanelIcon);
1959                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1960                                 }
1961
1962                                 if (appFeature != 0)
1963                                 {
1964                                         r = pStmt->BindInt(8, appFeature);
1965                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1966                                 }
1967
1968                                 if (!packageName.IsEmpty())
1969                                 {
1970                                         r = pStmt->BindString(9, packageName);
1971                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1972                                 }
1973
1974                                 if (!type.IsEmpty())
1975                                 {
1976                                         r = pStmt->BindString(10, type);
1977                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1978                                 }
1979
1980                                 pEnum = ExecuteStatementN(*__pDb, pStmt);
1981
1982                                 query.Clear();
1983                                 delete pStmt;
1984                                 pStmt = null;
1985                                 delete pEnum;
1986
1987                                 pAppInfoImpl->SetPkgId(id);
1988                                 uniqueId = pAppInfoImpl->GetUniqueId();
1989                                 RegisterLaunchConditionList(uniqueId, pLaunchConditionImplList);
1990                                 RegisterNotificationList(uniqueId, pNotificationImplList);
1991                                 RegisterAppFeatureList(uniqueId, pAppFeatureImplList);
1992                                 RegisterDataControlList(uniqueId, pDataControlImplList);
1993                                 //RegisterAppControlList(uniqueId, pAppControlImplList);
1994                         }
1995                 }
1996         }
1997
1998         r = GetLastResult();
1999
2000 CATCH:
2001         delete pStmt;
2002
2003         return r;
2004 }
2005
2006 result
2007 _PackageManagerImpl::RegisterLaunchConditionList(int id, ArrayList* pList)
2008 {
2009         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2010
2011         result r = E_SUCCESS;
2012         String query;
2013         DbStatement* pStmt = null;
2014
2015         if (pList != null)
2016         {
2017                 for (int i = 0; i < pList->GetCount(); i++)
2018                 {
2019                         _LaunchConditionInfoImpl* pLaunchCondition = dynamic_cast<_LaunchConditionInfoImpl*>(pList->GetAt(i));
2020
2021                         if (pLaunchCondition != null)
2022                         {
2023                                 DbEnumerator* pEnum = null;
2024
2025                                 String name = pLaunchCondition->GetName();
2026                                 String value = pLaunchCondition->GetValue();
2027
2028                                 query.Format(1024, L"INSERT INTO LaunchCondition (ID, NAME, VALUE) VALUES (?,?,?)");
2029
2030                                 pStmt = CreateStatementN(*__pDb, query);
2031                                 //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2032
2033                                 if (id != 0)
2034                                 {
2035                                         r = pStmt->BindInt(0, id);
2036                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2037                                 }
2038
2039                                 if (!name.IsEmpty())
2040                                 {
2041                                         r = pStmt->BindString(1, name);
2042                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2043                                 }
2044
2045                                 if (!value.IsEmpty())
2046                                 {
2047                                         r = pStmt->BindString(2, value);
2048                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2049                                 }
2050
2051                                 pEnum = ExecuteStatementN(*__pDb, pStmt);
2052
2053                                 query.Clear();
2054                                 delete pStmt;
2055                                 pStmt = null;
2056                                 delete pEnum;
2057                         }
2058                 }
2059         }
2060
2061         r = GetLastResult();
2062
2063 CATCH:
2064         delete pStmt;
2065
2066         return r;
2067 }
2068
2069 result
2070 _PackageManagerImpl::RegisterNotificationList(int id, ArrayList* pList)
2071 {
2072         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2073
2074         result r = E_SUCCESS;
2075         String query;
2076         DbStatement* pStmt = null;
2077
2078         if (pList != null)
2079         {
2080                 for (int i = 0; i < pList->GetCount(); i++)
2081                 {
2082                         _NotificationInfoImpl* pNotification = dynamic_cast<_NotificationInfoImpl*>(pList->GetAt(i));
2083
2084                         if (pNotification != null)
2085                         {
2086                                 DbEnumerator* pEnum = null;
2087
2088                                 String name = pNotification->GetName();
2089                                 String value = pNotification->GetValue();
2090
2091                                 query.Format(1024, L"INSERT INTO Notification (ID, NAME, VALUE) VALUES (?,?,?)");
2092
2093                                 pStmt = CreateStatementN(*__pDb, query);
2094                                 //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2095
2096                                 if (id != 0)
2097                                 {
2098                                         r = pStmt->BindInt(0, id);
2099                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2100                                 }
2101
2102                                 if (!name.IsEmpty())
2103                                 {
2104                                         r = pStmt->BindString(1, name);
2105                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2106                                 }
2107
2108                                 if (!value.IsEmpty())
2109                                 {
2110                                         r = pStmt->BindString(2, value);
2111                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2112                                 }
2113
2114                                 pEnum = ExecuteStatementN(*__pDb, pStmt);
2115
2116                                 query.Clear();
2117                                 delete pStmt;
2118                                 pStmt = null;
2119                                 delete pEnum;
2120                         }
2121                 }
2122         }
2123
2124         r = GetLastResult();
2125
2126 CATCH:
2127         delete pStmt;
2128
2129         return r;
2130 }
2131
2132 result
2133 _PackageManagerImpl::RegisterAppFeatureList(int id, ArrayList* pList)
2134 {
2135         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2136
2137         result r = E_SUCCESS;
2138         String query;
2139         DbStatement* pStmt = null;
2140
2141         if (pList != null)
2142         {
2143                 for (int i = 0; i < pList->GetCount(); i++)
2144                 {
2145                         _AppFeatureInfoImpl* pAppFeature = dynamic_cast<_AppFeatureInfoImpl*>(pList->GetAt(i));
2146
2147                         if (pAppFeature != null)
2148                         {
2149                                 DbEnumerator* pEnum = null;
2150
2151                                 String name = pAppFeature->GetName();
2152                                 String value = pAppFeature->GetValue();
2153
2154                                 query.Format(1024, L"INSERT INTO AppFeature (ID, NAME, VALUE) VALUES (?,?,?)");
2155
2156                                 pStmt = CreateStatementN(*__pDb, query);
2157                                 //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2158
2159                                 if (id != 0)
2160                                 {
2161                                         r = pStmt->BindInt(0, id);
2162                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2163                                 }
2164
2165                                 if (!name.IsEmpty())
2166                                 {
2167                                         r = pStmt->BindString(1, name);
2168                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2169                                 }
2170
2171                                 if (!value.IsEmpty())
2172                                 {
2173                                         r = pStmt->BindString(2, value);
2174                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2175                                 }
2176
2177                                 pEnum = ExecuteStatementN(*__pDb, pStmt);
2178
2179                                 query.Clear();
2180                                 delete pStmt;
2181                                 pStmt = null;
2182                                 delete pEnum;
2183                         }
2184                 }
2185         }
2186
2187         r = GetLastResult();
2188
2189 CATCH:
2190         delete pStmt;
2191
2192         return r;
2193 }
2194
2195 result
2196 _PackageManagerImpl::RegisterDataControlList(int id, ArrayList* pList)
2197 {
2198         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2199
2200         result r = E_SUCCESS;
2201         String query;
2202         DbStatement* pStmt = null;
2203
2204         if (pList != null)
2205         {
2206                 for (int i = 0; i < pList->GetCount(); i++)
2207                 {
2208                         _DataControlInfoImpl* pDataControl = dynamic_cast<_DataControlInfoImpl*>(pList->GetAt(i));
2209
2210                         if (pDataControl != null)
2211                         {
2212                                 DbEnumerator* pEnum = null;
2213
2214                                 String providerId = pDataControl->GetProviderId();
2215                                 ArrayList* pTypeList = pDataControl->GetControlTypeList();
2216
2217                                 if (pTypeList != null)
2218                                 {
2219                                         for (int j = 0; j < pTypeList->GetCount(); j++)
2220                                         {
2221                                                 _DataControlTypeImpl* pControlType = dynamic_cast<_DataControlTypeImpl*>(pTypeList->GetAt(j));
2222
2223                                                 if (pControlType != null)
2224                                                 {
2225                                                         String access = pControlType->GetAccess();
2226                                                         String type = pControlType->GetType();
2227
2228                                                         query.Format(1024, L"INSERT INTO DataControl (ID, PROVIDER_ID, TYPE, ACCESS) VALUES (?,?,?,?)");
2229
2230                                                         pStmt = CreateStatementN(*__pDb, query);
2231                                                         //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2232
2233                                                         if (id != 0)
2234                                                         {
2235                                                                 r = pStmt->BindInt(0, id);
2236                                                                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2237                                                         }
2238
2239                                                         if (!providerId.IsEmpty())
2240                                                         {
2241                                                                 r = pStmt->BindString(1, providerId);
2242                                                                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2243                                                         }
2244
2245                                                         if (!type.IsEmpty())
2246                                                         {
2247                                                                 r = pStmt->BindString(2, type);
2248                                                                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2249                                                         }
2250
2251                                                         if (!access.IsEmpty())
2252                                                         {
2253                                                                 r = pStmt->BindString(3, access);
2254                                                                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2255                                                         }
2256
2257                                                         pEnum = ExecuteStatementN(*__pDb, pStmt);
2258
2259                                                         query.Clear();
2260                                                         delete pStmt;
2261                                                         pStmt = null;
2262                                                         delete pEnum;
2263                                                 }
2264                                         }
2265                                 }
2266                         }
2267                 }
2268         }
2269
2270         r = GetLastResult();
2271
2272 CATCH:
2273         delete pStmt;
2274
2275         return r;
2276 }
2277
2278 int
2279 _PackageManagerImpl::FindRecord(const String& tableName, const String& columnName, const String& value) const
2280 {
2281
2282         result r = E_SUCCESS;
2283         Database db;
2284         String query;
2285         DbStatement* pStmt = null;
2286         DbEnumerator* pEnum = null;
2287         int uniqueId = 0;
2288
2289         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
2290         //SysTryCatch(NID_APP, r == E_SUCCESS, r, r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2291
2292         query.Format(1024, L"SELECT * FROM %ls WHERE %ls = '%ls'", tableName.GetPointer(), columnName.GetPointer(), value.GetPointer());
2293
2294         pStmt = CreateStatementN(db, query);
2295         //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2296
2297         pEnum = ExecuteStatementN(db, pStmt);
2298
2299         if (pEnum != null)
2300         {
2301                 if (pEnum->MoveNext() == E_SUCCESS)
2302                 {
2303                         pEnum->GetIntAt(0, uniqueId);
2304                 }
2305
2306                 delete pEnum;
2307         }
2308
2309 //CATCH:
2310         delete pStmt;
2311
2312         return uniqueId;
2313 }
2314
2315 result
2316 _PackageManagerImpl::GetRecord(const String& tableName, int uniqueId, const String& columnName, String& value) const
2317 {
2318         result r = E_SUCCESS;
2319         Database db;
2320         String query;
2321         DbStatement* pStmt = null;
2322         DbEnumerator* pEnum = null;
2323
2324         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
2325         //SysTryCatch(NID_APP, r == E_SUCCESS, r, r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2326
2327         query.Format(1024, L"SELECT %ls FROM %ls WHERE UNIQUE_ID = %d", columnName.GetPointer(), tableName.GetPointer(), uniqueId);
2328
2329         pStmt = CreateStatementN(db, query);
2330         //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2331
2332         pEnum = ExecuteStatementN(db, pStmt);
2333
2334         if (pEnum != null)
2335         {
2336                 if (pEnum->MoveNext() == E_SUCCESS)
2337                 {
2338                         pEnum->GetStringAt(0, value);
2339                 }
2340
2341                 delete pEnum;
2342         }
2343
2344 //CATCH:
2345         delete pStmt;
2346
2347         return r;
2348 }
2349
2350 result
2351 _PackageManagerImpl::RegisterPrivileges(int id, const String& privileges, const String& hmacPrivileges, int certType)
2352 {
2353         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2354
2355         result r = E_SUCCESS;
2356         String query;
2357         DbStatement* pStmt = null;
2358         DbEnumerator* pEnum = null;
2359
2360         query.Format(1024, L"INSERT INTO PkgPrivileges (ID, PRIVILEGES, HMAC_PPRIVILEGES, CERTIFICATE_TYPE) VALUES (?,?,?,?)");
2361
2362         pStmt = CreateStatementN(*__pDb, query);
2363         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2364
2365         if (id != 0)
2366         {
2367                 r = pStmt->BindInt(0, id);
2368                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2369         }
2370
2371         if (!privileges.IsEmpty())
2372         {
2373                 r = pStmt->BindString(1, privileges);
2374                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2375         }
2376
2377         if (!hmacPrivileges.IsEmpty())
2378         {
2379                 r = pStmt->BindString(2, hmacPrivileges);
2380                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2381         }
2382
2383         if (certType != 0)
2384         {
2385                 r = pStmt->BindInt(3, certType);
2386                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2387         }
2388
2389         pEnum = ExecuteStatementN(*__pDb, pStmt);
2390
2391         delete pStmt;
2392         pStmt = null;
2393         delete pEnum;
2394         pEnum = null;
2395
2396         r = GetLastResult();
2397
2398 CATCH:
2399         delete pStmt;
2400         return r;
2401 }
2402
2403 result
2404 _PackageManagerImpl::GetPackageName(const PackageId& packageId, const String* pName, char* pPackageName, int bufferSize)
2405 {
2406         result r = E_SUCCESS;
2407         Database db;
2408         DbStatement* pStmt = null;
2409         DbEnumerator* pEnum = null;
2410         String query;
2411         Tizen::Base::String packageName;
2412
2413         if (pName == null)
2414         {
2415                 query.Format(
2416                         1024,
2417                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
2418                         "True", packageId.GetPointer());
2419         }
2420         else
2421         {
2422                 query.Format(
2423                         1024,
2424                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and APP_NAME = '%ls' and PkgInfo.PKG_ID = '%ls'",
2425                         pName->GetPointer(), packageId.GetPointer());
2426         }
2427
2428         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
2429         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2430
2431         pStmt = CreateStatementN(db, query);
2432         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2433                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2434
2435         pEnum = ExecuteStatementN(db, pStmt);
2436         if (pEnum != null)
2437         {
2438                 if (pEnum->MoveNext() == E_SUCCESS)
2439                 {
2440                         pEnum->GetStringAt(0, packageName);
2441                         snprintf(pPackageName, bufferSize, "%ls", packageName.GetPointer());
2442                 }
2443                 delete pEnum;
2444         }
2445         else
2446         {
2447                 r = E_OBJ_NOT_FOUND;
2448         }
2449
2450 CATCH:
2451         delete pStmt;
2452
2453         return r;
2454 }
2455
2456 String
2457 _PackageManagerImpl::GetDefaultAppExecutableName(const PackageId& packageId)
2458 {
2459         result r = E_SUCCESS;
2460         Database db;
2461         DbStatement* pStmt = null;
2462         DbEnumerator* pEnum = null;
2463         String query;
2464         String executableName;
2465
2466         query.Format(
2467                 1024,
2468                 L"SELECT AppInfo.APP_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
2469                 "True", packageId.GetPointer());
2470
2471         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
2472         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2473
2474         pStmt = CreateStatementN(db, query);
2475         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2476                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2477
2478         pEnum = ExecuteStatementN(db, pStmt);
2479         if (pEnum != null)
2480         {
2481                 if (pEnum->MoveNext() == E_SUCCESS)
2482                 {
2483                         pEnum->GetStringAt(0, executableName);
2484                 }
2485                 delete pEnum;
2486         }
2487         else
2488         {
2489                 r = E_OBJ_NOT_FOUND;
2490                 SetLastResult(r);
2491         }
2492
2493 CATCH:
2494         delete pStmt;
2495
2496         return executableName;
2497 }
2498
2499 DbStatement*
2500 _PackageManagerImpl::CreateStatementN(Database& db, const String& query)
2501 {
2502         result r = E_SUCCESS;
2503         DbStatement* pStmt = null;
2504
2505         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2506         {
2507                 pStmt = db.CreateStatementN(query);
2508                 r = GetLastResult();
2509
2510                 if (r != E_OBJECT_LOCKED)
2511                 {
2512                         break;
2513                 }
2514                 else
2515                 {
2516                         SysLog(NID_APP, "RetryCount[%d] CreateStatementN - E_OBJECT_LOCKED", i);
2517                         delete pStmt;
2518                         pStmt = null;
2519                         usleep(50000);
2520                 }
2521         }
2522
2523         return pStmt;
2524 }
2525
2526 DbEnumerator*
2527 _PackageManagerImpl::ExecuteStatementN(Database& db, const DbStatement* pStmt)
2528 {
2529         result r = E_SUCCESS;
2530         DbEnumerator* pEnum = null;
2531
2532         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2533         {
2534                 pEnum = db.ExecuteStatementN(*pStmt);
2535                 r = GetLastResult();
2536
2537                 if (r != E_OBJECT_LOCKED)
2538                 {
2539                         break;
2540                 }
2541                 else
2542                 {
2543                         SysLog(NID_APP, "RetryCount[%d] ExecuteStatementN - E_OBJECT_LOCKED", i);
2544                         delete pEnum;
2545                         pEnum = null;
2546                         usleep(50000);
2547                 }
2548         }
2549
2550         return pEnum;
2551 }
2552
2553 } } } // Tizen::App::Package