TBool CLbsRootApiTest22Step::CheckProcessIsRunning(const TDesC& aProcessNamePattern) { TInt err = KErrNone; RProcess process; TFullName fullName; TFindProcess findProcess; TBool runningInstanceFound = EFalse; findProcess.Find(aProcessNamePattern); while (err = findProcess.Next(fullName), err == KErrNone) { TInt processOpenErr = process.Open(findProcess); if (processOpenErr == KErrNone) { TExitType exitType = process.ExitType(); if (exitType == EExitPending) { // found a running instance of the process, // so assume everything is ok; return ETrue runningInstanceFound = ETrue; process.Close(); break; } } process.Close(); } return runningInstanceFound; }
// ---------------------------------------------------------------------------------------- // CTerminalControlServer::StopProcessL // ---------------------------------------------------------------------------------------- void CTerminalControlServer::StopProcessByUidL ( const TUid& aUID ) { RDEBUG("CTerminalControlServer::StopProcessByUidL"); TInt rounds = 5; while( rounds-- ) { TFullName processName; TFindProcess findProcess; TInt ret = KErrNone; while( KErrNone == ( ret = findProcess.Next( processName ) ) ) { RProcess process; if( KErrNone == ( ret = process.Open( findProcess ) ) ) { if( aUID == process.SecureId() ) { RDEBUG("CTerminalControlServer::StopProcessByUidL Process with correct UID found => Kill(0) "); process.Kill( 0 ); } } else { RDEBUG_2("CTerminalControlServer::StopProcessByUidL process.Open returned %d", ret ); } } if( KErrNone != ret ) { RDEBUG_2("CTerminalControlServer::StopProcessByUidL findProcess.Next returned %d", ret ); } } }
/* ----------------------------------------------------------------------------- ---------------------------------------------------------------------------- */ TBool CTraceContainer::IsServerOn() { TBool Ret(EFalse); TFileName res; TFindProcess find; while(find.Next(res) == KErrNone) { RProcess ph; ph.Open(res); if(ph.SecureId() == (TUint32)KUidTraceServerUID.iUid) { TExitType Exxit =ph.ExitType(); if(Exxit == EExitPending) { Ret = ETrue; break; } } ph.Close(); } return Ret; }
TBool IsAlreadyRunning() { RDebug::Print(_L("TrkLauncher::IsAlreadyRunning()")); _LIT(KTrkConsoleSearchPattern, "*TRKPROCESS*"); _LIT(KTrkConsoleProcessPattern, "*"); TFindProcess finder; TFullName fullName; TBool found = EFalse; finder.Find(KTrkConsoleProcessPattern); while (!found && finder.Next(fullName) == KErrNone) { fullName.UpperCase(); if (fullName.Match(KTrkConsoleSearchPattern) != KErrNotFound) { found = ETrue; RDebug::Print(_L("process found Inside while")); break; } } if (found) { RDebug::Print(_L("TrkLauncher - Process found outside while")); } else { RDebug::Print(_L("TrkLauncher - Process was never found")); } return found; }
/* ----------------------------------------------------------------------------- ----------------------------------------------------------------------------- */ void CExPolicy_Server::KillProcess(TDes8& aName) { TFileName res,Hjep; Hjep.Copy(aName); TFindProcess find; while(find.Next(res) == KErrNone) { if(Hjep == res) { RProcess ph; ph.Open(find); ph.Kill(0); break; } } }
/* Forces the shutdown of the LbsNetGateway executable. */ TInt CTe_LbsNetworkPrivacySuiteStepBase::StopNetGateway() { // Shutdown the network gateway via the process // supervisor api that LbsRoot uses. TRAPD(err, iProcessSupervisor.OpenL(KDummyNetworkGatewayUid)); if (err == KErrNone) { // Find the network gateway manager process RProcess process; TFullName fullName; TFindProcess findProcess; _LIT(KGatewayProcessPattern, "te_dummynetgateway.exe*"); TBool runningInstanceFound = EFalse; findProcess.Find(KGatewayProcessPattern); while (err = findProcess.Next(fullName), err == KErrNone) { TInt processOpenErr = process.Open(findProcess); if (processOpenErr == KErrNone) { TExitType exitType = process.ExitType(); if (exitType == EExitPending) { // found a running instance of the process, // so assume everything is ok; runningInstanceFound = ETrue; break; } } process.Close(); } if (runningInstanceFound) { TRequestStatus status; process.Logon(status); iProcessSupervisor.CloseDownProcess(); User::WaitForRequest(status); process.Close(); iProcessSupervisor.Close(); } } return err; }
/* ----------------------------------------------------------------------------- ---------------------------------------------------------------------------- */ TBool CCrashContainer::IsServerOn() { TBool Ret(EFalse); TFileName res; TFindProcess find; while(find.Next(res) == KErrNone) { RProcess ph; ph.Open(res); if(ph.SecureId() == (TUint32)KUidCrashServerUID.iUid) { Ret = ETrue; break; } ph.Close(); } return Ret; }
/* ----------------------------------------------------------------------------- ---------------------------------------------------------------------------- */ TBool CMgAppUi::IsDrawerOn(void) { TBool Ret(EFalse); TFileName res; TFindProcess find; while(find.Next(res) == KErrNone) { RProcess ph; ph.Open(res); if(ph.SecureId() == (TUint32)(KUidServer.iUid)) { Ret = ETrue; break; } ph.Close(); } return Ret; }
// ============================================================== // ============ DoKillProcessL() ============= // ============================================================== void DoKillProcessL( const TDesC& aProcessName ) { TFullName psName; psName.Append( _L("*") ); psName.Append( aProcessName ); psName.Append( _L("*") ); TFindProcess psFinder; psFinder.Find( psName ); TInt killCount( 0 ); while( psFinder.Next( psName ) != KErrNotFound ) { RProcess ps; User::LeaveIfError( ps.Open( psFinder ) ); ps.Kill( -666 ); ps.Close(); killCount++; } User::Leave( killCount ); }
/* ----------------------------------------------------------------------------- ---------------------------------------------------------------------------- */ TBool CMainContainer::IsServerOn(const TDesC& aName) { TBool Ret(EFalse); TFileName res; TFindProcess find; while(find.Next(res) == KErrNone) { RProcess ph; ph.Open(res); if(ph.FileName().Find(aName) != KErrNotFound) { Ret = ETrue; break; } ph.Close(); } return Ret; }
// ---------------------------------------------------------------------------- // Searches process id for target selector plugin. // When the player has been opened in a mode, which is bound to the same engine // than certain application's engine, then need to fetch its process id. // (As a reference for parameter aMode see MMPXPlaybackUtility modes.) // Otherwise target selector plugin is notified wrongly about registered client // and key events are not propagated to correct application. // ---------------------------------------------------------------------------- // static void FindProcessIdForTsp( TInt aMode, TProcessId& aProcessId ) { TBool processFound( EFalse ); TFindProcess processFinder; TFullName processName; while ( processFinder.Next( processName ) == KErrNone && !processFound ) { RProcess process; TInt err = process.Open( processFinder ); if( err == KErrNone ) { if( process.SecureId().iId == aMode && process.ExitType() == EExitPending ) { MPX_DEBUG4("FindProcessIdForTsp(): pid changed from %d to %d (mode 0x%x)", TUint(aProcessId), TUint(process.Id()), aMode); aProcessId = process.Id(); processFound = ETrue; } process.Close(); } } }
HBufC8* CAgentDevice::GetInfoBufferL() { //create buffer CBufBase* buffer = CBufFlat::NewL(50); CleanupStack::PushL(buffer); TBuf<128> buf; _LIT(KNewLine,"\n"); // Processor TInt cpu = 0; HAL::Get(HAL::ECPU,cpu); TBuf<8> cpuBuf; switch (cpu){ case HAL::ECPU_ARM: cpuBuf.Copy(_L("ARM")); break; case HAL::ECPU_MCORE: cpuBuf.Copy(_L("MCORE")); break; case HAL::ECPU_X86: cpuBuf.Copy(_L("X86")); break; default: cpuBuf.Copy(_L("Unknown")); break; } _LIT(KFormatProcessor,"Processor: %S\n"); buf.Zero(); buf.Format(KFormatProcessor,&cpuBuf); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // Battery _LIT(KFormatBattery,"Battery: %u%% (on AC line)\n"); _LIT(KFormatBattery2,"Battery: %u%% \n"); TUint chargeLevel=0; CTelephony::TBatteryStatus batteryStatus; iPhone->GetBatteryInfoSync(chargeLevel, batteryStatus); buf.Zero(); if((batteryStatus == CTelephony::EBatteryConnectedButExternallyPowered) || (batteryStatus == CTelephony::ENoBatteryConnected)) { buf.Format(KFormatBattery,chargeLevel); } else { buf.Format(KFormatBattery2,chargeLevel); } buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // RAM TInt ram = 0; HAL::Get(HAL::EMemoryRAM, ram); TInt freeRam = 0; HAL::Get(HAL::EMemoryRAMFree, freeRam); _LIT(KFormatRam,"Memory: %i bytes free / %i bytes total\n"); buf.Zero(); buf.Format(KFormatRam,freeRam,ram); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // Storage _LIT(KFormatStorage,"Disk %c: %S - %Li bytes free / %Li bytes total\n"); TVolumeInfo volumeInfo; //TDriveInfo driveInfo; for (TInt driveNumber=EDriveA; driveNumber<=EDriveZ; driveNumber++) { // get drive info /* TInt err = iFs.Drive(driveInfo,driveNumber); if (err!=KErrNone) { continue; } */ // get volume info TInt err = iFs.Volume(volumeInfo,driveNumber); if (err!=KErrNone) { continue; } TChar letter; iFs.DriveToChar(driveNumber,letter); buf.Zero(); buf.Format(KFormatStorage,(TUint)letter,&volumeInfo.iName,volumeInfo.iFree,volumeInfo.iSize); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); } // OS version TBuf<KSysUtilVersionTextLength> versionBuf; SysUtil::GetSWVersion(versionBuf); _LIT(KFormatOsVersion,"\nOS Version: %S \n"); buf.Zero(); buf.Format(KFormatOsVersion,&versionBuf); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // device _LIT(KFormatDevice,"\nDevice: %S (%S)\n"); TBuf<CTelephony::KPhoneManufacturerIdSize> manufacturer; TBuf<CTelephony::KPhoneModelIdSize> model; iPhone->GetPhoneIdSync(manufacturer,model); buf.Zero(); buf.Format(KFormatDevice,&model,&manufacturer); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // IMSI TBuf<CTelephony::KIMSISize> imsi; iPhone->GetImsiSync(imsi); _LIT(KFormatImsi,"IMSI: %S \n"); buf.Zero(); buf.Format(KFormatImsi,&imsi); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // IMEI TBuf<CTelephony::KPhoneSerialNumberSize> imei; iPhone->GetImeiSync(imei); _LIT(KFormatImei,"IMEI: %S \n"); buf.Zero(); buf.Format(KFormatImei,&imei); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // Carrier //TBuf<CTelephony::KNetworkShortNameSize> carrier; TBuf<CTelephony::KNetworkLongNameSize> carrier; iPhone->GetOperatorNameSync(carrier); _LIT(KFormatCarrier,"Carrier: %S \n"); buf.Zero(); buf.Format(KFormatCarrier,&carrier); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // Uptime _LIT(KFormatUptime,"Uptime: %i days, %i hours, %i minutes\n"); TInt ms = User::NTickCount(); TInt min = (ms/(1000*60))%60; TInt hours = (ms/(1000*60*60))%24; TInt days = (ms/(1000*60*60*24)); buf.Zero(); buf.Format(KFormatUptime,days,hours,min); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); if(iList) { RApaLsSession lsSession; TApaAppInfo appInfo; TApaAppCapabilityBuf capability; //_LIT(KNewLine,"\n"); // Applications list: if( lsSession.Connect() == KErrNone) { CleanupClosePushL( lsSession ); lsSession.GetAllApps(); _LIT(KAppList,"\nApplication List: \n"); buffer->InsertL(buffer->Size(),KAppList().Ptr(),KAppList().Size()); while( lsSession.GetNextApp( appInfo ) == KErrNone ) { buffer->InsertL(buffer->Size(), appInfo.iCaption.Ptr(), appInfo.iCaption.Size()); buffer->InsertL(buffer->Size(),KNewLine().Ptr(),KNewLine().Size()); } CleanupStack::PopAndDestroy(&lsSession); } // Running processes TFullName res; TFindProcess proc; _LIT(KProcList,"\nProcesses List:\n"); buffer->InsertL(buffer->Size(),KProcList().Ptr(),KProcList().Size()); while(proc.Next(res) == KErrNone) { RProcess ph; TInt err = ph.Open(proc); if(err!=KErrNone) { continue; } buffer->InsertL(buffer->Size(),ph.Name().Ptr(),ph.Name().Size()); buffer->InsertL(buffer->Size(),KNewLine().Ptr(),KNewLine().Size()); ph.Close(); } } HBufC8* result = buffer->Ptr(0).AllocL(); CleanupStack::PopAndDestroy(buffer); return result; }
LOCAL_C void mainL() { CCommandLineArguments* cmdLine = CCommandLineArguments::NewLC(); TInt argTotal=cmdLine->Count(); if (argTotal < 2 || argTotal > 3) { User::Leave(KErrArgument); } TUint sidRequested; TLex processLex(cmdLine->Arg(1)); User::LeaveIfError(processLex.Val(sidRequested, EHex)); if (sidRequested == 0) { User::Leave(KErrArgument); } if (argTotal == 3) { TUint timeout; TLex timeoutLex(cmdLine->Arg(2)); User::LeaveIfError(timeoutLex.Val(timeout)); if (timeout > 0) { User::After(timeout); } } TUid sid = {sidRequested}; TBool needToScanFullList; TFullName fullName; do { needToScanFullList = EFalse; TFindProcess findProcess; while(findProcess.Next(fullName) == KErrNone) { RProcess process; TInt ret=KErrNone; TInt count=0; do { count++; ret=process.Open(findProcess); if (ret!=KErrNone) { User::After(200000); } }while (ret!=KErrNone && count<=10); if (ret!=KErrNone) { User::Leave(ret); } TUid processSid(process.SecureId()); if (processSid == sid && process.ExitType() == EExitPending) { process.Kill(KErrNone); needToScanFullList = ETrue; } process.Close(); } } while (needToScanFullList); CleanupStack::PopAndDestroy(cmdLine); }
// ---------------------------------------------------------------------------------------- // CTerminalControlServer::StopProcessByFullNameL // ---------------------------------------------------------------------------------------- void CTerminalControlServer::StopProcessByFullNameL(const TDesC8& aName) { RDEBUG("[CTerminalControlServer]-> StopProcessByFullNameL() >>>"); TInt rounds = 5; TFileName lMatchStr; lMatchStr.Copy(aName); lMatchStr.LowerCase(); TBool lIsAbsolute = EFalse; if(lMatchStr.LocateReverse(TChar('\\')) != KErrNotFound) { lIsAbsolute = ETrue; } while(rounds--) { TInt ret = KErrNone; TFullName processName; TFindProcess findProcess; while(KErrNone == (ret = findProcess.Next(processName))) { RProcess process; if(KErrNone == (ret = process.Open(findProcess))) { RDEBUG("[CTerminalControlServer]-> Process.Open() returned"); TFileName lStrSource(process.FileName()); lStrSource.LowerCase(); if(lIsAbsolute) { RDEBUG("[CTerminalControlServer]-> INFO: The input was specified as an absolute path..."); if(lStrSource.Compare(lMatchStr) == 0) { RDEBUG("[CTerminalControlServer]-> Process with correct Filename found => Kill(0) "); process.Kill(0); } } else { RDEBUG("[CTerminalControlServer]-> INFO: The input was specified as an application name..."); TInt lLastDirSepIndex = lStrSource.LocateReverse('\\'); TInt lExeIndex = lStrSource.Find(_L(".exe")); if(lLastDirSepIndex < lExeIndex) { TInt lAppNameIndex = lStrSource.Find(lMatchStr); /* * The logic works like this, if the value of lStrSource was 'z:\sys\bin\calendar.exe', lMatchStr would contain calendar * the values of the variables will be as follows * lLastDirSepIndex = 10 * lAppNameIndex = 11 * lExeIndex = 19 * * The below logic would make sure that the right process is killed */ if((lAppNameIndex == (lLastDirSepIndex + 1)) && ((lAppNameIndex + lMatchStr.Length()) == lExeIndex)) { RDEBUG("[CTerminalControlServer]-> Process with correct Filename found => Kill(0)"); process.Kill(0); } } } } else { RDEBUG_2("[CTerminalControlServer]-> Process.Open() returned %d", ret); } } if(KErrNone != ret) { RDEBUG_2("[CTerminalControlServer]-> findProcess.Next() returned %d", ret); } } RDEBUG("[CTerminalControlServer]-> StopProcessByFullNameL() <<<"); }
TVerdict Cman6Step::doTestStepL() /** * @return - TVerdict code * Override of base class pure virtual * Our implementation only gets called if the base class doTestStepPreambleL() did * not leave. That being the case, the current test result value will be EPass. */ { if (TestStepResult()==EPass) { TTime time; time.UniversalTime(); RDebug::Printf("%02d:%02d:%02d:%06d [%Ld] xxxxx Cman6Step::doTestStepL start", time.DateTime().Hour(), time.DateTime().Minute(), time.DateTime().Second(),time.DateTime().MicroSecond(), RProcess().Id().Id()); //This should be run as the last test in the te_man suite. This test uses the Root API // CLbsCloseDownRequestDetector to simulate the Root telling the AGPS Manager to shutdown. // The Manager should send a CancelLocationRequest message and a CloseDown power message // to the integration module. The Manager should then wait until the module makes the // Shutdown() call before beginning the shut down process. //Setup the test AGPS Module Channel RAgpsModuleTestChannel moduleInt; moduleInt.OpenL(); CleanupClosePushL(moduleInt); //Setup the root process ShutDown RLbsProcessSupervisor shutDownProcess; TUid managerModuleId = TUid::Uid(0x10281D44); //KLbsGpsLocManagerUidValue shutDownProcess.OpenL(managerModuleId); CleanupClosePushL(shutDownProcess); //Open up the test AGPS Manager Process RProcess proc; _LIT(KMatchName,"testlbsgpslocmanager*"); TFindProcess procName; TFullName procFullName; procName.Find(KMatchName); procName.Next(procFullName); //Check to see whether the manager process is still up and running TInt rc = proc.Open(procFullName); if(rc != KErrNone) { //Error, process has already closed down before receiving the shutdown from the module INFO_PRINTF1(_L("Error - cannot find the GPS Location Manager Process, failing test")); SetTestStepResult(EFail); } else { //Send the Shut Down to the Manager shutDownProcess.CloseDownProcess(); //The test integration module will wait 5 seconds before sending the shutdown message to // the manager. So the AGPS Manager should still be open. The test should wait here // until the AGPS Manager process is closed down. If the test times out, it is likely that // the AGPS Manager process was never closed, so the test cannot progress past this part TRequestStatus procStatus; proc.Logon(procStatus); time.UniversalTime(); RDebug::Printf("%02d:%02d:%02d:%06d [%Ld] xxxxx Cman6Step::doTestStepL after logon", time.DateTime().Hour(), time.DateTime().Minute(), time.DateTime().Second(),time.DateTime().MicroSecond(), RProcess().Id().Id()); User::WaitForRequest(procStatus); time.UniversalTime(); RDebug::Printf("%02d:%02d:%02d:%06d [%Ld] xxxxx Cman6Step::doTestStepL after wait", time.DateTime().Hour(), time.DateTime().Minute(), time.DateTime().Second(),time.DateTime().MicroSecond(), RProcess().Id().Id()); //When the Integration Module sends the shutdown message to the manager it updates the test // channel (so this message should also take 5 seconds before appearing on the channel and should // only appear when the manager has been given permission to close down). Check the channel // to make sure the right message is present (ShutdownEvent) RAgpsModuleTestChannel::TTestMsgType messageType = RAgpsModuleTestChannel::ETestMsgUnknown; moduleInt.GetMsg(messageType); if(messageType == RAgpsModuleTestChannel::ETestMsgShutdownEvent) { INFO_PRINTF1(_L("Module correctly waited for Shutdown call from Module to shutdown and then shutdown the manager process.")); SetTestStepResult(EPass); } else { INFO_PRINTF1(_L("Error - AGPS Manager has already been shutdown before receiving Shutdown() from Module")); SetTestStepResult(EFail); } } proc.Close(); CleanupStack::Pop(2, &moduleInt); //moduleInt, shutDownProcess } return TestStepResult(); }
int main(int argc, char *argv[]) { bool running = false; TFullName res; TFindProcess find; while(find.Next(res) == KErrNone) { RProcess ph; ph.Open(res); if(ph.SecureId() == 0x2002B30D) if (ph.ExitType() == EExitPending) { running = true; break; } ph.Close(); } if (running == false) { QProcess *myProcess = new QProcess; myProcess->start("whatsapp.exe"); } else { QApplication app(argc, argv); CAknConfirmationNote* run = new (ELeave) CAknConfirmationNote; QT_TRAP_THROWING(run->ExecuteLD(_L("Closed WhatsApp"))); TFullName res1; TFindProcess find1(_L("*[2002B306]*")); while(find1.Next(res1) == KErrNone) { RProcess ph1; ph1.Open(find1); ph1.Kill(KErrNone); ph1.Close(); } TFullName res2; TFindProcess find2(_L("*[2002B310]*")); while(find2.Next(res2) == KErrNone) { RProcess ph2; ph2.Open(find2); ph2.Kill(KErrNone); ph2.Close(); } TFullName res3; TFindProcess find3(_L("*[2002B30D]*")); while(find3.Next(res3) == KErrNone) { RProcess ph3; ph3.Open(find3); ph3.Kill(KErrNone); ph3.Close(); } QTest::qWait(1500); } return 1; }
TVerdict CFindRunningExe::doTestStepL() { TInt uidValue; _LIT(KUidKey, "uid"); if (!GetHexFromConfig(ConfigSection(), KUidKey, uidValue)) { ERR_PRINTF1(_L("Cannot read UID from config section.")); SetTestStepResult(EFail); return EFail; } TUid exeUid; exeUid.iUid = uidValue; SetTestStepResult(EFail); TInt loop=0; for(;(loop < 20)&&(TestStepResult() == EFail);loop++) { TFindProcess findProcess; TFullName fullName; while((findProcess.Next(fullName) == KErrNone) && (TestStepResult() == EFail)) { RProcess process; TInt ret=KErrNone; TInt count=0; do { count++; ret=process.Open(findProcess); if (ret!=KErrNone) { User::After(200000); } }while (ret!=KErrNone && count<=10); if (ret!=KErrNone) { User::Leave(ret); } TUidType uid = process.Type(); TExitType exitType = process.ExitType(); process.Close(); if(uid[2] == exeUid) { if (exitType == EExitPending) SetTestStepResult(EPass); } } User::After(1000000); } if (TestStepResult() == EPass) { INFO_PRINTF2(_L("Process with UID 0x%x running."), exeUid.iUid); } else { ERR_PRINTF2(_L("No process with UID 0x%x running."), exeUid.iUid); } return TestStepResult(); }
// ---------------------------------------------------------------------------------------- // CTerminalControlServer::GetRunningProcessesL // ---------------------------------------------------------------------------------------- CBufFlat* CTerminalControlServer::GetRunningProcessesL( ) { RDEBUG("CTerminalControlServer::GetRunningProcessesL"); TFullName processName; TFindProcess findProcess; CBufFlat *buffer = CBufFlat::NewL(128); iProcessInfoArray->Reset(); while( KErrNone == findProcess.Next( processName ) ) { TTcProcessInfo info; RProcess process; if( KErrNone == process.Open( findProcess ) ) { // // Add process information to local array // info.iProcessName = processName; info.iFileName = process.FileName(); info.iHandle = process.Handle(); info.iId = process.Id(); info.iSecureId = process.SecureId(); info.iProtected = EFalse; process.GetMemoryInfo( info.iMemoryInfo ); User::IsRomAddress( info.iCodeInRom, (TAny*)(info.iMemoryInfo.iCodeBase) ); if( !info.iCodeInRom ) { User::IsRomAddress( info.iCodeInRom, (TAny*)(info.iMemoryInfo.iCodeBase) ); } iProcessInfoArray->AppendL( info ); // // Add process also to return buffer // /* TInt appendPosition = buffer->Size(); if(iProcessInfoArray->Count() >= 2) { TBuf8<sizeof(info.iProcessName)> proName; proName.Copy(info.iProcessName); buffer->InsertL(appendPosition, _L8("/")); buffer->InsertL(appendPosition+1, proName); } else { TBuf8<sizeof(info.iProcessName)> proName; proName.Copy(info.iProcessName); buffer->InsertL(appendPosition, proName); } } */ // Enumerate names from 1 TInt appendPosition = buffer->Size(); TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> numBuf; TBuf8<sizeof(KFormatProcessNamePrefix)+20> nameBuf; numBuf.Num(iProcessInfoArray->Count()); nameBuf.Zero(); nameBuf.Append(KFormatProcessNamePrefix); nameBuf.Append(numBuf); if(iProcessInfoArray->Count() >= 2) { buffer->InsertL(appendPosition, _L8("/")); buffer->InsertL(appendPosition+1, nameBuf); } else { buffer->InsertL(appendPosition, nameBuf); } } } /* TUint32 flags = Exec::ProcessFlags(KCurrentProcessHandle); if (flags & KProcessFlagSystemPermanent) return ESystemPermanent; if (flags & KProcessFlagSystemCritical) return ESystemCritical; if (flags & KThreadFlagProcessPermanent) return EAllThreadsCritical; return ENotCritical; */ return buffer; }