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     //
 449     if (req != newreq) {
 450         // update request data
 451         req->dispzoneid = newreq->dispzoneid;
 452         if (NULL != req->dispzone) free(req->dispzone);
 453         req->dispzone = strdup(newreq->dispzone);
 454         req->layerid = newreq->layerid;
 455         if (NULL != req->animation) free(req->animation);
 456         req->animation = strdup(newreq->animation);
 457         req->animationTime = newreq->animationTime;
 458
 459         // delete new request
 460         delResourceRequest(newreq);
 461     }
 462
 463     if (false == control) {
 464         ICO_TRA("Enqueue waiting display resource request"
 465                 "(req=0x%08x appid=%s)", req, req->appid);
 466         m_waitingDispResReq.push_front(req);
 467 #if 1   //DEBUG
 468         dumpWaitingDispResReq();
 469 #endif  //DEBUG
 470         return true;
 471     }
 472
 473     int type = req->resid & RESID_TYPE_MASK;
 474     bool state = m_policyMgr->acquireDisplayResource(type,
 475                                                      req->dispzoneid,
 476                                                      req->prio);
 477     if (true == state) {
 478         updateDisplayResource(req, chgzone);
 479     }
 480     else {
 481         if (-1 != chgzone) {
 482             // move request window
 483             m_winCtrl->setGeometry(req->surfaceid, req->dispzone, req->layerid,
 484                                    req->animation, req->animationTime,
 485                                    req->animation, req->animationTime);
 486         }
 487         else {
 488             // just in case, hide window
 489             if (NULL != m_winCtrl) {
 490                 // hide request window
 491                 m_winCtrl->hide(req->surfaceid, NULL, 0);
 492             }
 493         }
 494         ICO_DBG("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     }
 501
 502     ICO_TRA("CicoSCResourceManager::acquireDisplayResource Leave");
 503     return true;
 504 }
 505
 506 void
 507 CicoSCResourceManager::releaseDisplayResource(resource_request_t *newreq)
 508 {
 509     ICO_TRA("CicoSCResourceManager::releaseDisplayResource Enter"
 510             "(newreq=0x%08x)", newreq);
 511
 512     // if exist in wating request list, pop request
 513     resource_request_t *req = popWaitingDispResReq(newreq);
 514     if (NULL != req) {
 515         delResourceRequest(req);
 516         delResourceRequest(newreq);
 517         ICO_TRA("CicoSCResourceManager::releaseDisplayResource Leave");
 518         return;
 519     }
 520
 521     // if exist current ower request, pop request
 522     req = popCurDispResOwerReq(newreq);
 523     if (NULL != req) {
 524         m_policyMgr->releaseDisplayResource(req->dispzoneid, req->prio);
 525         delResourceRequest(req);
 526     }
 527     delResourceRequest(newreq);
 528
 529     list<resource_request_t*>::iterator itr;
 530     itr = m_waitingDispResReq.begin();
 531     for (; itr != m_waitingDispResReq.end(); ++itr) {
 532         if (NULL != m_curDispResOwerReq[(*itr)->dispzoneid]) {
 533             continue;
 534         }
 535         int type = (*itr)->resid & RESID_TYPE_MASK;
 536         bool active = m_policyMgr->acquireDisplayResource(type,
 537                                                          (*itr)->dispzoneid,
 538                                                          (*itr)->prio);
 539         if (true == active) {
 540             resource_request_t* popreq = popWaitingDispResReq(*itr);
 541             updateDisplayResource(popreq);
 542             m_winCtrl->activeCB(NULL, NULL, popreq->surfaceid, -1);
 543             break;
 544         }
 545     }
 546
 547     ICO_TRA("CicoSCResourceManager::releaseDisplayResource Leave");
 548 }
 549
 550 bool
 551 CicoSCResourceManager::acquireSoundResource(resource_request_t *newreq)
 552 {
 553     ICO_TRA("CicoSCResourceManager::acquireSoundResource Enter");
 554
 555     CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
 556     const CicoSCAppKindConf *appKindConf = NULL;
 557     appKindConf = sysConf->findAppKindConfbyId(newreq->appkind);
 558     if (NULL == appKindConf) {
 559         ICO_ERR("not found CicoSCAppKindConf instance");
 560         ICO_TRA("CicoSCResourceManager::acquireSoundResource Leave(false)");
 561         return false;
 562     }
 563
 564     if ((appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_ALMIGHTY) ||
 565         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM)   ||
 566         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM_AUDIO)) {
 567
 568         delResourceRequest(newreq);
 569
 570         ICO_DBG("kind of system application");
 571         ICO_TRA("CicoSCResourceManager::acquireSoundResource Leave(true)");
 572         return true;
 573     }
 574
 575     resource_request_t *req = popSoundResReq(newreq);
 576     if (NULL == req) {
 577         req = newreq;
 578     }
 579
 580     // is change zone?
 581     CompSoundResourceRequest comp(req);
 582     if (true == comp(m_curSoundResReq[req->soundzoneid])) {
 583         ICO_DBG("already acquired appid=%s pid=%d soundid=0x%08X",
 584                 req->appid, req->pid, req->soundid);
 585         ICO_TRA("CicoSCResourceManager::acquireSoundResource Leave(true)");
 586         // free new request
 587         delResourceRequest(newreq);
 588         return true;
 589     }
 590
 591     int type = req->resid & RESID_TYPE_MASK;
 592     bool state = m_policyMgr->acquireSoundResource(type,
 593                                                    req->soundzoneid,
 594                                                    req->prio);
 595     if (true == state) {
 596         updateSoundResource(req);
 597     }
 598     else {
 599         ICO_DBG("Enqueue waiting sound request queue"
 600                 "(req=0x%08x zone:%02d:%s appid=%s)",
 601                 req, req->soundzoneid, req->soundzone, req->appid);
 602         m_soundReqQueue[req->soundzoneid].push_front(req);
 603     }
 604
 605     ICO_TRA("CicoSCResourceManager::acquireSoundResource Leave");
 606     return true;
 607 }
 608
 609 void
 610 CicoSCResourceManager::releaseSoundResource(resource_request_t *newreq)
 611 {
 612     ICO_TRA("CicoSCResourceManager::releaseSoundResource Enter");
 613
 614     bool curchg = false;
 615     CompSoundResourceRequest comp(newreq);
 616     for (int i = 0; i < (int)m_curSoundResReq.size(); ++i) {
 617          if (NULL == m_curSoundResReq[i]) {
 618             continue;
 619          }
 620
 621          if (true == comp(m_curSoundResReq[i])) {
 622             ICO_DBG("Dequeue current sound resource ower request"
 623                     "(req=0x%08x zoneid=%02d:%s appid=%s)",
 624                     m_curSoundResReq[i], m_curSoundResReq[i]->dispzoneid,
 625                     m_curSoundResReq[i]->dispzone,
 626                     m_curSoundResReq[i]->appid);
 627             ICO_PRF("CHG_GUI_RES sound   deprived zone=%02d:%s appid=%s",
 628                     m_curSoundResReq[i]->dispzoneid,
 629                     m_curSoundResReq[i]->dispzone,
 630                     m_curSoundResReq[i]->appid);
 631             ico_syc_mrp_release_sound_resource(m_curSoundResReq[i]);
 632             delResourceRequest(newreq);
 633             delResourceRequest(m_curSoundResReq[i]);
 634             m_curSoundResReq[i] = NULL;
 635             curchg = true;
 636             break;
 637          }
 638     }
 639
 640     // If current request is not changed,
 641     // remove the request from the waiting queue.
 642     if (false == curchg) {
 643        resource_request_t *req = popSoundResReq(newreq);
 644         if (NULL != req) {
 645             ico_syc_mrp_release_sound_resource(req);
 646             delResourceRequest(req);
 647             req = NULL;
 648         }
 649         delResourceRequest(newreq);
 650         ICO_TRA("CicoSCResourceManager::releaseSoundResource Leave");
 651         return;
 652     }
 653
 654     map<int, list<resource_request_t*> >::iterator itr;
 655     itr = m_soundReqQueue.begin();
 656     for (; itr != m_soundReqQueue.end(); ++itr) {
 657         list<resource_request_t*>::iterator itr2;
 658         itr2 = itr->second.begin();
 659         for (; itr2 !=  itr->second.end(); ++itr2) {
 660             if (NULL != m_curSoundResReq[(*itr2)->soundzoneid]) {
 661                 continue;
 662             }
 663
 664             int type = (*itr2)->resid & RESID_TYPE_MASK;
 665             bool active = m_policyMgr->acquireSoundResource(type,
 666                                                             (*itr2)->soundzoneid,
 667                                                             (*itr2)->prio);
 668             if (true == active) {
 669                 resource_request_t* req = *itr2;
 670                 ICO_DBG("Dequeue waiting sound request queue "
 671                         "(req=0x%08x zone:%02d:%s appid=%s)",
 672                         *itr2, itr->first, (*itr2)->soundzone, (*itr2)->appid);
 673                 itr->second.erase(itr2);
 674                 updateSoundResource(req);
 675                 break;
 676             }
 677         }
 678     }
 679
 680     ICO_TRA("CicoSCResourceManager::releaseSoundResource Leave");
 681 }
 682
 683 bool
 684 CicoSCResourceManager::acquireInputResource(resource_request_t *newreq)
 685 {
 686     ICO_TRA("CicoSCResourceManager::acquireInputResource Enter");
 687
 688     resource_request_t *req = popInputResReq(newreq);
 689     if (NULL == req) {
 690         req = newreq;
 691     }
 692
 693     // is change zone?
 694     CompInputResourceRequest comp(req);
 695     if (true == comp(m_curInputResReq[req->input])) {
 696         ICO_DBG("already acquired appid=%s pid=%d input=0x%08X",
 697                 req->appid, req->pid, req->input);
 698         ICO_TRA("CicoSCResourceManager::acquireInputResource Leave(true)");
 699         // free new request
 700         delResourceRequest(newreq);
 701         return true;
 702     }
 703
 704     bool state = m_policyMgr->acquireInputResource(req->input, req->prio);
 705     if (true == state) {
 706         updateInputResource(req);
 707     }
 708     else {
 709         ICO_DBG("Enqueue waiting input request queue"
 710                 "(req=0x%08x input:%d appid=%s)", req, req->input, req->appid);
 711         m_inputReqQueue[req->input].push_front(req);
 712     }
 713
 714     ICO_TRA("CicoSCResourceManager::acquireInputResource Leave(true)");
 715     return true;
 716 }
 717
 718 void
 719 CicoSCResourceManager::releaseInputResource(resource_request_t *newreq)
 720 {
 721     ICO_TRA("CicoSCResourceManager::releaseInputResource Enter");
 722     bool curchg = false;
 723     CompInputResourceRequest comp(newreq);
 724     for (int i = 0; i < (int)m_curInputResReq.size(); ++i) {
 725          if (NULL == m_curInputResReq[i]) {
 726             continue;
 727          }
 728
 729          if (true == comp(m_curInputResReq[i])) {
 730             if (NULL != m_inputCtrl) {
 731                 m_inputCtrl->delInputApp(m_curInputResReq[i]->appid,
 732                                          m_curInputResReq[i]->device,
 733                                          m_curInputResReq[i]->input);
 734             }
 735             ICO_DBG("Dequeue current input resource ower request"
 736                     "(req=0x%08x input=%d appid=%s)",
 737                     m_curInputResReq[i], m_curInputResReq[i]->input,
 738                     m_curInputResReq[i]->appid);
 739             ICO_PRF("CHG_GUI_RES input   deprived input=%d appid=%s",
 740                     m_curInputResReq[i]->input, m_curInputResReq[i]->appid);
 741             delResourceRequest(newreq);
 742             delResourceRequest(m_curInputResReq[i]);
 743             m_curInputResReq[i] = NULL;
 744             curchg = true;
 745             break;
 746          }
 747     }
 748
 749     // If current request is not changed,
 750     // remove the request from the waiting queue.
 751     if (false == curchg) {
 752        resource_request_t *req = popInputResReq(newreq);
 753         if (NULL != req) {
 754             delResourceRequest(req);
 755             req = NULL;
 756         }
 757         delResourceRequest(newreq);
 758         ICO_TRA("CicoSCResourceManager::releaseInputResource Leave");
 759         return;
 760     }
 761
 762     map<int, list<resource_request_t*> >::iterator itr;
 763     itr = m_inputReqQueue.begin();
 764     for (; itr != m_inputReqQueue.end(); ++itr) {
 765         list<resource_request_t*>::iterator itr2;
 766         itr2 = itr->second.begin();
 767         for (; itr2 !=  itr->second.end(); ++itr2) {
 768             if (NULL != m_curInputResReq[(*itr2)->input]) {
 769                 continue;
 770             }
 771             bool active = m_policyMgr->acquireInputResource((*itr2)->input,
 772                                                             (*itr2)->prio);
 773             if (true == active) {
 774                 resource_request_t* req = *itr2;
 775                 ICO_DBG("Dequeue waiting input request queue "
 776                         "(req=0x%08x input:%d appid=%s)",
 777                         *itr2, (*itr2)->input, (*itr2)->appid);
 778                 itr->second.erase(itr2);
 779                 updateInputResource(req);
 780                 break;
 781             }
 782         }
 783     }
 784     ICO_TRA("CicoSCResourceManager::releaseInputResource Leave");
 785 }
 786
 787 resource_request_t *
 788 CicoSCResourceManager::newResourceRequest(int resid,
 789                                           int reqtype,
 790                                           const CicoSCCommand &cmd)
 791 {
 792     ICO_TRA("CicoSCResourceManager::newResourceRequest Enter");
 793
 794     resource_request_t *req = NULL;
 795     req = (resource_request_t*)calloc(1, sizeof(resource_request_t));
 796     CicoSCCmdResCtrlOpt *opt = (CicoSCCmdResCtrlOpt*)cmd.opt;
 797     CicoSystemConfig *systemConfig = CicoSystemConfig::getInstance();
 798
 799     req->reqtype = reqtype;
 800
 801     CicoSCLifeCycleController *lifeCycle =
 802         CicoSCLifeCycleController::getInstance();
 803     const CicoAilItems* ailItem = lifeCycle->findAIL(cmd.appid);
 804     if (NULL != ailItem) {
 805         req->category = ailItem->m_categoryID;
 806         req->appkind = ailItem->m_kindID;
 807     }
 808
 809     req->prio = req->category;
 810
 811     req->released = 0;
 812
 813     /* set resource id */
 814     req->resid = RESID_TYPE_BASIC;
 815     if (1 == opt->type) {
 816         req->resid = RESID_TYPE_INTERRUPT;
 817     }
 818     req->resid |= resid;
 819
 820     req->resid |= RESID_CMD_RELEASE;
 821     if (MSG_CMD_ACQUIRE_RES == cmd.cmdid) {
 822         req->resid |= RESID_CMD_ACQUIRE;
 823     }
 824
 825     /* set application information */
 826     req->appid = strdup(cmd.appid.c_str());
 827     req->pid   = cmd.pid;
 828     req->state = RES_STATE_WAITING;
 829
 830     if (resid == RESID_KIND_DISPLAY) {
 831         req->dispzone   = strdup(opt->dispzone.c_str());
 832         req->dispzoneid = systemConfig->getDizplayZoneIdbyFullName(req->dispzone);
 833         req->layerid    = opt->layerid;
 834         req->winname    = strdup(opt->winname.c_str());
 835         req->surfaceid  = opt->surfaceid;
 836         req->id         = opt->surfaceid;;
 837         req->animation  = strdup(opt->animation.c_str());
 838         req->animationTime = opt->animationTime;
 839     }
 840     else if (resid == RESID_KIND_SOUND) {
 841         req->soundzone   = strdup(opt->soundzone.c_str());
 842         req->soundzoneid = systemConfig->getSoundZoneIdbyFullName(req->soundzone);
 843         ICO_DBG("req->soundzoneid=%d", req->soundzoneid);
 844         req->soundname   = strdup(opt->soundname.c_str());
 845         req->soundid     = opt->soundid;
 846         req->soundadjust = opt->adjust;
 847         req->id          = opt->soundid;
 848     }
 849     else if (resid == RESID_KIND_INPUT) {
 850         req->device = strdup(opt->device.c_str());
 851         req->input  = opt->input;
 852         req->id     = opt->input;
 853     }
 854
 855     ICO_TRA("CicoSCResourceManager::newResourceRequest Leave"
 856             "(req=0x%08x appid=%s)", req, req->appid);
 857     return req;
 858 }
 859
 860 void
 861 CicoSCResourceManager::delResourceRequest(resource_request_t *req)
 862 {
 863     if (NULL == req) return;
 864
 865     if (NULL != req->appid)     free(req->appid);
 866     if (NULL != req->dispzone)  free(req->dispzone);
 867     if (NULL != req->winname)   free(req->winname);
 868     if (NULL != req->animation) free(req->animation);
 869     if (NULL != req->soundzone) free(req->soundzone);
 870     if (NULL != req->soundname) free(req->soundname);
 871     if (NULL != req->device)    free(req->device);
 872
 873     free(req);
 874 }
 875
 876 void
 877 CicoSCResourceManager::enforceSound(unsigned short state,
 878                                     resource_request_t *req,
 879                                     void *user_data)
 880 {
 881     ICO_TRA("CicoSCResourceManager::enforceSound Enter");
 882     /* NOP */
 883     ICO_TRA("CicoSCResourceManager::enforceSound Leave");
 884 }
 885
 886 // receive changed state
 887 void
 888 CicoSCResourceManager::receiveChangedState(int state)
 889 {
 890     ICO_TRA("CicoSCResourceManager::receiveChangedState Enter"
 891             "(state=%d)", state);
 892
 893     if (STID_DRVREGULATION_ON == state) {
 894         if (true == isMatchDisplayed()) {
 895             updateDisplayResourceRegulation(state);
 896             updateSoundResourceRegulation(state);
 897             updateInputResourceRegulation(state);
 898         }
 899     }
 900     else {
 901         updateDisplayResourceRegulation(state);
 902         updateSoundResourceRegulation(state);
 903         updateInputResourceRegulation(state);
 904     }
 905
 906     ICO_TRA("CicoSCResourceManager::receiveChangedState Leave");
 907 }
 908
 909 //--------------------------------------------------------------------------
 910 /**
 911  *  @brief  get policy manager instance
 912  *
 913  *  @return resource manager instace
 914  */
 915 //--------------------------------------------------------------------------
 916 CicoSCPolicyManager *
 917 CicoSCResourceManager::getPolicyManager(void)
 918 {
 919     return m_policyMgr;
 920 }
 921
 922 void
 923 CicoSCResourceManager::updateDisplayResource(resource_request_t *req,
 924                                              int chgzoneid)
 925 {
 926     ICO_TRA("CicoSCResourceManager::updateDisplayResource Enter"
 927             "(req=0x%08x)", req);
 928
 929     std::map<unsigned int, resource_request_t*>::iterator itr;
 930     itr = m_curDispResOwerReq.find(req->dispzoneid);
 931     if ((m_curDispResOwerReq.end() != itr) && (NULL != itr->second)) {
 932         // already ower
 933         if (itr->second == req) {
 934             ICO_DBG("already ower appid=%s pid=%d surfaceid=0x%08X",
 935                     req->appid, req->pid, req->surfaceid);
 936             // show request window
 937             m_winCtrl->show(req->surfaceid, req->animation, req->animationTime);
 938             m_winCtrl->activeCB(NULL, NULL, req->surfaceid, -1);
 939             ICO_TRA("CicoSCResourceManager::updateDisplayResource Leave");
 940             return;
 941         }
 942         resource_request_t *popreq = popCurDispResOwerReq(itr->second);
 943         if (NULL != popreq) {
 944             if (NULL != m_winCtrl) {
 945                 // hide current window
 946                 m_winCtrl->hide(popreq->surfaceid, NULL, 0);
 947             }
 948
 949             // state change to waiting
 950             popreq->state = RES_STATE_WAITING;
 951             // enqueue request
 952             ICO_DBG("Enqueue waiting display resource request"
 953                     "(req=0x%08x zone=%02d:%s appid=%s",
 954                     popreq, popreq->dispzoneid,
 955                     popreq->dispzone, popreq->appid);
 956             m_waitingDispResReq.push_front(popreq);
 957 #if 1   //DEBUG
 958         dumpWaitingDispResReq();
 959 #endif  //DEBUG
 960         }
 961     }
 962
 963     std::map<unsigned int, resource_request_t*>::iterator itr2;
 964     itr2 = m_curDispResOwerReq.begin();
 965     for (; itr2 != m_curDispResOwerReq.end(); ++itr2) {
 966         resource_request_t *tmpreq = itr2->second;
 967
 968         if (true == m_policyMgr->getDispZoneState(itr2->first)) {
 969             continue;
 970         }
 971
 972         if (NULL == itr2->second) {
 973             continue;
 974         }
 975
 976         ICO_DBG("Dequeue current display resource ower request"
 977                 "(req=0x%08x zoneid=%02d:%s appid=%s)",
 978                 tmpreq, tmpreq->dispzoneid, tmpreq->dispzone, tmpreq->appid);
 979         ICO_PRF("CHG_GUI_RES display deprived zone=%02d:%s appid=%s",
 980                 tmpreq->dispzoneid, tmpreq->dispzone, tmpreq->appid);
 981         itr2->second = NULL;
 982
 983         // hide current window
 984         m_winCtrl->hide(tmpreq->surfaceid, NULL, 0);
 985
 986         ICO_DBG("Enqueue waiting display resource request"
 987                 "(req=0x%08x zone=%02d:%s appid=%s",
 988                 tmpreq, tmpreq->dispzoneid, tmpreq->dispzone, tmpreq->appid);
 989         m_waitingDispResReq.push_front(tmpreq);
 990     }
 991
 992     if (NULL != m_winCtrl) {
 993         int ret = ICO_SYC_EOK;
 994         if (-1 != chgzoneid) {
 995             // move request window
 996             ret = m_winCtrl->setGeometry(req->surfaceid, req->dispzone,
 997                                          req->layerid,
 998                                          req->animation, req->animationTime,
 999                                          req->animation, req->animationTime);
1000             if (ICO_SYC_EOK != ret) {
1001                 return;
1002             }
1003         }
1004
1005         // show request window
1006         m_winCtrl->show(req->surfaceid, req->animation, req->animationTime);
1007     }
1008     // state change to acquired
1009     req->state = RES_STATE_ACQUIRED;
1010     // update current zone request
1011     ICO_DBG("Enqueue current display resource ower request"
1012             "(req=0x%08x zoneid=%02d:%s appid=%s)",
1013             req, req->dispzoneid, req->dispzone, req->appid);
1014     ICO_PRF("CHG_GUI_RES display acquired zone=%02d:%s appid=%s",
1015             req->dispzoneid, req->dispzone, req->appid);
1016     m_curDispResOwerReq[req->dispzoneid] = req;
1017 #if 1   //DEBUG
1018     dumpCurDispResOwerReq();
1019 #endif  //DEBUG
1020
1021     // if current zone ower not exist after zone change
1022     if (-1 != chgzoneid) {
1023         list<resource_request_t*>::iterator itr;
1024         itr = m_waitingDispResReq.begin();
1025         for (; itr !=  m_waitingDispResReq.end(); ++itr) {
1026             if (m_curDispResOwerReq[(*itr)->dispzoneid] != NULL) {
1027                 continue;
1028             }
1029
1030             if (true == m_policyMgr->isExistDisplayZoneOwer((*itr)->dispzoneid)) {
1031                 continue;
1032             }
1033
1034             int type = (*itr)->resid & RESID_TYPE_MASK;
1035             bool active = false;
1036             active = m_policyMgr->acquireDisplayResource(type,
1037                                                          (*itr)->dispzoneid,
1038                                                          (*itr)->prio);
1039             if (true == active) {
1040                 resource_request_t* req = *itr;
1041                 ICO_DBG("Dequeue waiting display resource request"
1042                         "(req=0x%08x zone=%02d:%s appid=%s)",
1043                         *itr, (*itr)->dispzoneid,
1044                         (*itr)->dispzone, (*itr)->appid);
1045                 m_waitingDispResReq.erase(itr);
1046 #if 1   //DEBUG
1047                 dumpWaitingDispResReq();
1048 #endif  //DEBUG
1049                 updateDisplayResource(req);
1050 #if 0
1051                 m_winCtrl->active(req->surfaceid, -1);
1052 #endif
1053                 break;
1054             }
1055         }
1056     }
1057
1058     ICO_TRA("CicoSCResourceManager::updateDisplayResource Leave");
1059 }
1060
1061 void
1062 CicoSCResourceManager::updateSoundResource(resource_request_t *req)
1063 {
1064     ICO_TRA("CicoSCResourceManager::updateSoundResource Enter"
1065             "(req=0x%08x)", req);
1066     for (int i = 0; i < (int)m_curSoundResReq.size(); ++i) {
1067         ICO_DBG("zoneid=%d active=%d current=0x%08x",
1068                 i, m_policyMgr->getSoundZoneState(i), m_curSoundResReq[i]);
1069
1070         if (NULL == m_curSoundResReq[i]) {
1071             continue;
1072         }
1073
1074         if ((i == req->soundzoneid) ||
1075             (false == m_policyMgr->getSoundZoneState(i))) {
1076
1077             // state change to waiting
1078             m_curSoundResReq[i]->state = RES_STATE_WAITING;
1079             // enqueue request
1080             ICO_DBG("Enqueue waiting sound request queue "
1081                     "(req=0x%08x zone:%02d:%s appid=%s)",
1082                     m_curSoundResReq[i], i,
1083                     m_curSoundResReq[i]->soundzone, m_curSoundResReq[i]->appid);
1084             m_soundReqQueue[i].push_front(m_curSoundResReq[i]);
1085
1086             // initialize current zone request
1087             ICO_DBG("Dequeue current sound request queue "
1088                     "(req=0x%08x zone:%02d:%s appid=%s)",
1089                     m_curSoundResReq[i], i,
1090                     m_curSoundResReq[i]->soundzone, m_curSoundResReq[i]->appid);
1091             ICO_PRF("CHG_GUI_RES sound   deprived zone=%02d:%s appid=%s",
1092                     i, m_curSoundResReq[i]->soundzone,
1093                     m_curSoundResReq[i]->appid);
1094             m_curSoundResReq[i] = NULL;
1095         }
1096     }
1097
1098     if (req != m_curSoundResReq[req->soundzoneid]) {
1099         ico_syc_mrp_acquire_sound_resource(req);
1100         ico_syc_mrp_active_app(req->appid);
1101
1102         // state change to acquired
1103         req->state = RES_STATE_ACQUIRED;
1104         // update current zone request
1105         ICO_DBG("Enqueue current sound request queue "
1106                 "(req=0x%08x zone:%02d:%s appid=%s)",
1107                 req, req->soundzoneid, req->soundzone, req->appid);
1108         ICO_PRF("CHG_GUI_RES sound   acquired zone=%02d:%s appid=%s",
1109                 req->soundzoneid, req->soundzone, req->appid);
1110         m_curSoundResReq[req->soundzoneid] = req;
1111     }
1112     ICO_TRA("CicoSCResourceManager::updateSoundResource Leave");
1113 }
1114
1115 void
1116 CicoSCResourceManager::updateInputResource(resource_request_t *req)
1117 {
1118     ICO_TRA("CicoSCResourceManager::updateInputResource Enter"
1119             "(req=0x%08x)", req);
1120     for (int i = 0; i < (int)m_curInputResReq.size(); ++i) {
1121         ICO_DBG("input=%d active=%d current=0x%08x",
1122                 i, m_policyMgr->getInputState(i), m_curInputResReq[i]);
1123
1124         if (NULL == m_curInputResReq[i]) {
1125             continue;
1126         }
1127
1128         if ((i == req->input) ||
1129             (false == m_policyMgr->getInputState(i))) {
1130
1131             if (NULL != m_inputCtrl) {
1132                 // add input control
1133                 m_inputCtrl->delInputApp(req->appid, req->device, req->input);
1134             }
1135
1136             // state change to waiting
1137             m_curInputResReq[i]->state = RES_STATE_WAITING;
1138             // enqueue request
1139             ICO_DBG("Enqueue waiting input request queue "
1140                     "(req=0x%08x input:%d appid=%s)",
1141                     m_curInputResReq[i], i, m_curInputResReq[i]->appid);
1142             m_inputReqQueue[i].push_front(m_curInputResReq[i]);
1143             // initialize current zone request
1144             ICO_DBG("Dequeue current input request queue "
1145                     "(req=0x%08x input:%d appid=%s)",
1146                     m_curInputResReq[i],
1147                     m_curInputResReq[i]->input, m_curInputResReq[i]->appid);
1148             ICO_PRF("CHG_GUI_RES input   deprived input=%d appid=%s",
1149                     m_curInputResReq[i]->input,
1150                     m_curInputResReq[i]->appid);
1151             m_curInputResReq[i] = NULL;
1152         }
1153     }
1154
1155     if (req != m_curInputResReq[req->input]) {
1156         // delete input control
1157         m_inputCtrl->addInputApp(req->appid, req->device, req->input, 0, 0);
1158         // state change to acquired
1159         req->state = RES_STATE_ACQUIRED;
1160         // update current zone request
1161         ICO_DBG("Enqueue current input request queue "
1162                 "(req=0x%08x input:%d appid=%s)", req, req->input, req->appid);
1163         ICO_PRF("CHG_GUI_RES input   acquired input=%d appid=%s",
1164                 req->input, req->appid);
1165         m_curInputResReq[req->input] = req;
1166     }
1167     ICO_TRA("CicoSCResourceManager::updateInputResource Leave");
1168 }
1169
1170 void
1171 CicoSCResourceManager::updateDisplayResourceRegulation(int state)
1172 {
1173     ICO_TRA("CicoSCResourceManager::updateDisplayResourceRegulation Enter"
1174             "(state=%d)", state);
1175
1176     if (STID_DRVREGULATION_ON == state) {
1177         bool curchg = false;
1178         std::map<unsigned int, resource_request_t*>::iterator itr;
1179         itr = m_curDispResOwerReq.begin();
1180         for (; itr != m_curDispResOwerReq.end(); ++itr) {
1181             resource_request_t *current = itr->second;
1182             if (NULL == current) {
1183                 continue;
1184             }
1185
1186             int type = current->resid & RESID_TYPE_MASK;
1187             bool active = false;
1188             active = m_policyMgr->acquireDisplayResource(type,
1189                                                          current->dispzoneid,
1190                                                          current->prio);
1191             if (false == active) {
1192                 if (NULL != m_winCtrl) {
1193                     // hide current window
1194                     m_winCtrl->hide(current->surfaceid,
1195                                     m_animaName.c_str(), m_animaTime);
1196                 }
1197                 curchg = true;
1198             }
1199         }
1200
1201         if (false == curchg) {
1202             ICO_TRA("CicoSCResourceManager::updateDisplayResourceRegulation "
1203                     "Leave");
1204             return;
1205         }
1206
1207         list<resource_request_t*>::iterator itr2;
1208         itr2 = m_waitingDispResReq.begin();
1209         for (; itr2 !=  m_waitingDispResReq.end(); ++itr2) {
1210             int type = (*itr2)->resid & RESID_TYPE_MASK;
1211             bool active = false;
1212             active = m_policyMgr->acquireDisplayResource(type,
1213                                                          (*itr2)->dispzoneid,
1214                                                          (*itr2)->prio);
1215             if (true == active) {
1216                 if (NULL != m_winCtrl) {
1217                     // show current window
1218                     m_winCtrl->show((*itr2)->surfaceid,
1219                                     m_animaName.c_str(), m_animaTime);
1220                 }
1221                 break;
1222             }
1223         }
1224     }
1225     else if (STID_DRVREGULATION_OFF == state) {
1226         std::map<unsigned int, resource_request_t*>::iterator itr;
1227         itr = m_curDispResOwerReq.begin();
1228         for (; itr != m_curDispResOwerReq.end(); ++itr) {
1229             resource_request_t *current = itr->second;
1230             if (NULL == current) {
1231                 if (true == m_policyMgr->isExistDisplayZoneOwer(itr->first)) {
1232                     if (NULL != m_winCtrl) {
1233                         int surfaceid = m_winCtrl->getDisplayedWindow(itr->first);
1234
1235 #if 0
1236                         if ((surfaceid > 0) && (NULL != itr->second) &&
1237                             (itr->second->surfaceid != surfaceid)) {
1238                             m_winCtrl->hide(surfaceid,
1239                                             m_animaName.c_str(),
1240                                             m_animaTime);
1241                         }
1242 #else
1243                         if (surfaceid > 0) {
1244                             m_winCtrl->hide(surfaceid,
1245                                             m_animaName.c_str(),
1246                                             m_animaTime);
1247                         }
1248
1249 #endif
1250                     }
1251                     continue;
1252                 }
1253                 list<resource_request_t*>::iterator itr2;
1254                 itr2 = m_waitingDispResReq.begin();
1255                 for (; itr2 != m_waitingDispResReq.end(); ++itr2) {
1256                     resource_request_t *req = *itr2;
1257                     if (itr->first != (unsigned int)req->dispzoneid) {
1258                         continue;
1259                     }
1260                     int type = req->resid & RESID_TYPE_MASK;
1261                     bool active = false;
1262                     active = m_policyMgr->acquireDisplayResource(type,
1263                                                                  req->dispzoneid,
1264                                                                  req->prio);
1265                     if (true == active) {
1266                         ICO_DBG("Dequeue waiting display resource request"
1267                                 "(req=0x%08x zone=%02d:%s appid=%s)",
1268                                 req, req->dispzoneid,
1269                                 req->dispzone, req->appid);
1270                         m_waitingDispResReq.erase(itr2);
1271                         ICO_DBG("Enqueue current display resource request"
1272                                 "(req=0x%08x zone=%02d:%s appid=%s)",
1273                                 req, req->dispzoneid,
1274                                 req->dispzone, req->appid);
1275                         ICO_PRF("CHG_GUI_RES display acquired zone=%02d:%s "
1276                                 "appid=%s",
1277                                 req->dispzoneid, req->dispzone, req->appid);
1278                         m_curDispResOwerReq[req->dispzoneid] = req;
1279 #if 1   //DEBUG
1280                         dumpCurDispResOwerReq();
1281                         dumpWaitingDispResReq();
1282 #endif  //DEBUG
1283                         m_winCtrl->show(req->surfaceid,
1284                                         m_animaName.c_str(), m_animaTime);
1285                         m_winCtrl->active(req->surfaceid, -1);
1286                         break;
1287                     }
1288                 }
1289             }
1290             else {
1291                 int type = current->resid & RESID_TYPE_MASK;
1292                 bool active = false;
1293                 active = m_policyMgr->acquireDisplayResource(type,
1294                                                              current->dispzoneid,
1295                                                              current->prio);
1296                 if (true == active) {
1297                     if (NULL != m_winCtrl) {
1298                         int surfaceid = m_winCtrl->getDisplayedWindow(
1299                                                     itr->second->dispzoneid);
1300                         if ((itr->second->surfaceid != surfaceid) &&
1301                             (surfaceid > 0)) {
1302                             m_winCtrl->hide(surfaceid,
1303                                             m_animaName.c_str(), m_animaTime);
1304                         }
1305
1306                         // show current window
1307                         m_winCtrl->show(current->surfaceid,
1308                                         m_animaName.c_str(), m_animaTime);
1309                     }
1310                 }
1311 #if 1   //DEBUG
1312                         dumpCurDispResOwerReq();
1313                         dumpWaitingDispResReq();
1314 #endif  //DEBUG
1315             }
1316         }
1317     }
1318
1319     ICO_TRA("CicoSCResourceManager::updateDisplayResourceRegulation Leave");
1320 }
1321
1322 void
1323 CicoSCResourceManager::updateSoundResourceRegulation(int state)
1324 {
1325     ICO_TRA("CicoSCResourceManager::updateSoundResourceRegulation Enter"
1326             "(state=%d)", state);
1327
1328     bool curchg = false;
1329     for (int i = 0; i < (int)m_curSoundResReq.size(); ++i) {
1330         resource_request_t *current = m_curSoundResReq[i];
1331         if (NULL == current) {
1332             continue;
1333         }
1334
1335         int type = current->resid & RESID_TYPE_MASK;
1336         bool active = false;
1337         active = m_policyMgr->acquireSoundResource(type,
1338                                                    current->soundzoneid,
1339                                                    current->prio);
1340         if (false == active) {
1341             // state change to waiting
1342             current->state = RES_STATE_WAITING;
1343             // enqueue request
1344             ICO_DBG("Enqueue waiting sound request queue "
1345                     "(req=0x%08x zone:%02d:%s appid=%s)",
1346                     current,  i, current->soundzone, current->appid);
1347             m_soundReqQueue[i].push_front(current);
1348             // initialize current zone request
1349             m_curSoundResReq[i] = NULL;
1350             curchg = true;
1351          }
1352     }
1353
1354     if ((false == curchg) && (STID_DRVREGULATION_ON == state)) {
1355         ICO_TRA("CicoSCResourceManager::updateSoundResourceRegulation Leave");
1356         return;
1357     }
1358
1359     map<int, list<resource_request_t*> >::iterator itr;
1360     itr = m_soundReqQueue.begin();
1361     for (; itr != m_soundReqQueue.end(); ++itr) {
1362         if (NULL != m_curSoundResReq[itr->first]) {
1363             continue;
1364         }
1365
1366         list<resource_request_t*>::iterator itr2;
1367         itr2 = itr->second.begin();
1368         for (; itr2 !=  itr->second.end(); ++itr2) {
1369             int type = (*itr2)->resid & RESID_TYPE_MASK;
1370             bool active = false;
1371             active = m_policyMgr->acquireSoundResource(type,
1372                                                        (*itr2)->soundzoneid,
1373                                                        (*itr2)->prio);
1374             if (true == active) {
1375                 resource_request_t* req = *itr2;
1376                 ICO_DBG("Dequeue waiting sound request queue "
1377                         "(req=0x%08x zone:%02d:%s appid=%s)",
1378                         *itr2, itr->first, (*itr2)->soundzone, (*itr2)->appid);
1379                 itr->second.erase(itr2);
1380                 updateSoundResource(req);
1381                 break;
1382             }
1383         }
1384     }
1385
1386     ICO_TRA("CicoSCResourceManager::updateSoundResourceRegulation Leave");
1387 }
1388
1389 void
1390 CicoSCResourceManager::updateInputResourceRegulation(int state)
1391 {
1392     ICO_TRA("CicoSCResourceManager::updateInputResourceRegulation Enter"
1393             "(state=%d)", state);
1394
1395     bool curchg = false;
1396     for (int i = 0; i < (int)m_curInputResReq.size(); ++i) {
1397         resource_request_t *current = m_curInputResReq[i];
1398         if (NULL == current) {
1399             continue;
1400         }
1401
1402         bool active = false;
1403         active = m_policyMgr->acquireInputResource(current->input,
1404                                                    current->prio);
1405         if (false == active) {
1406             if (NULL != m_inputCtrl) {
1407                 // hide current window
1408                 m_inputCtrl->delInputApp(current->appid,
1409                                          current->device,
1410                                          current->input);
1411             }
1412             // state change to waiting
1413             current->state = RES_STATE_WAITING;
1414             // enqueue request
1415             ICO_DBG("Enqueue waiting input request queue "
1416                     "(req=0x%08x input:%d appid=%s)",
1417                     current, i, current->appid);
1418             m_inputReqQueue[i].push_front(current);
1419             // initialize current zone request
1420             m_curInputResReq[i] = NULL;
1421             curchg = true;
1422          }
1423     }
1424
1425     if ((false == curchg) && (STID_DRVREGULATION_ON == state)) {
1426         ICO_TRA("CicoSCResourceManager::updateInputResourceRegulation Leave");
1427         return;
1428     }
1429
1430     map<int, list<resource_request_t*> >::iterator itr;
1431     itr = m_inputReqQueue.begin();
1432     for (; itr != m_inputReqQueue.end(); ++itr) {
1433         if (NULL != m_curInputResReq[itr->first]) {
1434             continue;
1435         }
1436
1437         list<resource_request_t*>::iterator itr2;
1438         itr2 = itr->second.begin();
1439         for (; itr2 !=  itr->second.end(); ++itr2) {
1440             bool active = false;
1441             active = m_policyMgr->acquireInputResource((*itr2)->input,
1442                                                        (*itr2)->prio);
1443             if (true == active) {
1444                 resource_request_t* req = *itr2;
1445                 ICO_DBG("Dequeue waiting input request queue "
1446                         "(req=0x%08x input:%d appid=%s)",
1447                         *itr2, (*itr2)->input, (*itr2)->appid);
1448                 itr->second.erase(itr2);
1449                 updateInputResource(req);
1450                 break;
1451             }
1452         }
1453     }
1454
1455     ICO_TRA("CicoSCResourceManager::updateInputResourceRegulation Leave");
1456 }
1457
1458 //--------------------------------------------------------------------------
1459 /**
1460  *  @brief   find currnet dipalay resource ower request
1461  *
1462  *  @param [in] request  compare requset
1463  *
1464  *  @return request object on same requeset found, NULL on not found
1465  */
1466 //--------------------------------------------------------------------------
1467 resource_request_t *
1468 CicoSCResourceManager::findCurDispResOwerReq(resource_request_t *req)
1469 {
1470     if (NULL == req) {
1471         ICO_WRN("invalid argument. req is null");
1472         return NULL;
1473     }
1474     std::map<unsigned int, resource_request_t*>::iterator itr;
1475     itr = m_curDispResOwerReq.begin();
1476     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1477         CompDisplayResourceRequest comp(req);
1478         if (true == comp(itr->second)) {
1479             return itr->second;
1480         }
1481     }
1482     return NULL;
1483 }
1484
1485 //--------------------------------------------------------------------------
1486 /**
1487  *  @brief  pop currnet dipalay resource ower request from list
1488  *
1489  *  @param [in] request  compare requset
1490  *
1491  *  @return request object on same requeset found, NULL on not found
1492  */
1493 //--------------------------------------------------------------------------
1494 resource_request_t *
1495 CicoSCResourceManager::popCurDispResOwerReq(resource_request_t *req)
1496 {
1497     if (NULL == req) {
1498         ICO_WRN("invalid argument. req is null");
1499         return NULL;
1500     }
1501     std::map<unsigned int, resource_request_t*>::iterator itr;
1502     itr = m_curDispResOwerReq.begin();
1503     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1504         CompDisplayResourceRequest comp(req);
1505         if (true == comp(itr->second)) {
1506             ICO_DBG("Dequeue current display resource ower request"
1507                     "(req=0x%08x zoneid=%02d:%s appid=%s)",
1508                     itr->second, itr->first,
1509                     itr->second->dispzone, itr->second->appid);
1510             ICO_PRF("CHG_GUI_RES display deprived zone=%02d:%s appid=%s",
1511                     itr->first, itr->second->dispzone, itr->second->appid);
1512             resource_request_t *findreq = itr->second;
1513             itr->second = NULL;
1514 #if 1   //DEBUG
1515             dumpCurDispResOwerReq();
1516 #endif  //DEBUG
1517             return findreq;
1518         }
1519     }
1520     return NULL;
1521 }
1522
1523 //--------------------------------------------------------------------------
1524 /**
1525  *  @brief   dump currnet dipalay resource ower request
1526  */
1527 //--------------------------------------------------------------------------
1528 void
1529 CicoSCResourceManager::dumpCurDispResOwerReq(void)
1530 {
1531     std::map<unsigned int, resource_request_t*>::iterator itr;
1532     itr = m_curDispResOwerReq.begin();
1533     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1534         if (NULL == itr->second) {
1535             ICO_DBG("current req=0x%08x zone=%02d:(null) appid=(null)",
1536                     itr->second, itr->first);
1537         }
1538         else {
1539             ICO_DBG("current req=0x%08x zone=%02d:%s appid=%s",
1540                     itr->second, itr->first, itr->second->dispzone,
1541                     itr->second->appid);
1542         }
1543     }
1544 }
1545
1546 //--------------------------------------------------------------------------
1547 /**
1548  *  @brief  find waiting dipalay resource request
1549  *
1550  *  @param [in] request  compare requset
1551  *
1552  *  @return request object on same requeset found, NULL on not found
1553  */
1554 //--------------------------------------------------------------------------
1555 resource_request_t *
1556 CicoSCResourceManager::findWaitingDispResReq(resource_request_t *req)
1557 {
1558     if (NULL == req) {
1559         ICO_WRN("invalid argument. req is null");
1560         return NULL;
1561     }
1562     CompDisplayResourceRequest comp(req);
1563     std::list<resource_request_t*>::iterator itr;
1564     itr = find_if(m_waitingDispResReq.begin(), m_waitingDispResReq.end(), comp);
1565     if (m_waitingDispResReq.end() != itr) {
1566         return *itr;
1567     }
1568     return NULL;
1569 }
1570
1571 //--------------------------------------------------------------------------
1572 /**
1573  *  @brief  pop waiting dipalay resource request from waiting list
1574  *
1575  *  @param [in] request  compare requset
1576  *
1577  *  @return request object on same requeset found, NULL on not found
1578  */
1579 //--------------------------------------------------------------------------
1580 resource_request_t *
1581 CicoSCResourceManager::popWaitingDispResReq(resource_request_t *req)
1582 {
1583     if (NULL == req) {
1584         ICO_WRN("invalid argument. req is null");
1585         return NULL;
1586     }
1587     CompDisplayResourceRequest comp(req);
1588     std::list<resource_request_t*>::iterator itr;
1589     itr = find_if(m_waitingDispResReq.begin(), m_waitingDispResReq.end(), comp);
1590     if (m_waitingDispResReq.end() != itr) {
1591         ICO_DBG("Dequeue waiting display resource request"
1592                 "(req=0x%08x zone:%02d:%s appid=%s)",
1593                 *itr, (*itr)->dispzoneid, (*itr)->dispzone, (*itr)->appid);
1594         resource_request_t *findreq = *itr;
1595         m_waitingDispResReq.erase(itr);
1596 #if 1   //DEBUG
1597         dumpWaitingDispResReq();
1598 #endif  //DEBUG
1599         return findreq;
1600     }
1601     return NULL;
1602 }
1603
1604 //--------------------------------------------------------------------------
1605 /**
1606  *  @brief  dump waiting dipalay resource request
1607  */
1608 //--------------------------------------------------------------------------
1609 void
1610 CicoSCResourceManager::dumpWaitingDispResReq(void)
1611 {
1612     std::list<resource_request_t*>::iterator itr;
1613     itr = m_waitingDispResReq.begin();
1614     for (; itr != m_waitingDispResReq.end(); ++itr) {
1615         if (NULL == *itr) {
1616             ICO_DBG("waiting req=null");
1617         }
1618         else {
1619             ICO_DBG("waiting req=0x%08x zone=%02d:%s appid=%s",
1620                     *itr, (*itr)->dispzoneid, (*itr)->dispzone, (*itr)->appid);
1621         }
1622     }
1623 }
1624
1625 //--------------------------------------------------------------------------
1626 /**
1627  *  @brief  update display request for regulation pre-process
1628  */
1629 //--------------------------------------------------------------------------
1630 void
1631 CicoSCResourceManager::updateDispResRegulationPreProc(resource_request_t *req)
1632 {
1633     ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Enter");
1634 #if 1   //DEBUG
1635     dumpCurDispResOwerReq();
1636     dumpWaitingDispResReq();
1637 #endif  //DEBUG
1638
1639     if (NULL == req) {
1640         ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
1641         return;
1642     }
1643
1644     if (false == m_policyMgr->getRegulation()) {
1645         ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
1646         return;
1647     }
1648
1649     CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
1650     const CicoSCAppKindConf *appKindConf = NULL;
1651     appKindConf = sysConf->findAppKindConfbyId(req->appkind);
1652     if (NULL == appKindConf) {
1653         ICO_ERR("not found CicoSCAppKindConf instance");
1654         ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
1655         return;
1656     }
1657
1658     if ((appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_ALMIGHTY) ||
1659         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM)   ||
1660         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM_VISIBLE)) {
1661
1662         if (NULL != m_winCtrl) {
1663             m_winCtrl->show(req->surfaceid,
1664                             req->animation,
1665                             req->animationTime);
1666         }
1667         delResourceRequest(req);
1668
1669         ICO_DBG("kind of system application");
1670         ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
1671         return;
1672     }
1673
1674     int surfaceid = req->surfaceid;
1675     if (NULL != m_winCtrl) {
1676         surfaceid = m_winCtrl->getDisplayedWindow(req->dispzoneid);
1677         if (-1 == surfaceid) {
1678             ICO_WRN("displayed surface id is invalid.");
1679             surfaceid = req->surfaceid;
1680         }
1681     }
1682
1683     if (req->surfaceid != surfaceid) {
1684         ICO_WRN("req->surfaceid(0x%08X) != displayedsurfaceid(0x%08X)",
1685                 req->surfaceid, surfaceid);
1686     }
1687
1688     resource_request_t *curreq = NULL;
1689     int min = ICO_DISPLAY0_ZONEID_MIN;
1690     int max = ICO_DISPLAY0_ZONEID_MAX;
1691     if ((req->dispzoneid >= min) && (req->dispzoneid <= max)) {
1692         for (int i = min; i <= max; ++i) {
1693             std::map<unsigned int, resource_request_t*>::iterator itr;
1694             itr = m_curDispResOwerReq.find(i);
1695             if (itr != m_curDispResOwerReq.end()) {
1696                 if (NULL != itr->second) {
1697                     curreq = itr->second;
1698                     break;
1699                 }
1700             }
1701         }
1702     }
1703
1704     min = ICO_DISPLAY1_ZONEID_MIN;
1705     max = ICO_DISPLAY1_ZONEID_MAX;
1706     if ((NULL == curreq) &&
1707         (req->dispzoneid >= min) && (req->dispzoneid <= max)) {
1708         for (int i = min; i <= max; ++i) {
1709             std::map<unsigned int, resource_request_t*>::iterator itr;
1710             itr = m_curDispResOwerReq.find(i);
1711             if (itr != m_curDispResOwerReq.end()) {
1712                 if (NULL != itr->second) {
1713                     curreq = itr->second;
1714                     break;
1715                 }
1716             }
1717         }
1718     }
1719
1720 #if 0
1721     resource_request_t *curreq = NULL;
1722     std::map<unsigned int, resource_request_t*>::iterator itr;
1723     itr = m_curDispResOwerReq.find(req->dispzoneid);
1724     if (itr != m_curDispResOwerReq.end()) {
1725         curreq = itr->second;
1726     }
1727 #endif
1728
1729     if (NULL != curreq) {
1730         ICO_DBG("Dequeue current display resource request"
1731                 "(req=0x%08x zone:%02d:%s appid=%s)",
1732                 curreq, curreq->dispzoneid, curreq->dispzone, curreq->appid);
1733         ICO_PRF("CHG_GUI_RES display deprived zone=%02d:%s appid=%s",
1734                 curreq->dispzoneid, curreq->dispzone, curreq->appid);
1735         m_curDispResOwerReq[curreq->dispzoneid] = NULL;
1736
1737         if (curreq->surfaceid != req->surfaceid) {
1738             resource_request_t *waitreq = popWaitingDispResReq(req);
1739             ICO_DBG("Enqueue waiting display resource request"
1740                     "(req=0x%08x zone:%02d:%s appid=%s)",
1741                     curreq, curreq->dispzoneid,
1742                     curreq->dispzone, curreq->appid);
1743             m_waitingDispResReq.push_front(curreq);
1744
1745             if (NULL != waitreq) {
1746                 ICO_DBG("Enqueue current display resource request"
1747                         "(req=0x%08x zone:%02d:%s appid=%s)",
1748                         waitreq, waitreq->dispzoneid,
1749                         waitreq->dispzone, waitreq->appid);
1750                 ICO_PRF("CHG_GUI_RES display acquired zone=%02d:%s appid=%s",
1751                         waitreq->dispzoneid, waitreq->dispzone, waitreq->appid);
1752                 m_curDispResOwerReq[waitreq->dispzoneid] = waitreq;
1753             }
1754         }
1755         else {
1756             ICO_DBG("Enqueue current display resource request"
1757                     "(req=0x%08x zone:%02d:%s appid=%s)",
1758                     curreq, curreq->dispzoneid,
1759                     curreq->dispzone, curreq->appid);
1760             ICO_PRF("CHG_GUI_RES display acquired zone=%02d:%s appid=%s",
1761                     curreq->dispzoneid, curreq->dispzone, curreq->appid);
1762             m_curDispResOwerReq[curreq->dispzoneid] = curreq;
1763         }
1764     }
1765     delResourceRequest(req);
1766
1767 #if 1   //DEBUG
1768     dumpCurDispResOwerReq();
1769     dumpWaitingDispResReq();
1770 #endif  //DEBUG
1771     ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
1772 }
1773
1774 //--------------------------------------------------------------------------
1775 /**
1776  *  @brief  update sound request for regulation pre-process
1777  */
1778 //--------------------------------------------------------------------------
1779 void
1780 CicoSCResourceManager::updateSoundResRegulationPreProc(resource_request_t *req)
1781 {
1782     ICO_TRA("CicoSCResourceManager::updateSoundResRegulationPreProc Enter");
1783
1784     if (NULL == req) {
1785         return;
1786     }
1787
1788     if (false == m_policyMgr->getRegulation()) {
1789         return;
1790     }
1791
1792     CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
1793     const CicoSCAppKindConf *appKindConf = NULL;
1794     appKindConf = sysConf->findAppKindConfbyId(req->appkind);
1795     if (NULL == appKindConf) {
1796         ICO_ERR("not found CicoSCAppKindConf instance");
1797         ICO_TRA("CicoSCResourceManager::updateSoundResRegulationPreProc Leave");
1798         return;
1799     }
1800
1801     if ((appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_ALMIGHTY) ||
1802         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM)   ||
1803         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM_AUDIO)) {
1804
1805         delResourceRequest(req);
1806
1807         ICO_DBG("kind of system application");
1808         ICO_TRA("CicoSCResourceManager::updateSoundResRegulationPreProc Leave");
1809         return;
1810     }
1811
1812     resource_request_t *curreq = NULL;
1813     std::map<int, resource_request_t*>::iterator itr;
1814     itr = m_curSoundResReq.find(req->soundzoneid);
1815     if (itr != m_curSoundResReq.end()) {
1816         curreq = itr->second;
1817     }
1818
1819     if (NULL != curreq) {
1820         ICO_DBG("Dequeue current sound resource request"
1821                 "(req=0x%08x zone:%02d:%s appid=%s)",
1822                 curreq, curreq->soundzoneid, curreq->soundzone, curreq->appid);
1823         ICO_PRF("CHG_GUI_RES sound   deprived zone=%02d:%s appid=%s",
1824                 curreq->soundzoneid, curreq->soundzone, curreq->appid);
1825         m_curSoundResReq[curreq->soundzoneid] = NULL;
1826
1827         if (0 != strcmp(curreq->appid, req->appid)) {
1828             resource_request_t *waitreq = popSoundResReq(req);
1829             ICO_DBG("Enqueue waiting sound resource request"
1830                     "(req=0x%08x zone:%02d:%s appid=%s)",
1831                     curreq, curreq->soundzoneid,
1832                     curreq->soundzone, curreq->appid);
1833             m_soundReqQueue[curreq->soundzoneid].push_front(curreq);
1834
1835             if (NULL != waitreq) {
1836                 ICO_DBG("Enqueue current sound resource request"
1837                         "(req=0x%08x zone:%02d:%s appid=%s)",
1838                         waitreq, waitreq->soundzoneid,
1839                         waitreq->soundzone, waitreq->appid);
1840                 ICO_PRF("CHG_GUI_RES sound   acquired zone=%02d:%s appid=%s",
1841                         waitreq->soundzoneid, waitreq->soundzoneid,
1842                         waitreq->appid);
1843                 m_curSoundResReq[curreq->soundzoneid] = waitreq;
1844             }
1845         }
1846         else {
1847             ICO_DBG("Enqueue current sound resource request"
1848                     "(req=0x%08x zone:%02d:%s appid=%s)",
1849                     curreq, curreq->soundzoneid,
1850                     curreq->soundzone, curreq->appid);
1851             ICO_PRF("CHG_GUI_RES sound   acquired zone=%d:%s appid=%s",
1852                     curreq->soundzoneid, curreq->soundzone, curreq->appid);
1853             m_curSoundResReq[curreq->soundzoneid] = curreq;
1854         }
1855     }
1856     delResourceRequest(req);
1857     ICO_TRA("CicoSCResourceManager::updateSoundResRegulationPreProc Leave");
1858 }
1859
1860 //--------------------------------------------------------------------------
1861 /**
1862  *  @brief  update input request for regulation pre-process
1863  */
1864 //--------------------------------------------------------------------------
1865 void
1866 CicoSCResourceManager::updateInputResRegulationPreProc(resource_request_t *req)
1867 {
1868     ICO_TRA("CicoSCResourceManager::updateInputResRegulationPreProc Enter");
1869
1870     if (NULL == req) {
1871         return;
1872     }
1873
1874     if (false == m_policyMgr->getRegulation()) {
1875         return;
1876     }
1877
1878     resource_request_t *curreq = NULL;
1879     std::map<int, resource_request_t*>::iterator itr;
1880     itr = m_curInputResReq.find(req->input);
1881     if (itr != m_curInputResReq.end()) {
1882         curreq = itr->second;
1883     }
1884
1885     if (NULL != curreq) {
1886         ICO_DBG("Dequeue current input resource request"
1887                 "(req=0x%08x input:%d appid=%s)",
1888                 curreq, curreq->input, curreq->appid);
1889         ICO_PRF("CHG_GUI_RES input   deprived input=%d appid=%s",
1890                 curreq->input, curreq->appid);
1891         m_curInputResReq[curreq->input] = NULL;
1892
1893         if (0 != strcmp(curreq->appid, req->appid)) {
1894             resource_request_t *waitreq = popInputResReq(req);
1895             ICO_DBG("Enqueue waiting input resource request"
1896                     "(req=0x%08x input:%d appid=%s)",
1897                     curreq, curreq->input, curreq->appid);
1898             m_inputReqQueue[curreq->input].push_front(curreq);
1899
1900             if (NULL != waitreq) {
1901                 ICO_DBG("Enqueue current input resource request"
1902                         "(req=0x%08x input:%d appid=%s)",
1903                         waitreq, waitreq->input, waitreq->appid);
1904                 ICO_PRF("CHG_GUI_RES input   acquired input=%d appid=%s",
1905                         waitreq->input, waitreq->appid);
1906                 m_curInputResReq[curreq->input] = waitreq;
1907             }
1908         }
1909         else {
1910             ICO_DBG("Enqueue current input resource request"
1911                     "(req=0x%08x input:%d appid=%s)",
1912                     curreq, curreq->input, curreq->appid);
1913             ICO_PRF("CHG_GUI_RES input   acquired input=%d appid=%s",
1914                     curreq->input, curreq->appid);
1915             m_curInputResReq[curreq->input] = curreq;
1916         }
1917     }
1918     delResourceRequest(req);
1919     ICO_TRA("CicoSCResourceManager::updateInputResRegulationPreProc Leave");
1920 }
1921
1922 //--------------------------------------------------------------------------
1923 /**
1924  *  @brief  compare displayed surface and ower surface
1925  */
1926 //--------------------------------------------------------------------------
1927 bool
1928 CicoSCResourceManager::isMatchDisplayed(void)
1929 {
1930     bool ret = false;
1931     std::map<unsigned int, resource_request_t*>::iterator itr;
1932     itr = m_curDispResOwerReq.begin();
1933     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1934         if (NULL == itr->second) {
1935             continue;
1936         }
1937         if (NULL != m_winCtrl) {
1938             int surfaceid = m_winCtrl->getDisplayedWindow(
1939                                         itr->second->dispzoneid);
1940             std::map<unsigned int, resource_request_t*>::iterator itr2;
1941             itr2 = m_curDispResOwerReq.begin();
1942             for (; itr2 != m_curDispResOwerReq.end(); ++itr2) {
1943                 if (NULL == itr2->second) {
1944                     continue;
1945                 }
1946                 if ((itr2->second->surfaceid == surfaceid)) {
1947                     ret = true;
1948                     break;
1949                 }
1950             }
1951         }
1952     }
1953     return ret;
1954 }
1955 // vim:set expandtab ts=4 sw=4: