#include "ico_syc_mrp_resource_private.h"
#include "ico_syc_msg_cmd_def.h"
-#include "CicoSCSystemConfig.h"
-#include "CicoSCConf.h"
+#include "CicoSystemConfig.h"
+#include "CicoConf.h"
#include "CicoSCCommand.h"
#include "CicoSCPolicyManager.h"
#include "CicoSCLifeCycleController.h"
-#include "CicoSCAilItems.h"
+#include "CicoAilItems.h"
+#include "CicoSCWindow.h"
#include "CicoSCWindowController.h"
#include "CicoSCInputController.h"
#include "CicoSCPolicyDef.h"
+#include "CicoSCMessage.h"
+#include "CicoSCMessageRes.h"
+#include "CicoSCServer.h"
struct CompDisplayResourceRequest
{
CicoSCResourceManager::CicoSCResourceManager()
- : m_winCtrl(NULL), m_inputCtrl(NULL)
+ : m_policyMgr(NULL), m_winCtrl(NULL), m_inputCtrl(NULL),
+ m_animaName("Fade"), m_animaTime(400)
{
m_policyMgr = new CicoSCPolicyManager(this);
- CicoSCSystemConfig *sysConf = CicoSCSystemConfig::getInstance();
+ CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
list<resource_request_t*> l;
{
}
}
}
+ m_rrtHO = (resource_request_t*)NULL;
}
CicoSCResourceManager::~CicoSCResourceManager()
int
CicoSCResourceManager::initialize(void)
{
- ICO_DBG("CicoSCResourceManager::initialize Enter");
+ ICO_TRA("CicoSCResourceManager::initialize Enter");
int ret = ICO_SYC_EOK;
ret = ico_syc_mrp_init(enforceSound, this);
if (ICO_SYC_EOK != ret) {
+ ICO_TRA("CicoSCResourceManager::initialize Leave");
return ret;
}
ret = m_policyMgr->initialize();
if (ICO_SYC_EOK != ret) {
+ ICO_TRA("CicoSCResourceManager::initialize Leave");
return ret;
}
- ICO_DBG("CicoSCResourceManager::initialize Leave");
+ ICO_TRA("CicoSCResourceManager::initialize Leave");
return ret;
}
-
+
void
CicoSCResourceManager::terminate(void)
{
- ICO_DBG("CicoSCResourceManager::terminate Enter");
+ ICO_TRA("CicoSCResourceManager::terminate Enter");
m_policyMgr->terminate();
- ICO_DBG("CicoSCResourceManager::terminate Leave");
+ ico_syc_mrp_term();
+ ICO_TRA("CicoSCResourceManager::terminate Leave");
}
void
CicoSCResourceManager::handleCommand(const CicoSCCommand &cmd,
bool internal)
{
- ICO_DBG("CicoSCResourceManager::handleCommand Enter"
- "(cmdid=0x%08X internal=%s)",
+ ICO_TRA("CicoSCResourceManager::handleCommand Enter"
+ "(cmdid=0x%08x internal=%s)",
cmd.cmdid, internal ? "true" : "false");
CicoSCCmdResCtrlOpt *opt = (CicoSCCmdResCtrlOpt*)cmd.opt;
// request command from application or internal
int reqtype = internal ? REQTYPE_AUTO : REQTYPE_APP;
-
if ((MSG_CMD_CREATE_RES == cmd.cmdid) ||
(MSG_CMD_ACQUIRE_RES == cmd.cmdid)) {
-
+
if (true == opt->dispres) {
resource_request_t *req = newResourceRequest(RESID_KIND_DISPLAY,
reqtype,
acquireDisplayResource(req, false);
}
else {
- acquireDisplayResource(req);
+ // cmdid is MSG_CMD_ACQUIRE_RES
+ if (true == isTypeOnScreen(*req)) {
+ acquireOnScreenDisplayResource(req);
+ }
+ else
+ if ((true == m_policyMgr->getRegulation()) &&
+ (false == isMatchDisplayed())) {
+ updateDispResRegulationPreProc(req);
+ updateDisplayResourceRegulation(STID_DRVREGULATION_ON);
+ }
+ else {
+ acquireDisplayResource(req);
+ }
}
}
resource_request_t *req = newResourceRequest(RESID_KIND_SOUND,
reqtype,
cmd);
- acquireSoundResource(req);
+ if ((true == m_policyMgr->getRegulation()) &&
+ (false == isMatchDisplayed())) {
+ updateSoundResRegulationPreProc(req);
+ updateSoundResourceRegulation(STID_DRVREGULATION_ON);
+ }
+ else {
+ acquireSoundResource(req);
+ }
+
}
if (true == opt->inputres) {
resource_request_t *req = newResourceRequest(RESID_KIND_INPUT,
reqtype,
cmd);
- acquireInputResource(req);
+ if ((true == m_policyMgr->getRegulation()) &&
+ (false == isMatchDisplayed())) {
+ updateInputResRegulationPreProc(req);
+ updateInputResourceRegulation(STID_DRVREGULATION_ON);
+ }
+ else {
+ acquireInputResource(req);
+ }
}
}
else if ((MSG_CMD_RELEASE_RES == cmd.cmdid) ||
resource_request_t *req = newResourceRequest(RESID_KIND_DISPLAY,
reqtype,
cmd);
- releaseDisplayResource(req);
+ if (true == isTypeOnScreen(*req)) {
+ releaseOnScreenDisplayResource(req);
+ }
+ else {
+ releaseDisplayResource(req);
+ }
}
if (true == opt->soundres) {
resource_request_t *req = newResourceRequest(RESID_KIND_SOUND,
ICO_WRN("Unknown command");
}
- ICO_DBG("CicoSCResourceManager::handleCommand Leave");
+ ICO_TRA("CicoSCResourceManager::handleCommand Leave");
}
void
}
#if 0
-resource_request_t *
+resource_request_t *
CicoSCResourceManager::popDispResReq(resource_request_t *req)
{
- ICO_DBG("CicoSCResourceManager::popDispResReq Enter");
+ ICO_TRA("CicoSCResourceManager::popDispResReq Enter");
map<int, list<resource_request_t*> >::iterator itr;
itr = m_dispReqQueue.begin();
ICO_DBG("Dequeue waiting display request queue zone=%d req=0x%08x",
itr->first, *itr2);
m_dispReqQueue[req->dispzoneid].erase(itr2);
- ICO_DBG("CicoSCResourceManager::popDispResReq Leave"
+ ICO_TRA("CicoSCResourceManager::popDispResReq Leave"
"(0x%08x)", *itr2);
return *itr2;
}
}
- ICO_DBG("CicoSCResourceManager::popDispResReq Leave(NULL)");
+ ICO_TRA("CicoSCResourceManager::popDispResReq Leave(NULL)");
return NULL;
}
#endif
resource_request_t *
CicoSCResourceManager::popSoundResReq(resource_request_t *req)
{
- ICO_DBG("CicoSCResourceManager::popSoundResReq Enter");
+ ICO_TRA("CicoSCResourceManager::popSoundResReq Enter");
map<int, list<resource_request_t*> >::iterator itr;
itr = m_soundReqQueue.begin();
list<resource_request_t*>::iterator itr2;
itr2 = find_if(itr->second.begin(), itr->second.end(), comp);
if (itr->second.end() != itr2) {
- ICO_DBG("Dequeue waiting sound request queue zone=%d req=0x%08x",
- itr->first, *itr2);
+ ICO_DBG("Dequeue waiting sound request queue"
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ *itr2, itr->first, (*itr2)->soundzone, (*itr2)->appid);
m_soundReqQueue[req->soundzoneid].erase(itr2);
- ICO_DBG("CicoSCResourceManager::popSoundResReq Leave"
+ ICO_TRA("CicoSCResourceManager::popSoundResReq Leave"
"(0x%08x)", *itr2);
return *itr2;
}
}
- ICO_DBG("CicoSCResourceManager::popSoundResReq Leave(NULL)");
+ ICO_TRA("CicoSCResourceManager::popSoundResReq Leave(NULL)");
return NULL;
}
-resource_request_t *
+resource_request_t *
CicoSCResourceManager::popInputResReq(resource_request_t *req)
{
- ICO_DBG("CicoSCResourceManager::popInputResReq Enter");
+ ICO_TRA("CicoSCResourceManager::popInputResReq Enter");
map<int, list<resource_request_t*> >::iterator itr;
itr = m_inputReqQueue.begin();
list<resource_request_t*>::iterator itr2;
itr2 = find_if(itr->second.begin(), itr->second.end(), comp);
if (itr->second.end() != itr2) {
- ICO_DBG("Dequeue waiting input request queue input=%d req=0x%08x",
- itr->first, *itr2);
+ ICO_DBG("Dequeue waiting input request queue"
+ "(req=0x%08x input:%d appid=%s)",
+ *itr2, (*itr2)->input, (*itr2)->appid);
m_inputReqQueue[req->input].erase(itr2);
- ICO_DBG("CicoSCResourceManager::popInputResReq Leave"
+ ICO_TRA("CicoSCResourceManager::popInputResReq Leave"
"(0x%08x)", *itr2);
return *itr2;
}
}
- ICO_DBG("CicoSCResourceManager::popDispResReq Leave(NULL)");
+ ICO_TRA("CicoSCResourceManager::popDispResReq Leave(NULL)");
return NULL;
}
CicoSCResourceManager::acquireDisplayResource(resource_request_t *newreq,
bool control)
{
- ICO_DBG("CicoSCResourceManager::acquireDisplayResource Enter");
+ ICO_TRA("CicoSCResourceManager::acquireDisplayResource Enter");
- CicoSCSystemConfig *sysConf = CicoSCSystemConfig::getInstance();
+ CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
const CicoSCAppKindConf *appKindConf = NULL;
appKindConf = sysConf->findAppKindConfbyId(newreq->appkind);
if (NULL == appKindConf) {
ICO_ERR("not found CicoSCAppKindConf instance");
- ICO_DBG("CicoSCResourceManager::acquireDisplayResource Leave(false)");
+ ICO_TRA("CicoSCResourceManager::acquireDisplayResource Leave(false)");
return false;
}
delResourceRequest(newreq);
ICO_DBG("kind of system application");
- ICO_DBG("CicoSCResourceManager::acquireDisplayResource Leave(true)");
+ ICO_TRA("CicoSCResourceManager::acquireDisplayResource Leave(true)");
return true;
}
req->dispzone, newreq->dispzone);
if (req->dispzoneid != newreq->dispzoneid) {
req = popCurDispResOwerReq(req);
+ m_policyMgr->releaseDisplayResource(req->dispzoneid, req->prio);
chgzone = newreq->dispzoneid;
}
}
}
}
- //
+ bool displayMatch = false;
+ //
if (req != newreq) {
+ char zoneO[128],zoneN[128];
+ zoneO[0] = zoneN[0] = '\0';
+ if ((NULL != req) && (NULL != req->dispzone)) {
+ char* d = zoneO;
+ const char* s = req->dispzone;
+ while ('\0' != *s) { // is stop code
+ if ('.' == *s) { // DISPLAY.ZONE found a period
+ break; // break of while
+ }
+ *d++ = *s++; // char copy
+ }
+ *d='\0'; // set stop code
+ }
+ if ((NULL != newreq) && (NULL != newreq->dispzone)) {
+ char* d = zoneO;
+ const char* s = newreq->dispzone;
+ while ('\0' != *s) { // is stop code
+ if ('.' == *s) { // DISPLAY.ZONE found a period
+ break; // break of while
+ }
+ *d++ = *s++; // char copy
+ }
+ *d='\0'; // set stop code
+ }
+ if ((0 != strlen(zoneO)) || (0 != strlen(zoneN))) {
+ if (0 == strcmp(zoneO, zoneN)) {
+ displayMatch = true;
+ }
+ }
// update request data
req->dispzoneid = newreq->dispzoneid;
- if (NULL != req->dispzone) free(req->dispzone);
+ free(req->dispzone);
req->dispzone = strdup(newreq->dispzone);
- if (NULL != req->animation) free(req->animation);
+ req->layerid = newreq->layerid;
+ free(req->animation);
req->animation = strdup(newreq->animation);
req->animationTime = newreq->animationTime;
// delete new request
delResourceRequest(newreq);
}
-
+
if (false == control) {
- ICO_DBG("Enqueue waiting display resource request"
+ ICO_TRA("Enqueue waiting display resource request"
"(req=0x%08x appid=%s)", req, req->appid);
m_waitingDispResReq.push_front(req);
#if 1 //DEBUG
bool state = m_policyMgr->acquireDisplayResource(type,
req->dispzoneid,
req->prio);
- if (true == state) {
+ if ((true == state) && (false == displayMatch)){
updateDisplayResource(req, chgzone);
}
else {
+ if ((-1 != chgzone) || (true == displayMatch)) {
+ if (NULL != m_winCtrl) {
+ // move request window
+ m_winCtrl->setGeometry(req->surfaceid, req->dispzone, req->layerid,
+ req->animation, req->animationTime,
+ req->animation, req->animationTime);
+ }
+ }
+ else {
+ // just in case, hide window
+ if (NULL != m_winCtrl) {
+ // hide request window
+ m_winCtrl->hide(req->surfaceid, NULL, 0);
+ }
+ }
ICO_DBG("Enqueue waiting display resource request"
- "(req=0x%08x appid=%s)", req, req->appid);
+ "(req=0x%08x appid=%s)", req, req->appid);
m_waitingDispResReq.push_front(req);
#if 1 //DEBUG
dumpWaitingDispResReq();
#endif //DEBUG
}
-
- ICO_DBG("CicoSCResourceManager::acquireDisplayResource Leave");
+ ICO_TRA("CicoSCResourceManager::acquireDisplayResource Leave");
return true;
}
void
CicoSCResourceManager::releaseDisplayResource(resource_request_t *newreq)
{
- ICO_DBG("CicoSCResourceManager::releaseDisplayResource Enter"
+ ICO_TRA("CicoSCResourceManager::releaseDisplayResource Enter"
"(newreq=0x%08x)", newreq);
// if exist in wating request list, pop request
if (NULL != req) {
delResourceRequest(req);
delResourceRequest(newreq);
- ICO_DBG("CicoSCResourceManager::releaseDisplayResource Leave");
+ ICO_TRA("CicoSCResourceManager::releaseDisplayResource Leave");
return;
}
// if exist current ower request, pop request
req = popCurDispResOwerReq(newreq);
if (NULL != req) {
+ m_policyMgr->releaseDisplayResource(req->dispzoneid, req->prio);
delResourceRequest(req);
}
delResourceRequest(newreq);
list<resource_request_t*>::iterator itr;
itr = m_waitingDispResReq.begin();
for (; itr != m_waitingDispResReq.end(); ++itr) {
+ if (NULL != m_curDispResOwerReq[(*itr)->dispzoneid]) {
+ continue;
+ }
int type = (*itr)->resid & RESID_TYPE_MASK;
bool active = m_policyMgr->acquireDisplayResource(type,
(*itr)->dispzoneid,
if (true == active) {
resource_request_t* popreq = popWaitingDispResReq(*itr);
updateDisplayResource(popreq);
- m_winCtrl->active(popreq->surfaceid, -1);
+ m_winCtrl->activeCB(NULL, NULL, popreq->surfaceid, -1);
break;
}
}
- ICO_DBG("CicoSCResourceManager::releaseDisplayResource Leave");
+ ICO_TRA("CicoSCResourceManager::releaseDisplayResource Leave");
}
bool
CicoSCResourceManager::acquireSoundResource(resource_request_t *newreq)
{
- ICO_DBG("CicoSCResourceManager::acquireSoundResource Enter");
+ ICO_TRA("CicoSCResourceManager::acquireSoundResource Enter");
- CicoSCSystemConfig *sysConf = CicoSCSystemConfig::getInstance();
+ CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
const CicoSCAppKindConf *appKindConf = NULL;
appKindConf = sysConf->findAppKindConfbyId(newreq->appkind);
if (NULL == appKindConf) {
ICO_ERR("not found CicoSCAppKindConf instance");
- ICO_DBG("CicoSCResourceManager::acquireSoundResource Leave(false)");
+ ICO_TRA("CicoSCResourceManager::acquireSoundResource Leave(false)");
return false;
}
delResourceRequest(newreq);
ICO_DBG("kind of system application");
- ICO_DBG("CicoSCResourceManager::acquireSoundResource Leave(true)");
+ ICO_TRA("CicoSCResourceManager::acquireSoundResource Leave(true)");
return true;
}
// is change zone?
CompSoundResourceRequest comp(req);
if (true == comp(m_curSoundResReq[req->soundzoneid])) {
- ICO_DBG("already acquired appid=%s pid=%d soundid=0x%08X",
+ ICO_DBG("already acquired appid=%s pid=%d soundid=0x%08x",
req->appid, req->pid, req->soundid);
- ICO_DBG("CicoSCResourceManager::acquireSoundResource Leave(true)");
+ ICO_TRA("CicoSCResourceManager::acquireSoundResource Leave(true)");
// free new request
delResourceRequest(newreq);
return true;
updateSoundResource(req);
}
else {
- ICO_DBG("Enqueue waiting sound request queue zone=%d req=0x%08x",
- req->soundzoneid, req);
+ ICO_DBG("Enqueue waiting sound request queue"
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ req, req->soundzoneid, req->soundzone, req->appid);
m_soundReqQueue[req->soundzoneid].push_front(req);
}
- ICO_DBG("CicoSCResourceManager::acquireSoundResource Leave");
+ ICO_TRA("CicoSCResourceManager::acquireSoundResource Leave");
return true;
}
void
CicoSCResourceManager::releaseSoundResource(resource_request_t *newreq)
{
- ICO_DBG("CicoSCResourceManager::releaseSoundResource Enter");
+ ICO_TRA("CicoSCResourceManager::releaseSoundResource Enter");
bool curchg = false;
CompSoundResourceRequest comp(newreq);
}
if (true == comp(m_curSoundResReq[i])) {
+ ICO_DBG("Dequeue current sound resource ower request"
+ "(req=0x%08x zoneid=%02d:%s appid=%s)",
+ m_curSoundResReq[i], m_curSoundResReq[i]->dispzoneid,
+ m_curSoundResReq[i]->dispzone,
+ m_curSoundResReq[i]->appid);
+ ICO_PRF("CHG_GUI_RES sound deprived zone=%02d:%s appid=%s",
+ m_curSoundResReq[i]->dispzoneid,
+ m_curSoundResReq[i]->dispzone,
+ m_curSoundResReq[i]->appid);
ico_syc_mrp_release_sound_resource(m_curSoundResReq[i]);
delResourceRequest(newreq);
delResourceRequest(m_curSoundResReq[i]);
}
}
- // If current request is not changed,
+ // If current request is not changed,
// remove the request from the waiting queue.
if (false == curchg) {
resource_request_t *req = popSoundResReq(newreq);
req = NULL;
}
delResourceRequest(newreq);
- ICO_DBG("CicoSCResourceManager::releaseSoundResource Leave");
+ ICO_TRA("CicoSCResourceManager::releaseSoundResource Leave");
return;
}
list<resource_request_t*>::iterator itr2;
itr2 = itr->second.begin();
for (; itr2 != itr->second.end(); ++itr2) {
+ if (NULL != m_curSoundResReq[(*itr2)->soundzoneid]) {
+ continue;
+ }
+
int type = (*itr2)->resid & RESID_TYPE_MASK;
bool active = m_policyMgr->acquireSoundResource(type,
(*itr2)->soundzoneid,
if (true == active) {
resource_request_t* req = *itr2;
ICO_DBG("Dequeue waiting sound request queue "
- "zone=%d req=0x%08x", itr->first, *itr2);
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ *itr2, itr->first, (*itr2)->soundzone, (*itr2)->appid);
itr->second.erase(itr2);
updateSoundResource(req);
break;
}
}
- ICO_DBG("CicoSCResourceManager::releaseSoundResource Leave");
+ ICO_TRA("CicoSCResourceManager::releaseSoundResource Leave");
}
bool
CicoSCResourceManager::acquireInputResource(resource_request_t *newreq)
{
- ICO_DBG("CicoSCResourceManager::acquireInputResource Enter");
+ ICO_TRA("CicoSCResourceManager::acquireInputResource Enter");
resource_request_t *req = popInputResReq(newreq);
if (NULL == req) {
// is change zone?
CompInputResourceRequest comp(req);
if (true == comp(m_curInputResReq[req->input])) {
- ICO_DBG("already acquired appid=%s pid=%d input=0x%08X",
+ ICO_DBG("already acquired appid=%s pid=%d input=0x%08x",
req->appid, req->pid, req->input);
- ICO_DBG("CicoSCResourceManager::acquireInputResource Leave(true)");
+ ICO_TRA("CicoSCResourceManager::acquireInputResource Leave(true)");
// free new request
delResourceRequest(newreq);
return true;
updateInputResource(req);
}
else {
- ICO_DBG("Enqueue waiting input request queue input=%d req=0x%08x",
- req->input, req);
+ ICO_DBG("Enqueue waiting input request queue"
+ "(req=0x%08x input:%d appid=%s)", req, req->input, req->appid);
m_inputReqQueue[req->input].push_front(req);
}
- ICO_DBG("CicoSCResourceManager::acquireInputResource Leave");
+ ICO_TRA("CicoSCResourceManager::acquireInputResource Leave(true)");
return true;
}
void
CicoSCResourceManager::releaseInputResource(resource_request_t *newreq)
{
+ ICO_TRA("CicoSCResourceManager::releaseInputResource Enter");
bool curchg = false;
CompInputResourceRequest comp(newreq);
for (int i = 0; i < (int)m_curInputResReq.size(); ++i) {
m_curInputResReq[i]->device,
m_curInputResReq[i]->input);
}
+ ICO_DBG("Dequeue current input resource ower request"
+ "(req=0x%08x input=%d appid=%s)",
+ m_curInputResReq[i], m_curInputResReq[i]->input,
+ m_curInputResReq[i]->appid);
+ ICO_PRF("CHG_GUI_RES input deprived input=%d appid=%s",
+ m_curInputResReq[i]->input, m_curInputResReq[i]->appid);
delResourceRequest(newreq);
delResourceRequest(m_curInputResReq[i]);
m_curInputResReq[i] = NULL;
}
}
- // If current request is not changed,
+ // If current request is not changed,
// remove the request from the waiting queue.
if (false == curchg) {
resource_request_t *req = popInputResReq(newreq);
req = NULL;
}
delResourceRequest(newreq);
- ICO_DBG("CicoSCResourceManager::releaseInputResource Leave");
+ ICO_TRA("CicoSCResourceManager::releaseInputResource Leave");
return;
}
list<resource_request_t*>::iterator itr2;
itr2 = itr->second.begin();
for (; itr2 != itr->second.end(); ++itr2) {
+ if (NULL != m_curInputResReq[(*itr2)->input]) {
+ continue;
+ }
bool active = m_policyMgr->acquireInputResource((*itr2)->input,
(*itr2)->prio);
if (true == active) {
resource_request_t* req = *itr2;
ICO_DBG("Dequeue waiting input request queue "
- "input=%d req=0x%08x", itr->first, *itr2);
+ "(req=0x%08x input:%d appid=%s)",
+ *itr2, (*itr2)->input, (*itr2)->appid);
itr->second.erase(itr2);
updateInputResource(req);
break;
}
}
}
+ ICO_TRA("CicoSCResourceManager::releaseInputResource Leave");
}
resource_request_t *
int reqtype,
const CicoSCCommand &cmd)
{
- ICO_DBG("CicoSCResourceManager::newResourceRequest Enter");
+ ICO_TRA("CicoSCResourceManager::newResourceRequest Enter");
resource_request_t *req = NULL;
req = (resource_request_t*)calloc(1, sizeof(resource_request_t));
CicoSCCmdResCtrlOpt *opt = (CicoSCCmdResCtrlOpt*)cmd.opt;
- CicoSCSystemConfig *systemConfig = CicoSCSystemConfig::getInstance();
+ CicoSystemConfig *systemConfig = CicoSystemConfig::getInstance();
req->reqtype = reqtype;
CicoSCLifeCycleController *lifeCycle =
CicoSCLifeCycleController::getInstance();
- const CicoSCAilItems* ailItem = lifeCycle->findAIL(cmd.appid);
+ const CicoAilItems* ailItem = lifeCycle->findAIL(cmd.appid);
if (NULL != ailItem) {
req->category = ailItem->m_categoryID;
req->appkind = ailItem->m_kindID;
}
req->prio = req->category;
-
+
req->released = 0;
/* set resource id */
- req->resid = RESID_TYPE_BASIC;
- if (1 == opt->type) {
+ switch (opt->type) {
+ case ICO_SYC_RES_INTERRUPT:
req->resid = RESID_TYPE_INTERRUPT;
+ break;
+ case ICO_SYC_RES_ONSCREEN:
+ req->resid = RESID_TYPE_ONSCREEN;
+ break;
+ default: // include case ICO_SYC_RES_BASIC:
+ req->resid = RESID_TYPE_BASIC;
+ break;
}
req->resid |= resid;
if (resid == RESID_KIND_DISPLAY) {
req->dispzone = strdup(opt->dispzone.c_str());
req->dispzoneid = systemConfig->getDizplayZoneIdbyFullName(req->dispzone);
+ req->layerid = opt->layerid;
req->winname = strdup(opt->winname.c_str());
req->surfaceid = opt->surfaceid;
- req->id = opt->surfaceid;;
+ req->id = opt->surfaceid;
req->animation = strdup(opt->animation.c_str());
req->animationTime = opt->animationTime;
+ req->bEx = opt->dispresEx;
+ req->ECU = strdup(opt->ECU.c_str()); // name to identify ECU
+ req->display = strdup(opt->display.c_str()); // name to identify Display in ECU
+ req->layer = strdup(opt->layer.c_str()); // name to identify Layer in Display
+ req->layout = strdup(opt->layout.c_str()); // name to identify layout in Layer
+ req->area = strdup(opt->area.c_str()); // name to Output position in Layout
+ req->dispatchApp= strdup(opt->dispatchApp.c_str()); // dispatch of application
+ req->role = strdup(opt->role.c_str()); // role of notice
+ req->resourceId = opt->resourceID; // ID number of resource
}
else if (resid == RESID_KIND_SOUND) {
req->soundzone = strdup(opt->soundzone.c_str());
req->id = opt->input;
}
- ICO_DBG("CicoSCResourceManager::newResourceRequest Leave"
+ ICO_TRA("CicoSCResourceManager::newResourceRequest Leave"
"(req=0x%08x appid=%s)", req, req->appid);
return req;
}
{
if (NULL == req) return;
- if (NULL != req->appid) free(req->appid);
- if (NULL != req->dispzone) free(req->dispzone);
- if (NULL != req->winname) free(req->winname);
- if (NULL != req->animation) free(req->animation);
- if (NULL != req->soundzone) free(req->soundzone);
- if (NULL != req->soundname) free(req->soundname);
- if (NULL != req->device) free(req->device);
-
+ free(req->appid);
+ free(req->dispzone);
+ free(req->winname);
+ free(req->animation);
+ free(req->soundzone);
+ free(req->soundname);
+ free(req->device);
+ free(req->ECU); // name to identify ECU
+ free(req->display); // name to identify Display in ECU
+ free(req->layer); // name to identify Layer in Display
+ free(req->layout); // name to identify layout in Layer
+ free(req->area); // name to Output position in Layout
+ free(req->dispatchApp); // origin of application
+ free(req->role); // role of notice
free(req);
}
resource_request_t *req,
void *user_data)
{
- ICO_DBG("CicoSCResourceManager::enforceSound Enter");
+ ICO_TRA("CicoSCResourceManager::enforceSound Enter");
/* NOP */
- ICO_DBG("CicoSCResourceManager::enforceSound Leave");
+ ICO_TRA("CicoSCResourceManager::enforceSound Leave");
}
-
+
// receive changed state
void
CicoSCResourceManager::receiveChangedState(int state)
{
- ICO_DBG("CicoSCResourceManager::receiveChangedState Enter"
+ ICO_TRA("CicoSCResourceManager::receiveChangedState Enter"
"(state=%d)", state);
- if ((STID_DRVREGULATION_ON == state)||
- (STID_DRVREGULATION_OFF == state)) {
-
+ if (STID_DRVREGULATION_ON == state) {
+ if (true == isMatchDisplayed()) {
+ updateDisplayResourceRegulation(state);
+ updateSoundResourceRegulation(state);
+ updateInputResourceRegulation(state);
+ }
+ }
+ else {
updateDisplayResourceRegulation(state);
updateSoundResourceRegulation(state);
updateInputResourceRegulation(state);
}
- ICO_DBG("CicoSCResourceManager::receiveChangedState Leave");
+ ICO_TRA("CicoSCResourceManager::receiveChangedState Leave");
}
//--------------------------------------------------------------------------
CicoSCResourceManager::updateDisplayResource(resource_request_t *req,
int chgzoneid)
{
- ICO_DBG("CicoSCResourceManager::updateDisplayResource Enter"
+ ICO_TRA("CicoSCResourceManager::updateDisplayResource Enter"
"(req=0x%08x)", req);
+
std::map<unsigned int, resource_request_t*>::iterator itr;
itr = m_curDispResOwerReq.find(req->dispzoneid);
if ((m_curDispResOwerReq.end() != itr) && (NULL != itr->second)) {
// already ower
if (itr->second == req) {
- ICO_DBG("already ower appid=%s pid=%d surfaceid=0x%08X",
+ ICO_DBG("already ower appid=%s pid=%d surfaceid=%08x",
req->appid, req->pid, req->surfaceid);
// show request window
m_winCtrl->show(req->surfaceid, req->animation, req->animationTime);
- m_winCtrl->active(req->surfaceid, -1);
+#if 0
+ m_winCtrl->activeCB(NULL, NULL, req->surfaceid, -1);
+#endif
+ ICO_TRA("CicoSCResourceManager::updateDisplayResource Leave");
return;
}
resource_request_t *popreq = popCurDispResOwerReq(itr->second);
popreq->state = RES_STATE_WAITING;
// enqueue request
ICO_DBG("Enqueue waiting display resource request"
- "(req=0x%08x appid=%s", popreq, popreq->appid);
+ "(req=0x%08x zone=%02d:%s appid=%s",
+ popreq, popreq->dispzoneid,
+ popreq->dispzone, popreq->appid);
m_waitingDispResReq.push_front(popreq);
#if 1 //DEBUG
dumpWaitingDispResReq();
#endif //DEBUG
}
}
-
+
+ std::map<unsigned int, resource_request_t*>::iterator itr2;
+ itr2 = m_curDispResOwerReq.begin();
+ for (; itr2 != m_curDispResOwerReq.end(); ++itr2) {
+ resource_request_t *tmpreq = itr2->second;
+
+ if (true == m_policyMgr->getDispZoneState(itr2->first)) {
+ continue;
+ }
+
+ if (NULL == itr2->second) {
+ continue;
+ }
+
+ ICO_DBG("Dequeue current display resource ower request"
+ "(req=0x%08x zoneid=%02d:%s appid=%s)",
+ tmpreq, tmpreq->dispzoneid, tmpreq->dispzone, tmpreq->appid);
+ ICO_PRF("CHG_GUI_RES display deprived zone=%02d:%s appid=%s",
+ tmpreq->dispzoneid, tmpreq->dispzone, tmpreq->appid);
+ itr2->second = NULL;
+
+ // hide current window
+ m_winCtrl->hide(tmpreq->surfaceid, NULL, 0);
+
+ ICO_DBG("Enqueue waiting display resource request"
+ "(req=0x%08x zone=%02d:%s appid=%s",
+ tmpreq, tmpreq->dispzoneid, tmpreq->dispzone, tmpreq->appid);
+ m_waitingDispResReq.push_front(tmpreq);
+ }
+
if (NULL != m_winCtrl) {
+ int ret = ICO_SYC_EOK;
if (-1 != chgzoneid) {
// move request window
- m_winCtrl->setGeometry(req->surfaceid, req->dispzone,
- req->animation, req->animationTime,
- req->animation, req->animationTime);
+ ret = m_winCtrl->setGeometry(req->surfaceid, req->dispzone,
+ req->layerid,
+ req->animation, req->animationTime,
+ req->animation, req->animationTime);
+ if (ICO_SYC_EOK != ret) {
+ return;
+ }
}
+
// show request window
m_winCtrl->show(req->surfaceid, req->animation, req->animationTime);
}
req->state = RES_STATE_ACQUIRED;
// update current zone request
ICO_DBG("Enqueue current display resource ower request"
- "(req=0x%08x zoneid=%d appid=%s)",
- req, req->dispzoneid, req->appid);
+ "(req=0x%08x zoneid=%02d:%s appid=%s)",
+ req, req->dispzoneid, req->dispzone, req->appid);
+ ICO_PRF("CHG_GUI_RES display acquired zone=%02d:%s appid=%s",
+ req->dispzoneid, req->dispzone, req->appid);
m_curDispResOwerReq[req->dispzoneid] = req;
#if 1 //DEBUG
dumpCurDispResOwerReq();
if (m_curDispResOwerReq[(*itr)->dispzoneid] != NULL) {
continue;
}
+
+ if (true == m_policyMgr->isExistDisplayZoneOwer((*itr)->dispzoneid)) {
+ continue;
+ }
+
int type = (*itr)->resid & RESID_TYPE_MASK;
bool active = false;
active = m_policyMgr->acquireDisplayResource(type,
if (true == active) {
resource_request_t* req = *itr;
ICO_DBG("Dequeue waiting display resource request"
- "(req=0x%08x appid=%s)", *itr, (*itr)->appid);
+ "(req=0x%08x zone=%02d:%s appid=%s)",
+ *itr, (*itr)->dispzoneid,
+ (*itr)->dispzone, (*itr)->appid);
m_waitingDispResReq.erase(itr);
#if 1 //DEBUG
dumpWaitingDispResReq();
#endif //DEBUG
updateDisplayResource(req);
+#if 0
m_winCtrl->active(req->surfaceid, -1);
+#endif
break;
}
}
}
- ICO_DBG("CicoSCResourceManager::updateDisplayResource Leave");
+ ICO_TRA("CicoSCResourceManager::updateDisplayResource Leave");
}
void
CicoSCResourceManager::updateSoundResource(resource_request_t *req)
{
- ICO_DBG("CicoSCResourceManager::updateSoundResource Enter"
+ ICO_TRA("CicoSCResourceManager::updateSoundResource Enter"
"(req=0x%08x)", req);
for (int i = 0; i < (int)m_curSoundResReq.size(); ++i) {
ICO_DBG("zoneid=%d active=%d current=0x%08x",
m_curSoundResReq[i]->state = RES_STATE_WAITING;
// enqueue request
ICO_DBG("Enqueue waiting sound request queue "
- "zone=%d req=0x%08x", i, m_curSoundResReq[i]);
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ m_curSoundResReq[i], i,
+ m_curSoundResReq[i]->soundzone, m_curSoundResReq[i]->appid);
m_soundReqQueue[i].push_front(m_curSoundResReq[i]);
+
// initialize current zone request
+ ICO_DBG("Dequeue current sound request queue "
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ m_curSoundResReq[i], i,
+ m_curSoundResReq[i]->soundzone, m_curSoundResReq[i]->appid);
+ ICO_PRF("CHG_GUI_RES sound deprived zone=%02d:%s appid=%s",
+ i, m_curSoundResReq[i]->soundzone,
+ m_curSoundResReq[i]->appid);
m_curSoundResReq[i] = NULL;
}
}
// state change to acquired
req->state = RES_STATE_ACQUIRED;
// update current zone request
+ ICO_DBG("Enqueue current sound request queue "
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ req, req->soundzoneid, req->soundzone, req->appid);
+ ICO_PRF("CHG_GUI_RES sound acquired zone=%02d:%s appid=%s",
+ req->soundzoneid, req->soundzone, req->appid);
m_curSoundResReq[req->soundzoneid] = req;
}
- ICO_DBG("CicoSCResourceManager::updateSoundResource Leave");
+ ICO_TRA("CicoSCResourceManager::updateSoundResource Leave");
}
void
CicoSCResourceManager::updateInputResource(resource_request_t *req)
{
- ICO_DBG("CicoSCResourceManager::updateInputResource Enter"
+ ICO_TRA("CicoSCResourceManager::updateInputResource Enter"
"(req=0x%08x)", req);
for (int i = 0; i < (int)m_curInputResReq.size(); ++i) {
ICO_DBG("input=%d active=%d current=0x%08x",
m_curInputResReq[i]->state = RES_STATE_WAITING;
// enqueue request
ICO_DBG("Enqueue waiting input request queue "
- "zone=%d req=0x%08x", i, m_curInputResReq[i]);
+ "(req=0x%08x input:%d appid=%s)",
+ m_curInputResReq[i], i, m_curInputResReq[i]->appid);
m_inputReqQueue[i].push_front(m_curInputResReq[i]);
// initialize current zone request
+ ICO_DBG("Dequeue current input request queue "
+ "(req=0x%08x input:%d appid=%s)",
+ m_curInputResReq[i],
+ m_curInputResReq[i]->input, m_curInputResReq[i]->appid);
+ ICO_PRF("CHG_GUI_RES input deprived input=%d appid=%s",
+ m_curInputResReq[i]->input,
+ m_curInputResReq[i]->appid);
m_curInputResReq[i] = NULL;
}
}
// state change to acquired
req->state = RES_STATE_ACQUIRED;
// update current zone request
+ ICO_DBG("Enqueue current input request queue "
+ "(req=0x%08x input:%d appid=%s)", req, req->input, req->appid);
+ ICO_PRF("CHG_GUI_RES input acquired input=%d appid=%s",
+ req->input, req->appid);
m_curInputResReq[req->input] = req;
}
- ICO_DBG("CicoSCResourceManager::updateInputResource Leave");
+ ICO_TRA("CicoSCResourceManager::updateInputResource Leave");
}
void
CicoSCResourceManager::updateDisplayResourceRegulation(int state)
{
- ICO_DBG("CicoSCResourceManager::updateDisplayResourceRegulation Enter"
+ ICO_TRA("CicoSCResourceManager::updateDisplayResourceRegulation Enter"
"(state=%d)", state);
if (STID_DRVREGULATION_ON == state) {
if (false == active) {
if (NULL != m_winCtrl) {
// hide current window
- // TODO animation?
- m_winCtrl->hide(current->surfaceid, NULL, 0);
+ m_winCtrl->hide(current->surfaceid,
+ m_animaName.c_str(), m_animaTime);
}
curchg = true;
}
}
if (false == curchg) {
- ICO_DBG("CicoSCResourceManager::updateDisplayResourceRegulation "
+ ICO_TRA("CicoSCResourceManager::updateDisplayResourceRegulation "
"Leave");
return;
}
if (true == active) {
if (NULL != m_winCtrl) {
// show current window
- // TODO animation?
- m_winCtrl->show((*itr2)->surfaceid, NULL, 0);
- m_winCtrl->active((*itr2)->surfaceid, -1);
+ m_winCtrl->show((*itr2)->surfaceid,
+ m_animaName.c_str(), m_animaTime);
}
break;
}
for (; itr != m_curDispResOwerReq.end(); ++itr) {
resource_request_t *current = itr->second;
if (NULL == current) {
- continue;
- }
+ if (true == m_policyMgr->isExistDisplayZoneOwer(itr->first)) {
+ if (NULL != m_winCtrl) {
+ int surfaceid = m_winCtrl->getDisplayedWindow(itr->first);
- int type = current->resid & RESID_TYPE_MASK;
- bool active = false;
- active = m_policyMgr->acquireDisplayResource(type,
- current->dispzoneid,
- current->prio);
- if (true == active) {
- if (NULL != m_winCtrl) {
- // show current window
- // TODO animation?
- m_winCtrl->show(current->surfaceid, NULL, 0);
- m_winCtrl->active(current->surfaceid, -1);
+#if 0
+ if ((surfaceid > 0) && (NULL != itr->second) &&
+ (itr->second->surfaceid != surfaceid)) {
+ m_winCtrl->hide(surfaceid,
+ m_animaName.c_str(),
+ m_animaTime);
+ }
+#else
+ if (surfaceid > 0) {
+ m_winCtrl->hide(surfaceid,
+ m_animaName.c_str(),
+ m_animaTime);
+ }
+
+#endif
+ }
+ continue;
}
+ list<resource_request_t*>::iterator itr2;
+ itr2 = m_waitingDispResReq.begin();
+ for (; itr2 != m_waitingDispResReq.end(); ++itr2) {
+ resource_request_t *req = *itr2;
+ if (itr->first != (unsigned int)req->dispzoneid) {
+ continue;
+ }
+ int type = req->resid & RESID_TYPE_MASK;
+ bool active = false;
+ active = m_policyMgr->acquireDisplayResource(type,
+ req->dispzoneid,
+ req->prio);
+ if (true == active) {
+ ICO_DBG("Dequeue waiting display resource request"
+ "(req=0x%08x zone=%02d:%s appid=%s)",
+ req, req->dispzoneid,
+ req->dispzone, req->appid);
+ m_waitingDispResReq.erase(itr2);
+ ICO_DBG("Enqueue current display resource request"
+ "(req=0x%08x zone=%02d:%s appid=%s)",
+ req, req->dispzoneid,
+ req->dispzone, req->appid);
+ ICO_PRF("CHG_GUI_RES display acquired zone=%02d:%s "
+ "appid=%s",
+ req->dispzoneid, req->dispzone, req->appid);
+ m_curDispResOwerReq[req->dispzoneid] = req;
+#if 1 //DEBUG
+ dumpCurDispResOwerReq();
+ dumpWaitingDispResReq();
+#endif //DEBUG
+ m_winCtrl->show(req->surfaceid,
+ m_animaName.c_str(), m_animaTime);
+ m_winCtrl->active(req->surfaceid, -1);
+ break;
+ }
+ }
+ }
+ else {
+ int type = current->resid & RESID_TYPE_MASK;
+ bool active = false;
+ active = m_policyMgr->acquireDisplayResource(type,
+ current->dispzoneid,
+ current->prio);
+ if (true == active) {
+ if (NULL != m_winCtrl) {
+ int surfaceid = m_winCtrl->getDisplayedWindow(
+ itr->second->dispzoneid);
+ if ((itr->second->surfaceid != surfaceid) &&
+ (surfaceid > 0)) {
+ m_winCtrl->hide(surfaceid,
+ m_animaName.c_str(), m_animaTime);
+ }
+
+ // show current window
+ m_winCtrl->show(current->surfaceid,
+ m_animaName.c_str(), m_animaTime);
+ }
+ }
+#if 1 //DEBUG
+ dumpCurDispResOwerReq();
+ dumpWaitingDispResReq();
+#endif //DEBUG
}
}
}
- ICO_DBG("CicoSCResourceManager::updateDisplayResourceRegulation Leave");
+ ICO_TRA("CicoSCResourceManager::updateDisplayResourceRegulation Leave");
}
void
CicoSCResourceManager::updateSoundResourceRegulation(int state)
{
- ICO_DBG("CicoSCResourceManager::updateSoundResourceRegulation Enter"
+ ICO_TRA("CicoSCResourceManager::updateSoundResourceRegulation Enter"
"(state=%d)", state);
bool curchg = false;
current->state = RES_STATE_WAITING;
// enqueue request
ICO_DBG("Enqueue waiting sound request queue "
- "zone=%d req=0x%08x", i, current);
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ current, i, current->soundzone, current->appid);
m_soundReqQueue[i].push_front(current);
// initialize current zone request
m_curSoundResReq[i] = NULL;
}
if ((false == curchg) && (STID_DRVREGULATION_ON == state)) {
- ICO_DBG("CicoSCResourceManager::updateSoundResourceRegulation Leave");
+ ICO_TRA("CicoSCResourceManager::updateSoundResourceRegulation Leave");
return;
}
if (true == active) {
resource_request_t* req = *itr2;
ICO_DBG("Dequeue waiting sound request queue "
- "zone=%d req=0x%08x", itr->first, *itr2);
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ *itr2, itr->first, (*itr2)->soundzone, (*itr2)->appid);
itr->second.erase(itr2);
updateSoundResource(req);
break;
}
}
- ICO_DBG("CicoSCResourceManager::updateSoundResourceRegulation Leave");
+ ICO_TRA("CicoSCResourceManager::updateSoundResourceRegulation Leave");
}
void
CicoSCResourceManager::updateInputResourceRegulation(int state)
{
- ICO_DBG("CicoSCResourceManager::updateInputResourceRegulation Enter"
+ ICO_TRA("CicoSCResourceManager::updateInputResourceRegulation Enter"
"(state=%d)", state);
bool curchg = false;
current->state = RES_STATE_WAITING;
// enqueue request
ICO_DBG("Enqueue waiting input request queue "
- "zone=%d req=0x%08x", i, current);
+ "(req=0x%08x input:%d appid=%s)",
+ current, i, current->appid);
m_inputReqQueue[i].push_front(current);
// initialize current zone request
m_curInputResReq[i] = NULL;
}
if ((false == curchg) && (STID_DRVREGULATION_ON == state)) {
- ICO_DBG("CicoSCResourceManager::updateInputResourceRegulation Leave");
+ ICO_TRA("CicoSCResourceManager::updateInputResourceRegulation Leave");
return;
}
if (true == active) {
resource_request_t* req = *itr2;
ICO_DBG("Dequeue waiting input request queue "
- "zone=%d req=0x%08x", itr->first, *itr2);
+ "(req=0x%08x input:%d appid=%s)",
+ *itr2, (*itr2)->input, (*itr2)->appid);
itr->second.erase(itr2);
updateInputResource(req);
break;
}
}
- ICO_DBG("CicoSCResourceManager::updateDisplayResourceRegulation Leave");
+ ICO_TRA("CicoSCResourceManager::updateInputResourceRegulation Leave");
}
//--------------------------------------------------------------------------
* @brief find currnet dipalay resource ower request
*
* @param [in] request compare requset
- *
+ *
* @return request object on same requeset found, NULL on not found
*/
//--------------------------------------------------------------------------
* @brief pop currnet dipalay resource ower request from list
*
* @param [in] request compare requset
- *
+ *
* @return request object on same requeset found, NULL on not found
*/
//--------------------------------------------------------------------------
for (; itr != m_curDispResOwerReq.end(); ++itr) {
CompDisplayResourceRequest comp(req);
if (true == comp(itr->second)) {
- ICO_DBG("Dequeue current display reoursce ower request"
- "(req=0x%08x zoneid=%d appid=%s)",
- itr->second, itr->first, itr->second->appid);
+ ICO_DBG("Dequeue current display resource ower request"
+ "(req=0x%08x zoneid=%02d:%s appid=%s)",
+ itr->second, itr->first,
+ itr->second->dispzone, itr->second->appid);
+ ICO_PRF("CHG_GUI_RES display deprived zone=%02d:%s appid=%s",
+ itr->first, itr->second->dispzone, itr->second->appid);
resource_request_t *findreq = itr->second;
itr->second = NULL;
#if 1 //DEBUG
* @brief find waiting dipalay resource request
*
* @param [in] request compare requset
- *
+ *
* @return request object on same requeset found, NULL on not found
*/
//--------------------------------------------------------------------------
* @brief pop waiting dipalay resource request from waiting list
*
* @param [in] request compare requset
- *
+ *
* @return request object on same requeset found, NULL on not found
*/
//--------------------------------------------------------------------------
}
}
}
+
+//--------------------------------------------------------------------------
+/**
+ * @brief update display request for regulation pre-process
+ */
+//--------------------------------------------------------------------------
+void
+CicoSCResourceManager::updateDispResRegulationPreProc(resource_request_t *req)
+{
+ ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Enter");
+#if 1 //DEBUG
+ dumpCurDispResOwerReq();
+ dumpWaitingDispResReq();
+#endif //DEBUG
+
+ if (NULL == req) {
+ ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
+ return;
+ }
+
+ if (false == m_policyMgr->getRegulation()) {
+ ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
+ return;
+ }
+
+ CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
+ const CicoSCAppKindConf *appKindConf = NULL;
+ appKindConf = sysConf->findAppKindConfbyId(req->appkind);
+ if (NULL == appKindConf) {
+ ICO_ERR("not found CicoSCAppKindConf instance");
+ ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
+ return;
+ }
+
+ if ((appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_ALMIGHTY) ||
+ (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM) ||
+ (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM_VISIBLE)) {
+
+ if (NULL != m_winCtrl) {
+ m_winCtrl->show(req->surfaceid,
+ req->animation,
+ req->animationTime);
+ }
+ delResourceRequest(req);
+
+ ICO_DBG("kind of system application");
+ ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
+ return;
+ }
+
+ int surfaceid = req->surfaceid;
+ if (NULL != m_winCtrl) {
+ surfaceid = m_winCtrl->getDisplayedWindow(req->dispzoneid);
+ if (-1 == surfaceid) {
+ ICO_WRN("displayed surface id is invalid.");
+ surfaceid = req->surfaceid;
+ }
+ }
+
+ if (req->surfaceid != surfaceid) {
+ ICO_WRN("req->surfaceid(%08x) != displayedsurfaceid(%08x)",
+ req->surfaceid, surfaceid);
+ }
+
+ resource_request_t *curreq = NULL;
+ int min = ICO_DISPLAY0_ZONEID_MIN;
+ int max = ICO_DISPLAY0_ZONEID_MAX;
+ if ((req->dispzoneid >= min) && (req->dispzoneid <= max)) {
+ for (int i = min; i <= max; ++i) {
+ std::map<unsigned int, resource_request_t*>::iterator itr;
+ itr = m_curDispResOwerReq.find(i);
+ if (itr != m_curDispResOwerReq.end()) {
+ if (NULL != itr->second) {
+ curreq = itr->second;
+ break;
+ }
+ }
+ }
+ }
+
+ min = ICO_DISPLAY1_ZONEID_MIN;
+ max = ICO_DISPLAY1_ZONEID_MAX;
+ if ((NULL == curreq) &&
+ (req->dispzoneid >= min) && (req->dispzoneid <= max)) {
+ for (int i = min; i <= max; ++i) {
+ std::map<unsigned int, resource_request_t*>::iterator itr;
+ itr = m_curDispResOwerReq.find(i);
+ if (itr != m_curDispResOwerReq.end()) {
+ if (NULL != itr->second) {
+ curreq = itr->second;
+ break;
+ }
+ }
+ }
+ }
+
+#if 0
+ resource_request_t *curreq = NULL;
+ std::map<unsigned int, resource_request_t*>::iterator itr;
+ itr = m_curDispResOwerReq.find(req->dispzoneid);
+ if (itr != m_curDispResOwerReq.end()) {
+ curreq = itr->second;
+ }
+#endif
+
+ if (NULL != curreq) {
+ ICO_DBG("Dequeue current display resource request"
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ curreq, curreq->dispzoneid, curreq->dispzone, curreq->appid);
+ ICO_PRF("CHG_GUI_RES display deprived zone=%02d:%s appid=%s",
+ curreq->dispzoneid, curreq->dispzone, curreq->appid);
+ m_curDispResOwerReq[curreq->dispzoneid] = NULL;
+
+ if (curreq->surfaceid != req->surfaceid) {
+ resource_request_t *waitreq = popWaitingDispResReq(req);
+ ICO_DBG("Enqueue waiting display resource request"
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ curreq, curreq->dispzoneid,
+ curreq->dispzone, curreq->appid);
+ m_waitingDispResReq.push_front(curreq);
+
+ if (NULL != waitreq) {
+ ICO_DBG("Enqueue current display resource request"
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ waitreq, waitreq->dispzoneid,
+ waitreq->dispzone, waitreq->appid);
+ ICO_PRF("CHG_GUI_RES display acquired zone=%02d:%s appid=%s",
+ waitreq->dispzoneid, waitreq->dispzone, waitreq->appid);
+ m_curDispResOwerReq[waitreq->dispzoneid] = waitreq;
+ }
+ }
+ else {
+ ICO_DBG("Enqueue current display resource request"
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ curreq, curreq->dispzoneid,
+ curreq->dispzone, curreq->appid);
+ ICO_PRF("CHG_GUI_RES display acquired zone=%02d:%s appid=%s",
+ curreq->dispzoneid, curreq->dispzone, curreq->appid);
+ m_curDispResOwerReq[curreq->dispzoneid] = curreq;
+ }
+ }
+ delResourceRequest(req);
+
+#if 1 //DEBUG
+ dumpCurDispResOwerReq();
+ dumpWaitingDispResReq();
+#endif //DEBUG
+ ICO_TRA("CicoSCResourceManager::updateDispResRegulationPreProc Leave");
+}
+
+//--------------------------------------------------------------------------
+/**
+ * @brief update sound request for regulation pre-process
+ */
+//--------------------------------------------------------------------------
+void
+CicoSCResourceManager::updateSoundResRegulationPreProc(resource_request_t *req)
+{
+ ICO_TRA("CicoSCResourceManager::updateSoundResRegulationPreProc Enter");
+
+ if (NULL == req) {
+ return;
+ }
+
+ if (false == m_policyMgr->getRegulation()) {
+ return;
+ }
+
+ CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
+ const CicoSCAppKindConf *appKindConf = NULL;
+ appKindConf = sysConf->findAppKindConfbyId(req->appkind);
+ if (NULL == appKindConf) {
+ ICO_ERR("not found CicoSCAppKindConf instance");
+ ICO_TRA("CicoSCResourceManager::updateSoundResRegulationPreProc Leave");
+ return;
+ }
+
+ if ((appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_ALMIGHTY) ||
+ (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM) ||
+ (appKindConf->privilege == CicoSCAppKindConf::PRIVILEGE_SYSTEM_AUDIO)) {
+
+ delResourceRequest(req);
+
+ ICO_DBG("kind of system application");
+ ICO_TRA("CicoSCResourceManager::updateSoundResRegulationPreProc Leave");
+ return;
+ }
+
+ resource_request_t *curreq = NULL;
+ std::map<int, resource_request_t*>::iterator itr;
+ itr = m_curSoundResReq.find(req->soundzoneid);
+ if (itr != m_curSoundResReq.end()) {
+ curreq = itr->second;
+ }
+
+ if (NULL != curreq) {
+ ICO_DBG("Dequeue current sound resource request"
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ curreq, curreq->soundzoneid, curreq->soundzone, curreq->appid);
+ ICO_PRF("CHG_GUI_RES sound deprived zone=%02d:%s appid=%s",
+ curreq->soundzoneid, curreq->soundzone, curreq->appid);
+ m_curSoundResReq[curreq->soundzoneid] = NULL;
+
+ if (0 != strcmp(curreq->appid, req->appid)) {
+ resource_request_t *waitreq = popSoundResReq(req);
+ ICO_DBG("Enqueue waiting sound resource request"
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ curreq, curreq->soundzoneid,
+ curreq->soundzone, curreq->appid);
+ m_soundReqQueue[curreq->soundzoneid].push_front(curreq);
+
+ if (NULL != waitreq) {
+ ICO_DBG("Enqueue current sound resource request"
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ waitreq, waitreq->soundzoneid,
+ waitreq->soundzone, waitreq->appid);
+ ICO_PRF("CHG_GUI_RES sound acquired zone=%02d:%s appid=%s",
+ waitreq->soundzoneid, waitreq->soundzone,
+ waitreq->appid);
+ m_curSoundResReq[curreq->soundzoneid] = waitreq;
+ }
+ }
+ else {
+ ICO_DBG("Enqueue current sound resource request"
+ "(req=0x%08x zone:%02d:%s appid=%s)",
+ curreq, curreq->soundzoneid,
+ curreq->soundzone, curreq->appid);
+ ICO_PRF("CHG_GUI_RES sound acquired zone=%d:%s appid=%s",
+ curreq->soundzoneid, curreq->soundzone, curreq->appid);
+ m_curSoundResReq[curreq->soundzoneid] = curreq;
+ }
+ }
+ delResourceRequest(req);
+ ICO_TRA("CicoSCResourceManager::updateSoundResRegulationPreProc Leave");
+}
+
+//--------------------------------------------------------------------------
+/**
+ * @brief update input request for regulation pre-process
+ */
+//--------------------------------------------------------------------------
+void
+CicoSCResourceManager::updateInputResRegulationPreProc(resource_request_t *req)
+{
+ ICO_TRA("CicoSCResourceManager::updateInputResRegulationPreProc Enter");
+
+ if (NULL == req) {
+ return;
+ }
+
+ if (false == m_policyMgr->getRegulation()) {
+ return;
+ }
+
+ resource_request_t *curreq = NULL;
+ std::map<int, resource_request_t*>::iterator itr;
+ itr = m_curInputResReq.find(req->input);
+ if (itr != m_curInputResReq.end()) {
+ curreq = itr->second;
+ }
+
+ if (NULL != curreq) {
+ ICO_DBG("Dequeue current input resource request"
+ "(req=0x%08x input:%d appid=%s)",
+ curreq, curreq->input, curreq->appid);
+ ICO_PRF("CHG_GUI_RES input deprived input=%d appid=%s",
+ curreq->input, curreq->appid);
+ m_curInputResReq[curreq->input] = NULL;
+
+ if (0 != strcmp(curreq->appid, req->appid)) {
+ resource_request_t *waitreq = popInputResReq(req);
+ ICO_DBG("Enqueue waiting input resource request"
+ "(req=0x%08x input:%d appid=%s)",
+ curreq, curreq->input, curreq->appid);
+ m_inputReqQueue[curreq->input].push_front(curreq);
+
+ if (NULL != waitreq) {
+ ICO_DBG("Enqueue current input resource request"
+ "(req=0x%08x input:%d appid=%s)",
+ waitreq, waitreq->input, waitreq->appid);
+ ICO_PRF("CHG_GUI_RES input acquired input=%d appid=%s",
+ waitreq->input, waitreq->appid);
+ m_curInputResReq[curreq->input] = waitreq;
+ }
+ }
+ else {
+ ICO_DBG("Enqueue current input resource request"
+ "(req=0x%08x input:%d appid=%s)",
+ curreq, curreq->input, curreq->appid);
+ ICO_PRF("CHG_GUI_RES input acquired input=%d appid=%s",
+ curreq->input, curreq->appid);
+ m_curInputResReq[curreq->input] = curreq;
+ }
+ }
+ delResourceRequest(req);
+ ICO_TRA("CicoSCResourceManager::updateInputResRegulationPreProc Leave");
+}
+
+//--------------------------------------------------------------------------
+/**
+ * @brief compare displayed surface and ower surface
+ */
+//--------------------------------------------------------------------------
+bool
+CicoSCResourceManager::isMatchDisplayed(void)
+{
+ bool ret = false;
+ std::map<unsigned int, resource_request_t*>::iterator itr;
+ itr = m_curDispResOwerReq.begin();
+ for (; itr != m_curDispResOwerReq.end(); ++itr) {
+ if (NULL == itr->second) {
+ continue;
+ }
+ if (NULL != m_winCtrl) {
+ int surfaceid = m_winCtrl->getDisplayedWindow(
+ itr->second->dispzoneid);
+ std::map<unsigned int, resource_request_t*>::iterator itr2;
+ itr2 = m_curDispResOwerReq.begin();
+ for (; itr2 != m_curDispResOwerReq.end(); ++itr2) {
+ if (NULL == itr2->second) {
+ continue;
+ }
+ if ((itr2->second->surfaceid == surfaceid)) {
+ ret = true;
+ break; // break of for itr2
+ }
+ }
+ }
+ if (true == ret) {
+ break; // break of for itr
+ }
+ }
+ return ret;
+}
+
+bool
+CicoSCResourceManager::acquireOnScreenDisplayResource(resource_request_t *newreq)
+{
+ ICO_TRA("Enter (%08x)", newreq);
+ if (NULL == newreq) {
+ ICO_TRA("Leave param is NULL pointer");
+ return false;
+ }
+ CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
+
+ if (0 == newreq->role_stt) {
+ newreq->role_stt = sysConf->getRoleStt(newreq->role);
+ }
+ m_OnScreenItems.push_back(newreq);
+
+ const resource_request_t* rrtHO = getNoticeOfHighOder();
+ if (NULL == rrtHO) {
+ ICO_TRA("Leave %s, %d is not notice", newreq->role, newreq->resourceId);
+ return false;
+ }
+#if 1
+ const CicoSCWindow* nwo = m_winCtrl->findWindowObj(newreq->pid,
+ newreq->resourceId);
+#endif
+ const CicoSCWindow* bwo = NULL; // before window oject
+ const CicoSCWindow* awo = NULL; // after window object
+
+ if (NULL != m_rrtHO) {
+ bwo = m_winCtrl->findWindowObj(m_rrtHO->pid, m_rrtHO->resourceId);
+ }
+ if (NULL != rrtHO) {
+ awo = m_winCtrl->findWindowObj(rrtHO->pid, rrtHO->resourceId);
+ }
+ if ((NULL == m_rrtHO) && (NULL != rrtHO)) { // none -> on notice
+ ICO_TRA("_____ OPEN Layer \"%s\":%d", rrtHO->role, rrtHO->resourceId);
+ if (NULL != awo) {
+ m_winCtrl->showLayer(awo->displayid, awo->layerid);
+ }
+ else {
+ ICO_WRN("ON SCREEN none layer");
+ }
+ }
+#if 1
+ if ((NULL != nwo) && (awo != nwo) && (bwo != nwo)) {
+ ICO_TRA("_____ HIDW new REQUEST %x:%s:%d", newreq, newreq->role,
+ newreq->resourceId);
+ m_winCtrl->hide(nwo->surfaceid, NULL, 0);
+ }
+#endif
+ if (rrtHO != m_rrtHO) { // change Hige Oder notice
+ if (NULL != m_rrtHO) {
+ ICO_TRA("_____ HIDE surface %x:%s:%d", m_rrtHO, m_rrtHO->role,
+ m_rrtHO->resourceId);
+ if (NULL != bwo) {
+ m_winCtrl->hide(bwo->surfaceid, NULL, 0);
+ }
+ else {
+ ICO_WRN("ON SCREEN none Hide control");
+ }
+ resCB(ICO_SYC_EV_RES_WAITING, *m_rrtHO);
+ }
+ ICO_TRA("_____ SHOW surface %x:%s:%d", rrtHO, rrtHO->role, rrtHO->resourceId);
+ if (NULL != awo) {
+ m_winCtrl->show(awo->surfaceid, NULL, 0);
+ }
+ else {
+ ICO_WRN("ON SCREEN none show control");
+ }
+ resCB(ICO_SYC_EV_RES_ACQUIRE, *rrtHO);
+ ICO_TRA("_____ change %x -> %x", m_rrtHO, rrtHO);
+ m_rrtHO = rrtHO;
+ }
+//- if (m_rrtHO != newreq) {
+//- resCB(ICO_SYC_EV_RES_WAITING, *newreq);
+//- }
+ else {
+ ICO_TRA("_____ no change %x", m_rrtHO);
+ if (NULL != awo) {
+ m_winCtrl->show(awo->surfaceid, NULL, 0);
+ m_winCtrl->raise(awo->surfaceid, NULL, 0);
+ }
+ if (m_rrtHO != newreq) {
+ resCB(ICO_SYC_EV_RES_WAITING, *newreq);
+ }
+ }
+ ICO_TRA("Leave");
+ return true;
+}
+
+bool
+CicoSCResourceManager::releaseOnScreenDisplayResource(resource_request_t *req)
+{
+ ICO_TRA("Enter %08x", req);
+ if (NULL == req) {
+ ICO_TRA("Leave param is NULL pointer");
+ return false;
+ }
+ resource_request_t* tgt = NULL;
+ list<resource_request_t*>::iterator itr = m_OnScreenItems.begin();
+ for (; itr != m_OnScreenItems.end(); ++itr) {
+ if ((req->pid == (*itr)->pid) &&
+ (req->resourceId == (*itr)->resourceId)) {
+ tgt = (*itr);
+ break; // break of for itr
+ }
+ }
+
+ if (NULL != tgt) {
+ ICO_TRA("_____ erase list %x", tgt);
+ m_OnScreenItems.erase(itr);
+ }
+
+ const resource_request_t* rrtHO = getNoticeOfHighOder();
+
+ const CicoSCWindow* bwo = NULL; // before window oject
+ const CicoSCWindow* awo = NULL; // after window object
+ if (NULL != m_rrtHO) {
+ bwo = m_winCtrl->findWindowObj(m_rrtHO->pid, m_rrtHO->resourceId);
+ }
+ if (NULL != rrtHO) {
+ awo = m_winCtrl->findWindowObj(rrtHO->pid, rrtHO->resourceId);
+ }
+
+ if ((NULL == rrtHO) && (NULL == m_rrtHO)) {
+ ICO_WRN("ON SCREEN Resource NG");
+ if (NULL != tgt) {
+ resCB(ICO_SYC_EV_RES_RELEASE, *tgt);
+ delResourceRequest(tgt);
+ }
+ delResourceRequest(req);
+ ICO_TRA("Leave ON SCREEN Resource NG");
+ return false;
+ }
+
+ if (rrtHO != m_rrtHO) {
+ if (NULL != m_rrtHO) {
+ if (NULL != bwo) {
+ m_winCtrl->hide(bwo->surfaceid, NULL, 0);
+ if (m_rrtHO != tgt) {
+ ICO_DBG("_____ NG Control OnScreen Resource %x(%d, %d), %x",
+ m_rrtHO, m_rrtHO->pid, m_rrtHO->resourceId, tgt);
+ resCB(ICO_SYC_EV_RES_WAITING, *m_rrtHO);
+ }
+ }
+ else {
+ ICO_WRN("ON SCREEN Hide control NG");
+ }
+ }
+ if (NULL != rrtHO) {
+ if (NULL != awo) {
+ m_winCtrl->show(awo->surfaceid, NULL, 0);
+ m_winCtrl->raise(awo->surfaceid, NULL, 0);
+ resCB(ICO_SYC_EV_RES_ACQUIRE, *rrtHO);
+ }
+ else {
+ ICO_WRN("ON SCREEN Hide control NG");
+ }
+ }
+ else {
+ if (NULL != bwo) {
+ m_winCtrl->hideLayer(bwo->displayid, bwo->layerid);
+ }
+ else {
+ ICO_WRN("ON SCREEN layer hide control NG");
+ }
+ }
+ m_rrtHO = rrtHO;
+ }
+ else {
+ ICO_TRA("_____ no change");
+ }
+ // memory free
+ if (NULL != tgt) {
+ resCB(ICO_SYC_EV_RES_RELEASE, *tgt);
+ delResourceRequest(tgt);
+ }
+ delResourceRequest(req);
+ ICO_TRA("Leave");
+ return true;
+}
+
+bool
+CicoSCResourceManager::resCB(const ico_syc_ev_e ev, const resource_request_t& p) const
+{
+ ICO_TRA("Enter %d", (int)ev);
+ if ((NULL == p.appid) || (0 == strlen(p.appid))) {
+ ICO_TRA("Leave false");
+ return false;
+ }
+ if (false == p.bEx) {
+ ICO_TRA("Leave false");
+ return false;
+ }
+ int nEv = -1;
+ if (ICO_SYC_EV_RES_ACQUIRE == ev) {
+ nEv = MSG_CMD_ACQUIRE_RES;
+ }
+ else if (ICO_SYC_EV_RES_DEPRIVE == ev) {
+ nEv = MSG_CMD_DEPRIVE_RES;
+ }
+ else if (ICO_SYC_EV_RES_WAITING == ev) {
+ nEv = MSG_CMD_WAITING_RES;
+ }
+ else if (ICO_SYC_EV_RES_REVERT == ev) {
+ nEv = MSG_CMD_REVERT_RES;
+ }
+ else if (ICO_SYC_EV_RES_RELEASE == ev) {
+ nEv = MSG_CMD_RELEASE_RES;
+ }
+ else if (ICO_SYC_EV_RES_WINDOW_ID == ev) {
+ nEv = MSG_CMD_WINDOW_ID_RES;
+ }
+ else {
+ ICO_TRA("Leave false ev(%d) is not supp.",(int)ev);
+ return false;
+ }
+
+ bool r;
+ r = resCB(p.appid, nEv, p.ECU, p.display, p.layer, p.layout, p.area,
+ p.dispatchApp, p.role, p.resourceId);
+ ICO_TRA("Leave %s", r? "true":"false");
+ return r;
+}
+
+bool
+CicoSCResourceManager::resCB(const char* sendToAppid, const int ev,
+ const char* ECU, const char* display,
+ const char* layer, const char* layout,
+ const char* area, const char* dispatchApp,
+ const char* role, uint32_t resourceId) const
+{
+ ICO_TRA("Enter");
+ if (NULL == sendToAppid) {
+ ICO_TRA("Leave false");
+ return false;
+ }
+ CicoSCMessageRes* msg = new CicoSCMessageRes();
+ msg->addRootObject("command", ev);
+ if (NULL != ECU) {
+ msg->addWinObject("ECU", ECU);
+ }
+ if (NULL != display) {
+ msg->addWinObject("display", display);
+ }
+ if (NULL != layer) {
+ msg->addWinObject("layer", layer);
+ }
+ if (NULL != layout) {
+ msg->addWinObject("layout", layout);
+ }
+ if (NULL != area) {
+ msg->addWinObject("area", area);
+ }
+ if (NULL != dispatchApp) {
+ msg->addWinObject("dispatchApp", dispatchApp);
+ }
+ if (NULL != role) {
+ msg->addWinObject("role", role);
+ }
+ msg->addWinObject("resourceId", resourceId);
+ CicoSCServer *cscs = CicoSCServer::getInstance();
+ int r = cscs->sendMessage(sendToAppid, (CicoSCMessage*)msg);
+ if (ICO_SYC_EOK != r) {
+ ICO_TRA("Leave false(%d)", r);
+ return false;
+ }
+ ICO_TRA("Leave true");
+ return true;
+}
+
+const resource_request_t* CicoSCResourceManager::getNoticeOfHighOder()
+{
+ ICO_TRA("Enter (%d)", (int)m_OnScreenItems.size());
+ const CicoSCRoleConf* rC = CicoSystemConfig::getInstance()->getRoleConf();
+ m_policyMgr->sendSMEvent(rC->m_rst); // RESET OnScreen State
+ const resource_request_t* r = NULL;
+ list<resource_request_t*>::iterator itr = m_OnScreenItems.begin();
+ for (; itr != m_OnScreenItems.end(); ++itr) {
+ short hEv = (*itr)->role_stt;
+ if ((ICO_SYC_ROLE_CONF_DEF == hEv) || (0 == hEv)) {
+ continue; // continue of for itr
+ }
+ bool test = m_policyMgr->testSMEvent(hEv);
+ if (true == m_policyMgr->sendSMEvent(hEv)) {
+ r = (*itr);
+ }
+ else if (true == test) {
+ r = (*itr);
+ }
+ }
+ ICO_TRA("Leave %x", r);
+ return r;
+}
+
// vim:set expandtab ts=4 sw=4:
projects / profile / ivi / ico-uxf-homescreen.git / blobdiff