// ----------------------------------------------------------------------------- // CVibraTimer::Set(TInt aIntervalInMilliSecs) // Start the timer to complete after the specified number of microseconds. // If the duration is zero, then timer is set to predefined maximum value. // ----------------------------------------------------------------------------- // TInt CVibraTimer::Set(TInt aIntervalInMilliSecs) { __ASSERT_ALWAYS(CActiveScheduler::Current()!= NULL, User::Invariant()); if (!IsAdded()) { CActiveScheduler::Add(this); } // If the timer is already running, cancel it... if (IsActive()) { Cancel(); } // And set the new timer... // Convert to uS first -- which is, after all, why this method really exists... if ((0 == aIntervalInMilliSecs) || (aIntervalInMilliSecs > iMaximumVibraTimeMs)) { After(iMaximumVibraTimeMs * 1000); } else { After(aIntervalInMilliSecs * 1000); } return KErrNone; }
void CIkev1SA::StartTimer() { if (iRemainingTime > KMaxTInt/SECOND) //To avoid overflowing the Timer { iRemainingTime -= KMaxTInt/SECOND; After(KMaxTInt); } else //No overflow { After(iRemainingTime*SECOND); iRemainingTime = 0; } }
void CSenCoreShutdownTimer::ActivateShutdown() { CActiveScheduler::Add(this); if( iShutdownTimeInSecs > 0 ) { TTimeIntervalMicroSeconds32 interval = iShutdownTimeInSecs * 1000 * 1000; After( interval ); } else // use 30 secs (default) { TTimeIntervalMicroSeconds32 interval = KSenDefaultShutdownTime * 1000 * 1000; After( interval ); } }
/** * @brief Completes the second phase of Symbian object construction. * Put initialization code that could leave here. */ void Csymbian_ua_guiAppUi::ConstructL() { // [[[ begin generated region: do not modify [Generated Contents] BaseConstructL (EAknEnableSkin); InitializeContainersL(); // ]]] end generated region [Generated Contents] // Create private folder RProcess process; TFileName path; path.Copy (process.FileName().Left (2)); if (path.Compare (_L ("c")) || path.Compare (_L ("C"))) CEikonEnv::Static()->FsSession().CreatePrivatePath (EDriveC); else if (path.Compare (_L ("e")) || path.Compare (_L ("E"))) CEikonEnv::Static()->FsSession().CreatePrivatePath (EDriveE); // Init PJSUA if (symbian_ua_init() != 0) { symbian_ua_destroy(); Exit(); } ExecuteDlg_wait_initLD(); CTimer::ConstructL(); CActiveScheduler::Add (this); After (4000000); }
void CTestTimer::QueueAndInfoPrint() { After(iSecondsRemaining*1000000); TBuf<100> message; message.Format(_L("%d seconds remaining"), iSecondsRemaining); User::InfoPrint(message); }
/** Starts the shutdown timer. */ void CLlcpTimer::Start(TInt aMSecs) { BEGIN const TUint KDelay = (1000 * aMSecs); After(KDelay); END }
void CIkeV1KeepAlive::StartTimer() { if ( iRemainingTime > KMaxTInt/1000000 ) //To avoid overflowing the Timer { iRemainingTime -= KMaxTInt/1000000; After(KMaxTInt); } else //No overflow { if ( iRemainingTime ) { After(iRemainingTime*1000000); } iRemainingTime = 0; } }
/** context sensitive completion * take current line, give list of completions (both atoms and files) * thanks to Jan for crafting a proper interface wrapping SWI-Prolog available facilities */ QString Completion::initialize(int promptPosition, QTextCursor c, QStringList &strings) { QString rets; SwiPrologEngine::in_thread _int; try { int p = c.position(); Q_ASSERT(p >= promptPosition); c.setPosition(promptPosition, c.KeepAnchor); QString left = c.selectedText(); if (left.length()) { PlString Before(left.toStdWString().data()); c.setPosition(p); c.movePosition(c.EndOfLine, c.KeepAnchor); QString after = c.selectedText(); PlString After(after.toStdWString().data()); PlTerm Completions, Delete, word; if (PlCall("prolog", "complete_input", PlTermv(Before, After, Delete, Completions))) for (PlTail l(Completions); l.next(word); ) strings.append(t2w(word)); c.setPosition(p); rets = t2w(Delete); } } catch(PlException e) { qDebug() << t2w(e); } catch(...) { qDebug() << "..."; } return rets; }
void CTReadWrite::ReadL() { ReadFuncL(); if(iFrameNumber != KNumberOfFrames) { iFrameNumber++; for(TInt i=0; i<iBufferSize; i++) { if(iData[i] != iInitialColour) { RDebug::Print(_L("Unexpected pixel colour %x"), iData[i]); CActiveScheduler::Stop(); iTestPass = EFalse; return; } } //Re-issue the request After(TTimeIntervalMicroSeconds32(0)); } else { //Stop the active scheduler and process with test termination CActiveScheduler::Stop(); } }
void CTReadWrite::ReadWriteImageL() { ReadImageFuncL(); TBool ret = EFalse; for(TInt i=0; i<iBufferSize; i++) { if(iData[i] == iInitialColour) { iData[i] = iFinalColour; WriteImageFuncL(); //Re-issue the request After(TTimeIntervalMicroSeconds32(0)); ret = ETrue; break; } else if(iData[i] != iFinalColour) { CActiveScheduler::Stop(); iTestPass = EFalse; ret = ETrue; break; } } //If no pixels have been modified, check to see if the test should finish if( (IsFinished() != EFalse) && (ret == EFalse) ) { //Stop the active scheduler and process with test termination CActiveScheduler::Stop(); } }
void CIkev1SA::SetExpired() { DEBUG_LOG(_L("CIkev1SA::SetExpired")); if ( !iExpired ) //If already expired do nothing to avoid renewing the expiration timer. { DEBUG_LOG(_L("SA is still active. Expiring it...")); iExpired = ETrue; //if ( iHdr.iIkeData->iIpsecExpires ) //{ //DEB(iEngine->PrintText(_L("iIpsecExpires is ETrue\n"));) for (TInt i = 0; i < iSPIList->Count(); i++) { DEBUG_LOG(_L("Deleting IPsec SA")); TIpsecSPI* spi_node = iSPIList->At(i); iPluginSession.DeleteIpsecSA( spi_node->iSPI, spi_node->iSrcAddr, spi_node->iDstAddr, spi_node->iProtocol ); } //} Cancel(); //Cancel the current timer After(ISAKMP_DELETE_TIME); } }
void CGlxMediaListsTestCollectionPlugin::CTestTimer::RunL() { CMPXMedia* media = CMPXMedia::NewL(); CleanupStack::PushL(media); media->SetTObjectValueL<TMPXGeneralCategory>(KMPXMediaGeneralCategory, EMPXImage); switch (iNextEvent) { case EAddItem: iPlugin->AddL(*media); iNextEvent = ERemoveItem; break; case ERemoveItem: iPlugin->RemoveL(*media); iNextEvent = EAddItem; break; default: break; } CleanupStack::PopAndDestroy(media); After(2000000); }
void CSoftwareConnectTimer::SoftwareDisconnect(TInt aInterval) { OstTraceFunctionEntryExt( CSOFTWARECONNECTTIMER_SOFTWAREDISCONNECT_ENTRY, this ); iConnectType = EDisconnect; After(aInterval*KOneSecond); OstTraceFunctionExit1( CSOFTWARECONNECTTIMER_SOFTWAREDISCONNECT_EXIT, this ); }
void CRepositoryCacheManager::RescheduleTimer(const TTime& aTimeInUTC) { TTime now; now.UniversalTime(); //Get the 64bit time interval between now and the cache timeout TTimeIntervalMicroSeconds interval64 = aTimeInUTC.MicroSecondsFrom(now); TTimeIntervalMicroSeconds32 interval32(iDefaultTimeout); //If the interval is positive, i.e. the timeout is in the future, convert //this interval to a 32 bit value, otherwise use the default timeout if(interval64 > 0) { //If the interval value is less than the maximum 32 bit value cast //interval to 32 bit value, otherwise the interval is too large for //a 32 bit value so just set the interval to the max 32 bit value const TInt64 KMax32BitValue(KMaxTInt32); interval32 = (interval64 <= KMax32BitValue) ? static_cast<TTimeIntervalMicroSeconds32>(interval64.Int64()): KMaxTInt32; } //Reschedule the timer After(interval32); }
// -------------------------------------------------------------------------- // CUPnPBrowseTimer::Start // Starts the periodizer. // -------------------------------------------------------------------------- // void CUPnPBrowseTimer::Start() { if ( !IsActive() ) { After( TTimeIntervalMicroSeconds32( iTimerWavelength ) ); } }
// ----------------------------------------------------------------------------- // CRadioServerShutdown::Start // ----------------------------------------------------------------------------- // void CRadioServerShutdown::Start() { if ( !IsActive() ) { After(KServerShutdownDelay); } }
void CIniFileManager::ScheduleSaveIniFileSettings(TInt aSaveFlags, TBool aReplace) { // make sure all requested writes are saved iSaveType |= aSaveFlags; iReplace = aReplace; // make sure change isn't due to Internalize if (iBackupFlag != EIsRestoring) { iBackupFlag = ERequestSave; //iNumberOfAttemptedRetries = 0; // set the time to RunL if not already set to run // check that no Backup or Restore is in progress, // For Backup And Restore if (!(iDbMgrCtrlr.BackupRestoreAgent().BackupInProgress()) && !(iDbMgrCtrlr.BackupRestoreAgent().RestoreInProgress())) { if (!IsActive()) { #ifdef INIFILE_DEBUG_LOG RDebug::Print(_L("\n[CNTMODEL] CIniFileManager::ScheduleSaveIniFileSettings(aSaveFlags = %i, aReplace %i)\r\n"),aSaveFlags, aReplace); #endif After(KIniFileSaveDelay); } } } }
/** Set rendering mode to synchronous or asynchronous @param aMode Rendering mode to set. */ void CEglContent::SetMode(TMode aMode) { if(aMode == iMode) return; iMode = aMode; // reset mode if(aMode == ESync) { // cancel request for next frame Cancel(); iFrame = 0; } else if(aMode == EAsync) { // render init frame iFrame = 0; RenderNextFrame(); // issue request for next frame After(KEglContentDelay); } else // EAsyncDebug { // render init frame iFrame = 0; RenderNextFrame(); } }
// --------------------------------------------------------------------------- // Notifies the Plug-in's client of stream's current sending status. // --------------------------------------------------------------------------- // void CNATFWStunConnectionHandler::RunL() { ExecuteCallBack(); if ( iCallBackCmds.Count() ) { After( KWaitTime ); } }
/** * Retry a previously requested backup operation */ void CASSrvAlarmStore::RetryStoreOperation() { if (iFlags.IsSet(ERequestExternalize) && !IsActive()) { // can RunL now After(0); } }
void CMMF_TSU_SWCDWRAP_MakeAsyncHwDeviceCall::CallStopAndDeleteCodecAfter(CMMFHwDevice& aHwDevice, TTimeIntervalMicroSeconds32 aTimeInterval) { iCallActionCancelled = EFalse; iHwDevice = &aHwDevice; iCallStopAndDeleteCodec = ETrue; iStopError = KErrNone; After(aTimeInterval); }
// --------------------------------------------------------------------------- //CheckStatus of CacheDb and do cleanup if necessary // --------------------------------------------------------------------------- // void CIRCacheCleanup::CheckStatusL() { IRLOG_DEBUG( "CIRCacheCleanup::CheckStatusL - Entering" ); TTimeIntervalMicroSeconds32 interval(GetCleanupInterval()); After(interval); CleanupCacheDbL(); IRLOG_DEBUG( "CIRCacheCleanup::CheckStatusL - Exiting" ); }
inline void CShutdown::Start() { RDEBUG( "creenSaverServer: starting shutdown timeout" ); After(KSCPClientTestServerShutdownDelay); //SetActive(); }
// ----------------------------------------------------------------------------- // CNaviScrollTimer::StartScroll() // Starts to scroll the navigation pane text. // ----------------------------------------------------------------------------- // void CNaviScrollTimer::StartScroll() { // Start scrolling only if text do not fit to navi pane if( iNaviText->Des().Length() > KMaxVisibleStringLenth ) After( 1 ); else UpdateNaviPaneL(); }
void CMTPDeviceInfoTimer::Start() { OstTraceFunctionEntry0( CMTPDEVICEINFOTIMER_START_ENTRY ); After(KMTPDeviceInfoDelay); iState = EStartTimer; OstTraceFunctionExit0( CMTPDEVICEINFOTIMER_START_EXIT ); }
void CMMF_TSU_SWCDWRAP_MakeAsyncHwDeviceCall::CallPauseAfter(CMMFHwDevice& aHwDevice, TTimeIntervalMicroSeconds32 aTimeInterval) { iCallActionCancelled = EFalse; iHwDevice = &aHwDevice; iCallPause = ETrue; iPauseError = KErrNone; After(aTimeInterval); }
// ----------------------------------------------------------------------------- // CObexUtilsDialogTimer::Tickle // ----------------------------------------------------------------------------- // void CObexUtilsDialogTimer::Tickle() { FLOG(_L("[OBEXUTILS]\t CObexUtilsDialogTimer::Tickle()")); Cancel(); After( iTimeout ); FLOG(_L("[OBEXUTILS]\t CObexUtilsDialogTimer::Tickle() completed")); }
EXPORT_C void CRegisteredParserDll::ReleaseLibrary() /** Releases the parser DLL, and decrements the reference count. */ { iDllRefCount--; if(iDllRefCount==0) { After(KReleaseLibraryTimeout); } }
// ----------------------------------------------------------------------------- // CRadioServerShutdown::Start // ----------------------------------------------------------------------------- // void CSensrvShutdown::Start() { COMPONENT_TRACE( _L( "Sensor Server - CSensrvShutdown::Start" ) ); if ( !IsActive() ) { After(iProxyManager.TerminationPeriod()); } COMPONENT_TRACE( _L( "Sensor Server - CSensrvShutdown::Start - return" ) ); }
/** * @see CActive */ void CASSrvAlarmStore::RunL() { TInt error = iStatus.Int(); // operation isn't cancelled if (error == KErrNone) { // task : Externalize if (iFlags.IsSet(ERequestExternalize)) { // Try to Externalize error = Externalize(); if (error < KErrNone) { ++iNumberOfAttemptedRetries; // check retries, and reschedule if (iNumberOfAttemptedRetries == KNumberOfAttemptsAtExternalizingFile) { // Try one last time. Wait for 10 mins and then attempt operation again. // After that, give up. // // Possible reasons for entering this state: // // Low disk space, low memory, corrupt file system, etc etc. Don't think // its acceptable to panic - operation should be failed gracefully. After(KDelayInMicrosecondsBetweenFileOperationsLongDelay); } else if (iNumberOfAttemptedRetries < KNumberOfAttemptsAtExternalizingFile) { // Try again after the delay After(KDelayInMicrosecondsBetweenFileOperations); } else { // Tried max number of times already. Give up. iFlags.Clear(ERequestExternalize); } } } } }