lib/system-controller/CicoSCResourceManager.cpp

   1 /*
   2  * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
   3  *
   4  * This program is licensed under the terms and conditions of the
   5  * Apache License, version 2.0.  The full text of the Apache License is at
   6  * http://www.apache.org/licenses/LICENSE-2.0
   7  *
   8  */
   9
  10 //==========================================================================
  11 /**
  12  *  @file   CicoSCResourceManager.cpp
  13  *
  14  *  @brief  This file implementation of CicoSCResourceManager class
  15  */
  16 //==========================================================================
  17
  18 #include <sstream>
  19 using namespace std;
  20
  21 #include "CicoSCResourceManager.h"
  22 #include "CicoLog.h"
  23 #include "ico_syc_error.h"
  24 #include "ico_syc_mrp_resource_private.h"
  25
  26 #include "ico_syc_msg_cmd_def.h"
  27 #include "CicoSystemConfig.h"
  28 #include "CicoConf.h"
  29 #include "CicoSCCommand.h"
  30 #include "CicoSCPolicyManager.h"
  31 #include "CicoSCLifeCycleController.h"
  32 #include "CicoAilItems.h"
  33 #include "CicoSCWindowController.h"
  34 #include "CicoSCInputController.h"
  35 #include "CicoSCPolicyDef.h"
  36
  37 struct CompDisplayResourceRequest
  38 {
  39     CompDisplayResourceRequest(const resource_request_t *req)
  40         : m_req(req) {}
  41
  42     bool operator() (const resource_request_t *req)
  43     {
  44         if (NULL == req) {
  45             return false;
  46         }
  47         ICO_DBG("appid=%s:%s", req->appid, m_req->appid);
  48         if ((0 == strcmp(m_req->appid, req->appid)) &&
  49             (m_req->pid == req->pid) &&
  50             ((m_req->resid & RESID_TYPE_MASK) == (req->resid & RESID_TYPE_MASK)) &&
  51             (m_req->surfaceid == req->surfaceid)) {
  52             return true;
  53         }
  54         return false;
  55     }
  56
  57     const resource_request_t *m_req;
  58 };
  59
  60 struct CompSoundResourceRequest
  61 {
  62     CompSoundResourceRequest(const resource_request_t *req)
  63         : m_req(req) {}
  64
  65     bool operator() (const resource_request_t *req)
  66     {
  67         if (NULL == req) {
  68             return false;
  69         }
  70
  71         ICO_DBG("appid=%s:%s", req->appid, m_req->appid);
  72         if ((0 == strcmp(m_req->appid, req->appid)) &&
  73             (m_req->pid == req->pid) &&
  74             ((m_req->resid & RESID_TYPE_MASK) == (req->resid & RESID_TYPE_MASK)) &&
  75             (m_req->soundid == req->soundid)) {
  76             return true;
  77         }
  78         return false;
  79     }
  80
  81     const resource_request_t *m_req;
  82 };
  83
  84 struct CompInputResourceRequest
  85 {
  86     CompInputResourceRequest(const resource_request_t *req)
  87         : m_req(req) {}
  88
  89     bool operator() (const resource_request_t *req)
  90     {
  91         if (NULL == req) {
  92             return false;
  93         }
  94
  95         ICO_DBG("appid=%s:%s", req->appid, m_req->appid);
  96         if ((0 == strcmp(m_req->appid, req->appid)) &&
  97             (0 == strcmp(m_req->device, req->device)) &&
  98             (m_req->pid == req->pid) &&
  99             ((m_req->resid & RESID_TYPE_MASK) == (req->resid & RESID_TYPE_MASK))) {
 100             return true;
 101         }
 102         return false;
 103     }
 104
 105     const resource_request_t *m_req;
 106 };
 107
 108
 109 CicoSCResourceManager::CicoSCResourceManager()
 110     : m_policyMgr(NULL), m_winCtrl(NULL), m_inputCtrl(NULL),
 111       m_animaName("Fade"), m_animaTime(400)
 112 {
 113     m_policyMgr = new CicoSCPolicyManager(this);
 114
 115     CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
 116     list<resource_request_t*> l;
 117
 118     {
 119         // initialize display current request and waiting queue
 120         const vector<CicoSCDisplayConf*>& dispConfList
 121             = sysConf->getDisplayConfList();
 122         vector<CicoSCDisplayConf*>::const_iterator itr;
 123         itr = dispConfList.begin();
 124         for (; itr != dispConfList.end(); ++itr) {
 125             vector<CicoSCDisplayZoneConf*>::iterator itr2;
 126             itr2 = (*itr)->zoneConfList.begin();
 127             for (; itr2 != (*itr)->zoneConfList.end(); ++itr2) {
 128                 m_curDispResOwerReq[(*itr2)->id] = NULL;
 129             }
 130         }
 131     }
 132
 133     {
 134         // initialize sound current request and waiting queue
 135         const vector<CicoSCSoundConf*>& soundConfList
 136             = sysConf->getSoundConfList();
 137         vector<CicoSCSoundConf*>::const_iterator itr;
 138         itr = soundConfList.begin();
 139         for (; itr != soundConfList.end(); ++itr) {
 140             vector<CicoSCSoundZoneConf*>::iterator itr2;
 141             itr2 = (*itr)->zoneConfList.begin();
 142             for (; itr2 != (*itr)->zoneConfList.end(); ++itr2) {
 143                 m_curSoundResReq[(*itr2)->id] = NULL;
 144                 m_soundReqQueue[(*itr2)->id]  = l;
 145             }
 146         }
 147     }
 148
 149    {
 150         // initialize input current request and waiting queue
 151         const vector<CicoSCInputDevConf*>& inputDevConfList
 152             = sysConf->getInputDevConfList();
 153         vector<CicoSCInputDevConf*>::const_iterator itr;
 154         itr = inputDevConfList.begin();
 155         for (; itr != inputDevConfList.end(); ++itr) {
 156             vector<CicoSCSwitchConf*>::iterator itr2;
 157             itr2 = (*itr)->switchConfList.begin();
 158             for (; itr2 != (*itr)->switchConfList.end(); ++itr2) {
 159                 m_curInputResReq[(*itr2)->id] = NULL;
 160                 m_inputReqQueue[(*itr2)->id]  = l;
 161             }
 162         }
 163     }
 164 }
 165
 166 CicoSCResourceManager::~CicoSCResourceManager()
 167 {
 168     delete m_policyMgr;
 169 }
 170
 171 int
 172 CicoSCResourceManager::initialize(void)
 173 {
 174     ICO_TRA("CicoSCResourceManager::initialize Enter");
 175
 176     int ret = ICO_SYC_EOK;
 177
 178     ret = ico_syc_mrp_init(enforceSound, this);
 179     if (ICO_SYC_EOK != ret) {
 180         ICO_TRA("CicoSCResourceManager::initialize Leave");
 181         return ret;
 182     }
 183
 184     ret = m_policyMgr->initialize();
 185     if (ICO_SYC_EOK != ret) {
 186         ICO_TRA("CicoSCResourceManager::initialize Leave");
 187         return ret;
 188     }
 189
 190
 191     ICO_TRA("CicoSCResourceManager::initialize Leave");
 192     return ret;
 193 }
 194
 195 void
 196 CicoSCResourceManager::terminate(void)
 197 {
 198     ICO_TRA("CicoSCResourceManager::terminate Enter");
 199     m_policyMgr->terminate();
 200     ico_syc_mrp_term();
 201     ICO_TRA("CicoSCResourceManager::terminate Leave");
 202 }
 203
 204 void
 205 CicoSCResourceManager::handleCommand(const CicoSCCommand &cmd,
 206                                      bool internal)
 207 {
 208     ICO_TRA("CicoSCResourceManager::handleCommand Enter"
 209             "(cmdid=0x%08X internal=%s)",
 210             cmd.cmdid, internal ? "true" : "false");
 211
 212     CicoSCCmdResCtrlOpt *opt = (CicoSCCmdResCtrlOpt*)cmd.opt;
 213
 214     // request command from application or internal
 215     int reqtype = internal ? REQTYPE_AUTO : REQTYPE_APP;
 216
 217     if ((MSG_CMD_CREATE_RES == cmd.cmdid) ||
 218         (MSG_CMD_ACQUIRE_RES == cmd.cmdid)) {
 219
 220         if (true == opt->dispres) {
 221             resource_request_t *req = newResourceRequest(RESID_KIND_DISPLAY,
 222                                                          reqtype,
 223                                                          cmd);
 224             if (MSG_CMD_CREATE_RES == cmd.cmdid) {
 225                 acquireDisplayResource(req, false);
 226             }
 227             else {
 228                 if ((true == m_policyMgr->getRegulation()) &&
 229                     (false == isMatchDisplayed())) {
 230                     updateDispResRegulationPreProc(req);
 231                     updateDisplayResourceRegulation(STID_DRVREGULATION_ON);
 232                 }
 233                 else {
 234                     acquireDisplayResource(req);
 235                 }
 236             }
 237
 238         }
 239         if (true == opt->soundres) {
 240             resource_request_t *req = newResourceRequest(RESID_KIND_SOUND,
 241                                                          reqtype,
 242                                                          cmd);
 243             if ((true == m_policyMgr->getRegulation()) &&
 244                 (false == isMatchDisplayed())) {
 245                 updateSoundResRegulationPreProc(req);
 246                 updateSoundResourceRegulation(STID_DRVREGULATION_ON);
 247             }
 248             else {
 249                 acquireSoundResource(req);
 250             }
 251
 252         }
 253         if (true == opt->inputres) {
 254             resource_request_t *req = newResourceRequest(RESID_KIND_INPUT,
 255                                                          reqtype,
 256                                                          cmd);
 257             if ((true == m_policyMgr->getRegulation()) &&
 258                 (false == isMatchDisplayed())) {
 259                 updateInputResRegulationPreProc(req);
 260                 updateInputResourceRegulation(STID_DRVREGULATION_ON);
 261             }
 262             else {
 263                 acquireInputResource(req);
 264             }
 265         }
 266     }
 267     else if ((MSG_CMD_RELEASE_RES == cmd.cmdid) ||
 268              (MSG_CMD_DESTORY_RES == cmd.cmdid)) {
 269
 270         if (true == opt->dispres) {
 271             resource_request_t *req = newResourceRequest(RESID_KIND_DISPLAY,
 272                                                          reqtype,
 273                                                          cmd);
 274             releaseDisplayResource(req);
 275         }
 276         if (true == opt->soundres) {
 277             resource_request_t *req = newResourceRequest(RESID_KIND_SOUND,
 278                                                          reqtype,
 279                                                          cmd);
 280             releaseSoundResource(req);
 281         }
 282         if (true == opt->inputres) {
 283             resource_request_t *req = newResourceRequest(RESID_KIND_INPUT,
 284                                                          reqtype,
 285                                                          cmd);
 286             releaseInputResource(req);
 287         }
 288     }
 289     else {
 290         ICO_WRN("Unknown command");
 291     }
 292
 293     ICO_TRA("CicoSCResourceManager::handleCommand Leave");
 294 }
 295
 296 void
 297 CicoSCResourceManager::setWindowController(CicoSCWindowController *winCtrl)
 298 {
 299     m_winCtrl = winCtrl;
 300 }
 301
 302 void
 303 CicoSCResourceManager::setInputController(CicoSCInputController *inputCtrl)
 304 {
 305     m_inputCtrl = inputCtrl;
 306 }
 307
 308 #if 0
 309 resource_request_t *
 310 CicoSCResourceManager::popDispResReq(resource_request_t *req)
 311 {
 312     ICO_TRA("CicoSCResourceManager::popDispResReq Enter");
 313
 314     map<int, list<resource_request_t*> >::iterator itr;
 315     itr = m_dispReqQueue.begin();
 316     CompDisplayResourceRequest comp(req);
 317     for (; itr != m_dispReqQueue.end(); ++itr) {
 318         list<resource_request_t*>::iterator itr2;
 319         itr2 = find_if(itr->second.begin(), itr->second.end(), comp);
 320         if (itr->second.end() != itr2) {
 321             ICO_DBG("Dequeue waiting display request queue zone=%d req=0x%08x",
 322                     itr->first, *itr2);
 323             m_dispReqQueue[req->dispzoneid].erase(itr2);
 324             ICO_TRA("CicoSCResourceManager::popDispResReq Leave"
 325                     "(0x%08x)", *itr2);
 326             return *itr2;
 327         }
 328     }
 329
 330     ICO_TRA("CicoSCResourceManager::popDispResReq Leave(NULL)");
 331     return NULL;
 332 }
 333 #endif
 334
 335 resource_request_t *
 336 CicoSCResourceManager::popSoundResReq(resource_request_t *req)
 337 {
 338     ICO_TRA("CicoSCResourceManager::popSoundResReq Enter");
 339
 340     map<int, list<resource_request_t*> >::iterator itr;
 341     itr = m_soundReqQueue.begin();
 342     CompSoundResourceRequest comp(req);
 343     for (; itr != m_soundReqQueue.end(); ++itr) {
 344         list<resource_request_t*>::iterator itr2;
 345         itr2 = find_if(itr->second.begin(), itr->second.end(), comp);
 346         if (itr->second.end() != itr2) {
 347             ICO_DBG("Dequeue waiting sound request queue"
 348                     "(req=0x%08x zone:%02d:%s appid=%s)",
 349                     *itr2, itr->first, (*itr2)->soundzone, (*itr2)->appid);
 350             m_soundReqQueue[req->soundzoneid].erase(itr2);
 351             ICO_TRA("CicoSCResourceManager::popSoundResReq Leave"
 352                     "(0x%08x)", *itr2);
 353             return *itr2;
 354         }
 355     }
 356     ICO_TRA("CicoSCResourceManager::popSoundResReq Leave(NULL)");
 357     return NULL;
 358 }
 359
 360 resource_request_t *
 361 CicoSCResourceManager::popInputResReq(resource_request_t *req)
 362 {
 363     ICO_TRA("CicoSCResourceManager::popInputResReq Enter");
 364
 365     map<int, list<resource_request_t*> >::iterator itr;
 366     itr = m_inputReqQueue.begin();
 367     CompInputResourceRequest comp(req);
 368     for (; itr != m_inputReqQueue.end(); ++itr) {
 369         list<resource_request_t*>::iterator itr2;
 370         itr2 = find_if(itr->second.begin(), itr->second.end(), comp);
 371         if (itr->second.end() != itr2) {
 372             ICO_DBG("Dequeue waiting input request queue"
 373                     "(req=0x%08x input:%d appid=%s)",
 374                     *itr2, (*itr2)->input, (*itr2)->appid);
 375             m_inputReqQueue[req->input].erase(itr2);
 376             ICO_TRA("CicoSCResourceManager::popInputResReq Leave"
 377                     "(0x%08x)", *itr2);
 378             return *itr2;
 379         }
 380     }
 381
 382     ICO_TRA("CicoSCResourceManager::popDispResReq Leave(NULL)");
 383     return NULL;
 384 }
 385
 386
 387 bool
 388 CicoSCResourceManager::acquireDisplayResource(resource_request_t *newreq,
 389                                               bool control)
 390 {
 391     ICO_TRA("CicoSCResourceManager::acquireDisplayResource Enter");
 392
 393     CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
 394     const CicoSCAppKindConf *appKindConf = NULL;
 395     appKindConf = sysConf->findAppKindConfbyId(newreq->appkind);
 396     if (NULL == appKindConf) {
 397         ICO_ERR("not found CicoSCAppKindConf instance");
 398         ICO_TRA("CicoSCResourceManager::acquireDisplayResource Leave(false)");
 399         return false;
 400     }
 401
 402     if ((appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_ALMIGHTY) ||
 403         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM)   ||
 404         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM_VISIBLE)) {
 405
 406         if ((NULL != m_winCtrl) && (true == control)) {
 407             m_winCtrl->show(newreq->surfaceid,
 408                             newreq->animation,
 409                             newreq->animationTime);
 410         }
 411         delResourceRequest(newreq);
 412
 413         ICO_DBG("kind of system application");
 414         ICO_TRA("CicoSCResourceManager::acquireDisplayResource Leave(true)");
 415         return true;
 416     }
 417
 418     // if exist current ower request, pop request
 419     resource_request_t *req = findCurDispResOwerReq(newreq);
 420     int chgzone = -1;
 421     if (NULL != req) {
 422         ICO_DBG("dispzoneid=%d/%d zone=%s/%s",
 423                 req->dispzoneid, newreq->dispzoneid,
 424                 req->dispzone, newreq->dispzone);
 425         if (req->dispzoneid != newreq->dispzoneid) {
 426             req = popCurDispResOwerReq(req);
 427             m_policyMgr->releaseDisplayResource(req->dispzoneid, req->prio);
 428             chgzone = newreq->dispzoneid;
 429         }
 430     }
 431
 432     // if exist in wating request list, pop request
 433     if (NULL == req) {
 434         req = popWaitingDispResReq(newreq);
 435         if (NULL != req) {
 436             ICO_DBG("dispzoneid=%d/%d zone=%s/%s",
 437                     req->dispzoneid, newreq->dispzoneid,
 438                     req->dispzone, newreq->dispzone);
 439             if (req->dispzoneid != newreq->dispzoneid) {
 440                 chgzone = newreq->dispzoneid;
 441             }
 442         }
 443         else {
 444             req = newreq;
 445         }
 446     }
 447
 448     bool displayMatch = false;
 449     //
 450     if (req != newreq) {
 451         char zoneO[128],zoneN[128];
 452         zoneO[0] = zoneN[0] = '\0';
 453         if ((NULL != req) && (NULL != req->dispzone)) {
 454             char* d = zoneO;
 455             const char* s = req->dispzone;
 456             while ('\0' != *s) {  // is stop code
 457                 if ('.' == *s) {  // DISPLAY.ZONE found a period
 458                     break;  // break of while
 459                 }
 460                 *d++ = *s++; // char copy
 461             }
 462             *d='\0';  // set stop code
 463         }
 464         if ((NULL != newreq) && (NULL != newreq->dispzone)) {
 465             char* d = zoneO;
 466             const char* s = newreq->dispzone;
 467             while ('\0' != *s) {  // is stop code
 468                 if ('.' == *s) {  // DISPLAY.ZONE found a period
 469                     break;  // break of while
 470                 }
 471                 *d++ = *s++;  // char copy
 472             }
 473             *d='\0';  // set stop code
 474         }
 475         if ((0 != strlen(zoneO)) || (0 != strlen(zoneN))) {
 476             if (0 == strcmp(zoneO, zoneN)) {
 477                 displayMatch = true;
 478             }
 479         }
 480         // update request data
 481         req->dispzoneid = newreq->dispzoneid;
 482         if (NULL != req->dispzone) free(req->dispzone);
 483         req->dispzone = strdup(newreq->dispzone);
 484         req->layerid = newreq->layerid;
 485         if (NULL != req->animation) free(req->animation);
 486         req->animation = strdup(newreq->animation);
 487         req->animationTime = newreq->animationTime;
 488
 489         // delete new request
 490         delResourceRequest(newreq);
 491     }
 492
 493     if (false == control) {
 494         ICO_TRA("Enqueue waiting display resource request"
 495                 "(req=0x%08x appid=%s)", req, req->appid);
 496         m_waitingDispResReq.push_front(req);
 497 #if 1   //DEBUG
 498         dumpWaitingDispResReq();
 499 #endif  //DEBUG
 500         return true;
 501     }
 502
 503     int type = req->resid & RESID_TYPE_MASK;
 504     bool state = m_policyMgr->acquireDisplayResource(type,
 505                                                      req->dispzoneid,
 506                                                      req->prio);
 507     if ((true == state) && (false == displayMatch)){
 508         updateDisplayResource(req, chgzone);
 509     }
 510     else {
 511         if ((-1 != chgzone) || (true == displayMatch)) {
 512             if (NULL != m_winCtrl) {
 513                 // move request window
 514                 m_winCtrl->setGeometry(req->surfaceid, req->dispzone, req->layerid,
 515                                        req->animation, req->animationTime,
 516                                        req->animation, req->animationTime);
 517             }
 518         }
 519         else {
 520             // just in case, hide window
 521             if (NULL != m_winCtrl) {
 522                 // hide request window
 523                 m_winCtrl->hide(req->surfaceid, NULL, 0);
 524             }
 525         }
 526         ICO_DBG("Enqueue waiting display resource request"
 527                     "(req=0x%08x appid=%s)", req, req->appid);
 528         m_waitingDispResReq.push_front(req);
 529 #if 1   //DEBUG
 530         dumpWaitingDispResReq();
 531 #endif  //DEBUG
 532     }
 533
 534     ICO_TRA("CicoSCResourceManager::acquireDisplayResource Leave");
 535     return true;
 536 }
 537
 538 void
 539 CicoSCResourceManager::releaseDisplayResource(resource_request_t *newreq)
 540 {
 541     ICO_TRA("CicoSCResourceManager::releaseDisplayResource Enter"
 542             "(newreq=0x%08x)", newreq);
 543
 544     // if exist in wating request list, pop request
 545     resource_request_t *req = popWaitingDispResReq(newreq);
 546     if (NULL != req) {
 547         delResourceRequest(req);
 548         delResourceRequest(newreq);
 549         ICO_TRA("CicoSCResourceManager::releaseDisplayResource Leave");
 550         return;
 551     }
 552
 553     // if exist current ower request, pop request
 554     req = popCurDispResOwerReq(newreq);
 555     if (NULL != req) {
 556         m_policyMgr->releaseDisplayResource(req->dispzoneid, req->prio);
 557         delResourceRequest(req);
 558     }
 559     delResourceRequest(newreq);
 560
 561     list<resource_request_t*>::iterator itr;
 562     itr = m_waitingDispResReq.begin();
 563     for (; itr != m_waitingDispResReq.end(); ++itr) {
 564         if (NULL != m_curDispResOwerReq[(*itr)->dispzoneid]) {
 565             continue;
 566         }
 567         int type = (*itr)->resid & RESID_TYPE_MASK;
 568         bool active = m_policyMgr->acquireDisplayResource(type,
 569                                                          (*itr)->dispzoneid,
 570                                                          (*itr)->prio);
 571         if (true == active) {
 572             resource_request_t* popreq = popWaitingDispResReq(*itr);
 573             updateDisplayResource(popreq);
 574             m_winCtrl->activeCB(NULL, NULL, popreq->surfaceid, -1);
 575             break;
 576         }
 577     }
 578
 579     ICO_TRA("CicoSCResourceManager::releaseDisplayResource Leave");
 580 }
 581
 582 bool
 583 CicoSCResourceManager::acquireSoundResource(resource_request_t *newreq)
 584 {
 585     ICO_TRA("CicoSCResourceManager::acquireSoundResource Enter");
 586
 587     CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
 588     const CicoSCAppKindConf *appKindConf = NULL;
 589     appKindConf = sysConf->findAppKindConfbyId(newreq->appkind);
 590     if (NULL == appKindConf) {
 591         ICO_ERR("not found CicoSCAppKindConf instance");
 592         ICO_TRA("CicoSCResourceManager::acquireSoundResource Leave(false)");
 593         return false;
 594     }
 595
 596     if ((appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_ALMIGHTY) ||
 597         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM)   ||
 598         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM_AUDIO)) {
 599
 600         delResourceRequest(newreq);
 601
 602         ICO_DBG("kind of system application");
 603         ICO_TRA("CicoSCResourceManager::acquireSoundResource Leave(true)");
 604         return true;
 605     }
 606
 607     resource_request_t *req = popSoundResReq(newreq);
 608     if (NULL == req) {
 609         req = newreq;
 610     }
 611
 612     // is change zone?
 613     CompSoundResourceRequest comp(req);
 614     if (true == comp(m_curSoundResReq[req->soundzoneid])) {
 615         ICO_DBG("already acquired appid=%s pid=%d soundid=0x%08X",
 616                 req->appid, req->pid, req->soundid);
 617         ICO_TRA("CicoSCResourceManager::acquireSoundResource Leave(true)");
 618         // free new request
 619         delResourceRequest(newreq);
 620         return true;
 621     }
 622
 623     int type = req->resid & RESID_TYPE_MASK;
 624     bool state = m_policyMgr->acquireSoundResource(type,
 625                                                    req->soundzoneid,
 626                                                    req->prio);
 627     if (true == state) {
 628         updateSoundResource(req);
 629     }
 630     else {
 631         ICO_DBG("Enqueue waiting sound request queue"
 632                 "(req=0x%08x zone:%02d:%s appid=%s)",
 633                 req, req->soundzoneid, req->soundzone, req->appid);
 634         m_soundReqQueue[req->soundzoneid].push_front(req);
 635     }
 636
 637     ICO_TRA("CicoSCResourceManager::acquireSoundResource Leave");
 638     return true;
 639 }
 640
 641 void
 642 CicoSCResourceManager::releaseSoundResource(resource_request_t *newreq)
 643 {
 644     ICO_TRA("CicoSCResourceManager::releaseSoundResource Enter");
 645
 646     bool curchg = false;
 647     CompSoundResourceRequest comp(newreq);
 648     for (int i = 0; i < (int)m_curSoundResReq.size(); ++i) {
 649          if (NULL == m_curSoundResReq[i]) {
 650             continue;
 651          }
 652
 653          if (true == comp(m_curSoundResReq[i])) {
 654             ICO_DBG("Dequeue current sound resource ower request"
 655                     "(req=0x%08x zoneid=%02d:%s appid=%s)",
 656                     m_curSoundResReq[i], m_curSoundResReq[i]->dispzoneid,
 657                     m_curSoundResReq[i]->dispzone,
 658                     m_curSoundResReq[i]->appid);
 659             ICO_PRF("CHG_GUI_RES sound   deprived zone=%02d:%s appid=%s",
 660                     m_curSoundResReq[i]->dispzoneid,
 661                     m_curSoundResReq[i]->dispzone,
 662                     m_curSoundResReq[i]->appid);
 663             ico_syc_mrp_release_sound_resource(m_curSoundResReq[i]);
 664             delResourceRequest(newreq);
 665             delResourceRequest(m_curSoundResReq[i]);
 666             m_curSoundResReq[i] = NULL;
 667             curchg = true;
 668             break;
 669          }
 670     }
 671
 672     // If current request is not changed,
 673     // remove the request from the waiting queue.
 674     if (false == curchg) {
 675        resource_request_t *req = popSoundResReq(newreq);
 676         if (NULL != req) {
 677             ico_syc_mrp_release_sound_resource(req);
 678             delResourceRequest(req);
 679             req = NULL;
 680         }
 681         delResourceRequest(newreq);
 682         ICO_TRA("CicoSCResourceManager::releaseSoundResource Leave");
 683         return;
 684     }
 685
 686     map<int, list<resource_request_t*> >::iterator itr;
 687     itr = m_soundReqQueue.begin();
 688     for (; itr != m_soundReqQueue.end(); ++itr) {
 689         list<resource_request_t*>::iterator itr2;
 690         itr2 = itr->second.begin();
 691         for (; itr2 !=  itr->second.end(); ++itr2) {
 692             if (NULL != m_curSoundResReq[(*itr2)->soundzoneid]) {
 693                 continue;
 694             }
 695
 696             int type = (*itr2)->resid & RESID_TYPE_MASK;
 697             bool active = m_policyMgr->acquireSoundResource(type,
 698                                                             (*itr2)->soundzoneid,
 699                                                             (*itr2)->prio);
 700             if (true == active) {
 701                 resource_request_t* req = *itr2;
 702                 ICO_DBG("Dequeue waiting sound request queue "
 703                         "(req=0x%08x zone:%02d:%s appid=%s)",
 704                         *itr2, itr->first, (*itr2)->soundzone, (*itr2)->appid);
 705                 itr->second.erase(itr2);
 706                 updateSoundResource(req);
 707                 break;
 708             }
 709         }
 710     }
 711
 712     ICO_TRA("CicoSCResourceManager::releaseSoundResource Leave");
 713 }
 714
 715 bool
 716 CicoSCResourceManager::acquireInputResource(resource_request_t *newreq)
 717 {
 718     ICO_TRA("CicoSCResourceManager::acquireInputResource Enter");
 719
 720     resource_request_t *req = popInputResReq(newreq);
 721     if (NULL == req) {
 722         req = newreq;
 723     }
 724
 725     // is change zone?
 726     CompInputResourceRequest comp(req);
 727     if (true == comp(m_curInputResReq[req->input])) {
 728         ICO_DBG("already acquired appid=%s pid=%d input=0x%08X",
 729                 req->appid, req->pid, req->input);
 730         ICO_TRA("CicoSCResourceManager::acquireInputResource Leave(true)");
 731         // free new request
 732         delResourceRequest(newreq);
 733         return true;
 734     }
 735
 736     bool state = m_policyMgr->acquireInputResource(req->input, req->prio);
 737     if (true == state) {
 738         updateInputResource(req);
 739     }
 740     else {
 741         ICO_DBG("Enqueue waiting input request queue"
 742                 "(req=0x%08x input:%d appid=%s)", req, req->input, req->appid);
 743         m_inputReqQueue[req->input].push_front(req);
 744     }
 745
 746     ICO_TRA("CicoSCResourceManager::acquireInputResource Leave(true)");
 747     return true;
 748 }
 749
 750 void
 751 CicoSCResourceManager::releaseInputResource(resource_request_t *newreq)
 752 {
 753     ICO_TRA("CicoSCResourceManager::releaseInputResource Enter");
 754     bool curchg = false;
 755     CompInputResourceRequest comp(newreq);
 756     for (int i = 0; i < (int)m_curInputResReq.size(); ++i) {
 757          if (NULL == m_curInputResReq[i]) {
 758             continue;
 759          }
 760
 761          if (true == comp(m_curInputResReq[i])) {
 762             if (NULL != m_inputCtrl) {
 763                 m_inputCtrl->delInputApp(m_curInputResReq[i]->appid,
 764                                          m_curInputResReq[i]->device,
 765                                          m_curInputResReq[i]->input);
 766             }
 767             ICO_DBG("Dequeue current input resource ower request"
 768                     "(req=0x%08x input=%d appid=%s)",
 769                     m_curInputResReq[i], m_curInputResReq[i]->input,
 770                     m_curInputResReq[i]->appid);
 771             ICO_PRF("CHG_GUI_RES input   deprived input=%d appid=%s",
 772                     m_curInputResReq[i]->input, m_curInputResReq[i]->appid);
 773             delResourceRequest(newreq);
 774             delResourceRequest(m_curInputResReq[i]);
 775             m_curInputResReq[i] = NULL;
 776             curchg = true;
 777             break;
 778          }
 779     }
 780
 781     // If current request is not changed,
 782     // remove the request from the waiting queue.
 783     if (false == curchg) {
 784        resource_request_t *req = popInputResReq(newreq);
 785         if (NULL != req) {
 786             delResourceRequest(req);
 787             req = NULL;
 788         }
 789         delResourceRequest(newreq);
 790         ICO_TRA("CicoSCResourceManager::releaseInputResource Leave");
 791         return;
 792     }
 793
 794     map<int, list<resource_request_t*> >::iterator itr;
 795     itr = m_inputReqQueue.begin();
 796     for (; itr != m_inputReqQueue.end(); ++itr) {
 797         list<resource_request_t*>::iterator itr2;
 798         itr2 = itr->second.begin();
 799         for (; itr2 !=  itr->second.end(); ++itr2) {
 800             if (NULL != m_curInputResReq[(*itr2)->input]) {
 801                 continue;
 802             }
 803             bool active = m_policyMgr->acquireInputResource((*itr2)->input,
 804                                                             (*itr2)->prio);
 805             if (true == active) {
 806                 resource_request_t* req = *itr2;
 807                 ICO_DBG("Dequeue waiting input request queue "
 808                         "(req=0x%08x input:%d appid=%s)",
 809                         *itr2, (*itr2)->input, (*itr2)->appid);
 810                 itr->second.erase(itr2);
 811                 updateInputResource(req);
 812                 break;
 813             }
 814         }
 815     }
 816     ICO_TRA("CicoSCResourceManager::releaseInputResource Leave");
 817 }
 818
 819 resource_request_t *
 820 CicoSCResourceManager::newResourceRequest(int resid,
 821                                           int reqtype,
 822                                           const CicoSCCommand &cmd)
 823 {
 824     ICO_TRA("CicoSCResourceManager::newResourceRequest Enter");
 825
 826     resource_request_t *req = NULL;
 827     req = (resource_request_t*)calloc(1, sizeof(resource_request_t));
 828     CicoSCCmdResCtrlOpt *opt = (CicoSCCmdResCtrlOpt*)cmd.opt;
 829     CicoSystemConfig *systemConfig = CicoSystemConfig::getInstance();
 830
 831     req->reqtype = reqtype;
 832
 833     CicoSCLifeCycleController *lifeCycle =
 834         CicoSCLifeCycleController::getInstance();
 835     const CicoAilItems* ailItem = lifeCycle->findAIL(cmd.appid);
 836     if (NULL != ailItem) {
 837         req->category = ailItem->m_categoryID;
 838         req->appkind = ailItem->m_kindID;
 839     }
 840
 841     req->prio = req->category;
 842
 843     req->released = 0;
 844
 845     /* set resource id */
 846     req->resid = RESID_TYPE_BASIC;
 847     if (1 == opt->type) {
 848         req->resid = RESID_TYPE_INTERRUPT;
 849     }
 850     req->resid |= resid;
 851
 852     req->resid |= RESID_CMD_RELEASE;
 853     if (MSG_CMD_ACQUIRE_RES == cmd.cmdid) {
 854         req->resid |= RESID_CMD_ACQUIRE;
 855     }
 856
 857     /* set application information */
 858     req->appid = strdup(cmd.appid.c_str());
 859     req->pid   = cmd.pid;
 860     req->state = RES_STATE_WAITING;
 861
 862     if (resid == RESID_KIND_DISPLAY) {
 863         req->dispzone   = strdup(opt->dispzone.c_str());
 864         req->dispzoneid = systemConfig->getDizplayZoneIdbyFullName(req->dispzone);
 865         req->layerid    = opt->layerid;
 866         req->winname    = strdup(opt->winname.c_str());
 867         req->surfaceid  = opt->surfaceid;
 868         req->id         = opt->surfaceid;;
 869         req->animation  = strdup(opt->animation.c_str());
 870         req->animationTime = opt->animationTime;
 871     }
 872     else if (resid == RESID_KIND_SOUND) {
 873         req->soundzone   = strdup(opt->soundzone.c_str());
 874         req->soundzoneid = systemConfig->getSoundZoneIdbyFullName(req->soundzone);
 875         ICO_DBG("req->soundzoneid=%d", req->soundzoneid);
 876         req->soundname   = strdup(opt->soundname.c_str());
 877         req->soundid     = opt->soundid;
 878         req->soundadjust = opt->adjust;
 879         req->id          = opt->soundid;
 880     }
 881     else if (resid == RESID_KIND_INPUT) {
 882         req->device = strdup(opt->device.c_str());
 883         req->input  = opt->input;
 884         req->id     = opt->input;
 885     }
 886
 887     ICO_TRA("CicoSCResourceManager::newResourceRequest Leave"
 888             "(req=0x%08x appid=%s)", req, req->appid);
 889     return req;
 890 }
 891
 892 void
 893 CicoSCResourceManager::delResourceRequest(resource_request_t *req)
 894 {
 895     if (NULL == req) return;
 896
 897     if (NULL != req->appid)     free(req->appid);
 898     if (NULL != req->dispzone)  free(req->dispzone);
 899     if (NULL != req->winname)   free(req->winname);
 900     if (NULL != req->animation) free(req->animation);
 901     if (NULL != req->soundzone) free(req->soundzone);
 902     if (NULL != req->soundname) free(req->soundname);
 903     if (NULL != req->device)    free(req->device);
 904
 905     free(req);
 906 }
 907
 908 void
 909 CicoSCResourceManager::enforceSound(unsigned short state,
 910                                     resource_request_t *req,
 911                                     void *user_data)
 912 {
 913     ICO_TRA("CicoSCResourceManager::enforceSound Enter");
 914     /* NOP */
 915     ICO_TRA("CicoSCResourceManager::enforceSound Leave");
 916 }
 917
 918 // receive changed state
 919 void
 920 CicoSCResourceManager::receiveChangedState(int state)
 921 {
 922     ICO_TRA("CicoSCResourceManager::receiveChangedState Enter"
 923             "(state=%d)", state);
 924
 925     if (STID_DRVREGULATION_ON == state) {
 926         if (true == isMatchDisplayed()) {
 927             updateDisplayResourceRegulation(state);
 928             updateSoundResourceRegulation(state);
 929             updateInputResourceRegulation(state);
 930         }
 931     }
 932     else {
 933         updateDisplayResourceRegulation(state);
 934         updateSoundResourceRegulation(state);
 935         updateInputResourceRegulation(state);
 936     }
 937
 938     ICO_TRA("CicoSCResourceManager::receiveChangedState Leave");
 939 }
 940
 941 //--------------------------------------------------------------------------
 942 /**
 943  *  @brief  get policy manager instance
 944  *
 945  *  @return resource manager instace
 946  */
 947 //--------------------------------------------------------------------------
 948 CicoSCPolicyManager *
 949 CicoSCResourceManager::getPolicyManager(void)
 950 {
 951     return m_policyMgr;
 952 }
 953
 954 void
 955 CicoSCResourceManager::updateDisplayResource(resource_request_t *req,
 956                                              int chgzoneid)
 957 {
 958     ICO_TRA("CicoSCResourceManager::updateDisplayResource Enter"
 959             "(req=0x%08x)", req);
 960
 961     std::map<unsigned int, resource_request_t*>::iterator itr;
 962     itr = m_curDispResOwerReq.find(req->dispzoneid);
 963     if ((m_curDispResOwerReq.end() != itr) && (NULL != itr->second)) {
 964         // already ower
 965         if (itr->second == req) {
 966             ICO_DBG("already ower appid=%s pid=%d surfaceid=0x%08X",
 967                     req->appid, req->pid, req->surfaceid);
 968             // show request window
 969             m_winCtrl->show(req->surfaceid, req->animation, req->animationTime);
 970 #if 0 // MKMK
 971             m_winCtrl->activeCB(NULL, NULL, req->surfaceid, -1);
 972 #endif
 973             ICO_TRA("CicoSCResourceManager::updateDisplayResource Leave");
 974             return;
 975         }
 976         resource_request_t *popreq = popCurDispResOwerReq(itr->second);
 977         if (NULL != popreq) {
 978             if (NULL != m_winCtrl) {
 979                 // hide current window
 980                 m_winCtrl->hide(popreq->surfaceid, NULL, 0);
 981             }
 982
 983             // state change to waiting
 984             popreq->state = RES_STATE_WAITING;
 985             // enqueue request
 986             ICO_DBG("Enqueue waiting display resource request"
 987                     "(req=0x%08x zone=%02d:%s appid=%s",
 988                     popreq, popreq->dispzoneid,
 989                     popreq->dispzone, popreq->appid);
 990             m_waitingDispResReq.push_front(popreq);
 991 #if 1   //DEBUG
 992         dumpWaitingDispResReq();
 993 #endif  //DEBUG
 994         }
 995     }
 996
 997     std::map<unsigned int, resource_request_t*>::iterator itr2;
 998     itr2 = m_curDispResOwerReq.begin();
 999     for (; itr2 != m_curDispResOwerReq.end(); ++itr2) {
1000         resource_request_t *tmpreq = itr2->second;
1001
1002         if (true == m_policyMgr->getDispZoneState(itr2->first)) {
1003             continue;
1004         }
1005
1006         if (NULL == itr2->second) {
1007             continue;
1008         }
1009
1010         ICO_DBG("Dequeue current display resource ower request"
1011                 "(req=0x%08x zoneid=%02d:%s appid=%s)",
1012                 tmpreq, tmpreq->dispzoneid, tmpreq->dispzone, tmpreq->appid);
1013         ICO_PRF("CHG_GUI_RES display deprived zone=%02d:%s appid=%s",
1014                 tmpreq->dispzoneid, tmpreq->dispzone, tmpreq->appid);
1015         itr2->second = NULL;
1016
1017         // hide current window
1018         m_winCtrl->hide(tmpreq->surfaceid, NULL, 0);
1019
1020         ICO_DBG("Enqueue waiting display resource request"
1021                 "(req=0x%08x zone=%02d:%s appid=%s",
1022                 tmpreq, tmpreq->dispzoneid, tmpreq->dispzone, tmpreq->appid);
1023         m_waitingDispResReq.push_front(tmpreq);
1024     }
1025
1026     if (NULL != m_winCtrl) {
1027         int ret = ICO_SYC_EOK;
1028         if (-1 != chgzoneid) {
1029             // move request window
1030             ret = m_winCtrl->setGeometry(req->surfaceid, req->dispzone,
1031                                          req->layerid,
1032                                          req->animation, req->animationTime,
1033                                          req->animation, req->animationTime);
1034             if (ICO_SYC_EOK != ret) {
1035                 return;
1036             }
1037         }
1038
1039         // show request window
1040         m_winCtrl->show(req->surfaceid, req->animation, req->animationTime);
1041     }
1042     // state change to acquired
1043     req->state = RES_STATE_ACQUIRED;
1044     // update current zone request
1045     ICO_DBG("Enqueue current display resource ower request"
1046             "(req=0x%08x zoneid=%02d:%s appid=%s)",
1047             req, req->dispzoneid, req->dispzone, req->appid);
1048     ICO_PRF("CHG_GUI_RES display acquired zone=%02d:%s appid=%s",
1049             req->dispzoneid, req->dispzone, req->appid);
1050     m_curDispResOwerReq[req->dispzoneid] = req;
1051 #if 1   //DEBUG
1052     dumpCurDispResOwerReq();
1053 #endif  //DEBUG
1054
1055     // if current zone ower not exist after zone change
1056     if (-1 != chgzoneid) {
1057         list<resource_request_t*>::iterator itr;
1058         itr = m_waitingDispResReq.begin();
1059         for (; itr !=  m_waitingDispResReq.end(); ++itr) {
1060             if (m_curDispResOwerReq[(*itr)->dispzoneid] != NULL) {
1061                 continue;
1062             }
1063
1064             if (true == m_policyMgr->isExistDisplayZoneOwer((*itr)->dispzoneid)) {
1065                 continue;
1066             }
1067
1068             int type = (*itr)->resid & RESID_TYPE_MASK;
1069             bool active = false;
1070             active = m_policyMgr->acquireDisplayResource(type,
1071                                                          (*itr)->dispzoneid,
1072                                                          (*itr)->prio);
1073             if (true == active) {
1074                 resource_request_t* req = *itr;
1075                 ICO_DBG("Dequeue waiting display resource request"
1076                         "(req=0x%08x zone=%02d:%s appid=%s)",
1077                         *itr, (*itr)->dispzoneid,
1078                         (*itr)->dispzone, (*itr)->appid);
1079                 m_waitingDispResReq.erase(itr);
1080 #if 1   //DEBUG
1081                 dumpWaitingDispResReq();
1082 #endif  //DEBUG
1083                 updateDisplayResource(req);
1084 #if 0
1085                 m_winCtrl->active(req->surfaceid, -1);
1086 #endif
1087                 break;
1088             }
1089         }
1090     }
1091
1092     ICO_TRA("CicoSCResourceManager::updateDisplayResource Leave");
1093 }
1094
1095 void
1096 CicoSCResourceManager::updateSoundResource(resource_request_t *req)
1097 {
1098     ICO_TRA("CicoSCResourceManager::updateSoundResource Enter"
1099             "(req=0x%08x)", req);
1100     for (int i = 0; i < (int)m_curSoundResReq.size(); ++i) {
1101         ICO_DBG("zoneid=%d active=%d current=0x%08x",
1102                 i, m_policyMgr->getSoundZoneState(i), m_curSoundResReq[i]);
1103
1104         if (NULL == m_curSoundResReq[i]) {
1105             continue;
1106         }
1107
1108         if ((i == req->soundzoneid) ||
1109             (false == m_policyMgr->getSoundZoneState(i))) {
1110
1111             // state change to waiting
1112             m_curSoundResReq[i]->state = RES_STATE_WAITING;
1113             // enqueue request
1114             ICO_DBG("Enqueue waiting sound request queue "
1115                     "(req=0x%08x zone:%02d:%s appid=%s)",
1116                     m_curSoundResReq[i], i,
1117                     m_curSoundResReq[i]->soundzone, m_curSoundResReq[i]->appid);
1118             m_soundReqQueue[i].push_front(m_curSoundResReq[i]);
1119
1120             // initialize current zone request
1121             ICO_DBG("Dequeue current sound request queue "
1122                     "(req=0x%08x zone:%02d:%s appid=%s)",
1123                     m_curSoundResReq[i], i,
1124                     m_curSoundResReq[i]->soundzone, m_curSoundResReq[i]->appid);
1125             ICO_PRF("CHG_GUI_RES sound   deprived zone=%02d:%s appid=%s",
1126                     i, m_curSoundResReq[i]->soundzone,
1127                     m_curSoundResReq[i]->appid);
1128             m_curSoundResReq[i] = NULL;
1129         }
1130     }
1131
1132     if (req != m_curSoundResReq[req->soundzoneid]) {
1133         ico_syc_mrp_acquire_sound_resource(req);
1134         ico_syc_mrp_active_app(req->appid);
1135
1136         // state change to acquired
1137         req->state = RES_STATE_ACQUIRED;
1138         // update current zone request
1139         ICO_DBG("Enqueue current sound request queue "
1140                 "(req=0x%08x zone:%02d:%s appid=%s)",
1141                 req, req->soundzoneid, req->soundzone, req->appid);
1142         ICO_PRF("CHG_GUI_RES sound   acquired zone=%02d:%s appid=%s",
1143                 req->soundzoneid, req->soundzone, req->appid);
1144         m_curSoundResReq[req->soundzoneid] = req;
1145     }
1146     ICO_TRA("CicoSCResourceManager::updateSoundResource Leave");
1147 }
1148
1149 void
1150 CicoSCResourceManager::updateInputResource(resource_request_t *req)
1151 {
1152     ICO_TRA("CicoSCResourceManager::updateInputResource Enter"
1153             "(req=0x%08x)", req);
1154     for (int i = 0; i < (int)m_curInputResReq.size(); ++i) {
1155         ICO_DBG("input=%d active=%d current=0x%08x",
1156                 i, m_policyMgr->getInputState(i), m_curInputResReq[i]);
1157
1158         if (NULL == m_curInputResReq[i]) {
1159             continue;
1160         }
1161
1162         if ((i == req->input) ||
1163             (false == m_policyMgr->getInputState(i))) {
1164
1165             if (NULL != m_inputCtrl) {
1166                 // add input control
1167                 m_inputCtrl->delInputApp(req->appid, req->device, req->input);
1168             }
1169
1170             // state change to waiting
1171             m_curInputResReq[i]->state = RES_STATE_WAITING;
1172             // enqueue request
1173             ICO_DBG("Enqueue waiting input request queue "
1174                     "(req=0x%08x input:%d appid=%s)",
1175                     m_curInputResReq[i], i, m_curInputResReq[i]->appid);
1176             m_inputReqQueue[i].push_front(m_curInputResReq[i]);
1177             // initialize current zone request
1178             ICO_DBG("Dequeue current input request queue "
1179                     "(req=0x%08x input:%d appid=%s)",
1180                     m_curInputResReq[i],
1181                     m_curInputResReq[i]->input, m_curInputResReq[i]->appid);
1182             ICO_PRF("CHG_GUI_RES input   deprived input=%d appid=%s",
1183                     m_curInputResReq[i]->input,
1184                     m_curInputResReq[i]->appid);
1185             m_curInputResReq[i] = NULL;
1186         }
1187     }
1188
1189     if (req != m_curInputResReq[req->input]) {
1190         // delete input control
1191         m_inputCtrl->addInputApp(req->appid, req->device, req->input, 0, 0);
1192         // state change to acquired
1193         req->state = RES_STATE_ACQUIRED;
1194         // update current zone request
1195         ICO_DBG("Enqueue current input request queue "
1196                 "(req=0x%08x input:%d appid=%s)", req, req->input, req->appid);
1197         ICO_PRF("CHG_GUI_RES input   acquired input=%d appid=%s",
1198                 req->input, req->appid);
1199         m_curInputResReq[req->input] = req;
1200     }
1201     ICO_TRA("CicoSCResourceManager::updateInputResource Leave");
1202 }
1203
1204 void
1205 CicoSCResourceManager::updateDisplayResourceRegulation(int state)
1206 {
1207     ICO_TRA("CicoSCResourceManager::updateDisplayResourceRegulation Enter"
1208             "(state=%d)", state);
1209
1210     if (STID_DRVREGULATION_ON == state) {
1211         bool curchg = false;
1212         std::map<unsigned int, resource_request_t*>::iterator itr;
1213         itr = m_curDispResOwerReq.begin();
1214         for (; itr != m_curDispResOwerReq.end(); ++itr) {
1215             resource_request_t *current = itr->second;
1216             if (NULL == current) {
1217                 continue;
1218             }
1219
1220             int type = current->resid & RESID_TYPE_MASK;
1221             bool active = false;
1222             active = m_policyMgr->acquireDisplayResource(type,
1223                                                          current->dispzoneid,
1224                                                          current->prio);
1225             if (false == active) {
1226                 if (NULL != m_winCtrl) {
1227                     // hide current window
1228                     m_winCtrl->hide(current->surfaceid,
1229                                     m_animaName.c_str(), m_animaTime);
1230                 }
1231                 curchg = true;
1232             }
1233         }
1234
1235         if (false == curchg) {
1236             ICO_TRA("CicoSCResourceManager::updateDisplayResourceRegulation "
1237                     "Leave");
1238             return;
1239         }
1240
1241         list<resource_request_t*>::iterator itr2;
1242         itr2 = m_waitingDispResReq.begin();
1243         for (; itr2 !=  m_waitingDispResReq.end(); ++itr2) {
1244             int type = (*itr2)->resid & RESID_TYPE_MASK;
1245             bool active = false;
1246             active = m_policyMgr->acquireDisplayResource(type,
1247                                                          (*itr2)->dispzoneid,
1248                                                          (*itr2)->prio);
1249             if (true == active) {
1250                 if (NULL != m_winCtrl) {
1251                     // show current window
1252                     m_winCtrl->show((*itr2)->surfaceid,
1253                                     m_animaName.c_str(), m_animaTime);
1254                 }
1255                 break;
1256             }
1257         }
1258     }
1259     else if (STID_DRVREGULATION_OFF == state) {
1260         std::map<unsigned int, resource_request_t*>::iterator itr;
1261         itr = m_curDispResOwerReq.begin();
1262         for (; itr != m_curDispResOwerReq.end(); ++itr) {
1263             resource_request_t *current = itr->second;
1264             if (NULL == current) {
1265                 if (true == m_policyMgr->isExistDisplayZoneOwer(itr->first)) {
1266                     if (NULL != m_winCtrl) {
1267                         int surfaceid = m_winCtrl->getDisplayedWindow(itr->first);
1268
1269 #if 0
1270                         if ((surfaceid > 0) && (NULL != itr->second) &&
1271                             (itr->second->surfaceid != surfaceid)) {
1272                             m_winCtrl->hide(surfaceid,
1273                                             m_animaName.c_str(),
1274                                             m_animaTime);
1275                         }
1276 #else
1277                         if (surfaceid > 0) {
1278                             m_winCtrl->hide(surfaceid,
1279                                             m_animaName.c_str(),
1280                                             m_animaTime);
1281                         }
1282
1283 #endif
1284                     }
1285                     continue;
1286                 }
1287                 list<resource_request_t*>::iterator itr2;
1288                 itr2 = m_waitingDispResReq.begin();
1289                 for (; itr2 != m_waitingDispResReq.end(); ++itr2) {
1290                     resource_request_t *req = *itr2;
1291                     if (itr->first != (unsigned int)req->dispzoneid) {
1292                         continue;
1293                     }
1294                     int type = req->resid & RESID_TYPE_MASK;
1295                     bool active = false;
1296                     active = m_policyMgr->acquireDisplayResource(type,
1297                                                                  req->dispzoneid,
1298                                                                  req->prio);
1299                     if (true == active) {
1300                         ICO_DBG("Dequeue waiting display resource request"
1301                                 "(req=0x%08x zone=%02d:%s appid=%s)",
1302                                 req, req->dispzoneid,
1303                                 req->dispzone, req->appid);
1304                         m_waitingDispResReq.erase(itr2);
1305                         ICO_DBG("Enqueue current display resource request"
1306                                 "(req=0x%08x zone=%02d:%s appid=%s)",
1307                                 req, req->dispzoneid,
1308                                 req->dispzone, req->appid);
1309                         ICO_PRF("CHG_GUI_RES display acquired zone=%02d:%s "
1310                                 "appid=%s",
1311                                 req->dispzoneid, req->dispzone, req->appid);
1312                         m_curDispResOwerReq[req->dispzoneid] = req;
1313 #if 1   //DEBUG
1314                         dumpCurDispResOwerReq();
1315                         dumpWaitingDispResReq();
1316 #endif  //DEBUG
1317                         m_winCtrl->show(req->surfaceid,
1318                                         m_animaName.c_str(), m_animaTime);
1319                         m_winCtrl->active(req->surfaceid, -1);
1320                         break;
1321                     }
1322                 }
1323             }
1324             else {
1325                 int type = current->resid & RESID_TYPE_MASK;
1326                 bool active = false;
1327                 active = m_policyMgr->acquireDisplayResource(type,
1328                                                              current->dispzoneid,
1329                                                              current->prio);
1330                 if (true == active) {
1331                     if (NULL != m_winCtrl) {
1332                         int surfaceid = m_winCtrl->getDisplayedWindow(
1333                                                     itr->second->dispzoneid);
1334                         if ((itr->second->surfaceid != surfaceid) &&
1335                             (surfaceid > 0)) {
1336                             m_winCtrl->hide(surfaceid,
1337                                             m_animaName.c_str(), m_animaTime);
1338                         }
1339
1340                         // show current window
1341                         m_winCtrl->show(current->surfaceid,
1342                                         m_animaName.c_str(), m_animaTime);
1343                     }
1344                 }
1345 #if 1   //DEBUG
1346                         dumpCurDispResOwerReq();
1347                         dumpWaitingDispResReq();
1348 #endif  //DEBUG
1349             }
1350         }
1351     }
1352
1353     ICO_TRA("CicoSCResourceManager::updateDisplayResourceRegulation Leave");
1354 }
1355
1356 void
1357 CicoSCResourceManager::updateSoundResourceRegulation(int state)
1358 {
1359     ICO_TRA("CicoSCResourceManager::updateSoundResourceRegulation Enter"
1360             "(state=%d)", state);
1361
1362     bool curchg = false;
1363     for (int i = 0; i < (int)m_curSoundResReq.size(); ++i) {
1364         resource_request_t *current = m_curSoundResReq[i];
1365         if (NULL == current) {
1366             continue;
1367         }
1368
1369         int type = current->resid & RESID_TYPE_MASK;
1370         bool active = false;
1371         active = m_policyMgr->acquireSoundResource(type,
1372                                                    current->soundzoneid,
1373                                                    current->prio);
1374         if (false == active) {
1375             // state change to waiting
1376             current->state = RES_STATE_WAITING;
1377             // enqueue request
1378             ICO_DBG("Enqueue waiting sound request queue "
1379                     "(req=0x%08x zone:%02d:%s appid=%s)",
1380                     current,  i, current->soundzone, current->appid);
1381             m_soundReqQueue[i].push_front(current);
1382             // initialize current zone request
1383             m_curSoundResReq[i] = NULL;
1384             curchg = true;
1385          }
1386     }
1387
1388     if ((false == curchg) && (STID_DRVREGULATION_ON == state)) {
1389         ICO_TRA("CicoSCResourceManager::updateSoundResourceRegulation Leave");
1390         return;
1391     }
1392
1393     map<int, list<resource_request_t*> >::iterator itr;
1394     itr = m_soundReqQueue.begin();
1395     for (; itr != m_soundReqQueue.end(); ++itr) {
1396         if (NULL != m_curSoundResReq[itr->first]) {
1397             continue;
1398         }
1399
1400         list<resource_request_t*>::iterator itr2;
1401         itr2 = itr->second.begin();
1402         for (; itr2 !=  itr->second.end(); ++itr2) {
1403             int type = (*itr2)->resid & RESID_TYPE_MASK;
1404             bool active = false;
1405             active = m_policyMgr->acquireSoundResource(type,
1406                                                        (*itr2)->soundzoneid,
1407                                                        (*itr2)->prio);
1408             if (true == active) {
1409                 resource_request_t* req = *itr2;
1410                 ICO_DBG("Dequeue waiting sound request queue "
1411                         "(req=0x%08x zone:%02d:%s appid=%s)",
1412                         *itr2, itr->first, (*itr2)->soundzone, (*itr2)->appid);
1413                 itr->second.erase(itr2);
1414                 updateSoundResource(req);
1415                 break;
1416             }
1417         }
1418     }
1419
1420     ICO_TRA("CicoSCResourceManager::updateSoundResourceRegulation Leave");
1421 }
1422
1423 void
1424 CicoSCResourceManager::updateInputResourceRegulation(int state)
1425 {
1426     ICO_TRA("CicoSCResourceManager::updateInputResourceRegulation Enter"
1427             "(state=%d)", state);
1428
1429     bool curchg = false;
1430     for (int i = 0; i < (int)m_curInputResReq.size(); ++i) {
1431         resource_request_t *current = m_curInputResReq[i];
1432         if (NULL == current) {
1433             continue;
1434         }
1435
1436         bool active = false;
1437         active = m_policyMgr->acquireInputResource(current->input,
1438                                                    current->prio);
1439         if (false == active) {
1440             if (NULL != m_inputCtrl) {
1441                 // hide current window
1442                 m_inputCtrl->delInputApp(current->appid,
1443                                          current->device,
1444                                          current->input);
1445             }
1446             // state change to waiting
1447             current->state = RES_STATE_WAITING;
1448             // enqueue request
1449             ICO_DBG("Enqueue waiting input request queue "
1450                     "(req=0x%08x input:%d appid=%s)",
1451                     current, i, current->appid);
1452             m_inputReqQueue[i].push_front(current);
1453             // initialize current zone request
1454             m_curInputResReq[i] = NULL;
1455             curchg = true;
1456          }
1457     }
1458
1459     if ((false == curchg) && (STID_DRVREGULATION_ON == state)) {
1460         ICO_TRA("CicoSCResourceManager::updateInputResourceRegulation Leave");
1461         return;
1462     }
1463
1464     map<int, list<resource_request_t*> >::iterator itr;
1465     itr = m_inputReqQueue.begin();
1466     for (; itr != m_inputReqQueue.end(); ++itr) {
1467         if (NULL != m_curInputResReq[itr->first]) {
1468             continue;
1469         }
1470
1471         list<resource_request_t*>::iterator itr2;
1472         itr2 = itr->second.begin();
1473         for (; itr2 !=  itr->second.end(); ++itr2) {
1474             bool active = false;
1475             active = m_policyMgr->acquireInputResource((*itr2)->input,
1476                                                        (*itr2)->prio);
1477             if (true == active) {
1478                 resource_request_t* req = *itr2;
1479                 ICO_DBG("Dequeue waiting input request queue "
1480                         "(req=0x%08x input:%d appid=%s)",
1481                         *itr2, (*itr2)->input, (*itr2)->appid);
1482                 itr->second.erase(itr2);
1483                 updateInputResource(req);
1484                 break;
1485             }
1486         }
1487     }
1488
1489     ICO_TRA("CicoSCResourceManager::updateInputResourceRegulation Leave");
1490 }
1491
1492 //--------------------------------------------------------------------------
1493 /**
1494  *  @brief   find currnet dipalay resource ower request
1495  *
1496  *  @param [in] request  compare requset
1497  *
1498  *  @return request object on same requeset found, NULL on not found
1499  */
1500 //--------------------------------------------------------------------------
1501 resource_request_t *
1502 CicoSCResourceManager::findCurDispResOwerReq(resource_request_t *req)
1503 {
1504     if (NULL == req) {
1505         ICO_WRN("invalid argument. req is null");
1506         return NULL;
1507     }
1508     std::map<unsigned int, resource_request_t*>::iterator itr;
1509     itr = m_curDispResOwerReq.begin();
1510     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1511         CompDisplayResourceRequest comp(req);
1512         if (true == comp(itr->second)) {
1513             return itr->second;
1514         }
1515     }
1516     return NULL;
1517 }
1518
1519 //--------------------------------------------------------------------------
1520 /**
1521  *  @brief  pop currnet dipalay resource ower request from list
1522  *
1523  *  @param [in] request  compare requset
1524  *
1525  *  @return request object on same requeset found, NULL on not found
1526  */
1527 //--------------------------------------------------------------------------
1528 resource_request_t *
1529 CicoSCResourceManager::popCurDispResOwerReq(resource_request_t *req)
1530 {
1531     if (NULL == req) {
1532         ICO_WRN("invalid argument. req is null");
1533         return NULL;
1534     }
1535     std::map<unsigned int, resource_request_t*>::iterator itr;
1536     itr = m_curDispResOwerReq.begin();
1537     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1538         CompDisplayResourceRequest comp(req);
1539         if (true == comp(itr->second)) {
1540             ICO_DBG("Dequeue current display resource ower request"
1541                     "(req=0x%08x zoneid=%02d:%s appid=%s)",
1542                     itr->second, itr->first,
1543                     itr->second->dispzone, itr->second->appid);
1544             ICO_PRF("CHG_GUI_RES display deprived zone=%02d:%s appid=%s",
1545                     itr->first, itr->second->dispzone, itr->second->appid);
1546             resource_request_t *findreq = itr->second;
1547             itr->second = NULL;
1548 #if 1   //DEBUG
1549             dumpCurDispResOwerReq();
1550 #endif  //DEBUG
1551             return findreq;
1552         }
1553     }
1554     return NULL;
1555 }
1556
1557 //--------------------------------------------------------------------------
1558 /**
1559  *  @brief   dump currnet dipalay resource ower request
1560  */
1561 //--------------------------------------------------------------------------
1562 void
1563 CicoSCResourceManager::dumpCurDispResOwerReq(void)
1564 {
1565     std::map<unsigned int, resource_request_t*>::iterator itr;
1566     itr = m_curDispResOwerReq.begin();
1567     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1568         if (NULL == itr->second) {
1569             ICO_DBG("current req=0x%08x zone=%02d:(null) appid=(null)",
1570                     itr->second, itr->first);
1571         }
1572         else {
1573             ICO_DBG("current req=0x%08x zone=%02d:%s appid=%s",
1574                     itr->second, itr->first, itr->second->dispzone,
1575                     itr->second->appid);
1576         }
1577     }
1578 }
1579
1580 //--------------------------------------------------------------------------
1581 /**
1582  *  @brief  find waiting dipalay resource request
1583  *
1584  *  @param [in] request  compare requset
1585  *
1586  *  @return request object on same requeset found, NULL on not found
1587  */
1588 //--------------------------------------------------------------------------
1589 resource_request_t *
1590 CicoSCResourceManager::findWaitingDispResReq(resource_request_t *req)
1591 {
1592     if (NULL == req) {
1593         ICO_WRN("invalid argument. req is null");
1594         return NULL;
1595     }
1596     CompDisplayResourceRequest comp(req);
1597     std::list<resource_request_t*>::iterator itr;
1598     itr = find_if(m_waitingDispResReq.begin(), m_waitingDispResReq.end(), comp);
1599     if (m_waitingDispResReq.end() != itr) {
1600         return *itr;
1601     }
1602     return NULL;
1603 }
1604
1605 //--------------------------------------------------------------------------
1606 /**
1607  *  @brief  pop waiting dipalay resource request from waiting list
1608  *
1609  *  @param [in] request  compare requset
1610  *
1611  *  @return request object on same requeset found, NULL on not found
1612  */
1613 //--------------------------------------------------------------------------
1614 resource_request_t *
1615 CicoSCResourceManager::popWaitingDispResReq(resource_request_t *req)
1616 {
1617     if (NULL == req) {
1618         ICO_WRN("invalid argument. req is null");
1619         return NULL;
1620     }
1621     CompDisplayResourceRequest comp(req);
1622     std::list<resource_request_t*>::iterator itr;
1623     itr = find_if(m_waitingDispResReq.begin(), m_waitingDispResReq.end(), comp);
1624     if (m_waitingDispResReq.end() != itr) {
1625         ICO_DBG("Dequeue waiting display resource request"
1626                 "(req=0x%08x zone:%02d:%s appid=%s)",
1627                 *itr, (*itr)->dispzoneid, (*itr)->dispzone, (*itr)->appid);
1628         resource_request_t *findreq = *itr;
1629         m_waitingDispResReq.erase(itr);
1630 #if 1   //DEBUG
1631         dumpWaitingDispResReq();
1632 #endif  //DEBUG
1633         return findreq;
1634     }
1635     return NULL;
1636 }
1637
1638 //--------------------------------------------------------------------------
1639 /**
1640  *  @brief  dump waiting dipalay resource request
1641  */
1642 //--------------------------------------------------------------------------
1643 void
1644 CicoSCResourceManager::dumpWaitingDispResReq(void)
1645 {
1646     std::list<resource_request_t*>::iterator itr;
1647     itr = m_waitingDispResReq.begin();
1648     for (; itr != m_waitingDispResReq.end(); ++itr) {
1649         if (NULL == *itr) {
1650             ICO_DBG("waiting req=null");
1651         }
1652         else {
1653             ICO_DBG("waiting req=0x%08x zone=%02d:%s appid=%s",
1654                     *itr, (*itr)->dispzoneid, (*itr)->dispzone, (*itr)->appid);
1655         }
1656     }
1657 }
1658
1659 //--------------------------------------------------------------------------
1660 /**
1661  *  @brief  update display request for regulation pre-process
1662  */
1663 //--------------------------------------------------------------------------
1664 void
1665 CicoSCResourceManager::updateDispResRegulationPreProc(resource_request_t *req)
1666 {
1667     ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Enter");
1668 #if 1   //DEBUG
1669     dumpCurDispResOwerReq();
1670     dumpWaitingDispResReq();
1671 #endif  //DEBUG
1672
1673     if (NULL == req) {
1674         ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
1675         return;
1676     }
1677
1678     if (false == m_policyMgr->getRegulation()) {
1679         ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
1680         return;
1681     }
1682
1683     CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
1684     const CicoSCAppKindConf *appKindConf = NULL;
1685     appKindConf = sysConf->findAppKindConfbyId(req->appkind);
1686     if (NULL == appKindConf) {
1687         ICO_ERR("not found CicoSCAppKindConf instance");
1688         ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
1689         return;
1690     }
1691
1692     if ((appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_ALMIGHTY) ||
1693         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM)   ||
1694         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM_VISIBLE)) {
1695
1696         if (NULL != m_winCtrl) {
1697             m_winCtrl->show(req->surfaceid,
1698                             req->animation,
1699                             req->animationTime);
1700         }
1701         delResourceRequest(req);
1702
1703         ICO_DBG("kind of system application");
1704         ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
1705         return;
1706     }
1707
1708     int surfaceid = req->surfaceid;
1709     if (NULL != m_winCtrl) {
1710         surfaceid = m_winCtrl->getDisplayedWindow(req->dispzoneid);
1711         if (-1 == surfaceid) {
1712             ICO_WRN("displayed surface id is invalid.");
1713             surfaceid = req->surfaceid;
1714         }
1715     }
1716
1717     if (req->surfaceid != surfaceid) {
1718         ICO_WRN("req->surfaceid(0x%08X) != displayedsurfaceid(0x%08X)",
1719                 req->surfaceid, surfaceid);
1720     }
1721
1722     resource_request_t *curreq = NULL;
1723     int min = ICO_DISPLAY0_ZONEID_MIN;
1724     int max = ICO_DISPLAY0_ZONEID_MAX;
1725     if ((req->dispzoneid >= min) && (req->dispzoneid <= max)) {
1726         for (int i = min; i <= max; ++i) {
1727             std::map<unsigned int, resource_request_t*>::iterator itr;
1728             itr = m_curDispResOwerReq.find(i);
1729             if (itr != m_curDispResOwerReq.end()) {
1730                 if (NULL != itr->second) {
1731                     curreq = itr->second;
1732                     break;
1733                 }
1734             }
1735         }
1736     }
1737
1738     min = ICO_DISPLAY1_ZONEID_MIN;
1739     max = ICO_DISPLAY1_ZONEID_MAX;
1740     if ((NULL == curreq) &&
1741         (req->dispzoneid >= min) && (req->dispzoneid <= max)) {
1742         for (int i = min; i <= max; ++i) {
1743             std::map<unsigned int, resource_request_t*>::iterator itr;
1744             itr = m_curDispResOwerReq.find(i);
1745             if (itr != m_curDispResOwerReq.end()) {
1746                 if (NULL != itr->second) {
1747                     curreq = itr->second;
1748                     break;
1749                 }
1750             }
1751         }
1752     }
1753
1754 #if 0
1755     resource_request_t *curreq = NULL;
1756     std::map<unsigned int, resource_request_t*>::iterator itr;
1757     itr = m_curDispResOwerReq.find(req->dispzoneid);
1758     if (itr != m_curDispResOwerReq.end()) {
1759         curreq = itr->second;
1760     }
1761 #endif
1762
1763     if (NULL != curreq) {
1764         ICO_DBG("Dequeue current display resource request"
1765                 "(req=0x%08x zone:%02d:%s appid=%s)",
1766                 curreq, curreq->dispzoneid, curreq->dispzone, curreq->appid);
1767         ICO_PRF("CHG_GUI_RES display deprived zone=%02d:%s appid=%s",
1768                 curreq->dispzoneid, curreq->dispzone, curreq->appid);
1769         m_curDispResOwerReq[curreq->dispzoneid] = NULL;
1770
1771         if (curreq->surfaceid != req->surfaceid) {
1772             resource_request_t *waitreq = popWaitingDispResReq(req);
1773             ICO_DBG("Enqueue waiting display resource request"
1774                     "(req=0x%08x zone:%02d:%s appid=%s)",
1775                     curreq, curreq->dispzoneid,
1776                     curreq->dispzone, curreq->appid);
1777             m_waitingDispResReq.push_front(curreq);
1778
1779             if (NULL != waitreq) {
1780                 ICO_DBG("Enqueue current display resource request"
1781                         "(req=0x%08x zone:%02d:%s appid=%s)",
1782                         waitreq, waitreq->dispzoneid,
1783                         waitreq->dispzone, waitreq->appid);
1784                 ICO_PRF("CHG_GUI_RES display acquired zone=%02d:%s appid=%s",
1785                         waitreq->dispzoneid, waitreq->dispzone, waitreq->appid);
1786                 m_curDispResOwerReq[waitreq->dispzoneid] = waitreq;
1787             }
1788         }
1789         else {
1790             ICO_DBG("Enqueue current display resource request"
1791                     "(req=0x%08x zone:%02d:%s appid=%s)",
1792                     curreq, curreq->dispzoneid,
1793                     curreq->dispzone, curreq->appid);
1794             ICO_PRF("CHG_GUI_RES display acquired zone=%02d:%s appid=%s",
1795                     curreq->dispzoneid, curreq->dispzone, curreq->appid);
1796             m_curDispResOwerReq[curreq->dispzoneid] = curreq;
1797         }
1798     }
1799     delResourceRequest(req);
1800
1801 #if 1   //DEBUG
1802     dumpCurDispResOwerReq();
1803     dumpWaitingDispResReq();
1804 #endif  //DEBUG
1805     ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
1806 }
1807
1808 //--------------------------------------------------------------------------
1809 /**
1810  *  @brief  update sound request for regulation pre-process
1811  */
1812 //--------------------------------------------------------------------------
1813 void
1814 CicoSCResourceManager::updateSoundResRegulationPreProc(resource_request_t *req)
1815 {
1816     ICO_TRA("CicoSCResourceManager::updateSoundResRegulationPreProc Enter");
1817
1818     if (NULL == req) {
1819         return;
1820     }
1821
1822     if (false == m_policyMgr->getRegulation()) {
1823         return;
1824     }
1825
1826     CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
1827     const CicoSCAppKindConf *appKindConf = NULL;
1828     appKindConf = sysConf->findAppKindConfbyId(req->appkind);
1829     if (NULL == appKindConf) {
1830         ICO_ERR("not found CicoSCAppKindConf instance");
1831         ICO_TRA("CicoSCResourceManager::updateSoundResRegulationPreProc Leave");
1832         return;
1833     }
1834
1835     if ((appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_ALMIGHTY) ||
1836         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM)   ||
1837         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM_AUDIO)) {
1838
1839         delResourceRequest(req);
1840
1841         ICO_DBG("kind of system application");
1842         ICO_TRA("CicoSCResourceManager::updateSoundResRegulationPreProc Leave");
1843         return;
1844     }
1845
1846     resource_request_t *curreq = NULL;
1847     std::map<int, resource_request_t*>::iterator itr;
1848     itr = m_curSoundResReq.find(req->soundzoneid);
1849     if (itr != m_curSoundResReq.end()) {
1850         curreq = itr->second;
1851     }
1852
1853     if (NULL != curreq) {
1854         ICO_DBG("Dequeue current sound resource request"
1855                 "(req=0x%08x zone:%02d:%s appid=%s)",
1856                 curreq, curreq->soundzoneid, curreq->soundzone, curreq->appid);
1857         ICO_PRF("CHG_GUI_RES sound   deprived zone=%02d:%s appid=%s",
1858                 curreq->soundzoneid, curreq->soundzone, curreq->appid);
1859         m_curSoundResReq[curreq->soundzoneid] = NULL;
1860
1861         if (0 != strcmp(curreq->appid, req->appid)) {
1862             resource_request_t *waitreq = popSoundResReq(req);
1863             ICO_DBG("Enqueue waiting sound resource request"
1864                     "(req=0x%08x zone:%02d:%s appid=%s)",
1865                     curreq, curreq->soundzoneid,
1866                     curreq->soundzone, curreq->appid);
1867             m_soundReqQueue[curreq->soundzoneid].push_front(curreq);
1868
1869             if (NULL != waitreq) {
1870                 ICO_DBG("Enqueue current sound resource request"
1871                         "(req=0x%08x zone:%02d:%s appid=%s)",
1872                         waitreq, waitreq->soundzoneid,
1873                         waitreq->soundzone, waitreq->appid);
1874                 ICO_PRF("CHG_GUI_RES sound   acquired zone=%02d:%s appid=%s",
1875                         waitreq->soundzoneid, waitreq->soundzone,
1876                         waitreq->appid);
1877                 m_curSoundResReq[curreq->soundzoneid] = waitreq;
1878             }
1879         }
1880         else {
1881             ICO_DBG("Enqueue current sound resource request"
1882                     "(req=0x%08x zone:%02d:%s appid=%s)",
1883                     curreq, curreq->soundzoneid,
1884                     curreq->soundzone, curreq->appid);
1885             ICO_PRF("CHG_GUI_RES sound   acquired zone=%d:%s appid=%s",
1886                     curreq->soundzoneid, curreq->soundzone, curreq->appid);
1887             m_curSoundResReq[curreq->soundzoneid] = curreq;
1888         }
1889     }
1890     delResourceRequest(req);
1891     ICO_TRA("CicoSCResourceManager::updateSoundResRegulationPreProc Leave");
1892 }
1893
1894 //--------------------------------------------------------------------------
1895 /**
1896  *  @brief  update input request for regulation pre-process
1897  */
1898 //--------------------------------------------------------------------------
1899 void
1900 CicoSCResourceManager::updateInputResRegulationPreProc(resource_request_t *req)
1901 {
1902     ICO_TRA("CicoSCResourceManager::updateInputResRegulationPreProc Enter");
1903
1904     if (NULL == req) {
1905         return;
1906     }
1907
1908     if (false == m_policyMgr->getRegulation()) {
1909         return;
1910     }
1911
1912     resource_request_t *curreq = NULL;
1913     std::map<int, resource_request_t*>::iterator itr;
1914     itr = m_curInputResReq.find(req->input);
1915     if (itr != m_curInputResReq.end()) {
1916         curreq = itr->second;
1917     }
1918
1919     if (NULL != curreq) {
1920         ICO_DBG("Dequeue current input resource request"
1921                 "(req=0x%08x input:%d appid=%s)",
1922                 curreq, curreq->input, curreq->appid);
1923         ICO_PRF("CHG_GUI_RES input   deprived input=%d appid=%s",
1924                 curreq->input, curreq->appid);
1925         m_curInputResReq[curreq->input] = NULL;
1926
1927         if (0 != strcmp(curreq->appid, req->appid)) {
1928             resource_request_t *waitreq = popInputResReq(req);
1929             ICO_DBG("Enqueue waiting input resource request"
1930                     "(req=0x%08x input:%d appid=%s)",
1931                     curreq, curreq->input, curreq->appid);
1932             m_inputReqQueue[curreq->input].push_front(curreq);
1933
1934             if (NULL != waitreq) {
1935                 ICO_DBG("Enqueue current input resource request"
1936                         "(req=0x%08x input:%d appid=%s)",
1937                         waitreq, waitreq->input, waitreq->appid);
1938                 ICO_PRF("CHG_GUI_RES input   acquired input=%d appid=%s",
1939                         waitreq->input, waitreq->appid);
1940                 m_curInputResReq[curreq->input] = waitreq;
1941             }
1942         }
1943         else {
1944             ICO_DBG("Enqueue current input resource request"
1945                     "(req=0x%08x input:%d appid=%s)",
1946                     curreq, curreq->input, curreq->appid);
1947             ICO_PRF("CHG_GUI_RES input   acquired input=%d appid=%s",
1948                     curreq->input, curreq->appid);
1949             m_curInputResReq[curreq->input] = curreq;
1950         }
1951     }
1952     delResourceRequest(req);
1953     ICO_TRA("CicoSCResourceManager::updateInputResRegulationPreProc Leave");
1954 }
1955
1956 //--------------------------------------------------------------------------
1957 /**
1958  *  @brief  compare displayed surface and ower surface
1959  */
1960 //--------------------------------------------------------------------------
1961 bool
1962 CicoSCResourceManager::isMatchDisplayed(void)
1963 {
1964     bool ret = false;
1965     std::map<unsigned int, resource_request_t*>::iterator itr;
1966     itr = m_curDispResOwerReq.begin();
1967     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1968         if (NULL == itr->second) {
1969             continue;
1970         }
1971         if (NULL != m_winCtrl) {
1972             int surfaceid = m_winCtrl->getDisplayedWindow(
1973                                         itr->second->dispzoneid);
1974             std::map<unsigned int, resource_request_t*>::iterator itr2;
1975             itr2 = m_curDispResOwerReq.begin();
1976             for (; itr2 != m_curDispResOwerReq.end(); ++itr2) {
1977                 if (NULL == itr2->second) {
1978                     continue;
1979                 }
1980                 if ((itr2->second->surfaceid == surfaceid)) {
1981                     ret = true;
1982                     break;
1983                 }
1984             }
1985         }
1986     }
1987     return ret;
1988 }
1989 // vim:set expandtab ts=4 sw=4: