src/ui/FUi_ResourceManager.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 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 #include <dlfcn.h>
  18 #include <pthread.h>
  19 #include <feedback/feedback.h>
  20 #include <FBaseInteger.h>
  21 #include <FBaseByteBuffer.h>
  22 #include <FBaseColIMap.h>
  23 #include <FBaseColArrayListT.h>
  24 #include <FBaseSysLog.h>
  25 #include <FIoDirectory.h>
  26 #include <FIoFile.h>
  27 #include <FGrpBitmap.h>
  28 #include <FGrpDimension.h>
  29 #include <FGrpColor.h>
  30 #include <FMediaImageTypes.h>
  31 #include <FUiCtrlAnimationFrame.h>
  32 #include <FApp_AppInfo.h>
  33 #include <FAppPkg_PackageManagerImpl.h>
  34 #include <FIo_DirectoryImpl.h>
  35 #include <FGrp_BitmapImpl.h>
  36 #include <FGrp_CanvasImpl.h>
  37 #include <FGrp_CoordinateSystem.h>
  38 #include <FGrp_Screen.h>
  39 #include <FMedia_ImageDecoder.h>
  40 #include <FSys_SystemInfoImpl.h>
  41 #include "FUi_ControlManager.h"
  42 #include "FUi_CoordinateSystemUtils.h"
  43 #include "FUi_ResourceManager.h"
  44 #include "FUi_ResourceStringLoader.h"
  45 #include "FUi_ResourceConfigLoader.h"
  46 #include "FUi_ResourceConfigParser.h"
  47 #include "FUi_ResourceMapContainer.h"
  48
  49 using namespace Tizen::App;
  50 using namespace Tizen::App::Package;
  51 using namespace Tizen::Base;
  52 using namespace Tizen::Base::Collection;
  53 using namespace Tizen::Io;
  54 using namespace Tizen::Graphics;
  55 using namespace Tizen::Media;
  56 using namespace Tizen::Ui::Controls;
  57 using namespace Tizen::Ui::_Resource;
  58
  59 namespace
  60 {
  61 const int DEFAULT_SCREEN_WIDTH = 720;
  62 const int DEFAULT_SCREEN_HEIGHT = 1280;
  63
  64 const int DPI_FOR_XHIGH = 290;
  65 const int DPI_FOR_HIGH = 200;
  66 const int DPI_FOR_MIDDLE = 150;
  67 const int DPI_FOR_LOW = 0;
  68
  69 template<typename T> class ResourceFallbackItemComparer
  70         : public IComparerT <T>
  71 {
  72 public:
  73         ResourceFallbackItemComparer(void) {}
  74         virtual ~ResourceFallbackItemComparer(void) {}
  75         virtual result Compare(const T& obj1, const T& obj2, int& cmp) const
  76         {
  77                 if (obj1->scaleFactor > obj2->scaleFactor)
  78                 {
  79                         cmp = 1;
  80                         return E_SUCCESS;
  81                 }
  82                 else if (obj1->scaleFactor < obj2->scaleFactor)
  83                 {
  84                         cmp = -1;
  85                         return E_SUCCESS;
  86                 }
  87                 else
  88                 {
  89                         cmp = 0;
  90                         return E_SUCCESS;
  91                 }
  92         }
  93 };
  94
  95 MediaPixelFormat ConvertBitmapPixelFormatToMediaPixelFormat(BitmapPixelFormat format)
  96 {
  97         MediaPixelFormat out = MEDIA_PIXEL_FORMAT_NONE;
  98         switch(format)
  99         {
 100                 case BITMAP_PIXEL_FORMAT_RGB565:
 101                         out = MEDIA_PIXEL_FORMAT_RGB565LE;
 102                         break;
 103                 case BITMAP_PIXEL_FORMAT_ARGB8888:
 104                         out = MEDIA_PIXEL_FORMAT_BGRA8888;
 105                         break;
 106                 case BITMAP_PIXEL_FORMAT_R8G8B8A8:
 107                         out = MEDIA_PIXEL_FORMAT_RGBA8888;
 108                         break;
 109                 default:
 110                         break;
 111         }
 112         return out;
 113 }
 114
 115 feedback_pattern_e Convert_ResourceFeedbackPatternTofeedback_pattern_e(Tizen::Ui::_ResourceFeedbackPattern pattern)
 116 {
 117         feedback_pattern_e outPattern = FEEDBACK_PATTERN_TAP;
 118         switch (pattern)
 119         {
 120                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_TAP:
 121                         outPattern = FEEDBACK_PATTERN_TAP;
 122                         break;
 123                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_SIP:
 124                         outPattern = FEEDBACK_PATTERN_SIP;
 125                         break;
 126                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_SIP_BACKSPACE:
 127                         outPattern = FEEDBACK_PATTERN_SIP_BACKSPACE;
 128                         break;
 129                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_MAX_CHARACTER:
 130                         outPattern = FEEDBACK_PATTERN_MAX_CHARACTER;
 131                         break;
 132                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY0:
 133                         outPattern = FEEDBACK_PATTERN_KEY0;
 134                         break;
 135                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY1:
 136                         outPattern = FEEDBACK_PATTERN_KEY1;
 137                         break;
 138                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY2:
 139                         outPattern = FEEDBACK_PATTERN_KEY2;
 140                         break;
 141                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY3:
 142                         outPattern = FEEDBACK_PATTERN_KEY3;
 143                         break;
 144                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY4:
 145                         outPattern = FEEDBACK_PATTERN_KEY4;
 146                         break;
 147                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY5:
 148                         outPattern = FEEDBACK_PATTERN_KEY5;
 149                         break;
 150                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY6:
 151                         outPattern = FEEDBACK_PATTERN_KEY6;
 152                         break;
 153                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY7:
 154                         outPattern = FEEDBACK_PATTERN_KEY7;
 155                         break;
 156                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY8:
 157                         outPattern = FEEDBACK_PATTERN_KEY8;
 158                         break;
 159                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY9:
 160                         outPattern = FEEDBACK_PATTERN_KEY9;
 161                         break;
 162                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY_STAR:
 163                         outPattern = FEEDBACK_PATTERN_KEY_STAR;
 164                         break;
 165                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY_SHARP:
 166                         outPattern = FEEDBACK_PATTERN_KEY_SHARP;
 167                         break;
 168                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_HOLD:
 169                         outPattern = FEEDBACK_PATTERN_HOLD;
 170                         break;
 171                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_MULTI_TAP:
 172                         outPattern = FEEDBACK_PATTERN_MULTI_TAP;
 173                         break;
 174                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_HW_TAP:
 175                         outPattern = FEEDBACK_PATTERN_HW_TAP;
 176                         break;
 177                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_HW_HOLD:
 178                         outPattern = FEEDBACK_PATTERN_HW_HOLD;
 179                         break;
 180                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_MESSAGE:
 181                         outPattern = FEEDBACK_PATTERN_MESSAGE;
 182                         break;
 183                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_MESSAGE_ON_CALL:
 184                         outPattern = FEEDBACK_PATTERN_MESSAGE_ON_CALL;
 185                         break;
 186                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_EMAIL:
 187                         outPattern = FEEDBACK_PATTERN_EMAIL;
 188                         break;
 189                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_EMAIL_ON_CALL:
 190                         outPattern = FEEDBACK_PATTERN_EMAIL_ON_CALL;
 191                         break;
 192                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_WAKEUP:
 193                         outPattern = FEEDBACK_PATTERN_WAKEUP;
 194                         break;
 195                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_WAKEUP_ON_CALL:
 196                         outPattern = FEEDBACK_PATTERN_WAKEUP_ON_CALL;
 197                         break;
 198                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_SCHEDULE:
 199                         outPattern = FEEDBACK_PATTERN_SCHEDULE;
 200                         break;
 201                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_SCHEDULE_ON_CALL:
 202                         outPattern = FEEDBACK_PATTERN_SCHEDULE_ON_CALL;
 203                         break;
 204                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_TIMER:
 205                         outPattern = FEEDBACK_PATTERN_TIMER;
 206                         break;
 207                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_TIMER_ON_CALL:
 208                         outPattern = FEEDBACK_PATTERN_TIMER_ON_CALL;
 209                         break;
 210                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_GENERAL:
 211                         outPattern = FEEDBACK_PATTERN_GENERAL;
 212                         break;
 213                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_GENERAL_ON_CALL:
 214                         outPattern = FEEDBACK_PATTERN_GENERAL_ON_CALL;
 215                         break;
 216                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_POWERON:
 217                         outPattern = FEEDBACK_PATTERN_POWERON;
 218                         break;
 219                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_POWEROFF:
 220                         outPattern = FEEDBACK_PATTERN_POWEROFF;
 221                         break;
 222                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_CHARGERCONN:
 223                         outPattern = FEEDBACK_PATTERN_CHARGERCONN;
 224                         break;
 225                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_CHARGERCONN_ON_CALL:
 226                         outPattern = FEEDBACK_PATTERN_CHARGERCONN_ON_CALL;
 227                         break;
 228                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_FULLCHARGED:
 229                         outPattern = FEEDBACK_PATTERN_FULLCHARGED;
 230                         break;
 231                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_FULLCHARGED_ON_CALL:
 232                         outPattern = FEEDBACK_PATTERN_FULLCHARGED_ON_CALL;
 233                         break;
 234                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_LOWBATT:
 235                         outPattern = FEEDBACK_PATTERN_LOWBATT;
 236                         break;
 237                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_LOWBATT_ON_CALL:
 238                         outPattern = FEEDBACK_PATTERN_LOWBATT_ON_CALL;
 239                         break;
 240                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_LOCK:
 241                         outPattern = FEEDBACK_PATTERN_LOCK;
 242                         break;
 243                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_UNLOCK:
 244                         outPattern = FEEDBACK_PATTERN_UNLOCK;
 245                         break;
 246                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_CALLCONNECT:
 247                         outPattern = FEEDBACK_PATTERN_CALLCONNECT;
 248                         break;
 249                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_DISCALLCONNECT:
 250                         outPattern = FEEDBACK_PATTERN_DISCALLCONNECT;
 251                         break;
 252                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_MINUTEMINDER:
 253                         outPattern = FEEDBACK_PATTERN_MINUTEMINDER;
 254                         break;
 255                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_VIBRATION:
 256                         outPattern = FEEDBACK_PATTERN_VIBRATION;
 257                         break;
 258                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_SHUTTER:
 259                         outPattern = FEEDBACK_PATTERN_SHUTTER;
 260                         break;
 261                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_LIST_REORDER:
 262                         outPattern = FEEDBACK_PATTERN_LIST_REORDER;
 263                         break;
 264                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_SLIDER_SWEEP:
 265                         outPattern = FEEDBACK_PATTERN_SLIDER_SWEEP;
 266                         break;
 267                 default:
 268                         break;
 269         }
 270         return outPattern;
 271 }
 272 }
 273
 274 namespace Tizen { namespace Graphics
 275 {
 276 result
 277 _CreateCoordinateTransformer(_ICoordinateSystemTransformer*& pTransformer, int srcResolution, _BaseScreenSize srcBaseScreenSize, Dimension destResolution, _BaseScreenSize destBaseScreenSize);
 278 }}
 279
 280 namespace Tizen { namespace Ui
 281 {
 282
 283 int _SCREEN_HEIGHT_ = 0;
 284
 285 Color _GetDefaultBackgroundColor(void)
 286 {
 287         Color color;
 288         GET_COLOR_CONFIG(BASIC::background, color);
 289         return color;
 290 }
 291 Color _GetDefaultForegroundColor(void)
 292 {
 293         Color color;
 294         GET_COLOR_CONFIG(BASIC::foreground, color);
 295         return color;
 296 }
 297
 298 _ResourceManager* pRsrcMgr = null;
 299
 300 _ResourceManager*
 301 _ResourceManager::GetInstance(void)
 302 {
 303         static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
 304
 305         if (pRsrcMgr == null)
 306         {
 307                 pthread_once(&onceBlock, CreateInstance);
 308                 pRsrcMgr->DoPostInitialization();
 309         }
 310         return pRsrcMgr;
 311 }
 312
 313 void
 314 _ResourceManager::CreateInstance(void)
 315 {
 316         static _ResourceManager pManager;
 317         pRsrcMgr = &pManager;
 318         _CanvasImpl::SetThemeInfoCallback(_GetDefaultForegroundColor, _GetDefaultBackgroundColor);
 319 }
 320
 321 _ResourceManager::_ResourceManager(void)
 322         : __pStringLoader(null)
 323         , __pTransformer(null)
 324         , __appBasePortraitMode("")
 325         , __appBaseLandscapeMode("")
 326         , __targetPortraitMode("")
 327         , __targetLandscapeMode("")
 328         , __defaultPortraitMode(L"720x1280")
 329         , __defaultLandscapeMode(L"1280x720")
 330         , __systemTheme(L"")
 331         , __userTheme(L"")
 332         , __appliedUserTheme(false)
 333         , __initializeFeedback(false)
 334         , __appBaseWidth(-1)
 335         , __appBaseHeight(-1)
 336         , __targetWidth(0)
 337         , __targetHeight(0)
 338         , __deviceDPI(0)
 339         , __feedbackStatus(_RESOURCE_FEEDBACK_STATUS_INIT)
 340         , __feedbackAcquireCount(0)
 341         , __pFallbackList(null)
 342 {
 343         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT] = null;
 344         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE] = null;
 345         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT] = null;
 346         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE] = null;
 347
 348         int appBaseWidth = DEFAULT_SCREEN_WIDTH;
 349         int appBaseHeight = DEFAULT_SCREEN_HEIGHT;
 350
 351         result r = E_SUCCESS;
 352
 353         int appLogicalResolution = _CoordinateSystem::GetInstance()->GetLogicalResolutionInt();
 354
 355         if (_CreateCoordinateTransformer(__pTransformer,DEFAULT_SCREEN_WIDTH, _CoordinateSystem::GetInstance()->GetLogicalBaseScreenSize(),
 356                         Dimension(appLogicalResolution, appLogicalResolution), _CoordinateSystem::GetInstance()->GetPhysicalBaseScreenSize()) != E_SUCCESS)
 357         {
 358
 359                 SysAssert(0);
 360         }
 361         r = Tizen::System::_SystemInfoImpl::GetSysInfo(L"http://tizen.org/feature/screen.dpi", __deviceDPI);
 362         SysTryReturn(NID_UI, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] system error occurred");
 363
 364         _ControlManager::GetInstance()->SetScreenDpi(__deviceDPI);
 365
 366         switch(appLogicalResolution)
 367         {
 368                 case 240:
 369                         appBaseWidth = 240;
 370                         appBaseHeight = 400;
 371                         break;
 372                 case 320:
 373                         appBaseWidth = 320;
 374                         appBaseHeight = 480;
 375                         break;
 376                 case 480:
 377                         appBaseWidth = 480;
 378                         appBaseHeight = 800;
 379                         break;
 380                 case 720:
 381                         appBaseWidth = 720;
 382                         appBaseHeight = 1280;
 383                         break;
 384                 default:
 385                         r = Tizen::System::_SystemInfoImpl::GetSysInfo("http://tizen.org/feature/screen.width", appBaseWidth);
 386                         SysTryReturn(NID_UI, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] system error occurred");
 387                         r = Tizen::System::_SystemInfoImpl::GetSysInfo("http://tizen.org/feature/screen.height", appBaseHeight);
 388                         SysTryReturn(NID_UI, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] system error occurred");
 389                         break;
 390         }
 391         __appBaseWidth = appBaseWidth;
 392         __appBaseHeight = appBaseHeight;
 393
 394         __appBasePortraitMode.Append(appBaseWidth);
 395         __appBasePortraitMode.Append(L"x");
 396         __appBasePortraitMode.Append(appBaseHeight);
 397
 398         __appBaseLandscapeMode.Append(appBaseHeight);
 399         __appBaseLandscapeMode.Append(L"x");
 400         __appBaseLandscapeMode.Append(appBaseWidth);
 401         int _width = 0;
 402         int _height = 0;
 403         r = Tizen::System::_SystemInfoImpl::GetSysInfo("http://tizen.org/feature/screen.width", _width);
 404         SysTryReturn(NID_UI, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] system error occurred");
 405         r = Tizen::System::_SystemInfoImpl::GetSysInfo("http://tizen.org/feature/screen.height", _height);
 406         SysTryReturn(NID_UI, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] system error occurred");
 407
 408         __targetWidth = _width;
 409         __targetHeight = _height;
 410         __targetPortraitMode.Append(_width);
 411         __targetPortraitMode.Append(L"x");
 412         __targetPortraitMode.Append(_height);
 413
 414         __targetLandscapeMode.Append(_height);
 415         __targetLandscapeMode.Append(L"x");
 416         __targetLandscapeMode.Append(_width);
 417
 418         Dimension dim = _CoordinateSystemUtils::InverseTransform(Dimension(_Screen::GetWidth(), _Screen::GetHeight()));
 419         __logicalWidth = dim.width;
 420         __logicalHeight = dim.height;
 421         LoadThemeInformation(__systemTheme, __userTheme);
 422         // theme 2.0
 423         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT] = new (std::nothrow) MapContainer();
 424         SysTryReturnVoidResult(NID_UI, __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT], E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 425         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->SetResolution(__appBasePortraitMode);
 426         if (!(InitializeTheme(*__pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT])))
 427         {
 428                 SysAssert(0);
 429         }
 430         __pStringLoader = new (std::nothrow) StringLoader();
 431         SysTryReturnVoidResult(NID_UI, __pStringLoader, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 432 }
 433
 434 bool
 435 _ResourceManager::InitializeTheme(MapContainer& mapContainer)
 436 {
 437         bool r = false;
 438         String themeFile(L"");
 439         mapContainer.CreateMap(RESOURCE_TYPE_SHAPE);
 440         mapContainer.CreateMap(RESOURCE_TYPE_FIXED_VALUE);
 441         mapContainer.CreateMap(RESOURCE_TYPE_DIMENSION);
 442         mapContainer.CreateMap(RESOURCE_TYPE_IMAGE);
 443         mapContainer.CreateMap(RESOURCE_TYPE_COLOR);
 444         mapContainer.CreateMap(RESOURCE_TYPE_ANIMATION);
 445         mapContainer.SetResolution(__appBasePortraitMode);
 446         themeFile = String(L"/usr/share/osp/themes/"+__systemTheme + ".xml");
 447         ConfigParser* pParser = new (std::nothrow) ConfigParser();
 448         SysTryReturn(NID_UI, pParser, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 449         r = pParser->Parse(themeFile, mapContainer);
 450         LoadConfig(__appBasePortraitMode, mapContainer, __appBaseWidth, __appBaseHeight);
 451         if (__userTheme.GetLength() > 0)
 452         {
 453                 themeFile = String(_AppInfo::GetAppRootPath()+L"res/themes/" +__userTheme + L"/" +__userTheme + ".xml");
 454                 r = pParser->Parse(themeFile, mapContainer);
 455         }
 456         delete pParser;
 457         return r;
 458 }
 459
 460 void
 461 _ResourceManager::LoadConfig(const String& resolution, MapContainer& mapContainer, int width, int height)
 462 {
 463         _ICoordinateSystemTransformer* pTransformer = _CoordinateSystem::GetTransformerN(__appBaseWidth, _CoordinateSystem::GetInstance()->GetLogicalBaseScreenSize(),
 464         Dimension(width, height), BASE_SCREEN_SIZE_NORMAL);
 465
 466         if (pTransformer)
 467         {
 468                 _SCREEN_HEIGHT_ = pTransformer->Transform(__logicalHeight);
 469         }
 470         else
 471         {
 472                 _SCREEN_HEIGHT_ = __logicalHeight;
 473         }
 474
 475         SysLog(NID_UI, "_SCREEN_HEIGHT_ : %d, resolution : %ls", _SCREEN_HEIGHT_, resolution.GetPointer());
 476         int count = ConfigLoader::GetInstance()->GetInitFuncCount();
 477         for (int i = 0; i < count; i++)
 478         {
 479                 _Init_Func func = null;
 480                 ConfigLoader::GetInstance()->GetInitFunc(i, func);
 481                 if (func)
 482                 {
 483                         func(mapContainer, resolution);
 484                 }
 485         }
 486         delete pTransformer;
 487 }
 488
 489 void
 490 _ResourceManager::DoPostInitialization(void)
 491 {
 492         if (_AppInfo::IsOspCompat())
 493         {
 494                 SysLog(NID_UI, "Compatibility symbols are loaded.");
 495                 SetSystemColor();
 496         }
 497 }
 498
 499 MapContainer*
 500 _ResourceManager::GetMapContainer(MapContainerType type)
 501 {
 502         MapContainer* pContainer = null;
 503         switch (type)
 504         {
 505                 case MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT:
 506                         pContainer = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT];
 507                         break;
 508                 case MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE:
 509                         if (__pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE])
 510                         {
 511                                 pContainer = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE];
 512                         }
 513                         else
 514                         {
 515                                 pContainer = new (std::nothrow) MapContainer();
 516                                 SysTryReturn(NID_UI, pContainer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 517                                 pContainer->SetResolution(__appBaseLandscapeMode);
 518                                 pContainer->CreateMap(RESOURCE_TYPE_SHAPE);
 519                                 pContainer->CreateMap(RESOURCE_TYPE_DIMENSION);
 520                                 pContainer->CreateMap(RESOURCE_TYPE_FIXED_VALUE);
 521                                 LoadConfig(__appBaseLandscapeMode, *pContainer, __appBaseWidth, __appBaseHeight);
 522                                 __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE] = pContainer;
 523                         }
 524                         break;
 525                 case MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT:
 526                         if (__pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT])
 527                         {
 528                                 pContainer = __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT];
 529                         }
 530                         else
 531                         {
 532                                 if(__defaultPortraitMode == __appBasePortraitMode)
 533                                 {
 534                                         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT] = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT];
 535                                         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE] = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE];
 536                                         pContainer = __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT];
 537                                 }
 538                                 else
 539                                 {
 540                                         pContainer = new (std::nothrow) MapContainer();
 541                                         SysTryReturn(NID_UI, pContainer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 542                                         pContainer->SetResolution(__defaultPortraitMode);
 543                                         pContainer->CreateMap(RESOURCE_TYPE_SHAPE);
 544                                         pContainer->CreateMap(RESOURCE_TYPE_DIMENSION);
 545                                         pContainer->CreateMap(RESOURCE_TYPE_FIXED_VALUE);
 546                                         LoadConfig(__defaultPortraitMode, *pContainer, DEFAULT_SCREEN_WIDTH, DEFAULT_SCREEN_HEIGHT);
 547                                         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT] = pContainer;
 548                                 }
 549                         }
 550                         break;
 551                 case MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE:
 552                         if (__pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE])
 553                         {
 554                                 pContainer = __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE];
 555                         }
 556                         else
 557                         {
 558                                 if(__defaultPortraitMode == __appBasePortraitMode)
 559                                 {
 560                                         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT] = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT];
 561                                         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE] = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE];
 562                                         pContainer = __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE];
 563                                 }
 564                                 else
 565                                 {
 566                                         pContainer = new (std::nothrow) MapContainer();
 567                                         SysTryReturn(NID_UI, pContainer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 568                                         pContainer->SetResolution(__defaultLandscapeMode);
 569                                         pContainer->CreateMap(RESOURCE_TYPE_SHAPE);
 570                                         pContainer->CreateMap(RESOURCE_TYPE_DIMENSION);
 571                                         pContainer->CreateMap(RESOURCE_TYPE_FIXED_VALUE);
 572                                         LoadConfig(__defaultLandscapeMode, *pContainer, DEFAULT_SCREEN_WIDTH, DEFAULT_SCREEN_HEIGHT);
 573                                         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE] = pContainer;
 574                                 }
 575                         }
 576                         break;
 577                 default:
 578                         break;
 579         }
 580         return pContainer;
 581 }
 582
 583 _ResourceManager::~_ResourceManager(void)
 584 {
 585         delete __pStringLoader;
 586         __pStringLoader = null;
 587         delete __pTransformer;
 588         __pTransformer = null;
 589         delete __pFallbackList;
 590         __pFallbackList = null;
 591         bool deleteDefaultMap = true;
 592         if (__pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT] == __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT])
 593         {
 594                 deleteDefaultMap = false;
 595         }
 596         delete __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT];
 597         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT] = null;
 598         delete __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE];
 599         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE] = null;
 600
 601         if (deleteDefaultMap)
 602         {
 603                 delete __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT];
 604                 __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT] = null;
 605                 delete __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE];
 606                 __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE] = null;
 607         }
 608
 609         feedback_deinitialize();
 610 }
 611 void
 612 _ResourceManager::ReloadTheme(Tizen::Base::String& themeName, bool userdefine)
 613 {
 614         if(userdefine)
 615         {
 616                 __userTheme = themeName;
 617         }
 618         else
 619         {
 620                 __systemTheme = themeName;
 621         }
 622 }
 623
 624 result
 625 _ResourceManager::GetBitmapInternalN(const String& fileName, BitmapPixelFormat pixelFormat, _ControlOrientation orientation, Bitmap*& pBitmap)
 626 {
 627         result r = E_SYSTEM;
 628         Bitmap* pTempBitmap = null;
 629         int foundFolderWidth = 0;
 630         String fullName = FindImagePath(fileName, foundFolderWidth);
 631         if(foundFolderWidth == __targetWidth)
 632         {
 633                 pTempBitmap = new (std::nothrow) Bitmap;
 634                 SysTryReturn(NID_UI, pTempBitmap, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Propagating.", GetErrorMessage(r));
 635                 r = _BitmapImpl::GetInstance(*pTempBitmap)->Construct(fullName, pixelFormat);
 636                 SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 637                 pBitmap = pTempBitmap;
 638                 return r;
 639         }
 640         else
 641         {
 642                 if (_BitmapImpl::HasNinePatchedBitmapTag(fileName))
 643                 {
 644                         pTempBitmap = new (std::nothrow) Bitmap;
 645                         SysTryReturn(NID_UI, pTempBitmap, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Propagating.", GetErrorMessage(r));
 646                         r = _BitmapImpl::GetInstance(*pTempBitmap)->Construct(fullName, pixelFormat);
 647                         SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 648                         pBitmap = pTempBitmap;
 649                         return r;
 650                 }
 651                 else
 652                 {
 653                         ByteBuffer* pImageBuffer = null;
 654                         int imageWidth = 0;
 655                         int imageHeight = 0;
 656                         MediaPixelFormat format = ConvertBitmapPixelFormatToMediaPixelFormat(pixelFormat);
 657                         pImageBuffer = _ImageDecoder::DecodeToBufferN(fullName, format, imageWidth, imageHeight);
 658                         if (pImageBuffer)
 659                         {
 660                                 pTempBitmap = _BitmapImpl::GetNonScaledBitmapN(*pImageBuffer, Dimension(imageWidth, imageHeight), pixelFormat);
 661                                 delete pImageBuffer;
 662                         }
 663                         if(pTempBitmap != null)
 664                         {
 665                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pTempBitmap))
 666                                 {
 667                                         pBitmap = pTempBitmap;
 668                                         r = E_SUCCESS;
 669                                 }
 670                                 else
 671                                 {
 672                                         float scaleFactor = (float)((float)__targetWidth/(float)foundFolderWidth);
 673                                         r = pTempBitmap->Scale(Dimension(pTempBitmap->GetWidth()*scaleFactor, pTempBitmap->GetHeight()*scaleFactor));
 674                                         if (r == E_SUCCESS)
 675                                         {
 676                                                 pBitmap = pTempBitmap;
 677                                         }
 678                                         else
 679                                         {
 680                                                 delete pTempBitmap;
 681                                         }
 682                                 }
 683                         }
 684                 }
 685         }
 686         return r;
 687 CATCH:
 688         delete pTempBitmap;
 689         return r;
 690 }
 691
 692 result
 693 _ResourceManager::GetBitmapN(int bitmapId, BitmapPixelFormat pixelFormat, _ControlOrientation orientation, Bitmap*& pBitmap)
 694 {
 695         result r = E_SYSTEM;
 696         ResourceItem* pItem = null;
 697         String fileName;
 698         r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetImageMap()->GetValue(bitmapId, pItem);
 699         if (r == E_SUCCESS)
 700         {
 701                 fileName = pItem->GetImageName();
 702                 if (fileName.IsEmpty())
 703                 {
 704                         r = E_OBJ_NOT_FOUND;
 705                 }
 706                 else
 707                 {
 708                         r = GetBitmapInternalN(fileName, pixelFormat, orientation, pBitmap);
 709                 }
 710         }
 711         return r;
 712 }
 713
 714 result
 715 _ResourceManager::GetString(const String& stringId, String& string)
 716 {
 717         return __pStringLoader->GetString(stringId, string);
 718 }
 719
 720 result
 721 _ResourceManager::GetColor(int colorId, Color& color)
 722 {
 723         result r = E_SYSTEM;
 724         ResourceItem* pItem = null;
 725         r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetColorMap()->GetValue(colorId, pItem);
 726         if(r == E_SUCCESS)
 727         {
 728                 if(pItem->isInitialized())
 729                 {
 730                         color.SetRGB32(pItem->GetColor(), true);
 731                 }
 732                 else
 733                 {
 734                         unsigned int value = 0;
 735                         ResourceItem* pPaletteItem = null;
 736                         const char* key = pItem->GetRawString();
 737                         ResourceKey resourceKey(key);
 738                         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetPalette()->GetValue(resourceKey, pPaletteItem);
 739                         if(pPaletteItem)
 740                         {
 741                                 value = pPaletteItem->GetColor();
 742                                 pItem->SetRawDataColor(value);
 743                                 color.SetRGB32(value, true);
 744                         }
 745                         else
 746                         {
 747                                 color.SetRGB32(0,true);
 748                         }
 749                 }
 750         }
 751         return r;
 752 }
 753
 754 result
 755 _ResourceManager::GetDimension(int dimensionId, _ControlOrientation orientation, Dimension& dimension)
 756 {
 757         result r = E_SUCCESS;
 758         ResourceItem* pItem = null;
 759
 760         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 761         {
 762                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetDimensionMap()->GetValue(dimensionId, pItem);
 763                 if (r != E_SUCCESS)
 764                 {
 765                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetDimensionMap()->GetValue(dimensionId, pItem);
 766                 }
 767         }
 768         else
 769         {
 770                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetDimensionMap()->GetValue(dimensionId, pItem);
 771                 if (r != E_SUCCESS)
 772                 {
 773                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetDimensionMap()->GetValue(dimensionId, pItem);
 774                 }
 775         }
 776
 777         if (r == E_SUCCESS)
 778         {
 779                 dimension.SetSize(pItem->GetDimension().width, pItem->GetDimension().height);
 780         }
 781         else
 782         {
 783                 r = GetDefaultShapeWithScaling(dimensionId, orientation, dimension);
 784         }
 785
 786         return r;
 787 }
 788
 789 result
 790 _ResourceManager::GetDimension(int dimensionId, _ControlOrientation orientation, Tizen::Graphics::FloatDimension& dimension)
 791 {
 792         result r = E_SUCCESS;
 793         ResourceItem* pItem = null;
 794
 795         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 796         {
 797                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetDimensionMap()->GetValue(dimensionId, pItem);
 798                 if (r != E_SUCCESS)
 799                 {
 800                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetDimensionMap()->GetValue(dimensionId, pItem);
 801                 }
 802         }
 803         else
 804         {
 805                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetDimensionMap()->GetValue(dimensionId, pItem);
 806                 if (r != E_SUCCESS)
 807                 {
 808                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetDimensionMap()->GetValue(dimensionId, pItem);
 809                 }
 810         }
 811
 812         if (r == E_SUCCESS)
 813         {
 814                 dimension = pItem->GetDimension();
 815         }
 816         else
 817         {
 818                 r = GetDefaultShapeWithScaling(dimensionId, orientation, dimension);
 819         }
 820
 821         return r;
 822 }
 823
 824 result
 825 _ResourceManager::GetAnimationN(int animationId, ArrayList*& pList)
 826 {
 827         ResourceAnimationFrameList* pFrameList = null;
 828         AnimationFrame* pFrame = null;
 829         Bitmap* pBitmap = null;
 830         ResourceItem* pItem = null;
 831
 832         result r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetAnimationMap()->GetValue(animationId, pItem);
 833         SysTryReturnResult(NID_UI, r == E_SUCCESS, E_SYSTEM,"System error is occured.");
 834
 835         pFrameList = pItem->GetAnimationFrameList();
 836         Tizen::Base::Collection::LinkedListT<ResourceAnimationFrame>* pAnimationList = static_cast<Tizen::Base::Collection::LinkedListT<ResourceAnimationFrame>* >(pFrameList->GetAnimationList());
 837         if (pAnimationList == null)
 838         {
 839                 return E_SYSTEM;
 840         }
 841         int count = pAnimationList->GetCount();
 842         if (count == 0)
 843         {
 844                 return E_SYSTEM;
 845         }
 846         pList = new (std::nothrow) ArrayList();
 847         int i = 0;
 848         for (; i < count ; i++)
 849         {
 850                 ResourceAnimationFrame frame;
 851                 r = pAnimationList->GetAt(i, frame);
 852                 SysTryCatch(NID_UI, r == E_SUCCESS, , E_SYSTEM,"System error is occured.");
 853                 r = GetBitmapInternalN(frame.__fileName, BITMAP_PIXEL_FORMAT_ARGB8888, _CONTROL_ORIENTATION_PORTRAIT, pBitmap);
 854                 SysTryCatch(NID_UI, r == E_SUCCESS, , E_SYSTEM,"System error is occured.");
 855                 pFrame = new (std::nothrow) AnimationFrame(*pBitmap, frame.__duration);
 856                 SysTryCatch(NID_UI, pFrame, , E_SYSTEM,"System error is occured.");
 857                 pList->Add(pFrame);
 858                 delete pBitmap;
 859         }
 860         return E_SUCCESS;
 861
 862 CATCH:
 863         delete pBitmap;
 864         delete pFrame;
 865         delete pList;
 866         pList = null;
 867         return E_SYSTEM;
 868 }
 869 result
 870 _ResourceManager::GetShape(int shapeId, _ControlOrientation orientation, int& value)
 871 {
 872         result r = E_SUCCESS;
 873         ResourceItem* pItem = null;
 874
 875         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 876         {
 877                 r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetShapeMap()->GetValue(shapeId, pItem);
 878                 if (r != E_SUCCESS)
 879                 {
 880                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
 881                 }
 882         }
 883         else
 884         {
 885                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
 886                 if (r != E_SUCCESS)
 887                 {
 888                         r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetShapeMap()->GetValue(shapeId, pItem);
 889                 }
 890         }
 891
 892         if (r == E_SUCCESS)
 893         {
 894                 value = (int)pItem->GetFloat();
 895         }
 896         else
 897         {
 898                 r = GetDefaultShapeWithScaling(shapeId, orientation, value);
 899         }
 900         return r;
 901 }
 902
 903 result
 904 _ResourceManager::GetShape(int shapeId, _ControlOrientation orientation, float& value)
 905 {
 906         result r = E_SUCCESS;
 907         ResourceItem* pItem = null;
 908
 909         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 910         {
 911                 r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetShapeMap()->GetValue(shapeId, pItem);
 912                 if (r != E_SUCCESS)
 913                 {
 914                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
 915                 }
 916         }
 917         else
 918         {
 919                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
 920                 if (r != E_SUCCESS)
 921                 {
 922                         r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetShapeMap()->GetValue(shapeId, pItem);
 923                 }
 924         }
 925
 926         if (r == E_SUCCESS)
 927         {
 928                 value = pItem->GetFloat();
 929         }
 930         else
 931         {
 932                 r = GetDefaultShapeWithScaling(shapeId, orientation, value);
 933         }
 934
 935         return r;
 936 }
 937
 938 result
 939 _ResourceManager::GetFixedValue(int fixedValueId, _ControlOrientation orientation, int& value)
 940 {
 941         result r = E_SUCCESS;
 942         ResourceItem* pItem = null;
 943
 944         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 945         {
 946                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 947                 if (r != E_SUCCESS)
 948                 {
 949
 950                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 951                 }
 952         }
 953         else
 954         {
 955                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 956                 if (r != E_SUCCESS)
 957                 {
 958                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 959                 }
 960         }
 961
 962         if (r != E_SUCCESS)
 963         {
 964                 if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 965                 {
 966                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 967                         if (r != E_SUCCESS)
 968                         {
 969                                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 970                         }
 971                 }
 972                 else
 973                 {
 974                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 975                         if (r != E_SUCCESS)
 976                         {
 977                                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 978                         }
 979                 }
 980         }
 981
 982         if (r == E_SUCCESS)
 983         {
 984                 value = (int)(pItem->GetFloat());
 985         }
 986
 987         return r;
 988 }
 989
 990 result
 991 _ResourceManager::GetFixedValue(int fixedValueId, _ControlOrientation orientation, float& value)
 992 {
 993         result r = E_SUCCESS;
 994         ResourceItem* pItem = null;
 995
 996         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 997         {
 998                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 999                 if (r != E_SUCCESS)
1000                 {
1001
1002                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1003                 }
1004         }
1005         else
1006         {
1007                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1008                 if (r != E_SUCCESS)
1009                 {
1010                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1011                 }
1012         }
1013
1014         if (r != E_SUCCESS)
1015         {
1016                 if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1017                 {
1018                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1019                         if (r != E_SUCCESS)
1020                         {
1021                                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1022                         }
1023                 }
1024                 else
1025                 {
1026                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1027                         if (r != E_SUCCESS)
1028                         {
1029                                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1030                         }
1031                 }
1032         }
1033
1034         if (r == E_SUCCESS)
1035         {
1036                 value = pItem->GetFloat();
1037         }
1038
1039         return r;
1040 }
1041
1042 bool
1043 _ResourceManager::IsCustomColor(int colorId)
1044 {
1045         return __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetColorMap()->IsUserThemeItem(colorId);
1046 }
1047 bool
1048 _ResourceManager::IsCustomBitmap(int bitmapId)
1049 {
1050         return __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetImageMap()->IsUserThemeItem(bitmapId);
1051 }
1052
1053 result
1054 _ResourceManager::PlayFeedback(_ResourceFeedbackPattern pattern)
1055 {
1056         if (unlikely(__initializeFeedback == false))
1057         {
1058                 feedback_error_e error = (feedback_error_e)feedback_initialize();
1059                 if(error != FEEDBACK_ERROR_NONE)
1060                 {
1061                         SysAssert(0);
1062                 }
1063                 __initializeFeedback = true;
1064         }
1065         if (__feedbackStatus == _RESOURCE_FEEDBACK_STATUS_PLAYED)
1066         {
1067                 SysLog(NID_UI, "feedback is already played.");
1068                 return E_SUCCESS;
1069         }
1070         feedback_pattern_e playPattern = Convert_ResourceFeedbackPatternTofeedback_pattern_e(pattern);
1071         __feedbackStatus = _RESOURCE_FEEDBACK_STATUS_PLAYED;
1072         int r = feedback_play(playPattern);
1073         if (r == FEEDBACK_ERROR_NONE)
1074         {
1075                 SysLog(NID_UI, "It succeeded to play feedback.");
1076                 return E_SUCCESS;
1077         }
1078         else
1079         {
1080                 SysLog(NID_UI, "It failed to play feedback.");
1081                 return E_SYSTEM;
1082         }
1083         return E_SUCCESS;
1084 }
1085
1086 result
1087 _ResourceManager::GetDefaultShapeWithScaling(int shapeId, _ControlOrientation orientation, int& value)
1088 {
1089         result r = E_SUCCESS;
1090         ResourceItem* pItem = null;
1091
1092         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1093         {
1094                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetShapeMap()->GetValue(shapeId, pItem);
1095                 if (r != E_SUCCESS)
1096                 {
1097                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
1098                 }
1099         }
1100         else
1101         {
1102                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
1103                 if (r != E_SUCCESS)
1104                 {
1105                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetShapeMap()->GetValue(shapeId, pItem);
1106                 }
1107         }
1108
1109         if (r == E_SUCCESS)
1110         {
1111                 value = (int)pItem->GetFloat();
1112         }
1113
1114         if (r == E_SUCCESS)
1115         {
1116                 int temp = __pTransformer->Transform(value);
1117                 if (temp == 0 && value > 0)
1118                 {
1119                         value = 1;
1120                 }
1121                 else
1122                 {
1123                         value = temp;
1124                 }
1125         }
1126         return r;
1127 }
1128
1129 result
1130 _ResourceManager::GetDefaultShapeWithScaling(int shapeId, _ControlOrientation orientation, Tizen::Graphics::FloatDimension& dimension)
1131 {
1132         result r = E_SUCCESS;
1133         ResourceItem* pItem = null;
1134
1135         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1136         {
1137                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetDimensionMap()->GetValue(shapeId, pItem);
1138                 if (r != E_SUCCESS)
1139                 {
1140                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetDimensionMap()->GetValue(shapeId, pItem);
1141                 }
1142         }
1143         else
1144         {
1145                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetDimensionMap()->GetValue(shapeId, pItem);
1146                 if (r != E_SUCCESS)
1147                 {
1148                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetDimensionMap()->GetValue(shapeId, pItem);
1149                 }
1150         }
1151
1152         if (r == E_SUCCESS)
1153         {
1154                 dimension = __pTransformer->Transform(pItem->GetDimension());
1155         }
1156
1157         return r;
1158 }
1159
1160 result
1161 _ResourceManager::GetDefaultShapeWithScaling(int shapeId, _ControlOrientation orientation, float& outValue)
1162 {
1163         result r = E_SUCCESS;
1164         ResourceItem* pItem = null;
1165
1166         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1167         {
1168                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetShapeMap()->GetValue(shapeId, pItem);
1169                 if (r != E_SUCCESS)
1170                 {
1171                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
1172                 }
1173         }
1174         else
1175         {
1176                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
1177                 if (r != E_SUCCESS)
1178                 {
1179                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetShapeMap()->GetValue(shapeId, pItem);
1180                 }
1181         }
1182
1183         if (r == E_SUCCESS)
1184         {
1185                 outValue = __pTransformer->Transform(pItem->GetFloat());
1186         }
1187
1188         return r;
1189 }
1190
1191 result
1192 _ResourceManager::GetDefaultShapeWithScaling(int shapeId, _ControlOrientation orientation, Dimension& dimension)
1193 {
1194         result r = E_SUCCESS;
1195         ResourceItem* pItem = null;
1196
1197         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1198         {
1199                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetDimensionMap()->GetValue(shapeId, pItem);
1200                 if (r != E_SUCCESS)
1201                 {
1202                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetDimensionMap()->GetValue(shapeId, pItem);
1203                 }
1204         }
1205         else
1206         {
1207                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetDimensionMap()->GetValue(shapeId, pItem);
1208                 if (r != E_SUCCESS)
1209                 {
1210                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetDimensionMap()->GetValue(shapeId, pItem);
1211                 }
1212         }
1213
1214         if (r == E_SUCCESS)
1215         {
1216                 Dimension dim((int)pItem->GetDimension().width, (int)pItem->GetDimension().height);
1217                 Dimension temp = __pTransformer->Transform(dim);
1218                 if (temp.width == 0 && dim.width > 0)
1219                 {
1220                         temp.width = 1;
1221                 }
1222                 if (temp.height == 0 && dim.height > 0)
1223                 {
1224                         temp.height = 1;
1225                 }
1226                 dimension = temp;
1227         }
1228         return r;
1229 }
1230
1231 result
1232 _ResourceManager::LoadThemeInformation(String& systemTheme, String& userTheme)
1233 {
1234         AppId appId = _AppInfo::GetPackageId();
1235         IMap* pList = null;
1236         pList = _PackageManagerImpl::GetInstance()->GetUiThemeListN(appId);
1237
1238         if (pList)
1239         {
1240                 IMapEnumerator* pMapEnum = pList->GetMapEnumeratorN();
1241                 while (pMapEnum->MoveNext() == E_SUCCESS)
1242                 {
1243                         String* pKey = static_cast<String*> (pMapEnum->GetKey());
1244                         String* pValue = static_cast<String*> (pMapEnum->GetValue());
1245                         String key(*pKey);
1246                         key.ToLowerCase();
1247                         if (key == L"systemtheme")
1248                         {
1249                                 systemTheme = *pValue;
1250                                 systemTheme.ToLowerCase();
1251                         }
1252                         if (key == L"userdefinedtheme")
1253                         {
1254                                 userTheme = *pValue;
1255                         }
1256                 }
1257                 delete pMapEnum;
1258
1259                 pList->RemoveAll(true);
1260                 delete pList;
1261         }
1262         if (systemTheme.GetLength() < 1)
1263         {
1264                 systemTheme = L"black";
1265         }
1266         return E_SUCCESS;
1267 }
1268
1269 void
1270 _ResourceManager::GetThemeName(String& systemTheme, String& userTheme) const
1271 {
1272         systemTheme = __systemTheme;
1273         userTheme = __userTheme;
1274 }
1275
1276 void
1277 _ResourceManager::SetSystemColor(void)
1278 {
1279         void* handle =null;
1280         Color* pColor = null;
1281         Color* (*GetSystemColor)(const String&) = null;
1282
1283         handle = dlopen ("libosp-compat.so", RTLD_LAZY);
1284         if (!handle)
1285         {
1286                 return;
1287         }
1288         GetSystemColor = reinterpret_cast<Color*(*)(const String&)>(dlsym(handle, "_GetSystemColor"));
1289         if (dlerror() != NULL)
1290         {
1291                 goto CATCH;
1292         }
1293
1294         pColor = GetSystemColor(L"TITLE_TEXT");
1295         if (pColor != null)
1296         {
1297                 GET_COLOR_CONFIG(HEADER::TITLE_TEXT_NORMAL, *pColor);
1298         }
1299
1300         pColor = GetSystemColor(L"BODY_TEXT");
1301         if (pColor != null)
1302         {
1303                 GET_COLOR_CONFIG(BUTTON::TEXT_NORMAL, *pColor);
1304         }
1305
1306         pColor = GetSystemColor(L"FOREGROUND");
1307         if (pColor != null)
1308         {
1309                 GET_COLOR_CONFIG(BASIC::foreground, *pColor);
1310         }
1311
1312         pColor = GetSystemColor(L"BACKGROUND");
1313         if (pColor != null)
1314         {
1315                 GET_COLOR_CONFIG(BASIC::background, *pColor);
1316         }
1317
1318         pColor = GetSystemColor(L"LIST_BACKGROUND");
1319         if (pColor != null)
1320         {
1321                 GET_COLOR_CONFIG(FORM::BG_NORMAL, *pColor);
1322         }
1323
1324         pColor = GetSystemColor(L"FORM_BACKGROUND");
1325         if (pColor != null)
1326         {
1327                 GET_COLOR_CONFIG(FORM::BG_NORMAL, *pColor);
1328         }
1329
1330         pColor = GetSystemColor(L"FORM_GROUP_BACKGROUND");
1331         if (pColor != null)
1332         {
1333                 GET_COLOR_CONFIG(PANEL::GROUPED_STYLE_BG_NORMAL, *pColor);
1334         }
1335
1336         pColor = GetSystemColor(L"POPUP_BACKGROUND");
1337         if (pColor != null)
1338         {
1339                 GET_COLOR_CONFIG(POPUP::BG_NORMAL, *pColor);
1340         }
1341
1342         pColor = GetSystemColor(L"GROUP_ITEM_TEXT");
1343         if (pColor != null)
1344         {
1345                 GET_COLOR_CONFIG(CHECKBUTTON::TEXT_NORMAL, *pColor);
1346         }
1347
1348         pColor = GetSystemColor(L"LIST_ITEM_TEXT");
1349         if (pColor != null)
1350         {
1351                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_NORMAL, *pColor);
1352         }
1353
1354         pColor = GetSystemColor(L"LIST_ITEM_PRESSED_TEXT");
1355         if (pColor != null)
1356         {
1357                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_PRESSED, *pColor);
1358         }
1359
1360         pColor = GetSystemColor(L"LIST_ITEM_HIGHLIGHTED_TEXT");
1361         if (pColor != null)
1362         {
1363                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_HIGHLIGHTED, *pColor);
1364         }
1365
1366         //fall through
1367 CATCH:
1368         dlclose(handle);
1369         return;
1370 }
1371 bool
1372 _ResourceManager::GetDensityDirectory(const String& directoryName, float& scaleFactor)
1373 {
1374         float denominator = 0.0;
1375         float numerator = 0.0;
1376         if(!(directoryName.StartsWith(L"screen-density",0)))
1377         {
1378                 return false;
1379         }
1380
1381         if (__deviceDPI >= DPI_FOR_XHIGH)
1382         {
1383                 numerator = 9.0;
1384         }
1385         else if (__deviceDPI >= DPI_FOR_HIGH)
1386         {
1387                 numerator = 6.0;
1388         }
1389         else if (__deviceDPI >= DPI_FOR_MIDDLE)
1390         {
1391                 numerator = 4.0;
1392         }
1393         else if (__deviceDPI < DPI_FOR_MIDDLE && __deviceDPI > DPI_FOR_LOW)
1394         {
1395                 numerator = 3.0;
1396         }
1397         else
1398         {
1399                 return false;
1400         }
1401
1402         if(directoryName.Contains(L"xhigh"))
1403         {
1404                 denominator = 9.0;
1405         }
1406         else if(directoryName.Contains(L"high"))
1407         {
1408                 denominator = 6.0;
1409         }
1410         else if(directoryName.Contains(L"middle"))
1411         {
1412                 denominator = 4.0;
1413         }
1414         else if(directoryName.Contains(L"low"))
1415         {
1416                 denominator = 3.0;
1417         }
1418         else
1419         {
1420                 return false;
1421         }
1422
1423         scaleFactor = numerator / denominator;
1424         return true;
1425 }
1426
1427 bool
1428 _ResourceManager::GetResolutionDirectory(const String& directoryName, float& scaleFactor)
1429 {
1430         if(!(directoryName.Contains(L"0")))
1431         {
1432                 return false;
1433         }
1434
1435         int index = 0;
1436         if(directoryName.IndexOf(L"x", 0, index) != E_SUCCESS)
1437         {
1438                 return false;
1439         }
1440         String width = 0;
1441
1442         if(directoryName.SubString(0, index - 1, width))
1443         {
1444                 int denominatorInt = 0;
1445                 float denominator = 0;
1446                 float numerator = 0;
1447                 if(Integer::Parse(width, denominatorInt) == E_SUCCESS)
1448                 {
1449                         denominator = (float)denominatorInt;
1450                         numerator = __targetWidth;
1451                         scaleFactor = numerator / denominator;
1452                         return true;
1453                 }
1454         }
1455         return false;
1456 }
1457
1458 String
1459 _ResourceManager::FindImagePath(const String& fileName, int& foundFolderWidth)
1460 {
1461         bool find = false;
1462         String fullName(L"");
1463         ResourceFallbackItem* pItem = null;
1464
1465         if(__userTheme.GetLength() > 0)
1466         {
1467                 String resDirectory = _AppInfo::GetAppRootPath() + L"res/themes/"+__userTheme;
1468                 if(__pFallbackList == null)
1469                 {
1470                         __pFallbackList = new (std::nothrow) ArrayListT<ResourceFallbackItem*>;
1471                         SysTryReturn(NID_UI, __pFallbackList, L"", E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1472                         Directory dir;
1473                         result r = dir.Construct(resDirectory);
1474                         if (r == E_SUCCESS)
1475                         {
1476                                 DirEnumerator* pDirEnum = dir.ReadN();
1477                                 if (pDirEnum != null)
1478                                 {
1479                                         while (pDirEnum->MoveNext() == E_SUCCESS)
1480                                         {
1481                                                 DirEntry entry = pDirEnum->GetCurrentDirEntry();
1482                                                 if(entry.IsDirectory())
1483                                                 {
1484                                                         float scaleFactor = 0;
1485                                                         String directoryName = entry.GetName();
1486                                                         if(GetDensityDirectory(directoryName, scaleFactor))
1487                                                         {
1488                                                                 pItem = new (std::nothrow) ResourceFallbackItem;
1489                                                                 SysTryCatch(NID_UI, pItem, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1490                                                                 pItem->scaleFactor = scaleFactor;
1491                                                                 pItem->directoryName = directoryName;
1492                                                                 __pFallbackList->Add(pItem);
1493                                                         }
1494                                                         else if(GetResolutionDirectory(directoryName, scaleFactor))
1495                                                         {
1496                                                                 pItem = new (std::nothrow) ResourceFallbackItem;
1497                                                                 SysTryCatch(NID_UI, pItem, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1498                                                                 pItem->scaleFactor = scaleFactor;
1499                                                                 pItem->directoryName = directoryName;
1500                                                                 __pFallbackList->Add(pItem);
1501                                                         }
1502                                                 }
1503                                         }
1504                                         ResourceFallbackItemComparer<ResourceFallbackItem*> comparer;
1505                                         __pFallbackList->Sort(comparer);
1506                                         delete pDirEnum;
1507                                 }
1508                                 for(int i = 0 ; i < __pFallbackList->GetCount() ; i++)
1509                                 {
1510                                         ResourceFallbackItem* pItem;
1511                                         if(__pFallbackList->GetAt(i,pItem) == E_SUCCESS)
1512                                         {
1513                                                 if(pItem->scaleFactor < 1.001 && pItem->scaleFactor > 0.999)
1514                                                 {
1515                                                         __pFallbackList->RemoveAt(i);
1516                                                         __pFallbackList->InsertAt(pItem,0);
1517                                                         if(pItem->directoryName.Contains(L"0"))
1518                                                         {
1519                                                                 break;
1520                                                         }
1521                                                 }
1522                                         }
1523                                 }
1524                         }
1525                 }
1526                 for(int i = 0 ; i <__pFallbackList->GetCount() ; i++)
1527                 {
1528                         ResourceFallbackItem* pItem;
1529                         __pFallbackList->GetAt(i,pItem);
1530                         fullName = resDirectory + L"/" + pItem->directoryName + L"/" + fileName;
1531                         if (File::IsFileExist(fullName))
1532                         {
1533                                 find = true;
1534                                 foundFolderWidth = __targetWidth / pItem->scaleFactor;
1535                                 if(foundFolderWidth > __targetWidth)
1536                                 {
1537                                         if( foundFolderWidth < __targetWidth + 3)
1538                                         {
1539                                                 foundFolderWidth = __targetWidth;
1540                                         }
1541                                 }
1542                                 else
1543                                 {
1544                                         if( foundFolderWidth >__targetWidth - 3)
1545                                         {
1546                                                 foundFolderWidth = __targetWidth;
1547                                         }
1548                                 }
1549                                 break;
1550                         }
1551                 }
1552         }
1553         if(!find)
1554         {
1555                 fullName = String(L"/usr/share/osp/bitmaps/" + __targetPortraitMode+ "/" + __systemTheme + L"/" + fileName);
1556                 if (File::IsFileExist(fullName))
1557                 {
1558                         find = true;
1559                         foundFolderWidth = __targetWidth;
1560                 }
1561                 else
1562                 {
1563                         fullName = String(L"/usr/share/osp/bitmaps/" + __defaultPortraitMode+ "/" + __systemTheme + L"/" + fileName);
1564                         if (File::IsFileExist(fullName))
1565                         {
1566                                 find = true;
1567                                 foundFolderWidth = DEFAULT_SCREEN_WIDTH;
1568                         }
1569                 }
1570         }
1571
1572         if(!find)
1573         {
1574                 fullName = String(L"/usr/share/osp/bitmaps/" + __targetPortraitMode + "/" + fileName);
1575                 if (File::IsFileExist(fullName))
1576                 {
1577                         find = true;
1578                         foundFolderWidth = __targetWidth;
1579                 }
1580                 else
1581                 {
1582                         fullName = String(L"/usr/share/osp/bitmaps/" + __defaultPortraitMode+ "/" + fileName);
1583                         if (File::IsFileExist(fullName))
1584                         {
1585                                 find = true;
1586                                 foundFolderWidth = DEFAULT_SCREEN_WIDTH;
1587                         }
1588                 }
1589         }
1590
1591         if(!find)
1592         {
1593                 return L"";
1594         }
1595         else
1596         {
1597                 return fullName;
1598         }
1599 CATCH:
1600         delete __pFallbackList;
1601         __pFallbackList = null;
1602         return L"";
1603 }
1604
1605 bool
1606 _ResourceManager::IsFeedbackPlayed(void)
1607 {
1608         if (__feedbackStatus == _RESOURCE_FEEDBACK_STATUS_INIT)
1609         {
1610                 return false;
1611         }
1612         return true;
1613 }
1614
1615 void
1616 _ResourceManager::AcquireFeedback(void)
1617 {
1618         ++__feedbackAcquireCount;
1619 }
1620
1621 void
1622 _ResourceManager::ReleaseFeedback(void)
1623 {
1624         __feedbackAcquireCount >0 ? --__feedbackAcquireCount : __feedbackAcquireCount = 0;
1625         if(__feedbackAcquireCount == 0)
1626         {
1627                 __feedbackStatus = _RESOURCE_FEEDBACK_STATUS_INIT;
1628         }
1629 }
1630 void
1631 _ResourceManager::ResetFeedback(void)
1632 {
1633         __feedbackAcquireCount = 0;
1634         __feedbackStatus = _RESOURCE_FEEDBACK_STATUS_INIT;
1635 }
1636 }}//Tizen::Ui