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         else {
 402             ICO_DBG("already ower appid=%s", req->appid);
 403             ICO_DBG("CicoSCResourceManager::acquireDisplayResource Leave(true)");
 404             return true;
 405         }
 406     }
 407
 408     // if exist in wating request list, pop request
 409     if (NULL == req) {
 410         req = popWaitingDispResReq(newreq);
 411         if (NULL != req) {
 412             ICO_DBG("dispzoneid=%d/%d zone=%s/%s",
 413                     req->dispzoneid, newreq->dispzoneid,
 414                     req->dispzone, newreq->dispzone);
 415             if (req->dispzoneid != newreq->dispzoneid) {
 416                 chgzone = newreq->dispzoneid;
 417             }
 418         }
 419         else {
 420             req = newreq;
 421         }
 422     }
 423
 424     //
 425     if (req != newreq) {
 426         // update request data
 427         req->dispzoneid = newreq->dispzoneid;
 428         if (NULL != req->dispzone) free(req->dispzone);
 429         req->dispzone = strdup(newreq->dispzone);
 430         if (NULL != req->animation) free(req->animation);
 431         req->animation = strdup(newreq->animation);
 432         req->animationTime = newreq->animationTime;
 433
 434         // delete new request
 435         delResourceRequest(newreq);
 436     }
 437
 438     if (false == control) {
 439         ICO_DBG("Enqueue waiting display resource request"
 440                 "(req=0x%08x appid=%s)", req, req->appid);
 441         m_waitingDispResReq.push_front(req);
 442 #if 1   //DEBUG
 443         dumpWaitingDispResReq();
 444 #endif  //DEBUG
 445         return true;
 446     }
 447
 448     int type = req->resid & RESID_TYPE_MASK;
 449     bool state = m_policyMgr->acquireDisplayResource(type,
 450                                                      req->dispzoneid,
 451                                                      req->prio);
 452     if (true == state) {
 453         updateDisplayResource(req, chgzone);
 454     }
 455     else {
 456         ICO_DBG("Enqueue waiting display resource request"
 457                 "(req=0x%08x appid=%s)", req, req->appid);
 458         m_waitingDispResReq.push_front(req);
 459 #if 1   //DEBUG
 460         dumpWaitingDispResReq();
 461 #endif  //DEBUG
 462     }
 463
 464
 465     ICO_DBG("CicoSCResourceManager::acquireDisplayResource Leave");
 466     return true;
 467 }
 468
 469 void
 470 CicoSCResourceManager::releaseDisplayResource(resource_request_t *newreq)
 471 {
 472     ICO_DBG("CicoSCResourceManager::releaseDisplayResource Enter"
 473             "(newreq=0x%08x)", newreq);
 474
 475     // if exist current ower request, pop request
 476     resource_request_t *req = popCurDispResOwerReq(newreq);
 477     if (NULL == req) {
 478         // if exist in wating request list, pop request
 479         req = popWaitingDispResReq(newreq);
 480     }
 481
 482     if (NULL != req) {
 483         delResourceRequest(req);
 484     }
 485     delResourceRequest(newreq);
 486
 487     list<resource_request_t*>::iterator itr;
 488     itr = m_waitingDispResReq.begin();
 489     for (; itr != m_waitingDispResReq.end(); ++itr) {
 490         int type = (*itr)->resid & RESID_TYPE_MASK;
 491         bool active = m_policyMgr->acquireDisplayResource(type,
 492                                                          (*itr)->dispzoneid,
 493                                                          (*itr)->prio);
 494         if (true == active) {
 495             resource_request_t* popreq = popWaitingDispResReq(*itr);
 496             updateDisplayResource(popreq);
 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 void
 831 CicoSCResourceManager::updateDisplayResource(resource_request_t *req,
 832                                              int chgzoneid)
 833 {
 834     ICO_DBG("CicoSCResourceManager::updateDisplayResource Enter"
 835             "(req=0x%08x)", req);
 836     std::map<unsigned int, resource_request_t*>::iterator itr;
 837     itr = m_curDispResOwerReq.find(req->dispzoneid);
 838     if ((m_curDispResOwerReq.end() != itr) && (NULL != itr->second)) {
 839         // already ower
 840         if (itr->second == req) {
 841             ICO_DBG("already ower appid=%s pid=%d surfaceid=0x%08X",
 842                     req->appid, req->pid, req->surfaceid);
 843             return;
 844         }
 845         resource_request_t *popreq = popCurDispResOwerReq(itr->second);
 846         if (NULL != popreq) {
 847             if (NULL != m_winCtrl) {
 848                 // hide current window
 849                 m_winCtrl->hide(popreq->surfaceid, NULL, 0);
 850             }
 851
 852             // state change to waiting
 853             popreq->state = RES_STATE_WAITING;
 854             // enqueue request
 855             ICO_DBG("Enqueue waiting display resource request"
 856                     "(req=0x%08x appid=%s", popreq, popreq->appid);
 857             m_waitingDispResReq.push_front(popreq);
 858 #if 1   //DEBUG
 859         dumpWaitingDispResReq();
 860 #endif  //DEBUG
 861         }
 862     }
 863
 864     if (NULL != m_winCtrl) {
 865         if (-1 == chgzoneid) {
 866             // show request window
 867             m_winCtrl->show(req->surfaceid, req->animation, req->animationTime);
 868         }
 869         else {
 870             // move request window
 871             m_winCtrl->setGeometry(req->surfaceid, req->dispzone,
 872                                    req->animation, req->animationTime,
 873                                    req->animation, req->animationTime);
 874             m_winCtrl->show(req->surfaceid, NULL, 0);
 875         }
 876     }
 877     // state change to acquired
 878     req->state = RES_STATE_ACQUIRED;
 879     // update current zone request
 880     ICO_DBG("Enqueue current display resource ower request"
 881             "(req=0x%08x zoneid=%d appid=%s)",
 882             req, req->dispzoneid, req->appid);
 883     m_curDispResOwerReq[req->dispzoneid] = req;
 884 #if 1   //DEBUG
 885     dumpCurDispResOwerReq();
 886 #endif  //DEBUG
 887
 888     // if current zone ower not exist after zone change
 889     if (-1 != chgzoneid) {
 890         list<resource_request_t*>::iterator itr;
 891         itr = m_waitingDispResReq.begin();
 892         for (; itr !=  m_waitingDispResReq.end(); ++itr) {
 893             if (m_curDispResOwerReq[(*itr)->dispzoneid] != NULL) {
 894                 continue;
 895             }
 896             int type = (*itr)->resid & RESID_TYPE_MASK;
 897             bool active = false;
 898             active = m_policyMgr->acquireDisplayResource(type,
 899                                                          (*itr)->dispzoneid,
 900                                                          (*itr)->prio);
 901             if (true == active) {
 902                 resource_request_t* req = *itr;
 903                 ICO_DBG("Dequeue waiting display resource request"
 904                         "(req=0x%08x appid=%s)", *itr, (*itr)->appid);
 905                 m_waitingDispResReq.erase(itr);
 906 #if 1   //DEBUG
 907                 dumpWaitingDispResReq();
 908 #endif  //DEBUG
 909                 updateDisplayResource(req);
 910                 break;
 911             }
 912         }
 913     }
 914
 915     ICO_DBG("CicoSCResourceManager::updateDisplayResource Leave");
 916 }
 917
 918 void
 919 CicoSCResourceManager::updateSoundResource(resource_request_t *req)
 920 {
 921     ICO_DBG("CicoSCResourceManager::updateSoundResource Enter"
 922             "(req=0x%08x)", req);
 923     for (int i = 0; i < (int)m_curSoundResReq.size(); ++i) {
 924         ICO_DBG("zoneid=%d active=%d current=0x%08x",
 925                 i, m_policyMgr->getSoundZoneState(i), m_curSoundResReq[i]);
 926
 927         if (NULL == m_curSoundResReq[i]) {
 928             continue;
 929         }
 930
 931         if ((i == req->soundzoneid) ||
 932             (false == m_policyMgr->getSoundZoneState(i))) {
 933
 934             // state change to waiting
 935             m_curSoundResReq[i]->state = RES_STATE_WAITING;
 936             // enqueue request
 937             ICO_DBG("Enqueue waiting sound request queue "
 938                     "zone=%d req=0x%08x", i, m_curSoundResReq[i]);
 939             m_soundReqQueue[i].push_front(m_curSoundResReq[i]);
 940             // initialize current zone request
 941             m_curSoundResReq[i] = NULL;
 942         }
 943     }
 944
 945     if (req != m_curSoundResReq[req->soundzoneid]) {
 946         ico_syc_mrp_acquire_sound_resource(req);
 947         ico_syc_mrp_active_app(req->appid);
 948
 949         // state change to acquired
 950         req->state = RES_STATE_ACQUIRED;
 951         // update current zone request
 952         m_curSoundResReq[req->soundzoneid] = req;
 953     }
 954     ICO_DBG("CicoSCResourceManager::updateSoundResource Leave");
 955 }
 956
 957 void
 958 CicoSCResourceManager::updateInputResource(resource_request_t *req)
 959 {
 960     ICO_DBG("CicoSCResourceManager::updateInputResource Enter"
 961             "(req=0x%08x)", req);
 962     for (int i = 0; i < (int)m_curInputResReq.size(); ++i) {
 963         ICO_DBG("input=%d active=%d current=0x%08x",
 964                 i, m_policyMgr->getInputState(i), m_curInputResReq[i]);
 965
 966         if (NULL == m_curInputResReq[i]) {
 967             continue;
 968         }
 969
 970         if ((i == req->input) ||
 971             (false == m_policyMgr->getInputState(i))) {
 972
 973             if (NULL != m_inputCtrl) {
 974                 // add input control
 975                 m_inputCtrl->delInputApp(req->appid, req->device, req->input);
 976             }
 977
 978             // state change to waiting
 979             m_curInputResReq[i]->state = RES_STATE_WAITING;
 980             // enqueue request
 981             ICO_DBG("Enqueue waiting input request queue "
 982                     "zone=%d req=0x%08x", i, m_curInputResReq[i]);
 983             m_inputReqQueue[i].push_front(m_curInputResReq[i]);
 984             // initialize current zone request
 985             m_curInputResReq[i] = NULL;
 986         }
 987     }
 988
 989     if (req != m_curInputResReq[req->input]) {
 990         // delete input control
 991         m_inputCtrl->addInputApp(req->appid, req->device, req->input, 0, 0);
 992         // state change to acquired
 993         req->state = RES_STATE_ACQUIRED;
 994         // update current zone request
 995         m_curInputResReq[req->input] = req;
 996     }
 997     ICO_DBG("CicoSCResourceManager::updateInputResource Leave");
 998 }
 999
1000 void
1001 CicoSCResourceManager::updateDisplayResourceRegulation(int state)
1002 {
1003     ICO_DBG("CicoSCResourceManager::updateDisplayResourceRegulation Enter"
1004             "(state=%d)", state);
1005
1006     if (STID_DRVREGULATION_ON == state) {
1007         bool curchg = false;
1008         std::map<unsigned int, resource_request_t*>::iterator itr;
1009         itr = m_curDispResOwerReq.begin();
1010         for (; itr != m_curDispResOwerReq.end(); ++itr) {
1011             resource_request_t *current = itr->second;
1012             if (NULL == current) {
1013                 continue;
1014             }
1015
1016             int type = current->resid & RESID_TYPE_MASK;
1017             bool active = false;
1018             active = m_policyMgr->acquireDisplayResource(type,
1019                                                          current->dispzoneid,
1020                                                          current->prio);
1021             if (false == active) {
1022                 if (NULL != m_winCtrl) {
1023                     // hide current window
1024                     // TODO animation?
1025                     m_winCtrl->hide(current->surfaceid, NULL, 0);
1026                 }
1027                 curchg = true;
1028             }
1029         }
1030
1031         if (false == curchg) {
1032             ICO_DBG("CicoSCResourceManager::updateDisplayResourceRegulation "
1033                     "Leave");
1034             return;
1035         }
1036
1037         list<resource_request_t*>::iterator itr2;
1038         itr2 = m_waitingDispResReq.begin();
1039         for (; itr2 !=  m_waitingDispResReq.end(); ++itr2) {
1040             int type = (*itr2)->resid & RESID_TYPE_MASK;
1041             bool active = false;
1042             active = m_policyMgr->acquireDisplayResource(type,
1043                                                          (*itr2)->dispzoneid,
1044                                                          (*itr2)->prio);
1045             if (true == active) {
1046                 if (NULL != m_winCtrl) {
1047                     // show current window
1048                     // TODO animation?
1049                     m_winCtrl->show((*itr2)->surfaceid, NULL, 0);
1050                 }
1051                 break;
1052             }
1053         }
1054     }
1055     else if (STID_DRVREGULATION_OFF == state) {
1056         std::map<unsigned int, resource_request_t*>::iterator itr;
1057         itr = m_curDispResOwerReq.begin();
1058         for (; itr != m_curDispResOwerReq.end(); ++itr) {
1059             resource_request_t *current = itr->second;
1060             if (NULL == current) {
1061                 continue;
1062             }
1063
1064             int type = current->resid & RESID_TYPE_MASK;
1065             bool active = false;
1066             active = m_policyMgr->acquireDisplayResource(type,
1067                                                          current->dispzoneid,
1068                                                          current->prio);
1069             if (true == active) {
1070                 if (NULL != m_winCtrl) {
1071                     // hide current window
1072                     // TODO animation?
1073                     m_winCtrl->show(current->surfaceid, NULL, 0);
1074                 }
1075             }
1076         }
1077     }
1078
1079     ICO_DBG("CicoSCResourceManager::updateDisplayResourceRegulation Leave");
1080 }
1081
1082 void
1083 CicoSCResourceManager::updateSoundResourceRegulation(int state)
1084 {
1085     ICO_DBG("CicoSCResourceManager::updateSoundResourceRegulation Enter"
1086             "(state=%d)", state);
1087
1088     bool curchg = false;
1089     for (int i = 0; i < (int)m_curSoundResReq.size(); ++i) {
1090         resource_request_t *current = m_curSoundResReq[i];
1091         if (NULL == current) {
1092             continue;
1093         }
1094
1095         int type = current->resid & RESID_TYPE_MASK;
1096         bool active = false;
1097         active = m_policyMgr->acquireSoundResource(type,
1098                                                    current->soundzoneid,
1099                                                    current->prio);
1100         if (false == active) {
1101             // state change to waiting
1102             current->state = RES_STATE_WAITING;
1103             // enqueue request
1104             ICO_DBG("Enqueue waiting sound request queue "
1105                     "zone=%d req=0x%08x", i, current);
1106             m_soundReqQueue[i].push_front(current);
1107             // initialize current zone request
1108             m_curSoundResReq[i] = NULL;
1109             curchg = true;
1110          }
1111     }
1112
1113     if ((false == curchg) && (STID_DRVREGULATION_ON == state)) {
1114         ICO_DBG("CicoSCResourceManager::updateSoundResourceRegulation Leave");
1115         return;
1116     }
1117
1118     map<int, list<resource_request_t*> >::iterator itr;
1119     itr = m_soundReqQueue.begin();
1120     for (; itr != m_soundReqQueue.end(); ++itr) {
1121         if (NULL != m_curSoundResReq[itr->first]) {
1122             continue;
1123         }
1124
1125         list<resource_request_t*>::iterator itr2;
1126         itr2 = itr->second.begin();
1127         for (; itr2 !=  itr->second.end(); ++itr2) {
1128             int type = (*itr2)->resid & RESID_TYPE_MASK;
1129             bool active = false;
1130             active = m_policyMgr->acquireSoundResource(type,
1131                                                        (*itr2)->soundzoneid,
1132                                                        (*itr2)->prio);
1133             if (true == active) {
1134                 resource_request_t* req = *itr2;
1135                 ICO_DBG("Dequeue waiting sound request queue "
1136                         "zone=%d req=0x%08x", itr->first, *itr2);
1137                 itr->second.erase(itr2);
1138                 updateSoundResource(req);
1139                 break;
1140             }
1141         }
1142     }
1143
1144     ICO_DBG("CicoSCResourceManager::updateSoundResourceRegulation Leave");
1145 }
1146
1147 void
1148 CicoSCResourceManager::updateInputResourceRegulation(int state)
1149 {
1150     ICO_DBG("CicoSCResourceManager::updateInputResourceRegulation Enter"
1151             "(state=%d)", state);
1152
1153     bool curchg = false;
1154     for (int i = 0; i < (int)m_curInputResReq.size(); ++i) {
1155         resource_request_t *current = m_curInputResReq[i];
1156         if (NULL == current) {
1157             continue;
1158         }
1159
1160         bool active = false;
1161         active = m_policyMgr->acquireInputResource(current->input,
1162                                                    current->prio);
1163         if (false == active) {
1164             if (NULL != m_inputCtrl) {
1165                 // hide current window
1166                 m_inputCtrl->delInputApp(current->appid,
1167                                          current->device,
1168                                          current->input);
1169             }
1170             // state change to waiting
1171             current->state = RES_STATE_WAITING;
1172             // enqueue request
1173             ICO_DBG("Enqueue waiting input request queue "
1174                     "zone=%d req=0x%08x", i, current);
1175             m_inputReqQueue[i].push_front(current);
1176             // initialize current zone request
1177             m_curInputResReq[i] = NULL;
1178             curchg = true;
1179          }
1180     }
1181
1182     if ((false == curchg) && (STID_DRVREGULATION_ON == state)) {
1183         ICO_DBG("CicoSCResourceManager::updateInputResourceRegulation Leave");
1184         return;
1185     }
1186
1187     map<int, list<resource_request_t*> >::iterator itr;
1188     itr = m_inputReqQueue.begin();
1189     for (; itr != m_inputReqQueue.end(); ++itr) {
1190         if (NULL != m_curInputResReq[itr->first]) {
1191             continue;
1192         }
1193
1194         list<resource_request_t*>::iterator itr2;
1195         itr2 = itr->second.begin();
1196         for (; itr2 !=  itr->second.end(); ++itr2) {
1197             bool active = false;
1198             active = m_policyMgr->acquireInputResource((*itr2)->input,
1199                                                        (*itr2)->prio);
1200             if (true == active) {
1201                 resource_request_t* req = *itr2;
1202                 ICO_DBG("Dequeue waiting input request queue "
1203                         "zone=%d req=0x%08x", itr->first, *itr2);
1204                 itr->second.erase(itr2);
1205                 updateInputResource(req);
1206                 break;
1207             }
1208         }
1209     }
1210
1211     ICO_DBG("CicoSCResourceManager::updateDisplayResourceRegulation Leave");
1212 }
1213
1214 //--------------------------------------------------------------------------
1215 /**
1216  *  @brief   find currnet dipalay resource ower request
1217  *
1218  *  @param [in] request  compare requset
1219  *
1220  *  @return request object on same requeset found, NULL on not found
1221  */
1222 //--------------------------------------------------------------------------
1223 resource_request_t *
1224 CicoSCResourceManager::findCurDispResOwerReq(resource_request_t *req)
1225 {
1226     if (NULL == req) {
1227         ICO_WRN("invalid argument. req is null");
1228         return NULL;
1229     }
1230     std::map<unsigned int, resource_request_t*>::iterator itr;
1231     itr = m_curDispResOwerReq.begin();
1232     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1233         CompDisplayResourceRequest comp(req);
1234         if (true == comp(itr->second)) {
1235             return itr->second;
1236         }
1237     }
1238     return NULL;
1239 }
1240
1241 //--------------------------------------------------------------------------
1242 /**
1243  *  @brief  pop currnet dipalay resource ower request from list
1244  *
1245  *  @param [in] request  compare requset
1246  *
1247  *  @return request object on same requeset found, NULL on not found
1248  */
1249 //--------------------------------------------------------------------------
1250 resource_request_t *
1251 CicoSCResourceManager::popCurDispResOwerReq(resource_request_t *req)
1252 {
1253     if (NULL == req) {
1254         ICO_WRN("invalid argument. req is null");
1255         return NULL;
1256     }
1257     std::map<unsigned int, resource_request_t*>::iterator itr;
1258     itr = m_curDispResOwerReq.begin();
1259     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1260         CompDisplayResourceRequest comp(req);
1261         if (true == comp(itr->second)) {
1262             ICO_DBG("Dequeue current display reoursce ower request"
1263                     "(req=0x%08x zoneid=%d appid=%s)",
1264                     itr->second, itr->first, itr->second->appid);
1265             resource_request_t *findreq = itr->second;
1266             itr->second = NULL;
1267 #if 1   //DEBUG
1268             dumpCurDispResOwerReq();
1269 #endif  //DEBUG
1270             return findreq;
1271         }
1272     }
1273     return NULL;
1274 }
1275
1276 //--------------------------------------------------------------------------
1277 /**
1278  *  @brief   dump currnet dipalay resource ower request
1279  */
1280 //--------------------------------------------------------------------------
1281 void
1282 CicoSCResourceManager::dumpCurDispResOwerReq(void)
1283 {
1284     std::map<unsigned int, resource_request_t*>::iterator itr;
1285     itr = m_curDispResOwerReq.begin();
1286     for (; itr != m_curDispResOwerReq.end(); ++itr) {
1287         if (NULL == itr->second) {
1288             ICO_DBG("current req=0x%08x zone=%02d:(null) appid=(null)",
1289                     itr->second, itr->first);
1290         }
1291         else {
1292             ICO_DBG("current req=0x%08x zone=%02d:%s appid=%s",
1293                     itr->second, itr->first, itr->second->dispzone,
1294                     itr->second->appid);
1295         }
1296     }
1297 }
1298
1299 //--------------------------------------------------------------------------
1300 /**
1301  *  @brief  find waiting dipalay resource request
1302  *
1303  *  @param [in] request  compare requset
1304  *
1305  *  @return request object on same requeset found, NULL on not found
1306  */
1307 //--------------------------------------------------------------------------
1308 resource_request_t *
1309 CicoSCResourceManager::findWaitingDispResReq(resource_request_t *req)
1310 {
1311     if (NULL == req) {
1312         ICO_WRN("invalid argument. req is null");
1313         return NULL;
1314     }
1315     CompDisplayResourceRequest comp(req);
1316     std::list<resource_request_t*>::iterator itr;
1317     itr = find_if(m_waitingDispResReq.begin(), m_waitingDispResReq.end(), comp);
1318     if (m_waitingDispResReq.end() != itr) {
1319         return *itr;
1320     }
1321     return NULL;
1322 }
1323
1324 //--------------------------------------------------------------------------
1325 /**
1326  *  @brief  pop waiting dipalay resource request from waiting list
1327  *
1328  *  @param [in] request  compare requset
1329  *
1330  *  @return request object on same requeset found, NULL on not found
1331  */
1332 //--------------------------------------------------------------------------
1333 resource_request_t *
1334 CicoSCResourceManager::popWaitingDispResReq(resource_request_t *req)
1335 {
1336     if (NULL == req) {
1337         ICO_WRN("invalid argument. req is null");
1338         return NULL;
1339     }
1340     CompDisplayResourceRequest comp(req);
1341     std::list<resource_request_t*>::iterator itr;
1342     itr = find_if(m_waitingDispResReq.begin(), m_waitingDispResReq.end(), comp);
1343     if (m_waitingDispResReq.end() != itr) {
1344         ICO_DBG("Dequeue waiting display resource request"
1345                 "(req=0x%08x zone:%02d:%s appid=%s)",
1346                 *itr, (*itr)->dispzoneid, (*itr)->dispzone, (*itr)->appid);
1347         resource_request_t *findreq = *itr;
1348         m_waitingDispResReq.erase(itr);
1349 #if 1   //DEBUG
1350         dumpWaitingDispResReq();
1351 #endif  //DEBUG
1352         return findreq;
1353     }
1354     return NULL;
1355 }
1356
1357 //--------------------------------------------------------------------------
1358 /**
1359  *  @brief  dump waiting dipalay resource request
1360  */
1361 //--------------------------------------------------------------------------
1362 void
1363 CicoSCResourceManager::dumpWaitingDispResReq(void)
1364 {
1365     std::list<resource_request_t*>::iterator itr;
1366     itr = m_waitingDispResReq.begin();
1367     for (; itr != m_waitingDispResReq.end(); ++itr) {
1368         if (NULL == *itr) {
1369             ICO_DBG("waiting req=null");
1370         }
1371         else {
1372             ICO_DBG("waiting req=0x%08x zone=%02d:%s appid=%s",
1373                     *itr, (*itr)->dispzoneid, (*itr)->dispzone, (*itr)->appid);
1374         }
1375     }
1376 }
1377 // vim:set expandtab ts=4 sw=4: