status_t BnDMAgent::onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) { XLOGI("OnTransact (%u,%u)", code, flags); reply->writeInt32(DM_READ_NO_EXCEPTION);//used for readException switch (code) { case TRANSACTION_setLockFlag: { /* XLOGI("setLockFlag\n"); data.enforceInterface (descriptor); reply->writeInt32 (setLockFlag ()); // XLOGI("locked\n"); return NO_ERROR; */ XLOGI("setLockFlag\n"); data.enforceInterface(descriptor); int len = data.readInt32(); XLOGD("setLockFlag len = %d\n", len); if (len == -1) { // array is null reply->writeInt32(0); } else { char buff[len]; data.read(buff, len); XLOGD("setLockFlag buff = %s\n", buff); reply->writeInt32(setLockFlag(buff, len)); } XLOGI("setLockFlag done\n"); return NO_ERROR; } break; case TRANSACTION_clearLockFlag: { XLOGI("clearLockFlag\n"); data.enforceInterface(descriptor); reply->writeInt32(clearLockFlag()); XLOGI("cleared\n"); return NO_ERROR; } break; case TRANSACTION_readDMTree: { XLOGI("readDMTree\n"); data.enforceInterface(descriptor); int size = 0; char * ret = readDMTree(size); if (ret == NULL) { reply->writeInt32(-1); } else { reply->writeInt32(size); reply->write(ret, size); free(ret); } XLOGI("DMTree read done\n"); return NO_ERROR; } break; case TRANSACTION_writeDMTree: { XLOGI("writeDMTree\n"); data.enforceInterface(descriptor); int len = data.readInt32(); if (len == -1) { // array is null reply->writeInt32(0); } else { char buff[len]; data.read(buff, len); reply->writeInt32(writeDMTree(buff, len)); } XLOGI("DMTree wrote\n"); return NO_ERROR; } break; case TRANSACTION_isLockFlagSet: { XLOGI("isLockFlagSet\n"); data.enforceInterface(descriptor); reply->writeInt32(isLockFlagSet()); XLOGI("isLockFlagSet done\n"); return NO_ERROR; } break; case TRANSACTION_readIMSI: { XLOGI("readIMSI\n"); data.enforceInterface(descriptor); int size = 0; char * ret = readIMSI(size); XLOGD("readIMSI = %s\n", ret); if (ret == NULL) { reply->writeInt32(-1); } else { reply->writeInt32(size); reply->write(ret, size); free(ret); } XLOGI("readIMSI done\n"); return NO_ERROR; } break; case TRANSACTION_writeIMSI: { XLOGI("writeIMSI\n"); data.enforceInterface(descriptor); int len = data.readInt32(); XLOGD("writeIMSI len = %d\n", len); if (len == -1) { // array is null reply->writeInt32(0); } else { char buff[len]; data.read(buff, len); XLOGD("writeIMSI buff = %s\n", buff); reply->writeInt32(writeIMSI(buff, len)); } XLOGI("writeIMSI done\n"); return NO_ERROR; } break; case TRANSACTION_readCTA: { XLOGI("readCTA\n"); data.enforceInterface(descriptor); int size = 0; char * ret = readCTA(size); XLOGD("readCTA = %s\n", ret); if (ret == NULL) { reply->writeInt32(-1); } else { reply->writeInt32(size); reply->write(ret, size); free(ret); } XLOGI("readCTA done\n"); return NO_ERROR; } break; case TRANSACTION_writeCTA: { XLOGI("writeCTA\n"); data.enforceInterface(descriptor); int len = data.readInt32(); XLOGD("writeCTA len = %d\n", len); if (len == -1) { // array is null reply->writeInt32(0); } else { char buff[len]; data.read(buff, len); XLOGD("writeCTA buff = %s\n", buff); reply->writeInt32(writeCTA(buff, len)); } XLOGI("writeCTA done\n"); return NO_ERROR; } break; case TRANSACTION_readOperatorName: { XLOGI("readOperatorName\n"); data.enforceInterface(descriptor); int size = 0; char * ret = readOperatorName(size); if (ret == NULL) { reply->writeInt32(-1); } else { reply->writeInt32(size); reply->write(ret, size); free(ret); } XLOGI("readOperatorName done\n"); return NO_ERROR; } break; case TRANSACTION_setRebootFlag: { XLOGI("setRebootFlag\n"); data.enforceInterface(descriptor); reply->writeInt32(setRebootFlag()); XLOGI("setRebootFlag done\n"); return NO_ERROR; } break; case TRANSACTION_getLockType: { XLOGI("getLockType\n"); data.enforceInterface(descriptor); reply->writeInt32(getLockType()); XLOGI("getLockType done\n"); return NO_ERROR; } break; case TRANSACTION_getOperatorID: { XLOGI("getOperatorID\n"); data.enforceInterface(descriptor); reply->writeInt32(getOperatorID()); XLOGI("getOperatorID done\n"); return NO_ERROR; } break; case TRANSACTION_getOperatorName: { XLOGI("getOperatorName\n"); data.enforceInterface(descriptor); char * ret = getOperatorName(); if (ret == NULL) reply->writeInt32(-1); else reply->writeInt32(0); XLOGI("getOperatorName done\n"); return NO_ERROR; } break; case TRANSACTION_isHangMoCallLocking: { XLOGI("isHangMoCallLocking\n"); data.enforceInterface(descriptor); reply->writeInt32(isHangMoCallLocking()); XLOGI("isHangMoCallLocking done\n"); return NO_ERROR; } break; case TRANSACTION_isHangMtCallLocking: { XLOGI("isHangMtCallLocking\n"); data.enforceInterface(descriptor); reply->writeInt32(isHangMtCallLocking()); XLOGI("isHangMtCallLocking\n"); return NO_ERROR; } break; case TRANSACTION_clearRebootFlag: { XLOGI("clearRebootFlag\n"); data.enforceInterface(descriptor); reply->writeInt32(clearRebootFlag()); XLOGI("clearRebootFlag done\n"); return NO_ERROR; } break; case TRANSACTION_isBootRecoveryFlag: { XLOGI("isBootRecoveryFlag\n"); data.enforceInterface(descriptor); reply->writeInt32(isBootRecoveryFlag()); XLOGI("isBootRecoveryFlag done\n"); return NO_ERROR; } break; case TRANSACTION_isWipeSet: { XLOGI("isWipeset\n"); data.enforceInterface(descriptor); reply->writeInt32(isWipeSet()); XLOGI("isWipeset done\n"); return NO_ERROR; } break; case TRANSACTION_setWipeFlag: { XLOGI("setWipeFlag\n"); data.enforceInterface(descriptor); //int len=data.readInt32 (); reply->writeInt32(setWipeFlag("FactoryReset", sizeof("FactoryReset"))); XLOGI("setWipeFlag done\n"); return NO_ERROR; } break; case TRANSACTION_clearWipeFlag: { XLOGI("clearWipeFlag\n"); data.enforceInterface(descriptor); reply->writeInt32(clearWipeFlag()); XLOGI("clearWipeFlag done\n"); return NO_ERROR; } break; case TRANSACTION_getUpgradeStatus: { XLOGI("getUpgradeStatus\n"); data.enforceInterface(descriptor); reply->writeInt32(getUpgradeStatus()); XLOGI("getUpgradeStatus done\n"); return NO_ERROR; } break; case TRANSACTION_restartAndroid: { XLOGI("restartAndroid\n"); data.enforceInterface(descriptor); reply->writeInt32(restartAndroid()); XLOGI("restartAndroid\n"); return NO_ERROR; } break; case TRANSACTION_readOtaResult: { XLOGI("readOtaResult\n"); data.enforceInterface(descriptor); reply->writeInt32(readOtaResult()); return NO_ERROR; } break; case TRANSACTION_clearOtaResult: { XLOGI("clearOtaResult\n"); data.enforceInterface(descriptor); reply->writeInt32(clearOtaResult()); return NO_ERROR; } break; default: return BBinder::onTransact(code, data, reply, flags); } return NO_ERROR; }
void instr(SgGlobal* global) { // Create the lock and key variables in global scope. // In main: // EnterScope(); // lock = getTopLock(); // key = getTopKey(); // .... rest of main // ExitScope(); // return; // FIXME: Add case where we handle arbitrary exits from main // This can be handled similar to the way returns are handled // for basic blocks. SgScopeStatement* scope = isSgScopeStatement(global); // Insert lock and key variables at the top of the global scope // lock variable std::cout << "VarCounter: " << Util::VarCounter << std::endl; SgName lock_name("lock_var" + boost::lexical_cast<std::string>(Util::VarCounter)); SgVariableDeclaration* lock_var = Util::createLocalVariable(lock_name, getLockType(), NULL, scope); // Add declaration at the top of the scope scope->prepend_statement(lock_var); // key variable // **** IMPORTANT: Using same counter value for lock and key SgName key_name("key_var" + boost::lexical_cast<std::string>(Util::VarCounter)); Util::VarCounter++; SgVariableDeclaration* key_var = Util::createLocalVariable(key_name, getKeyType(), NULL, scope); // Insert this key decl after the lock decl SI::insertStatementAfter(lock_var, key_var); // Now, find the main function and insert... // EnterScope(); // lock = getTopLock(); // key = getTopKey(); // .... rest of main // ExitScope() // return; -- this already exists... // see FIXME above // find main function... SgFunctionDeclaration* MainFn = SI::findMain(global); if(!MainFn) { #ifdef HANDLE_GLOBAL_SCOPE_DEBUG printf("Can't find Main function. Not inserting Global Enter and Exit Scopes\n"); #endif return; } SgBasicBlock *bb = Util::getBBForFn(MainFn); // insert EnterScope() #if 0 SgExpression* overload = buildOverloadFn("EnterScope", NULL, NULL, SgTypeVoid::createType(), scope, GEFD(bb)); #endif SgExpression* overload = buildMultArgOverloadFn("EnterScope", SB::buildExprListExp(), SgTypeVoid::createType(), scope, GEFD(bb)); SgStatement* enter_scope = SB::buildExprStatement(overload); Util::insertAtTopOfBB(bb, enter_scope); // insert lock = getTopLock(); //overload = buildOverloadFn("getTopLock", NULL, NULL, getLockType(), scope, GEFD(bb)); overload = buildMultArgOverloadFn("getTopLock", SB::buildExprListExp(), getLockType(), scope, GEFD(bb)); //SgStatement* lock_assign = SB::buildExprStatement(SB::buildAssignOp(SB::buildVarRefExp(lock_var), overload)); //SI::insertStatementAfter(enter_scope, lock_assign); //RMM COMMENTED OUT // insert key = getTopKey(); // overload = buildOverloadFn("getTopKey", NULL, NULL, getKeyType(), scope, GEFD(bb)); overload = buildMultArgOverloadFn("getTopKey", SB::buildExprListExp(), getKeyType(), scope, GEFD(bb)); //SgStatement* key_assign = SB::buildExprStatement(SB::buildAssignOp(SB::buildVarRefExp(key_var), overload)); //SI::insertStatementAfter(lock_assign, key_assign); //RMM COMMENTED OUT // add to scope -> lock and key map... SLKM LockKeyPair lock_key = std::make_pair(lock_var, key_var); scopeLockMap[scope] = lock_key; ROSE_ASSERT(existsInSLKM(scope)); // Insert ExitScope if last stmt is not return. SgStatementPtrList& stmts = bb->get_statements(); SgStatementPtrList::iterator it = stmts.begin(); it += (stmts.size() - 1); // A little iffy on the scope part here... lets check that. if(!isSgReturnStmt(*it)) { // Last statement is not return. So, add exit scope... // If its a break/continue statement, insert statement before, // otherwise, add exit_scope afterwards. //SgExpression* overload = buildOverloadFn("ExitScope", NULL, NULL, SgTypeVoid::createType(), scope, GEFD(bb)); SgExpression* overload = buildMultArgOverloadFn("ExitScope", SB::buildExprListExp(), SgTypeVoid::createType(), scope, GEFD(bb)); // check if its break/continue if(isSgBreakStmt(*it) || isSgContinueStmt(*it)) { SI::insertStatementBefore(*it, SB::buildExprStatement(overload)); } else { SI::insertStatementAfter(*it, SB::buildExprStatement(overload)); } } }
/** Configures a given focus mode. While configuring a focus mode, it configures * 1. Range Control * 2. Focus Control * 3. Optionally, Focus Lock, if ENABLE_LOCK is enabled. */ OMX_ERRORTYPE FocusHandler::setUpFocus(const char* const aFocus) { DBGT_PROLOG("Focus: %s", aFocus); DBGT_ASSERT(NULL != aFocus, "Focus is NULL"); OMX_ERRORTYPE err = OMX_ErrorNone; mFocusModeIndex = getFocusModeIndex(aFocus); if (kInvalidIndex == mFocusModeIndex) { DBGT_EPILOG("OMX_ErrorBadParameter"); return OMX_ErrorBadParameter; } //Setting Focus Range OmxUtils::StructContainer<OMX_SYMBIAN_CONFIG_FOCUSRANGETYPE> rangeControl; rangeControl.ptr()->nPortIndex = OMX_ALL; err = OMX_GetConfig(mSTECamera->mCam, mSTECamera->mOmxILExtIndex->getIndex(OmxILExtIndex::EFocusRange), rangeControl.ptr()); if(OMX_ErrorNone != err) { DBGT_CRITICAL("OMX_GetConfig failed err = %d", err); DBGT_EPILOG(""); return err; } rangeControl.ptr()->eFocusRange = g_STECamFocusProp[mFocusModeIndex].eRangeType; DBGT_PTRACE("Setting Range %s",OmxUtils::name ((OMX_SYMBIAN_FOCUSRANGETYPE)rangeControl.ptr()->eFocusRange)); err = OMX_SetConfig(mSTECamera->mCam, mSTECamera->mOmxILExtIndex->getIndex(OmxILExtIndex::EFocusRange), rangeControl.ptr()); if(OMX_ErrorNone != err) { DBGT_CRITICAL("OMX_SetConfig failed err = %d", err); DBGT_EPILOG(""); return err; } //Setting Focus lock #ifdef ENABLE_LOCK OmxUtils::StructContainer<OMX_SYMBIAN_CONFIG_LOCKTYPE> focuslock; focuslock.ptr()->nPortIndex=OMX_ALL; #ifndef DISABLE_GET_CONFIG_LOCK //Remove this workaround when ER 351601 is resolved err = OMX_GetConfig(mSTECamera->mCam, mSTECamera->mOmxILExtIndex->getIndex(OmxILExtIndex::EFocusLock), focuslock.ptr()); if(OMX_ErrorNone != err) { DBGT_CRITICAL("OMX_GetConfig failed err = %d", err); DBGT_EPILOG(""); return err; } #endif //DISABLE_GET_CONFIG_LOCK focuslock.ptr()->eImageLock = getLockType(); DBGT_PTRACE("Setting Lock %s",OmxUtils::name((OMX_SYMBIAN_LOCKTYPE) focuslock.ptr()->eImageLock)); err = OMX_SetConfig(mSTECamera->mCam, mSTECamera->mOmxILExtIndex->getIndex(OmxILExtIndex::EFocusLock), focuslock.ptr() ); if(OMX_ErrorNone != err) { DBGT_CRITICAL("OMX_SetConfig failed err = %d", err); DBGT_EPILOG(""); return err; } #endif //ENABLE_LOCK //Setting Focus Control OmxUtils::StructContainer<OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE> focusControl; focusControl.ptr()->nPortIndex = OMX_ALL; err = OMX_GetConfig(mSTECamera->mCam, (OMX_INDEXTYPE)(OMX_IndexConfigFocusControl), focusControl.ptr()); if(OMX_ErrorNone != err) { DBGT_CRITICAL("OMX_GetConfig failed err = %d", err); DBGT_EPILOG(""); return err; } focusControl.ptr()->eFocusControl = g_STECamFocusProp[mFocusModeIndex].eFocusType; DBGT_PTRACE("Setting Control %u", focusControl.ptr()->eFocusControl); err = OMX_SetConfig(mSTECamera->mCam, (OMX_INDEXTYPE)(OMX_IndexConfigFocusControl), focusControl.ptr()); if(OMX_ErrorNone != err) { DBGT_CRITICAL("OMX_SetConfig failed err = %d", err); DBGT_EPILOG(""); return err; } DBGT_EPILOG(""); return err; }
void instr(SgBasicBlock* bb) { // 1. Add Enter Scope -- This will be removed when RTED ScopeGuard is used // 2. Insert lock and key variables at the top of stack. // 3. Create a map for lock and key with each scope // 4. Insert ExitScope statement if the last statement in the list isn't // a return stmt. Return stmts are handled in handleReturnStmts SgScopeStatement* scope = isSgScopeStatement(bb); // 1. Add Enter Scope #if 0 SgExpression* overload = buildOverloadFn("EnterScope", NULL, NULL, SgTypeVoid::createType(), scope, GEFD(bb)); #endif SgExpression* overload = buildMultArgOverloadFn("EnterScope", SB::buildExprListExp(), SgTypeVoid::createType(), scope, GEFD(bb)); SgStatement* enter_scope = SB::buildExprStatement(overload); Util::insertAtTopOfBB(bb, enter_scope); // 2. Insert lock and key variables // lock calls "getTopLock" // key calls "getTopKey" #if 0 overload = buildOverloadFn("getTopLock", NULL, NULL, getLockType(), scope, GEFD(bb)); #endif overload = buildMultArgOverloadFn("getTopLock", SB::buildExprListExp(), getLockType(), scope, GEFD(bb)); // **** IMPORTANT: Using same counter value for lock and key SgName lock_name("lock_var" + boost::lexical_cast<std::string>(Util::VarCounter)); //SgVariableDeclaration* lock_var = Util::createLocalVariable(lock_name, getLockType(), overload, scope); // Insert this lock declaration after the EnterScope //SI::insertStatementAfter(enter_scope, lock_var); //RMM COMMENTED OUT // For the key... #if 0 overload = buildOverloadFn("getTopKey", NULL, NULL, getKeyType(), scope, GEFD(bb)); #endif overload = buildMultArgOverloadFn("getTopKey", SB::buildExprListExp(), getKeyType(), scope, GEFD(bb)); // **** IMPORTANT: Using same counter value for lock and key SgName key_name("key_var" + boost::lexical_cast<std::string>(Util::VarCounter++)); //SgVariableDeclaration* key_var = Util::createLocalVariable(key_name, getKeyType(), overload, scope); // Insert this key decl after the lock decl //SI::insertStatementAfter(lock_var, key_var); //RMM COMMENTED OUT // Add to scope -> lock and key map //LockKeyPair lock_key = std::make_pair(lock_var, key_var); //SLKM[scope] = lock_key; //ROSE_ASSERT(existsInSLKM(scope)); // 4. Insert ExitScope if last stmt is not return. SgStatementPtrList& stmts = bb->get_statements(); SgStatementPtrList::iterator it = stmts.begin(); it += (stmts.size() - 1); if(!isSgReturnStmt(*it)) { // Last statement is not return. So, add exit scope... // If its a break/continue statement, insert statement before, // otherwise, add exit_scope afterwards. //SgExpression* overload = buildOverloadFn("ExitScope", NULL, NULL, SgTypeVoid::createType(), scope, GEFD(bb)); SgExpression* overload = buildMultArgOverloadFn("ExitScope", SB::buildExprListExp(), SgTypeVoid::createType(), scope, GEFD(bb)); // check if its break/continue if(isSgBreakStmt(*it) || isSgContinueStmt(*it)) { SI::insertStatementBefore(*it, SB::buildExprStatement(overload)); } else { SI::insertStatementAfter(*it, SB::buildExprStatement(overload)); } } return; }