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