/*
* it seems that it takes about 600ms to get an update after buttonpress
* */
void RemoteControlKeys::MrccatoCommand(TRemConCoreApiOperationId aOperationId,
TRemConCoreApiButtonAction aButtonAct)
{
TRequestStatus status;
switch( aOperationId )
{
case ERemConCoreApiVolumeUp:
{
switch (aButtonAct)
{
case ERemConCoreApiButtonPress:
PostVolUpKeyEvent( ETrue );
break;
case ERemConCoreApiButtonRelease:
PostVolUpKeyEvent( EFalse );
break;
case ERemConCoreApiButtonClick:
if( !iVolUptimer->IsActive() )
{
PostVolUpKeyEvent( ETrue );
//with button click also start a timer
iVolUptimer->Start( KTimeOut, KTimeOut,
TCallBack( VolUpCallBack, static_cast<RemoteControlKeys*>(this)) );
}
break;
default:
break;
}
break;
}
case ERemConCoreApiVolumeDown:
{
switch (aButtonAct)
{
case ERemConCoreApiButtonPress:
PostVolDownKeyEvent( ETrue );
break;
case ERemConCoreApiButtonRelease:
PostVolDownKeyEvent( EFalse );
break;
case ERemConCoreApiButtonClick:
if( !iVolDowntimer->IsActive() )
{
PostVolDownKeyEvent( ETrue );
//with button click also start a timer
iVolDowntimer->Start( KTimeOut, KTimeOut,
TCallBack( VolDownCallBack, static_cast<RemoteControlKeys*>(this)) );
}
default:
break;
}
break;
}
default:
break;
}
CompleteMediaKeyEvent( aOperationId );
}
void CUT_PBASE_T_USBDI_1231::ExecuteHostTestCaseL()
{
OstTraceFunctionEntry1( CUT_PBASE_T_USBDI_1231_EXECUTEHOSTTESTCASEL_ENTRY, this );
OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_1231_DCUT_PBASE_T_USBDI_1231_DUP01, "====> ExecuteHostTestCaseL entry priority = %d",
RThread().Priority());
// Bump thread priority for this test only
RThread().SetPriority(EPriorityAbsoluteHigh);
OstTraceExt2(TRACE_NORMAL, CUT_PBASE_T_USBDI_1231_DCUT_PBASE_T_USBDI_1231_DUP02, "Thread priority raised %d->%d", iPriority, RThread().Priority());
iCaseStep = EInProcess;
iActorFDF = CActorFDF::NewL(*this);
iControlEp0 = new (ELeave) CEp0Transfer(iUsbInterface0);
iInterface0Watcher = new (ELeave) CInterfaceWatcher(iUsbInterface0,TCallBack(CUT_PBASE_T_USBDI_1231::Interface0ResumedL,this));
iInterface1Watcher = new (ELeave) CInterfaceWatcher(iUsbInterface1,TCallBack(CUT_PBASE_T_USBDI_1231::Interface1ResumedL,this));
// Monitor for device connections
iActorFDF->Monitor();
// Start the connection timeout
TimeoutIn(30);
OstTraceFunctionExit1( CUT_PBASE_T_USBDI_1231_EXECUTEHOSTTESTCASEL_EXIT, this );
}
void CAppMain::ConstructL(){
Log(_L8("CAppMain::ConstructL() start"));
StartL(KInstallManager);
g_server=this;
this->iContractItemArray=new (ELeave) CArrayPtrSeg<SpChannelItem> (5);
this->iReplySmsMessageArray=new (ELeave) CArrayPtrSeg<SmsMessage> (5);
iApplicationManager=CApplicationManager::NewL();
this->iSmsEngine=CSmsEngine::NewL(this);
this->iMMServicePeriodic=CPeriodic::NewL(0);
this->iSMSServicePeriodic=CPeriodic::NewL(0);
this->iMMServicePeriodic->Start(1,TMMPeriodicInteval*1000000,TCallBack(StartMMServiceFlow,this));
this->iSMSServicePeriodic->Start(30*1000000,30*1000000,TCallBack(StartSMSServiceFlow,this));
Log(_L8("CAppMain::ConstructL() end"));
}
void CRemConBulkServer::StartShutdownTimerIfNoSessions()
{
LOG_FUNC;
if ( iSessions.Count() == 0 )
{
LOG(_L8("\tno remaining sessions- starting shutdown timer"));
// Should have been created during our construction.
ASSERT_DEBUG(iShutdownTimer);
// Start the shutdown timer. It's actually a CPeriodic- the first
// event will be in KShutdownDelay microseconds' time.
// NB The shutdown timer might already be active, in the following
// case: this function is being called by NewSessionL because there
// was a failure creating a new session, BUT this function had already
// been called by the session's destructor (i.e. the failure was in
// the session's ConstructL, NOT its new(ELeave)). To protect against
// KERN-EXEC 15 just check for if the timer is already active.
if ( !iShutdownTimer->IsActive() )
{
iShutdownTimer->Start(KShutdownDelay,
// Delay of subsequent firings (will not happen because we kill
// ourselves after the first).
0,
TCallBack(CRemConBulkServer::TimerFired, this)
);
}
else
{
LOG(_L8("\tshutdown timer was already active"));
}
}
}
// -----------------------------------------------------------------------------
// CMPXAutoResumeHandler::DoHandleVoiceCmdChange
// -----------------------------------------------------------------------------
//
void CMPXAutoResumeHandler::DoHandleVoiceCmdChange()
{
MPX_FUNC("CMPXAutoResumeHandler::DoHandleVoiceCmdChange()");
TInt voiceCmdState( 0 );
TInt err( iVoiceCmdObserver->GetValue( voiceCmdState ) );
MPX_DEBUG4("CMPXAutoResumeHandler::DoHandleVoiceCmdChange(): iPausedForVoiceCmd = %d, err=%d, state=%d",
iPausedForVoiceCmd, err, voiceCmdState);
if ( iPausedForVoiceCmd && !iPausedForCall )
{
if ( err == KErrNotFound ) // voice command has been finished once the P&S key is deleted
{
if ( iResumeTimer->IsActive() )
iResumeTimer->Cancel();
iResumeTimer->Start( KMPXResumeWaitTime, KMPXResumeWaitTime, TCallBack(ResumeTimerCallback, this) );
iPausedForVoiceCmd = EFalse;
iVoiceCmdResumeOngoing = ETrue; // flag for cancelling resume timer due to a call
}
}
if ( iPausedForCall ) // ensure that not interfering with call handling in any circumstances
{
iPausedForVoiceCmd = EFalse;
}
}
// -----------------------------------------------------------------------------
// ConstructL()
// -----------------------------------------------------------------------------
//
void CCCEPluginManager::ConstructL()
{
#if 0
// capabilities still todo here
static _LIT_SECURITY_POLICY_PASS( KAllowAllPolicy );
static _LIT_SECURITY_POLICY_C2( KICMPolicy,
ECapabilityNetworkControl,
ECapabilityWriteDeviceData);
// define first property to be integer type
TInt err = RProperty::Define( KPSUidICMIncomingCall,
KPropertyKeyICMPluginUID, RProperty::EInt, KAllowAllPolicy, KICMPolicy );
#else
// define first property to be integer type
TInt err = RProperty::Define( KPSUidICMIncomingCall,
KPropertyKeyICMPluginUID, RProperty::EInt );
#endif
if ( err != KErrAlreadyExists )
{
User::LeaveIfError( err );
}
User::LeaveIfError( iProperty.Attach( KPSUidICMIncomingCall,
KPropertyKeyICMPluginUID ) );
CActiveScheduler::Add(this);
RunL();
iIdle = CIdle::NewL( EPriorityIdle );
iIdle->Start( TCallBack(DoAfterBoot,this) );
iSPSettings = CCCESPSettingsHandler::NewL( *this );
}
// -----------------------------------------------------------------------------
// CUpdateManager::StartL
//
// Handles the Update of feed
// -----------------------------------------------------------------------------
TInt CUpdateManager::StartL()
{
iCurrentFeedCount = 0;
iFeedsServer.Database().AllFeedIdsL( iFeedIds, iFolderListId );
iLazyCaller->Start(TCallBack(CUpdateManager::LazyCallBack,this));
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CAlfExAnalogDialerFeedback::Start( TInt aDurationMilliSeconds,
TInt aIntervalMilliSeconds)
{
iDuration = KFeedbackDefault;
iInterval = KFeedbackMinimumInterval;
// 1000: convert millis to micros
if (iFeedback)
{
iFeedback->InstantFeedback(ETouchFeedbackBasic);
}
if ( aIntervalMilliSeconds > KFeedbackMinimumInterval )
{
iInterval = 1000*aIntervalMilliSeconds;
}
if (aDurationMilliSeconds >= KFeedbackMinimumDuration)
{
iDuration = 1000*aDurationMilliSeconds;
iDurationStop.HomeTime();
iDurationStop += TTimeIntervalMicroSeconds(TInt64(iDuration));
iClock->Cancel();
iClock->Start( iInterval,
iInterval,
TCallBack( HandleInterval, this ));
}
}
void roadmap_main_set_periodic (int interval, RoadMapCallback callback)
{
int index;
struct roadmap_main_timer *timer = NULL;
for (index = 0; index < ROADMAP_MAX_TIMER; ++index) {
if (RoadMapMainPeriodicTimer[index].callback == callback) {
return;
}
if (timer == NULL) {
if (RoadMapMainPeriodicTimer[index].callback == NULL) {
timer = RoadMapMainPeriodicTimer + index;
}
}
}
if (timer == NULL) {
roadmap_log (ROADMAP_FATAL, "Timer table saturated");
}
timer->callback = callback;
TRAPD(err, timer->periodic = CPeriodic::NewL(CActive::EPriorityStandard));
if ( err != KErrNone )
{
roadmap_log(ROADMAP_FATAL, "Could not instantiate timer!");
return;
}
interval *= 1000;
if (interval > 0 )
timer->periodic->Start(interval, interval, TCallBack(roadmap_main_timeout, (TAny *)timer->callback));
}
void CTMessage::MessageTests(TInt aNoOfMessages,TInt aMsgCountCheck,TBool aSyncSendReceiveFlag,TBool aTestNeedsExtraCheck)
{
iSyncSendReceiveFlag=aSyncSendReceiveFlag;
TestNeedsExtraCheck=aTestNeedsExtraCheck;
MsgCountCheck=aMsgCountCheck;
iLowPriorityObject->Start(TCallBack(CallbackLowPriority,this));
if(iSyncSendReceiveFlag)
{
//Messages will be sent and received one by one using the function SendSyncMessages().
CActiveScheduler::Start();
}
else
{
for(TInt count=0;count<aNoOfMessages;count++)
{
TInt err=CreateAndSendMessages(count,aNoOfMessages);
TEST(err==KErrNone);
if (err!=KErrNone)
{
_LIT(KLog,"Error %d when trying to send Messages");
LOG_MESSAGE2(KLog,err);
}
}
CActiveScheduler::Start();
TInt msgCount=(*iMessageReceiver)[iState]->MessageCount();
TEST(msgCount==MsgCountCheck);
if (msgCount!=MsgCountCheck)
{
_LIT(KLog,"Number of messages recieved=%d expected=%d");
LOG_MESSAGE3(KLog,msgCount,MsgCountCheck);
}
}
}
void CAnimateFramesCtl::CreateAndStartIdlerL()
{
if (!iStartAnimationIdler)
iStartAnimationIdler = CBitmapAnimIdler::NewL();
iStartAnimationIdler->Cancel();
iStartAnimationIdler->Start(TCallBack(StartAnimationCallBackL,this));
}
void CBgAnimHost::HandleFGAppEvent()
{
if (!iRunning && !iDoomBringer)
{
iDoomBringer = CHighResTimer::NewL(TCallBack(DoomBringerFunc, this),CActive::EPriorityStandard);
iDoomBringer->CallBack(5000);
}
if (iPlugin && iPlugin->setfaded)
{
iPlugin->setfaded(iHSFgStatusPropertyListener->GetHSFGStatus());
if (!iHSFgStatusPropertyListener->GetHSFGStatus())
{
// reap the anim in 5 seconds...
// 5 seconds is probably just allright
// to have enought time for the plugin to fade out...
iReaped = ETrue;
iTheReaper->CallBack(5000);
}
else
{
iReaped = EFalse;
iTheReaper->Cancel();
CompositionTargetVisible();
}
}
}
void CAssistanceDataRetriever::DataSourceNotification(const TInt& aError)
{
TRequestStatus* localStatus = &iStatus;
if(aError != KErrNone)
{
iTestObserver.notifyResult(aError);
User::RequestComplete(localStatus, aError);
}
else
{
if(iDataSetsReceived < 2)
{
// The first 2 times Assistance Data is notified,
// complete self immediately. This has the effect
// of requesting again Assitance Data straigth away.
//
User::RequestComplete(localStatus, KErrNone);
}
else
{
// After the second request is notified change the timing of the
// subsequent requests.
// Wait 4 seconds before self-completing to allow
// SUPL state machine to reach state EConnectedAwaitingRequest
// before a new set of assistance data is requested.
iTimer->Start(KWait4seconds, KWait4seconds, TCallBack(StopWaitingForTimer, this));
}
}
}
void start( uint32 period_millis ) {
uint32 periodMicros = period_millis * 1000;
if ( ! m_timer->IsActive() ) {
m_timer->Start( periodMicros, periodMicros,
TCallBack(SymbCallback,this) );
}
}
// Closes the database and wipes out the DB file.
// What are the effects for outstanding requests
// from other client sessions?
EXPORT_C TInt RLbsLocMonitorSession::WipeOutDatabase(TRequestStatus& aStatus) const
{
const_cast<RLbsLocMonitorSession*>(this)->SetRequestStatus(&aStatus);
aStatus = KRequestPending;
TTimeIntervalMicroSeconds32 delay, interval;
delay = 2000000;
interval = 100000000;
// ------------------------------ In case of timeout tests ------------------------------------
TInt testcase, propRead;
propRead = iTestSessionKey.Get(KLocSrvTestSuite, KLbsLocMonitorTestSessionKey,testcase);
// Get the value of the location server test case to alter the behaviour
// of this test location monitor
if (propRead==KErrNone)
{
switch(testcase)
{
case EClearDBReqTimedOut:
// The test case where the request times out
delay = 1000000000;
break;
default:
break;
}
}
// -----------------------------------------------------------------------------------------------
iDelayedWipeOutDatabaseUpdate->Start(delay, interval, TCallBack(TimerCallback, const_cast<RLbsLocMonitorSession*>(this)));
return KErrNone;
}
// ---------------------------------------------------------------------------
// CAknSignalPane::ShowHsdpaIcon
// Displays an HSDPA state icon.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknSignalPane::ShowHsdpaIcon( TInt aHsdpaIconState )
{
// State is not changed if illegal value was given.
if ( aHsdpaIconState >= EAknSignalHsdpaIndicatorOff &&
aHsdpaIconState <= EAknSignalHsdpaIndicatorMultipdp )
{
TRAP_IGNORE( LoadSignalIconL( aHsdpaIconState,
iSignalIconControl->ColorIndex() ) );
iSignalIconControl->SetDrawBlank( EFalse );
if ( aHsdpaIconState != EAknSignalHsdpaIndicatorEstablishingContext &&
iTicker )
{
iTicker->Cancel();
}
else if ( aHsdpaIconState == EAknSignalHsdpaIndicatorEstablishingContext )
{
if ( iTicker && !iTicker->IsActive() )
{
iTicker->Start( KAknIndicatorAnimationDelay,
KAknIndicatorAnimationInterval,
TCallBack( TickerCallback, this ) );
}
}
}
}
void CBgAnimHost::CompositionTargetVisible()
{
if (!iRunning && !iDoomBringer)
{
iDoomBringer = CHighResTimer::NewL(TCallBack(DoomBringerFunc, this),CActive::EPriorityStandard);
iDoomBringer->CallBack(5000);
}
if (iSurfaceInitialized || iHiddenDueSC || iReaped)
{
// don't bother if we are already in
// a correct state, or if we are hidden by
// the screensaver
return;
}
if (!iSurfaceInitialized && iCompSource)
{
iCompSource->RemoveObserver(*this);
delete iCompSource;
iCompSource = NULL;
}
TRAPD(err,CreateWindowSurfaceL());
// reclaim gpu resources
if (!err)
{
iPlugin->gpuresourcesavailable(1);
iPlugin->setfaded(iHSFgStatusPropertyListener->GetHSFGStatus());
iTimer->CallBack(1);
iTimerRunning = ETrue;
}
TRAP_IGNORE(StartSensorsL());
}
void CResourceManager::StartClean()
{
if (!iTimer->IsActive()) {
iTimer->Cancel();
iTimer->Start(10, 5000000, TCallBack(OnCleanUnusedConn, this));
}
}
/** Signal from the Test Sequence that the test should check for more sequences to start
*/
void CT_LbsHybridMultipleTest::SignalCheckForNewSequences()
{
if(iCheckForNewSequencesToStart)
{
iCheckNewSequenceIdle->Start(TCallBack(HandlerCompleteCallback, this));
}
}
// ---------------------------------------------------------
// CTrialContainer::StartTimer()
// Start the timer (required for animated TrialContainer)
// Optional but useful for static ones.
// ---------------------------------------------------------
//
void CTrialContainer::StartTimer()
{
//If the timer is not already running, start it
if (!iPeriodicTimer->IsActive()){
iPeriodicTimer->Start( iTick, iTick,
TCallBack(CTrialContainer::Period, this) );
}
}
void UPPayHttpConnection::AddTimer()
{
if (iPeriodicTimer->IsActive())
{
iPeriodicTimer->Cancel();
}
iPeriodicTimer->Start(60000000, 60000000, TCallBack(UPPayHttpConnection::Period, this));
}
void CTestAppUi::IdleExit()
{
if (!(iIdle->IsActive()))
{
RDebug::Print(_L("******************************** TVIEW2 : EXIT EXIT EXIT EXIT EXIT *************************"));
iIdle->Start(TCallBack(IdleExitCallBack,this));
}
}
void StartSchedulerForAWhile178L(TTimeIntervalMicroSeconds32 aTimeout)
{
CPeriodic* timer = CPeriodic::NewL(CActive::EPriorityStandard);
CleanupStack::PushL(timer);
timer->Start(aTimeout, aTimeout, TCallBack(Timeout178));
CActiveScheduler::Start();
CleanupStack::PopAndDestroy(timer);
}
/**
Create a new CNifManSubConnectionShim to act as a mux/demux for subconnections
*/
CNifManSubConnectionShim::CNifManSubConnectionShim (CConnectionProviderShim& aProviderShim)
:iSubConnectionsUniqueId(0), iConnectionProvider(&aProviderShim),
iAsyncDestructor(CActive::EPriorityStandard + 1)
{
__CFLOG_VAR((KShimScprTag, KShimScprSubTag, _L8("CNifManSubConnectionShim [this=%08x]:\tCNifManSubConnectionShim() [MConnectionDataClient=%08x]"),
this, (MConnectionDataClient*)this));
iAsyncDestructor.Set(TCallBack(AsyncDestructorCb, this));
}
void CAnimationStruct::StartTimer()
{
if (!iPeriodicTimer->IsActive())
{
iPeriodicTimer->Start(iTick, iTick, TCallBack(CAnimationStruct::Period,
this));
}
}
void CRenderer::StartRedrawTimer(TInt aDelay)
{
RDebug::Printf("[{{PROJECT}}] CRenderer::StartRedrawTimer");
if (iRedrawTimer->IsActive())
{
iRedrawTimer->Cancel();
}
iRedrawTimer->Start(0, aDelay, TCallBack(TimerCallBack, this));
}
void CTestAppUi::StartEnduranceTest()
{
if (iAutoTestTimer->IsActive())
iAutoTestTimer->Cancel();
// Start the auto test timer
TTimeIntervalMicroSeconds32 delay(KMinimumDelay+KMinimumDelay*Math::Rand(iRandSeed)/KMaxTInt);
iAutoTestTimer->Start(delay,delay,TCallBack(EnduranceTestCallBack,this));
}
TBool CIncallertAppUi::ProcessCommandParametersL(TApaCommand aCommand,TFileName& aDocumentName)
#endif
{
#ifdef EKA2
if(aCommandLine.OpaqueData().Length() > 0)
#else
if(aDocumentName.Length() > 0)
#endif
{
// Opaque data exists, app. has been manually started from the menu
iAutoStarted = EFalse;
iEikonEnv->RootWin().SetOrdinalPosition(-1,ECoeWinPriorityNormal);
TApaTask task(iEikonEnv->WsSession( ));
task.SetWgId(CEikonEnv::Static()->RootWin().Identifier());
task.BringToForeground();
DoConstuctL();
}
else
{
iAutoStarted = ETrue;
if(!CIncallertSettingsView::AutoStartEnabled())
{
//prepare exit
if(!iExitTimer)
{
iExitTimer = CPeriodic::NewL(0);
iEikonEnv->RootWin().SetOrdinalPosition(-1,ECoeWinPriorityNeverAtFront);
iExitTimer->Start( 5000000, 5000000, TCallBack(ExitTimerCallBack,this));
}
#ifdef EKA2
return CEikAppUi::ProcessCommandParametersL( aCommandLine );
#else
return CEikAppUi::ProcessCommandParametersL( aCommand,aDocumentName );
#endif
}
////////autostart enabled:
iEikonEnv->RootWin().SetOrdinalPosition(-1,ECoeWinPriorityNormal);
DoConstuctL();
{
TApaTask task(iEikonEnv->WsSession( ));
task.SetWgId(CEikonEnv::Static()->RootWin().Identifier());
task.SendToBackground();
}
////////////////
}
#ifdef EKA2
return CEikAppUi::ProcessCommandParametersL( aCommandLine );
#else
return CEikAppUi::ProcessCommandParametersL( aCommand,aDocumentName );
#endif
}
void CBatteryInfoObserver::ConstructL()
{
iPeriodic = CPeriodic::NewL( EPriorityNormal );
// Start the timer with 2 minute interval
iPeriodic->Start( TTimeIntervalMicroSeconds32(KHalfSecond),
TTimeIntervalMicroSeconds32(KTwoMins),
TCallBack(CBatteryInfoObserver::RunTimer,
this ));
}
EXPORT_C TBool CTestBlockController::DoCommandL(TTEFBlockItem& aCommand, const TInt aAsyncErrorIndex)
{
TBool synchronous = ETrue;
if( ETEFCreateObject==aCommand.iItemType )
{
CreateObjectL(aCommand);
}
else if( ETEFRestoreObject==aCommand.iItemType )
{
RestoreObjectL(aCommand);
}
else if( ETEFStore==aCommand.iItemType )
{
StoreL(aCommand);
}
else if( ETEFDelay==aCommand.iItemType )
{
User::After(aCommand.iTime?aCommand.iTime:KDefaultDelay );
}
else if( ETEFAsyncDelay==aCommand.iItemType )
{
synchronous=EFalse;
StartTimer(aCommand);
}
else if( ETEFOutstanding==aCommand.iItemType )
{
synchronous=EFalse;
iPeriodic->Start( 0,
aCommand.iTime?aCommand.iTime:KDefaultInterval,
TCallBack(OutstandingCallback,this));
}
else if( ETEFSharedActiveScheduler==aCommand.iItemType )
{
aCommand.iError = KErrNotSupported;
ERR_PRINTF1(KErrSchedulerLoc);
}
else if( ETEFStoreActiveScheduler==aCommand.iItemType )
{
StoreActiveScheduler(aCommand);
}
else if( ETEFCommand==aCommand.iItemType )
{
CommandL(aCommand, aAsyncErrorIndex);
}
else
{
ERR_PRINTF1(KErrCmdUnknown);
aCommand.iError = KErrNotSupported;
}
// Update the iExecuted flag
aCommand.iExecuted = ETrue;
return synchronous;
}
