自学教程：C++ After函数代码示例

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

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

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

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