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;
}
