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 "CicoSCSystemConfig.h"
  28 #include "CicoSCConf.h"
  29 #include "CicoSCCommand.h"
  30 #include "CicoSCPolicyManager.h"
  31 #include "CicoSCLifeCycleController.h"
  32 #include "CicoSCAilItems.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_winCtrl(NULL), m_inputCtrl(NULL)
 111 {
 112     m_policyMgr = new CicoSCPolicyManager(this);
 113
 114     CicoSCSystemConfig *sysConf = CicoSCSystemConfig::getInstance();
 115     list<resource_request_t*> l;
 116
 117     {
 118         // initialize display current request and waiting queue
 119         const vector<CicoSCDisplayConf*>& dispConfList
 120             = sysConf->getDisplayConfList();
 121         vector<CicoSCDisplayConf*>::const_iterator itr;
 122         itr = dispConfList.begin();
 123         for (; itr != dispConfList.end(); ++itr) {
 124             vector<CicoSCDisplayZoneConf*>::iterator itr2;
 125             itr2 = (*itr)->zoneConfList.begin();
 126             for (; itr2 != (*itr)->zoneConfList.end(); ++itr2) {
 127                 m_curDispResOwerReq[(*itr2)->id] = NULL;
 128             }
 129         }
 130     }
 131
 132     {
 133         // initialize sound current request and waiting queue
 134         const vector<CicoSCSoundConf*>& soundConfList
 135             = sysConf->getSoundConfList();
 136         vector<CicoSCSoundConf*>::const_iterator itr;
 137         itr = soundConfList.begin();
 138         for (; itr != soundConfList.end(); ++itr) {
 139             vector<CicoSCSoundZoneConf*>::iterator itr2;
 140             itr2 = (*itr)->zoneConfList.begin();
 141             for (; itr2 != (*itr)->zoneConfList.end(); ++itr2) {
 142                 m_curSoundResReq[(*itr2)->id] = NULL;
 143                 m_soundReqQueue[(*itr2)->id]  = l;
 144             }
 145         }
 146     }
 147
 148    {
 149         // initialize input current request and waiting queue
 150         const vector<CicoSCInputDevConf*>& inputDevConfList
 151             = sysConf->getInputDevConfList();
 152         vector<CicoSCInputDevConf*>::const_iterator itr;
 153         itr = inputDevConfList.begin();
 154         for (; itr != inputDevConfList.end(); ++itr) {
 155             vector<CicoSCSwitchConf*>::iterator itr2;
 156             itr2 = (*itr)->switchConfList.begin();
 157             for (; itr2 != (*itr)->switchConfList.end(); ++itr2) {
 158                 m_curInputResReq[(*itr2)->id] = NULL;
 159                 m_inputReqQueue[(*itr2)->id]  = l;
 160             }
 161         }
 162     }
 163 }
 164
 165 CicoSCResourceManager::~CicoSCResourceManager()
 166 {
 167     delete m_policyMgr;
 168 }
 169
 170 int
 171 CicoSCResourceManager::initialize(void)
 172 {
 173     ICO_DBG("CicoSCResourceManager::initialize Enter");
 174
 175     int ret = ICO_SYC_EOK;
 176
 177     ret = ico_syc_mrp_init(enforceSound, this);
 178     if (ICO_SYC_EOK != ret) {
 179         return ret;
 180     }
 181
 182     ret = m_policyMgr->initialize();
 183     if (ICO_SYC_EOK != ret) {
 184         return ret;
 185     }
 186
 187
 188     ICO_DBG("CicoSCResourceManager::initialize Leave");
 189     return ret;
 190 }
 191
 192 void
 193 CicoSCResourceManager::terminate(void)
 194 {
 195     ICO_DBG("CicoSCResourceManager::terminate Enter");
 196     m_policyMgr->terminate();
 197     ICO_DBG("CicoSCResourceManager::terminate Leave");
 198 }
 199
 200 void
 201 CicoSCResourceManager::handleCommand(const CicoSCCommand &cmd,
 202                                      bool internal)
 203 {
 204     ICO_DBG("CicoSCResourceManager::handleCommand Enter"
 205             "(cmdid=0x%08X internal=%s)",
 206             cmd.cmdid, internal ? "true" : "false");
 207
 208     CicoSCCmdResCtrlOpt *opt = (CicoSCCmdResCtrlOpt*)cmd.opt;
 209
 210     // request command from application or internal
 211     int reqtype = internal ? REQTYPE_AUTO : REQTYPE_APP;
 212
 213     if ((MSG_CMD_CREATE_RES == cmd.cmdid) ||
 214         (MSG_CMD_ACQUIRE_RES == cmd.cmdid)) {
 215
 216         if (true == opt->dispres) {
 217             resource_request_t *req = newResourceRequest(RESID_KIND_DISPLAY,
 218                                                          reqtype,
 219                                                          cmd);
 220             if (MSG_CMD_CREATE_RES == cmd.cmdid) {
 221                 acquireDisplayResource(req, false);
 222             }
 223             else {
 224                 acquireDisplayResource(req);
 225             }
 226
 227         }
 228         if (true == opt->soundres) {
 229             resource_request_t *req = newResourceRequest(RESID_KIND_SOUND,
 230                                                          reqtype,
 231                                                          cmd);
 232             acquireSoundResource(req);
 233         }
 234         if (true == opt->inputres) {
 235             resource_request_t *req = newResourceRequest(RESID_KIND_INPUT,
 236                                                          reqtype,
 237                                                          cmd);
 238             acquireInputResource(req);
 239         }
 240     }
 241     else if ((MSG_CMD_RELEASE_RES == cmd.cmdid) ||
 242              (MSG_CMD_DESTORY_RES == cmd.cmdid)) {
 243
 244         if (true == opt->dispres) {
 245             resource_request_t *req = newResourceRequest(RESID_KIND_DISPLAY,
 246                                                          reqtype,
 247                                                          cmd);
 248             releaseDisplayResource(req);
 249         }
 250         if (true == opt->soundres) {
 251             resource_request_t *req = newResourceRequest(RESID_KIND_SOUND,
 252                                                          reqtype,
 253                                                          cmd);
 254             releaseSoundResource(req);
 255         }
 256         if (true == opt->inputres) {
 257             resource_request_t *req = newResourceRequest(RESID_KIND_INPUT,
 258                                                          reqtype,
 259                                                          cmd);
 260             releaseInputResource(req);
 261         }
 262     }
 263     else {
 264         ICO_WRN("Unknown command");
 265     }
 266
 267     ICO_DBG("CicoSCResourceManager::handleCommand Leave");
 268 }
 269
 270 void
 271 CicoSCResourceManager::setWindowController(CicoSCWindowController *winCtrl)
 272 {
 273     m_winCtrl = winCtrl;
 274 }
 275
 276 void
 277 CicoSCResourceManager::setInputController(CicoSCInputController *inputCtrl)
 278 {
 279     m_inputCtrl = inputCtrl;
 280 }
 281
 282 #if 0
 283 resource_request_t *
 284 CicoSCResourceManager::popDispResReq(resource_request_t *req)
 285 {
 286     ICO_DBG("CicoSCResourceManager::popDispResReq Enter");
 287
 288     map<int, list<resource_request_t*> >::iterator itr;
 289     itr = m_dispReqQueue.begin();
 290     CompDisplayResourceRequest comp(req);
 291     for (; itr != m_dispReqQueue.end(); ++itr) {
 292         list<resource_request_t*>::iterator itr2;
 293         itr2 = find_if(itr->second.begin(), itr->second.end(), comp);
 294         if (itr->second.end() != itr2) {
 295             ICO_DBG("Dequeue waiting display request queue zone=%d req=0x%08x",
 296                     itr->first, *itr2);
 297             m_dispReqQueue[req->dispzoneid].erase(itr2);
 298             ICO_DBG("CicoSCResourceManager::popDispResReq Leave"
 299                     "(0x%08x)", *itr2);
 300             return *itr2;
 301         }
 302     }
 303
 304     ICO_DBG("CicoSCResourceManager::popDispResReq Leave(NULL)");
 305     return NULL;
 306 }
 307 #endif
 308
 309 resource_request_t *
 310 CicoSCResourceManager::popSoundResReq(resource_request_t *req)
 311 {
 312     ICO_DBG("CicoSCResourceManager::popSoundResReq Enter");
 313
 314     map<int, list<resource_request_t*> >::iterator itr;
 315     itr = m_soundReqQueue.begin();
 316     CompSoundResourceRequest comp(req);
 317     for (; itr != m_soundReqQueue.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 sound request queue zone=%d req=0x%08x",
 322                     itr->first, *itr2);
 323             m_soundReqQueue[req->soundzoneid].erase(itr2);
 324             ICO_DBG("CicoSCResourceManager::popSoundResReq Leave"
 325                     "(0x%08x)", *itr2);
 326             return *itr2;
 327         }
 328     }
 329     ICO_DBG("CicoSCResourceManager::popSoundResReq Leave(NULL)");
 330     return NULL;
 331 }
 332
 333 resource_request_t *
 334 CicoSCResourceManager::popInputResReq(resource_request_t *req)
 335 {
 336     ICO_DBG("CicoSCResourceManager::popInputResReq Enter");
 337
 338     map<int, list<resource_request_t*> >::iterator itr;
 339     itr = m_inputReqQueue.begin();
 340     CompInputResourceRequest comp(req);
 341     for (; itr != m_inputReqQueue.end(); ++itr) {
 342         list<resource_request_t*>::iterator itr2;
 343         itr2 = find_if(itr->second.begin(), itr->second.end(), comp);
 344         if (itr->second.end() != itr2) {
 345             ICO_DBG("Dequeue waiting input request queue input=%d req=0x%08x",
 346                     itr->first, *itr2);
 347             m_inputReqQueue[req->input].erase(itr2);
 348             ICO_DBG("CicoSCResourceManager::popInputResReq Leave"
 349                     "(0x%08x)", *itr2);
 350             return *itr2;
 351         }
 352     }
 353
 354     ICO_DBG("CicoSCResourceManager::popDispResReq Leave(NULL)");
 355     return NULL;
 356 }
 357
 358
 359 bool
 360 CicoSCResourceManager::acquireDisplayResource(resource_request_t *newreq,
 361                                               bool control)
 362 {
 363     ICO_DBG("CicoSCResourceManager::acquireDisplayResource Enter");
 364
 365     CicoSCSystemConfig *sysConf = CicoSCSystemConfig::getInstance();
 366     const CicoSCAppKindConf *appKindConf = NULL;
 367     appKindConf = sysConf->findAppKindConfbyId(newreq->appkind);
 368     if (NULL == appKindConf) {
 369         ICO_ERR("not found CicoSCAppKindConf instance");
 370         ICO_DBG("CicoSCResourceManager::acquireDisplayResource Leave(false)");
 371         return false;
 372     }
 373
 374     if ((appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_ALMIGHTY) ||
 375         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM)   ||
 376         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM_VISIBLE)) {
 377
 378         if ((NULL != m_winCtrl) && (true == control)) {
 379             m_winCtrl->show(newreq->surfaceid,
 380                             newreq->animation,
 381                             newreq->animationTime);
 382         }
 383         delResourceRequest(newreq);
 384
 385         ICO_DBG("kind of system application");
 386         ICO_DBG("CicoSCResourceManager::acquireDisplayResource Leave(true)");
 387         return true;
 388     }
 389
 390     // if exist current ower request, pop request
 391     resource_request_t *req = findCurDispResOwerReq(newreq);
 392     int chgzone = -1;
 393     if (NULL != req) {
 394         ICO_DBG("dispzoneid=%d/%d zone=%s/%s",
 395                 req->dispzoneid, newreq->dispzoneid,
 396                 req->dispzone, newreq->dispzone);
 397         if (req->dispzoneid != newreq->dispzoneid) {
 398             req = popCurDispResOwerReq(req);
 399             chgzone = newreq->dispzoneid;
 400         }
 401     }
 402
 403     // if exist in wating request list, pop request
 404     if (NULL == req) {
 405         req = popWaitingDispResReq(newreq);
 406         if (NULL != req) {
 407             ICO_DBG("dispzoneid=%d/%d zone=%s/%s",
 408                     req->dispzoneid, newreq->dispzoneid,
 409                     req->dispzone, newreq->dispzone);
 410             if (req->dispzoneid != newreq->dispzoneid) {
 411                 chgzone = newreq->dispzoneid;
 412             }
 413         }
 414         else {
 415             req = newreq;
 416         }
 417     }
 418
 419     //
 420     if (req != newreq) {
 421         // update request data
 422         req->dispzoneid = newreq->dispzoneid;
 423         if (NULL != req->dispzone) free(req->dispzone);
 424         req->dispzone = strdup(newreq->dispzone);
 425         if (NULL != req->animation) free(req->animation);
 426         req->animation = strdup(newreq->animation);
 427         req->animationTime = newreq->animationTime;
 428
 429         // delete new request
 430         delResourceRequest(newreq);
 431     }
 432
 433     if (false == control) {
 434         ICO_DBG("Enqueue waiting display resource request"
 435                 "(req=0x%08x appid=%s)", req, req->appid);
 436         m_waitingDispResReq.push_front(req);
 437 #if 1   //DEBUG
 438         dumpWaitingDispResReq();
 439 #endif  //DEBUG
 440         return true;
 441     }
 442
 443     int type = req->resid & RESID_TYPE_MASK;
 444     bool state = m_policyMgr->acquireDisplayResource(type,
 445                                                      req->dispzoneid,
 446                                                      req->prio);
 447     if (true == state) {
 448         updateDisplayResource(req, chgzone);
 449     }
 450     else {
 451         ICO_DBG("Enqueue waiting display resource request"
 452                 "(req=0x%08x appid=%s)", req, req->appid);
 453         m_waitingDispResReq.push_front(req);
 454 #if 1   //DEBUG
 455         dumpWaitingDispResReq();
 456 #endif  //DEBUG
 457     }
 458
 459
 460     ICO_DBG("CicoSCResourceManager::acquireDisplayResource Leave");
 461     return true;
 462 }
 463
 464 void
 465 CicoSCResourceManager::releaseDisplayResource(resource_request_t *newreq)
 466 {
 467     ICO_DBG("CicoSCResourceManager::releaseDisplayResource Enter"
 468             "(newreq=0x%08x)", newreq);
 469
 470     // if exist in wating request list, pop request
 471     resource_request_t *req = popWaitingDispResReq(newreq);
 472     if (NULL != req) {
 473         delResourceRequest(req);
 474         delResourceRequest(newreq);
 475         ICO_DBG("CicoSCResourceManager::releaseDisplayResource Leave");
 476         return;
 477     }
 478
 479     // if exist current ower request, pop request
 480     req = popCurDispResOwerReq(newreq);
 481     if (NULL != req) {
 482         delResourceRequest(req);
 483     }
 484     delResourceRequest(newreq);
 485
 486     list<resource_request_t*>::iterator itr;
 487     itr = m_waitingDispResReq.begin();
 488     for (; itr != m_waitingDispResReq.end(); ++itr) {
 489         int type = (*itr)->resid & RESID_TYPE_MASK;
 490         bool active = m_policyMgr->acquireDisplayResource(type,
 491                                                          (*itr)->dispzoneid,
 492                                                          (*itr)->prio);
 493         if (true == active) {
 494             resource_request_t* popreq = popWaitingDispResReq(*itr);
 495             updateDisplayResource(popreq);
 496             m_winCtrl->active(popreq->surfaceid, -1);
 497             break;
 498         }
 499     }
 500
 501     ICO_DBG("CicoSCResourceManager::releaseDisplayResource Leave");
 502 }
 503
 504 bool
 505 CicoSCResourceManager::acquireSoundResource(resource_request_t *newreq)
 506 {
 507     ICO_DBG("CicoSCResourceManager::acquireSoundResource Enter");
 508
 509     CicoSCSystemConfig *sysConf = CicoSCSystemConfig::getInstance();
 510     const CicoSCAppKindConf *appKindConf = NULL;
 511     appKindConf = sysConf->findAppKindConfbyId(newreq->appkind);
 512     if (NULL == appKindConf) {
 513         ICO_ERR("not found CicoSCAppKindConf instance");
 514         ICO_DBG("CicoSCResourceManager::acquireSoundResource Leave(false)");
 515         return false;
 516     }
 517
 518     if ((appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_ALMIGHTY) ||
 519         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM)   ||
 520         (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM_AUDIO)) {
 521
 522         delResourceRequest(newreq);
 523
 524         ICO_DBG("kind of system application");
 525         ICO_DBG("CicoSCResourceManager::acquireSoundResource Leave(true)");
 526         return true;
 527     }
 528
 529     resource_request_t *req = popSoundResReq(newreq);
 530     if (NULL == req) {
 531         req = newreq;
 532     }
 533
 534     // is change zone?
 535     CompSoundResourceRequest comp(req);
 536     if (true == comp(m_curSoundResReq[req->soundzoneid])) {
 537         ICO_DBG("already acquired appid=%s pid=%d soundid=0x%08X",
 538                 req->appid, req->pid, req->soundid);
 539         ICO_DBG("CicoSCResourceManager::acquireSoundResource Leave(true)");
 540         // free new request
 541         delResourceRequest(newreq);
 542         return true;
 543     }
 544
 545     int type = req->resid & RESID_TYPE_MASK;
 546     bool state = m_policyMgr->acquireSoundResource(type,
 547                                                    req->soundzoneid,
 548                                                    req->prio);
 549     if (true == state) {
 550         updateSoundResource(req);
 551     }
 552     else {
 553         ICO_DBG("Enqueue waiting sound request queue zone=%d req=0x%08x",
 554                 req->soundzoneid, req);
 555         m_soundReqQueue[req->soundzoneid].push_front(req);
 556     }
 557
 558     ICO_DBG("CicoSCResourceManager::acquireSoundResource Leave");
 559     return true;
 560 }
 561
 562 void
 563 CicoSCResourceManager::releaseSoundResource(resource_request_t *newreq)
 564 {
 565     ICO_DBG("CicoSCResourceManager::releaseSoundResource Enter");
 566
 567     bool curchg = false;
 568     CompSoundResourceRequest comp(newreq);
 569     for (int i = 0; i < (int)m_curSoundResReq.size(); ++i) {
 570          if (NULL == m_curSoundResReq[i]) {
 571             continue;
 572          }
 573
 574          if (true == comp(m_curSoundResReq[i])) {
 575             ico_syc_mrp_release_sound_resource(m_curSoundResReq[i]);
 576             delResourceRequest(newreq);
 577             delResourceRequest(m_curSoundResReq[i]);
 578             m_curSoundResReq[i] = NULL;
 579             curchg = true;
 580             break;
 581          }
 582     }
 583
 584     // If current request is not changed,
 585     // remove the request from the waiting queue.
 586     if (false == curchg) {
 587        resource_request_t *req = popSoundResReq(newreq);
 588         if (NULL != req) {
 589             ico_syc_mrp_release_sound_resource(req);
 590             delResourceRequest(req);
 591             req = NULL;
 592         }
 593         delResourceRequest(newreq);
 594         ICO_DBG("CicoSCResourceManager::releaseSoundResource Leave");
 595         return;
 596     }
 597
 598     map<int, list<resource_request_t*> >::iterator itr;
 599     itr = m_soundReqQueue.begin();
 600     for (; itr != m_soundReqQueue.end(); ++itr) {
 601         list<resource_request_t*>::iterator itr2;
 602         itr2 = itr->second.begin();
 603         for (; itr2 !=  itr->second.end(); ++itr2) {
 604             int type = (*itr2)->resid & RESID_TYPE_MASK;
 605             bool active = m_policyMgr->acquireSoundResource(type,
 606                                                             (*itr2)->soundzoneid,
 607                                                             (*itr2)->prio);
 608             if (true == active) {
 609                 resource_request_t* req = *itr2;
 610                 ICO_DBG("Dequeue waiting sound request queue "
 611                         "zone=%d req=0x%08x", itr->first, *itr2);
 612                 itr->second.erase(itr2);
 613                 updateSoundResource(req);
 614                 break;
 615             }
 616         }
 617     }
 618
 619     ICO_DBG("CicoSCResourceManager::releaseSoundResource Leave");
 620 }
 621
 622 bool
 623 CicoSCResourceManager::acquireInputResource(resource_request_t *newreq)
 624 {
 625     ICO_DBG("CicoSCResourceManager::acquireInputResource Enter");
 626
 627     resource_request_t *req = popInputResReq(newreq);
 628     if (NULL == req) {
 629         req = newreq;
 630     }
 631
 632     // is change zone?
 633     CompInputResourceRequest comp(req);
 634     if (true == comp(m_curInputResReq[req->input])) {
 635         ICO_DBG("already acquired appid=%s pid=%d input=0x%08X",
 636                 req->appid, req->pid, req->input);
 637         ICO_DBG("CicoSCResourceManager::acquireInputResource Leave(true)");
 638         // free new request
 639         delResourceRequest(newreq);
 640         return true;
 641     }
 642
 643     bool state = m_policyMgr->acquireInputResource(req->input, req->prio);
 644     if (true == state) {
 645         updateInputResource(req);
 646     }
 647     else {
 648         ICO_DBG("Enqueue waiting input request queue input=%d req=0x%08x",
 649                 req->input, req);
 650         m_inputReqQueue[req->input].push_front(req);
 651     }
 652
 653     ICO_DBG("CicoSCResourceManager::acquireInputResource Leave");
 654     return true;
 655 }
 656
 657 void
 658 CicoSCResourceManager::releaseInputResource(resource_request_t *newreq)
 659 {
 660     bool curchg = false;
 661     CompInputResourceRequest comp(newreq);
 662     for (int i = 0; i < (int)m_curInputResReq.size(); ++i) {
 663          if (NULL == m_curInputResReq[i]) {
 664             continue;
 665          }
 666
 667          if (true == comp(m_curInputResReq[i])) {
 668             if (NULL != m_inputCtrl) {
 669                 m_inputCtrl->delInputApp(m_curInputResReq[i]->appid,
 670                                          m_curInputResReq[i]->device,
 671                                          m_curInputResReq[i]->input);
 672             }
 673             delResourceRequest(newreq);
 674             delResourceRequest(m_curInputResReq[i]);
 675             m_curInputResReq[i] = NULL;
 676             curchg = true;
 677             break;
 678          }
 679     }
 680
 681     // If current request is not changed,
 682     // remove the request from the waiting queue.
 683     if (false == curchg) {
 684        resource_request_t *req = popInputResReq(newreq);
 685         if (NULL != req) {
 686             delResourceRequest(req);
 687             req = NULL;
 688         }
 689         delResourceRequest(newreq);
 690         ICO_DBG("CicoSCResourceManager::releaseInputResource Leave");
 691         return;
 692     }
 693
 694     map<int, list<resource_request_t*> >::iterator itr;
 695     itr = m_inputReqQueue.begin();
 696     for (; itr != m_inputReqQueue.end(); ++itr) {
 697         list<resource_request_t*>::iterator itr2;
 698         itr2 = itr->second.begin();
 699         for (; itr2 !=  itr->second.end(); ++itr2) {
 700             bool active = m_policyMgr->acquireInputResource((*itr2)->input,
 701                                                             (*itr2)->prio);
 702             if (true == active) {
 703                 resource_request_t* req = *itr2;
 704                 ICO_DBG("Dequeue waiting input request queue "
 705                         "input=%d req=0x%08x", itr->first, *itr2);
 706                 itr->second.erase(itr2);
 707                 updateInputResource(req);
 708                 break;
 709             }
 710         }
 711     }
 712 }
 713
 714 resource_request_t *
 715 CicoSCResourceManager::newResourceRequest(int resid,
 716                                           int reqtype,
 717                                           const CicoSCCommand &cmd)
 718 {
 719     ICO_DBG("CicoSCResourceManager::newResourceRequest Enter");
 720
 721     resource_request_t *req = NULL;
 722     req = (resource_request_t*)calloc(1, sizeof(resource_request_t));
 723     CicoSCCmdResCtrlOpt *opt = (CicoSCCmdResCtrlOpt*)cmd.opt;
 724     CicoSCSystemConfig *systemConfig = CicoSCSystemConfig::getInstance();
 725
 726     req->reqtype = reqtype;
 727
 728     CicoSCLifeCycleController *lifeCycle =
 729         CicoSCLifeCycleController::getInstance();
 730     const CicoSCAilItems* ailItem = lifeCycle->findAIL(cmd.appid);
 731     if (NULL != ailItem) {
 732         req->category = ailItem->m_categoryID;
 733         req->appkind = ailItem->m_kindID;
 734     }
 735
 736     req->prio = req->category;
 737
 738     req->released = 0;
 739
 740     /* set resource id */
 741     req->resid = RESID_TYPE_BASIC;
 742     if (1 == opt->type) {
 743         req->resid = RESID_TYPE_INTERRUPT;
 744     }
 745     req->resid |= resid;
 746
 747     req->resid |= RESID_CMD_RELEASE;
 748     if (MSG_CMD_ACQUIRE_RES == cmd.cmdid) {
 749         req->resid |= RESID_CMD_ACQUIRE;
 750     }
 751
 752     /* set application information */
 753     req->appid = strdup(cmd.appid.c_str());
 754     req->pid   = cmd.pid;
 755     req->state = RES_STATE_WAITING;
 756
 757     if (resid == RESID_KIND_DISPLAY) {
 758         req->dispzone   = strdup(opt->dispzone.c_str());
 759         req->dispzoneid = systemConfig->getDizplayZoneIdbyFullName(req->dispzone);
 760         req->winname    = strdup(opt->winname.c_str());
 761         req->surfaceid  = opt->surfaceid;
 762         req->id         = opt->surfaceid;;
 763         req->animation  = strdup(opt->animation.c_str());
 764         req->animationTime = opt->animationTime;
 765     }
 766     else if (resid == RESID_KIND_SOUND) {
 767         req->soundzone   = strdup(opt->soundzone.c_str());
 768         req->soundzoneid = systemConfig->getSoundZoneIdbyFullName(req->soundzone);
 769         ICO_DBG("req->soundzoneid=%d", req->soundzoneid);
 770         req->soundname   = strdup(opt->soundname.c_str());
 771         req->soundid     = opt->soundid;
 772         req->soundadjust = opt->adjust;
 773         req->id          = opt->soundid;
 774     }
 775     else if (resid == RESID_KIND_INPUT) {
 776         req->device = strdup(opt->device.c_str());
 777         req->input  = opt->input;
 778         req->id     = opt->input;
 779     }
 780
 781     ICO_DBG("CicoSCResourceManager::newResourceRequest Leave"
 782             "(req=0x%08x appid=%s)", req, req->appid);
 783     return req;
 784 }
 785
 786 void
 787 CicoSCResourceManager::delResourceRequest(resource_request_t *req)
 788 {
 789     if (NULL == req) return;
 790
 791     if (NULL != req->appid)     free(req->appid);
 792     if (NULL != req->dispzone)  free(req->dispzone);
 793     if (NULL != req->winname)   free(req->winname);
 794     if (NULL != req->animation) free(req->animation);
 795     if (NULL != req->soundzone) free(req->soundzone);
 796     if (NULL != req->soundname) free(req->soundname);
 797     if (NULL != req->device)    free(req->device);
 798
 799     free(req);
 800 }
 801
 802 void
 803 CicoSCResourceManager::enforceSound(unsigned short state,
 804                                     resource_request_t *req,
 805                                     void *user_data)
 806 {
 807     ICO_DBG("CicoSCResourceManager::enforceSound Enter");
 808     /* NOP */
 809     ICO_DBG("CicoSCResourceManager::enforceSound Leave");
 810 }
 811
 812 // receive changed state
 813 void
 814 CicoSCResourceManager::receiveChangedState(int state)
 815 {
 816     ICO_DBG("CicoSCResourceManager::receiveChangedState Enter"
 817             "(state=%d)", state);
 818
 819     if ((STID_DRVREGULATION_ON == state)||
 820         (STID_DRVREGULATION_OFF == state)) {
 821
 822         updateDisplayResourceRegulation(state);
 823         updateSoundResourceRegulation(state);
 824         updateInputResourceRegulation(state);
 825     }
 826
 827     ICO_DBG("CicoSCResourceManager::receiveChangedState Leave");
 828 }
 829
 830 //--------------------------------------------------------------------------
 831 /**
 832  *  @brief  get policy manager instance
 833  *
 834  *  @return resource manager instace
 835  */
 836 //--------------------------------------------------------------------------
 837 CicoSCPolicyManager *
 838 CicoSCResourceManager::getPolicyManager(void)
 839 {
 840     return m_policyMgr;
 841 }
 842
 843 void
 844 CicoSCResourceManager::updateDisplayResource(resource_request_t *req,
 845                                              int chgzoneid)
 846 {
 847     ICO_DBG("CicoSCResourceManager::updateDisplayResource Enter"
 848             "(req=0x%08x)", req);
 849     std::map<unsigned int, resource_request_t*>::iterator itr;
 850     itr = m_curDispResOwerReq.find(req->dispzoneid);
 851     if ((m_curDispResOwerReq.end() != itr) && (NULL != itr->second)) {
 852         // already ower
 853         if (itr->second == req) {
 854             ICO_DBG("already ower appid=%s pid=%d surfaceid=0x%08X",
 855                     req->appid, req->pid, req->surfaceid);
 856             // show request window
 857             m_winCtrl->show(req->surfaceid, req->animation, req->animationTime);
 858             m_winCtrl->active(req->surfaceid, -1);
 859             return;
 860         }
 861         resource_request_t *popreq = popCurDispResOwerReq(itr->second);
 862         if (NULL != popreq) {
 863             if (NULL != m_winCtrl) {
 864                 // hide current window
 865                 m_winCtrl->hide(popreq->surfaceid, NULL, 0);
 866             }
 867
 868             // state change to waiting
 869             popreq->state = RES_STATE_WAITING;
 870             // enqueue request
 871             ICO_DBG("Enqueue waiting display resource request"
 872                     "(req=0x%08x appid=%s", popreq, popreq->appid);
 873             m_waitingDispResReq.push_front(popreq);
 874 #if 1   //DEBUG
 875         dumpWaitingDispResReq();
 876 #endif  //DEBUG
 877         }
 878     }
 879
 880     if (NULL != m_winCtrl) {
 881         if (-1 != chgzoneid) {
 882             // move request window
 883             m_winCtrl->setGeometry(req->surfaceid, req->dispzone,
 884                                    req->animation, req->animationTime,
 885                                    req->animation, req->animationTime);
 886         }
 887         // show request window
 888         m_winCtrl->show(req->surfaceid, req->animation, req->animationTime);
 889     }
 890     // state change to acquired
 891     req->state = RES_STATE_ACQUIRED;
 892     // update current zone request
 893     ICO_DBG("Enqueue current display resource ower request"
 894             "(req=0x%08x zoneid=%d appid=%s)",
 895             req, req->dispzoneid, req->appid);
 896     m_curDispResOwerReq[req->dispzoneid] = req;
 897 #if 1   //DEBUG
 898     dumpCurDispResOwerReq();
 899 #endif  //DEBUG
 900
 901     // if current zone ower not exist after zone change
 902     if (-1 != chgzoneid) {
 903         list<resource_request_t*>::iterator itr;
 904         itr = m_waitingDispResReq.begin();
 905         for (; itr !=  m_waitingDispResReq.end(); ++itr) {
 906             if (m_curDispResOwerReq[(*itr)->dispzoneid] != NULL) {
 907                 continue;
 908             }
 909             int type = (*itr)->resid & RESID_TYPE_MASK;
 910             bool active = false;
 911             active = m_policyMgr->acquireDisplayResource(type,
 912                                                          (*itr)->dispzoneid,
 913                                                          (*itr)->prio);
 914             if (true == active) {
 915                 resource_request_t* req = *itr;
 916                 ICO_DBG("Dequeue waiting display resource request"
 917                         "(req=0x%08x appid=%s)", *itr, (*itr)->appid);
 918                 m_waitingDispResReq.erase(itr);
 919 #if 1   //DEBUG
 920                 dumpWaitingDispResReq();
 921 #endif  //DEBUG
 922                 updateDisplayResource(req);
 923                 m_winCtrl->active(req->surfaceid, -1);
 924                 break;
 925             }
 926         }
 927     }
 928
 929     ICO_DBG("CicoSCResourceManager::updateDisplayResource Leave");
 930 }
 931
 932 void
 933 CicoSCResourceManager::updateSoundResource(resource_request_t *req)
 934 {
 935     ICO_DBG("CicoSCResourceManager::updateSoundResource Enter"
 936             "(req=0x%08x)", req);
 937     for (int i = 0; i < (int)m_curSoundResReq.size(); ++i) {
 938         ICO_DBG("zoneid=%d active=%d current=0x%08x",
 939                 i, m_policyMgr->getSoundZoneState(i), m_curSoundResReq[i]);
 940
 941         if (NULL == m_curSoundResReq[i]) {
 942             continue;
 943         }
 944
 945         if ((i == req->soundzoneid) ||
 946             (false == m_policyMgr->getSoundZoneState(i))) {
 947
 948             // state change to waiting
 949             m_curSoundResReq[i]->state = RES_STATE_WAITING;
 950             // enqueue request
 951             ICO_DBG("Enqueue waiting sound request queue "
 952                     "zone=%d req=0x%08x", i, m_curSoundResReq[i]);
 953             m_soundReqQueue[i].push_front(m_curSoundResReq[i]);
 954             // initialize current zone request
 955             m_curSoundResReq[i] = NULL;
 956         }
 957     }
 958
 959     if (req != m_curSoundResReq[req->soundzoneid]) {
 960         ico_syc_mrp_acquire_sound_resource(req);
 961         ico_syc_mrp_active_app(req->appid);
 962
 963         // state change to acquired
 964         req->state = RES_STATE_ACQUIRED;
 965         // update current zone request
 966         m_curSoundResReq[req->soundzoneid] = req;
 967     }
 968     ICO_DBG("CicoSCResourceManager::updateSoundResource Leave");
 969 }
 970
 971 void
 972 CicoSCResourceManager::updateInputResource(resource_request_t *req)
 973 {
 974     ICO_DBG("CicoSCResourceManager::updateInputResource Enter"
 975             "(req=0x%08x)", req);
 976     for (int i = 0; i < (int)m_curInputResReq.size(); ++i) {
 977         ICO_DBG("input=%d active=%d current=0x%08x",
 978                 i, m_policyMgr->getInputState(i), m_curInputResReq[i]);
 979
 980         if (NULL == m_curInputResReq[i]) {
 981             continue;
 982         }
 983
 984         if ((i == req->input) ||
 985             (false == m_policyMgr->getInputState(i))) {
 986
 987             if (NULL != m_inputCtrl) {
 988                 // add input control
 989                 m_inputCtrl->delInputApp(req->appid, req->device, req->input);
 990             }
 991
 992             // state change to waiting
 993             m_curInputResReq[i]->state = RES_STATE_WAITING;
 994             // enqueue request
 995             ICO_DBG("Enqueue waiting input request queue "
 996                     "zone=%d req=0x%08x", i, m_curInputResReq[i]);
 997             m_inputReqQueue[i].push_front(m_curInputResReq[i]);
 998             // initialize current zone request
 999             m_curInputResReq[i] = NULL;
1000         }
1001     }
1002
1003     if (req != m_curInputResReq[req->input]) {
1004         // delete input control
1005         m_inputCtrl->addInputApp(req->appid, req->device, req->input, 0, 0);
1006         // state change to acquired
1007         req->state = RES_STATE_ACQUIRED;
1008         // update current zone request
1009         m_curInputResReq[req->input] = req;
1010     }
1011     ICO_DBG("CicoSCResourceManager::updateInputResource Leave");
1012 }
1013
1014 void
1015 CicoSCResourceManager::updateDisplayResourceRegulation(int state)
1016 {
1017     ICO_DBG("CicoSCResourceManager::updateDisplayResourceRegulation Enter"
1018             "(state=%d)", state);
1019
1020     if (STID_DRVREGULATION_ON == state) {
1021         bool curchg = false;
1022         std::map<unsigned int, resource_request_t*>::iterator itr;
1023         itr = m_curDispResOwerReq.begin();
1024         for (; itr != m_curDispResOwerReq.end(); ++itr) {
1025             resource_request_t *current = itr->second;
1026             if (NULL == current) {
1027                 continue;
1028             }
1029
1030             int type = current->resid & RESID_TYPE_MASK;
1031             bool active = false;
1032             active = m_policyMgr->acquireDisplayResource(type,
1033                                                          current->dispzoneid,
1034                                                          current->prio);
1035             if (false == active) {
1036                 if (NULL != m_winCtrl) {
1037                     // hide current window
1038                     // TODO animation?
1039                     m_winCtrl->hide(current->surfaceid, NULL, 0);
1040                 }
1041                 curchg = true;
1042             }
1043         }
1044
1045         if (false == curchg) {
1046             ICO_DBG("CicoSCResourceManager::updateDisplayResourceRegulation "
1047                     "Leave");
1048             return;
1049         }
1050
1051         list<resource_request_t*>::iterator itr2;
1052         itr2 = m_waitingDispResReq.begin();
1053         for (; itr2 !=  m_waitingDispResReq.end(); ++itr2) {
1054             int type = (*itr2)->resid & RESID_TYPE_MASK;
1055             bool active = false;
1056             active = m_policyMgr->acquireDisplayResource(type,
1057                                                          (*itr2)->dispzoneid,
1058                                                          (*itr2)->prio);
1059             if (true == active) {
1060                 if (NULL != m_winCtrl) {
1061                     // show current window
1062                     // TODO animation?
1063                     m_winCtrl->show((*itr2)->surfaceid, NULL, 0);
1064                     m_winCtrl->active((*itr2)->surfaceid, -1);
1065                 }
1066                 break;
1067             }
1068         }
1069     }
1070     else if (STID_DRVREGULATION_OFF == state) {
1071         std::map<unsigned int, resource_request_t*>::iterator itr;
1072         itr = m_curDispResOwerReq.begin();
1073         for (; itr != m_curDispResOwerReq.end(); ++itr) {
1074             resource_request_t *current = itr->second;
1075             if (NULL == current) {
1076                 continue;
1077             }
1078
1079             int type = current->resid & RESID_TYPE_MASK;
1080             bool active = false;
1081             active = m_policyMgr->acquireDisplayResource(type,
1082                                                          current->dispzoneid,
1083                                                          current->prio);
1084             if (true == active) {
1085                 if (NULL != m_winCtrl) {
1086                     // show current window
1087                     // TODO animation?
1088                     m_winCtrl->show(current->surfaceid, NULL, 0);
1089                     m_winCtrl->active(current->surfaceid, -1);
1090                 }
1091             }
1092         }
1093     }
1094
1095     ICO_DBG("CicoSCResourceManager::updateDisplayResourceRegulation Leave");
1096 }
1097
1098 void
1099 CicoSCResourceManager::updateSoundResourceRegulation(int state)
1100 {
1101     ICO_DBG("CicoSCResourceManager::updateSoundResourceRegulation Enter"
1102             "(state=%d)", state);
1103
1104     bool curchg = false;
1105     for (int i = 0; i < (int)m_curSoundResReq.size(); ++i) {
1106         resource_request_t *current = m_curSoundResReq[i];
1107         if (NULL == current) {
1108             continue;
1109         }
1110
1111         int type = current->resid & RESID_TYPE_MASK;
1112         bool active = false;
1113         active = m_policyMgr->acquireSoundResource(type,
1114                                                    current->soundzoneid,
1115                                                    current->prio);
1116         if (false == active) {
1117             // state change to waiting
1118             current->state = RES_STATE_WAITING;
1119             // enqueue request
1120             ICO_DBG("Enqueue waiting sound request queue "
1121                     "zone=%d req=0x%08x", i, current);
1122             m_soundReqQueue[i].push_front(current);
1123             // initialize current zone request
1124             m_curSoundResReq[i] = NULL;
1125             curchg = true;
1126          }
1127     }
1128
1129     if ((false == curchg) && (STID_DRVREGULATION_ON == state)) {
1130         ICO_DBG("CicoSCResourceManager::updateSoundResourceRegulation Leave");
1131         return;
1132     }
1133
1134     map<int, list<resource_request_t*> >::iterator itr;
1135     itr = m_soundReqQueue.begin();
1136     for (; itr != m_soundReqQueue.end(); ++itr) {
1137         if (NULL != m_curSoundResReq[itr->first]) {
1138             continue;
1139         }
1140
1141         list<resource_request_t*>::iterator itr2;
1142         itr2 = itr->second.begin();
1143         for (; itr2 !=  itr->second.end(); ++itr2) {
1144             int type = (*itr2)->resid & RESID_TYPE_MASK;
1145             bool active = false;
1146             active = m_policyMgr->acquireSoundResource(type,
1147                                                        (*itr2)->soundzoneid,
1148                                                        (*itr2)->prio);
1149             if (true == active) {
1150                 resource_request_t* req = *itr2;
1151                 ICO_DBG("Dequeue waiting sound request queue "
1152                         "zone=%d req=0x%08x", itr->first, *itr2);
1153                 itr->second.erase(itr2);
1154                 updateSoundResource(req);
1155                 break;
1156             }
1157         }
1158     }
1159
1160     ICO_DBG("CicoSCResourceManager::updateSoundResourceRegulation Leave");
1161 }
1162
1163 void
1164 CicoSCResourceManager::updateInputResourceRegulation(int state)
1165 {
1166     ICO_DBG("CicoSCResourceManager::updateInputResourceRegulation Enter"
1167             "(state=%d)", state);
1168
1169     bool curchg = false;
1170     for (int i = 0; i < (int)m_curInputResReq.size(); ++i) {
1171         resource_request_t *current = m_curInputResReq[i];
1172         if (NULL == current) {
1173             continue;
1174         }
1175
1176         bool active = false;
1177         active = m_policyMgr->acquireInputResource(current->input,
1178                                                    current->prio);
1179         if (false == active) {
1180             if (NULL != m_inputCtrl) {
1181                 // hide current window
1182                 m_inputCtrl->delInputApp(current->appid,
1183                                          current->device,
1184                                          current->input);
1185             }
1186             // state change to waiting
1187             current->state = RES_STATE_WAITING;
1188             // enqueue request
1189             ICO_DBG("Enqueue waiting input request queue "
1190                     "zone=%d req=0x%08x", i, current);
1191             m_inputReqQueue[i].push_front(current);
1192             // initialize current zone request
1193             m_curInputResReq[i] = NULL;
1194             curchg = true;
1195          }
1196     }
1197
1198     if ((false == curchg) && (STID_DRVREGULATION_ON == state)) {
1199         ICO_DBG("CicoSCResourceManager::updateInputResourceRegulation Leave");
1200         return;
1201     }
1202
1203     map<int, list<resource_request_t*> >::iterator itr;
1204     itr = m_inputReqQueue.begin();
1205     for (; itr != m_inputReqQueue.end(); ++itr) {
1206         if (NULL != m_curInputResReq[itr->first]) {
1207             continue;
1208         }
1209
1210         list<resource_request_t*>::iterator itr2;
1211         itr2 = itr->second.begin();
1212         for (; itr2 !=  itr->second.end(); ++itr2) {
1213             bool active = false;
1214             active = m_policyMgr->acquireInputResource((*itr2)->input,
1215                                                        (*itr2)->prio);
1216             if (true == active) {
1217                 resource_request_t* req = *itr2;
1218                 ICO_DBG("Dequeue waiting input request queue "
1219                         "zone=%d req=0x%08x", itr->first, *itr2);
1220                 itr->second.erase(itr2);
1221                 updateInputResource(req);
1222                 break;
1223             }
1224         }
1225     }
1226
1227     ICO_DBG("CicoSCResourceManager::updateDisplayResourceRegulation Leave");
1228 }
1229
1230 //--------------------------------------------------------------------------
1231 /**
1232  *  @brief   find currnet dipalay resource ower request
1233  *
1234  *  @param [in] request  compare requset
1235  *
1236  *  @return request object on same requeset found, NULL on not found
1237  */
1238 //--------------------------------------------------------------------------
1239 resource_request_t *
1240 CicoSCResourceManager::findCurDispResOwerReq(resource_request_t *req)
1241 {
1242     if (NULL == req) {
1243         ICO_WRN("invalid argument. req is null");
1244         return NULL;
1245     }
1246     std::map<unsigned int, resource_request_t*>::iterator itr;
1247     itr = m_curDispResOwerReq.begin();
1248     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1249         CompDisplayResourceRequest comp(req);
1250         if (true == comp(itr->second)) {
1251             return itr->second;
1252         }
1253     }
1254     return NULL;
1255 }
1256
1257 //--------------------------------------------------------------------------
1258 /**
1259  *  @brief  pop currnet dipalay resource ower request from list
1260  *
1261  *  @param [in] request  compare requset
1262  *
1263  *  @return request object on same requeset found, NULL on not found
1264  */
1265 //--------------------------------------------------------------------------
1266 resource_request_t *
1267 CicoSCResourceManager::popCurDispResOwerReq(resource_request_t *req)
1268 {
1269     if (NULL == req) {
1270         ICO_WRN("invalid argument. req is null");
1271         return NULL;
1272     }
1273     std::map<unsigned int, resource_request_t*>::iterator itr;
1274     itr = m_curDispResOwerReq.begin();
1275     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1276         CompDisplayResourceRequest comp(req);
1277         if (true == comp(itr->second)) {
1278             ICO_DBG("Dequeue current display reoursce ower request"
1279                     "(req=0x%08x zoneid=%d appid=%s)",
1280                     itr->second, itr->first, itr->second->appid);
1281             resource_request_t *findreq = itr->second;
1282             itr->second = NULL;
1283 #if 1   //DEBUG
1284             dumpCurDispResOwerReq();
1285 #endif  //DEBUG
1286             return findreq;
1287         }
1288     }
1289     return NULL;
1290 }
1291
1292 //--------------------------------------------------------------------------
1293 /**
1294  *  @brief   dump currnet dipalay resource ower request
1295  */
1296 //--------------------------------------------------------------------------
1297 void
1298 CicoSCResourceManager::dumpCurDispResOwerReq(void)
1299 {
1300     std::map<unsigned int, resource_request_t*>::iterator itr;
1301     itr = m_curDispResOwerReq.begin();
1302     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1303         if (NULL == itr->second) {
1304             ICO_DBG("current req=0x%08x zone=%02d:(null) appid=(null)",
1305                     itr->second, itr->first);
1306         }
1307         else {
1308             ICO_DBG("current req=0x%08x zone=%02d:%s appid=%s",
1309                     itr->second, itr->first, itr->second->dispzone,
1310                     itr->second->appid);
1311         }
1312     }
1313 }
1314
1315 //--------------------------------------------------------------------------
1316 /**
1317  *  @brief  find waiting dipalay resource request
1318  *
1319  *  @param [in] request  compare requset
1320  *
1321  *  @return request object on same requeset found, NULL on not found
1322  */
1323 //--------------------------------------------------------------------------
1324 resource_request_t *
1325 CicoSCResourceManager::findWaitingDispResReq(resource_request_t *req)
1326 {
1327     if (NULL == req) {
1328         ICO_WRN("invalid argument. req is null");
1329         return NULL;
1330     }
1331     CompDisplayResourceRequest comp(req);
1332     std::list<resource_request_t*>::iterator itr;
1333     itr = find_if(m_waitingDispResReq.begin(), m_waitingDispResReq.end(), comp);
1334     if (m_waitingDispResReq.end() != itr) {
1335         return *itr;
1336     }
1337     return NULL;
1338 }
1339
1340 //--------------------------------------------------------------------------
1341 /**
1342  *  @brief  pop waiting dipalay resource request from waiting list
1343  *
1344  *  @param [in] request  compare requset
1345  *
1346  *  @return request object on same requeset found, NULL on not found
1347  */
1348 //--------------------------------------------------------------------------
1349 resource_request_t *
1350 CicoSCResourceManager::popWaitingDispResReq(resource_request_t *req)
1351 {
1352     if (NULL == req) {
1353         ICO_WRN("invalid argument. req is null");
1354         return NULL;
1355     }
1356     CompDisplayResourceRequest comp(req);
1357     std::list<resource_request_t*>::iterator itr;
1358     itr = find_if(m_waitingDispResReq.begin(), m_waitingDispResReq.end(), comp);
1359     if (m_waitingDispResReq.end() != itr) {
1360         ICO_DBG("Dequeue waiting display resource request"
1361                 "(req=0x%08x zone:%02d:%s appid=%s)",
1362                 *itr, (*itr)->dispzoneid, (*itr)->dispzone, (*itr)->appid);
1363         resource_request_t *findreq = *itr;
1364         m_waitingDispResReq.erase(itr);
1365 #if 1   //DEBUG
1366         dumpWaitingDispResReq();
1367 #endif  //DEBUG
1368         return findreq;
1369     }
1370     return NULL;
1371 }
1372
1373 //--------------------------------------------------------------------------
1374 /**
1375  *  @brief  dump waiting dipalay resource request
1376  */
1377 //--------------------------------------------------------------------------
1378 void
1379 CicoSCResourceManager::dumpWaitingDispResReq(void)
1380 {
1381     std::list<resource_request_t*>::iterator itr;
1382     itr = m_waitingDispResReq.begin();
1383     for (; itr != m_waitingDispResReq.end(); ++itr) {
1384         if (NULL == *itr) {
1385             ICO_DBG("waiting req=null");
1386         }
1387         else {
1388             ICO_DBG("waiting req=0x%08x zone=%02d:%s appid=%s",
1389                     *itr, (*itr)->dispzoneid, (*itr)->dispzone, (*itr)->appid);
1390         }
1391     }
1392 }
1393 // vim:set expandtab ts=4 sw=4: