hsError pfPatcherWorker::Run() { // So here's the rub: // We have one or many manifests in the fRequests deque. We begin issuing those requests one-by one, starting here. // As we receive the answer, the NetCli thread populates fQueuedFiles and pings the fFileSignal semaphore, then issues the next request... // In this non-UI/non-Net thread, we do the stutter-prone/time-consuming IO/hashing operations. (Typically, the UI thread == Net thread) // As we find files that need updating, we add them to fRequests. // If there is no net request from ME when we find a file, we issue the request // Once a file is downloaded, the next request is issued. // When there are no files in my deque and no requests in my deque, we exit without errors. PatcherLogWhite("--- Patch Started (%i requests) ---", fRequests.size()); fStarted = true; IssueRequest(); // Now, work until we're done processing files do { fFileSignal.Wait(); hsTempMutexLock fileLock(fFileMut); if (!fQueuedFiles.empty()) { ProcessFile(); continue; } // This makes sure both queues are empty before exiting. if (!fRequestActive) if(!IssueRequest()) break; } while (fStarted); EndPatch(kNetSuccess); return hsOK; }
void TeamWorkApi::GetProjects(){ typeCurrentRequest = TypeOfRequest::TmpmGetProjects; if( !bMultiPage ) hashTempProjects.clear(); IssueRequest( "/projects.xml" ); }
// --------------------------------------------------------------------------- // CEventChannel::OpenChannel() // ?implementation_description // --------------------------------------------------------------------------- // TInt CEventChannel::OpenChannel() { TBuf<16> location; location.Copy( iChannelInfo.iLocation ); COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::OpenChannel() - %S" ), &location ) ); TInt err( KErrNone ); if( iChannelState == EChannelIdle ) { COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::OpenChannel() iChannelState = EChannelOpening" ) ) ); iChannelState = EChannelOpening; IssueRequest(); RProperty::Set( KPSUidSensrvTest, KSensrvLatestOpenedChannel, iChannelInfo.iChannelId ); } else { COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::OpenChannel() Incorrect channel state" ) ) ); err = KErrGeneral; } COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::OpenChannel() - Return %d" ), err ) ); return err; }
// ---------------------------------------------------------------------------------- // CSSYChannel::StopChannelDataL() // ---------------------------------------------------------------------------------- // void CSSYChannel::StopChannelDataL( const TSensrvChannelId aChannelId ) { SSY_TRACE_IN(); SSY_TRACE( EExtended, "ORIENTATIONSSY::ChannelId %d", iChannelInfo.iChannelId ); if ( ChannelId() != aChannelId ) { SSY_TRACE( EError, "ORIENTATIONSSY::ERROR: StartChannelDataL wrong channelId!" ); User::Leave( KErrArgument ); } if ( iChannelState & KChannelCanBeStopped ) { iOrientationHandler->StopListeningL(); SetChannelState( EChannelStopListening ); IssueRequest(); } else { SSY_TRACE( EError, "ORIENTATIONSSY:ERROR: Trying to stop listening a channel that is not listened! channelId: %d, state: %S", aChannelId, ConvertChannelStateIntoString( iChannelState ) ); User::Leave( KErrGeneral ); } SSY_TRACE_OUT(); }
// ---------------------------------------------------------------------------------- // CSSYChannel::ForceBufferFilledL() // ---------------------------------------------------------------------------------- // void CSSYChannel::ForceBufferFilledL( const TSensrvChannelId aChannelId ) { SSY_TRACE_IN(); SSY_TRACE( EExtended, "ORIENTATIONSSY:ChannelId %d", iChannelInfo.iChannelId ); if ( ChannelId() != aChannelId ) { SSY_TRACE( EError, "ORIENTATIONSSY:ERROR: StartChannelDataL wrong channelId!" ); User::Leave( KErrArgument ); } if( iChannelState & KChannelCanBeFilled ) { SetChannelState( EChannelForceBufferFilled ); IssueRequest(); } else { SSY_TRACE( EError, "ORIENTATIONSSY:ERROR: ForceBufferFilledL called in incorrected state! channelId: %d, state: %S", aChannelId, ConvertChannelStateIntoString( iChannelState ) ); User::Leave( KErrGeneral ); } SSY_TRACE_OUT(); }
// ---------------------------------------------------------------------------------- // CSSYChannel::OpenChannel() // ---------------------------------------------------------------------------------- // TInt CSSYChannel::OpenChannel() { SSY_TRACE_IN(); SSY_TRACE( EExtended, "ORIENTATIONSSY:ChannelId %d", iChannelInfo.iChannelId ); TInt err( KErrNone ); if ( iChannelState & KChannelCanBeOpened ) { TRAP( err, iOrientationHandler->OpenChannelL() ); if ( err == KErrNone ) { SetChannelState( EChannelOpening ); IssueRequest(); } } else { SSY_TRACE( EExtended, "ORIENTATIONSSY:ERROR: Trying to open a channel in a wrong state! channelId: %d, state: %S", iChannelInfo.iChannelId, ConvertChannelStateIntoString( iChannelState ) ); err = KErrGeneral; } SSY_TRACE_OUT(); return err; }
// -------------------------------------------------------------------------- // Event ready in window server event queue // -------------------------------------------------------------------------- void CAknCompaSrvWsEventHandler::RunL() { // Window server event queue read to purge it in case wsrv sends // something. As we dont have window group created this is probably // unneccesary as there seem to be no events. TWsEvent wsEvent; iWsSession.GetEvent(wsEvent); IssueRequest(); }
void plResPatcher::Start() { hsAssert(!fPatching, "Too many calls to plResPatcher::Start"); fPatching = true; PatcherLog(kHeader, "--- Patch Started (%i requests) ---", fRequests.size()); fProgress = plProgressMgr::GetInstance()->RegisterOperation(0.0, "Checking for updates...", plProgressMgr::kUpdateText, false, true); IssueRequest(); }
// --------------------------------------------------------------------------- // CCsConversationCacheHelper::HandleProcessConversationL() // Process Conversation and update cache // --------------------------------------------------------------------------- // void CCsConversationCacheHelper::HandleProcessConversationL() { iConversationEvent = GetNextEvent(); // check to see if all the events are consumed // then mark cache as caching done.. if (!iConversationEvent) { iConversationCache->CachingCompletedL(); return; } CCsConversationEntry* conEntry = iConversationEvent->ClientConversation()->GetConversationEntry(); //handle add, modify events if (iConversationEvent->Event() != KConversationEventDelete) { TUint8 SpecialId = NeedsSpecialProcessing(conEntry); if (SpecialId) { // this is for draft(unlnown)/BT/IR processing iState = ECsSpecialConversation; } // check only if contact is a valid address else if (conEntry->Contact()) { iCurrentConversationIndex = iConversationCache->FindConversation(* (conEntry->Contact())); if (iCurrentConversationIndex != KErrNotFound) { iState = ECsConversationFoundInCache; } else { iState = ECsResolveConversation; } } else { // this is when contact number is NULL // delete the entry from temp list DeleteEvent(*iConversationEvent); iState = ECsProcessConversation; } } else { //handle delete event DeleteConversationEntryL(conEntry); DeleteEvent(*iConversationEvent); iState = ECsProcessConversation; } //move to other state IssueRequest(); }
void pfPatcherWorker::ProcessFile() { do { NetCliFileManifestEntry& entry = fQueuedFiles.front(); // eap sucks plFileName clName = plString::FromWchar(entry.clientName); plString dlName = plString::FromWchar(entry.downloadName); // Check to see if ours matches plFileInfo mine(clName); if (mine.FileSize() == entry.fileSize) { plMD5Checksum cliMD5(clName); plMD5Checksum srvMD5; srvMD5.SetFromHexString(plString::FromWchar(entry.md5, 32).c_str()); if (cliMD5 == srvMD5) { WhitelistFile(clName, false); fQueuedFiles.pop_front(); continue; } } // It's different... but do we want it? if (fFileDownloadDesired) { if (!fFileDownloadDesired(clName)) { PatcherLogRed("\tDeclined '%S'", entry.clientName); fQueuedFiles.pop_front(); continue; } } // If you got here, they're different and we want it. PatcherLogYellow("\tEnqueuing '%S'", entry.clientName); plFileSystem::CreateDir(plFileName(clName).StripFileName()); // If someone registered for SelfPatch notifications, then we should probably // let them handle the gruntwork... Otherwise, go nuts! if (fSelfPatch) { if (clName == plFileSystem::GetCurrentAppPath().GetFileName()) { clName += ".tmp"; // don't overwrite myself! entry.flags |= kSelfPatch; } } pfPatcherStream* s = new pfPatcherStream(this, dlName, entry); s->Open(clName, "wb"); hsTempMutexLock lock(fRequestMut); fRequests.push_back(Request(dlName, Request::kFile, s)); fQueuedFiles.pop_front(); if (!fRequestActive) IssueRequest(); } while (!fQueuedFiles.empty()); }
// --------------------------------------------------------------------------- // CEventChannel::DataError() // ?implementation_description // --------------------------------------------------------------------------- // void CEventChannel::DataError( CSensrvChannel& /*aChannel*/, TSensrvErrorSeverity aError ) { COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::DataReceived(): aError = %d" ), aError ) ); if( aError == ESensrvErrorSeverityFatal ) { COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::CloseChannel() iChannelState = EChannelClosing" ) ) ); iChannelState = EChannelClosing; IssueRequest(); } }
void TeamWorkApi::GetTasks( int idProject, int iPage ){ typeCurrentRequest = TypeOfRequest::TmpmGetTaskLists; idCurrent = idProject; if( !bMultiPage ) hashTempTasks.clear(); QString strRequest = QString( "/projects/%1/todo_lists.xml?status=all" ).arg( idProject ); if( 1 < iPage ) strRequest += QString( "&page=%1" ).arg( iPage ); IssueRequest( strRequest ); }
// ---------------------------------------------------------------------------------- // CSensrvTestObserver::CSensrvTestObserver() // ---------------------------------------------------------------------------------- CSensrvTestObserver::CSensrvTestObserver(TInt aProcessID) : CActive( CActive::EPriorityStandard ), iMyProcessID(aProcessID) { TInt retval(KErrNone); retval = iProperty.Attach( KPSUidSensrvTest, KSensrvTestProcessCommand ); User::LeaveIfError(retval); CActiveScheduler::Add( this ); IssueRequest(); }
// --------------------------------------------------------------------------- // From class CActive. // Gets called when NVRAM has changed // --------------------------------------------------------------------------- // void CDunAtNvramListen::RunL() { FTRACE(FPrint( _L("CDunAtNvramListen::RunL()") )); iNvramHandleState = EDunStateIdle; TInt retTemp = iStatus.Int(); if ( retTemp != KErrNone ) { FTRACE(FPrint( _L("CDunAtNvramListen::RunL() (ERROR) complete (%d)"), retTemp )); return; } iAtCmdExt->BroadcastNvramStatusChange( iNvramBuffer ); IssueRequest(); FTRACE(FPrint( _L("CDunAtNvramListen::RunL() complete") )); }
/****************************************************************************\ | Function: CExampleWsClient::RunL() | Called by active scheduler when an even occurs | Purpose: Processes events according to their type | For key events: calls HandleKeyEventL() (global to client) | For pointer event: calls HandlePointerEvent() for window | event occurred in. \****************************************************************************/ void CExampleWsClient::RunL() { // get the event iWs.GetEvent(iWsEvent); TInt eventType = iWsEvent.Type(); // take action on it switch (eventType) { // events global within window group case EEventNull: case EEventKey: case EEventModifiersChanged: case EEventKeyUp: case EEventKeyDown: case EEventFocusLost: case EEventFocusGained: case EEventSwitchOn: case EEventPassword: case EEventWindowGroupsChanged: case EEventErrorMessage: break; // events local to specific windows case EEventPointer: { CWindow* window = (CWindow*) (iWsEvent.Handle()); // get window TPointerEvent& pointerEvent = *iWsEvent.Pointer(); window->HandlePointerEvent(pointerEvent); } break; case EEventPointerExit: case EEventPointerEnter: break; case EEventPointerBufferReady: { CWindow* window = (CWindow*) (iWsEvent.Handle()); // get window window->HandlePointerMoveBufferReady(); } break; case EEventDragDrop: break; default: break; } IssueRequest(); // maintain outstanding request }
// // ---------------------------------------------------------------------------------- // CSensrvTestObserver::RunL() // ---------------------------------------------------------------------------------- void CSensrvTestObserver::RunL() { COMPONENT_TRACE( ( _L( "CSensrvTestObserver::RunL()" ) ) ); TInt retval(KErrNone); TPckgBuf<TSensrvProcessData> buf; retval = iProperty.Get( KPSUidSensrvTest, KSensrvTestProcessCommand, buf ); User::LeaveIfError(retval); //if( iMyProcessID & buf().iProcessID ) if( iMyProcessID == buf().iProcessID ) { //Command is for this process switch( buf().iCommand ) { case KProcessCommandOpenChannel: { DoOpenChannelL( buf().iExpectedResult ); } break; case KProcessCommandCloseChannel: { DoCloseChannelL( buf().iExpectedResult ); } break; case KProcessCommandSetProperty: { DoSetPropertyL( buf().iExpectedResult, buf().iProperty ); } break; case KProcessCommandFindChannel: { DoFindChannelL(); } break; default: { COMPONENT_TRACE( ( _L( "CSensrvTestObserver::RunL - ERROR: unknown command" ) ) ); } break; } RProperty::Set( KPSUidSensrvTest, KSensrvTestComplete1, KErrNone );//only KSensrvTestComplete1 supported at the momont } IssueRequest(); }
// --------------------------------------------------------------------------- // CCsConversationCacheHelper::HandleConversationInCacheL() // Handle the case when the conversation is found in the cache // so there is no need for resolving the contact // --------------------------------------------------------------------------- // void CCsConversationCacheHelper::HandleConversationInCacheL() { CCsConversationEntry* conEntry = iConversationEvent->ClientConversation()->GetConversationEntry(); AddConversationEntryL(conEntry, iCurrentConversationIndex); DeleteEvent(*iConversationEvent); // reset back the conversation index iCurrentConversationIndex = KErrNotFound; iState = ECsProcessConversation; IssueRequest(); }
// ----------------------------------------------------------------------------- // CCbsRecEtelMonitor::RunL // Becomes active when EPOC Telephony Server has copied a CB message to // iMsgData. The message is then given to CCbsRecEtel for // processing. // Finally this function re-issues the ReceiveMessage request. // (other items were commented in a header). // ----------------------------------------------------------------------------- // void CCbsRecEtelMonitor::RunL() { CBSLOGSTRING2("CBSSERVER: >>> CCbsRecEtelMonitor::RunL(), iStatus: %d", iStatus.Int() ); if ( iStatus == KErrNone ) { CCbsMessage* currentMessage = NULL; TCbsMessageType msgType( ECbsMessageTypeUnspecified ); CBSLOGSTRING("CBSSERVER: CCbsRecEtelMonitor::RunL(): Calling CreateMessageL()..." ); currentMessage = iFactory.CreateMessageL( iMsgData, iAttributes, msgType ); CBSLOGSTRING("CBSSERVER: CCbsRecEtelMonitor::RunL(): CreateMessageL() called OK." ); if ( currentMessage ) { if ( msgType == ECbsMessageLivecast ) { CBSLOGSTRING("CBSSERVER: CCbsRecEtelMonitor::RunL(): LC message" ); if ( iNewstickerSupported ) { // Ownership of currentMessage transferred to iLivecastHandler CBSLOGSTRING("CBSSERVER: CCbsRecEtelMonitor::RunL(): Calling HandleLivecastMessageL()..." ); TInt lcResult( KErrNone ); TRAP( lcResult, iLivecastHandler.HandleLivecastMessageL( currentMessage ) ); CBSLOGSTRING2("CBSSERVER: CCbsRecEtelMonitor::RunL(): HandleLivecastMessageL() finished, result: %d", lcResult ); } else { CBSLOGSTRING("CBSSERVER: CCbsRecEtelMonitor::RunL(): NewsSticker is not supported" ); } } else { CBSLOGSTRING("CBSSERVER: CCbsRecEtelMonitor::RunL(): Normal message" ); // Ownership of currentMessage transferred to iEtel CBSLOGSTRING("CBSSERVER: CCbsRecEtelMonitor::RunL(): Calling HandleMessageReceivedL()..." ); TInt result( KErrNone ); TRAP( result, iEtel.HandleMessageReceivedL( currentMessage ) ); CBSLOGSTRING2("CBSSERVER: CCbsRecEtelMonitor::RunL(): HandleMessageReceivedL() finished, result: %d", result ); } } // Renew the request IssueRequest(); } CBSLOGSTRING("CBSSERVER: <<< CCbsRecEtelMonitor::RunL()"); }
EXPORT_C void TestMsvOperationTimer::RunL() { // display the current progress TMsvId temp; TPckgC<TMsvId> paramPack(temp); const TDesC8& progBuf = iMsvOperation->ProgressL(); paramPack.Set(progBuf); TMsvId progress=paramPack(); iRTest.Console()->SetPos(0, 10); iRTest.Printf(_L(" MessageId %d \n"),progress); IssueRequest(); };
// ---------------------------------------------------------------------------------- // CSSYChannel::StartChannelDataL() // ---------------------------------------------------------------------------------- // void CSSYChannel::StartChannelDataL( const TSensrvChannelId aChannelId, TUint8* aBuffer, TInt aCount ) { SSY_TRACE_IN(); SSY_TRACE( EExtended, "ORIENTATIONSSY:ChannelId %d", iChannelInfo.iChannelId ); if ( ChannelId() != aChannelId ) { SSY_TRACE( EError, "ORIENTATIONSSY:ERROR: StartChannelDataL wrong channelId!" ); User::Leave( KErrArgument ); } ASSERT_DEBUG_SSY( aBuffer ); ASSERT_DEBUG_SSY( aCount ); if ( !aBuffer || !aCount ) { User::Leave( KErrArgument ); } iBuffer = aBuffer; iCount = aCount; SSY_TRACE( EExtended, "ORIENTATIONSSY:New data buffer: 0x%x", iBuffer ); SSY_TRACE( EExtended, "ORIENTATIONSSY:New data count : %d", iCount ); if ( iChannelState & KChannelCanBeListened ) { iOrientationHandler->StartListeningL(); SetChannelState( EChannelListening ); IssueRequest(); } else { SSY_TRACE( EError, "ORIENTATIONSSY:ERROR: Trying to listen a channel that is not open! channelId: %d, state: %S", aChannelId, ConvertChannelStateIntoString( iChannelState ) ); User::Leave( KErrGeneral ); } SSY_TRACE_OUT(); }
// --------------------------------------------------------------------------- // CCsConversationCacheHelper::HandleSpecialConversationL() // Hnadle the case when the conversation has no contact, // BlueTooth/IrDa messages // --------------------------------------------------------------------------- // void CCsConversationCacheHelper::HandleSpecialConversationL() { CCsConversationEntry* conEntry = iConversationEvent->ClientConversation()->GetConversationEntry(); if (ECsBlueTooth == conEntry->GetType()|| ECsBlueTooth_VCard == conEntry->GetType()|| ECsBlueTooth_VCal == conEntry->GetType()) { AddConversationEntryL(conEntry, KBluetoothMsgsConversationId); } else { AddConversationEntryL(conEntry, KUnknownConversationId); } DeleteEvent(*iConversationEvent); iState = ECsProcessConversation; IssueRequest(); PRINT ( _L("CCsConversationCacheHelper::HandleSpecialConversationL") ); }
void CWsRedrawer::RunL() { // find out what needs to be done in response to the event TWsRedrawEvent redrawEvent; iClient->iWs.GetRedraw(redrawEvent); // get event CWindow* window = (CWindow*) (redrawEvent.Handle()); // get window if (window) { TRect rect = redrawEvent.Rect(); // and rectangle that needs redrawing // now do drawing iClient->iGc->Activate(window->Window()); window->Window().BeginRedraw(); window->Draw(rect); window->Window().EndRedraw(); iClient->iGc->Deactivate(); } // maintain outstanding request IssueRequest(); }
void TeamWorkApi::PostTime( QString strDesc, int iHours, int iMinutes, int idProject, int idTask, bool bIsBillable ){ typeCurrentRequest = TypeOfRequest::TmpmPostTime; QString strData = QString( "<request><time-entry><description>%1</description><person-id>%2</person-id><date>%3</date><hours>%4</hours><minutes>%5</minutes><time>%6</time><isbillable type=\"boolean\">%7</isbillable></time-entry></request>" ) .arg( strDesc ) .arg( idPerson ) .arg( QDate::currentDate().toString( "yyyyMMdd" ) ) .arg( iHours ) .arg( iMinutes ) .arg( "08:00" ) .arg( bIsBillable ? "yes" : "no" ); QString strRequest; if( idTask ) strRequest = QString( "/todo_items/%1/time_entries.xml" ).arg( idTask ); else strRequest = QString( "/projects/%1/time_entries.xml" ).arg( idProject ); IssueRequest( strRequest, strData ); }
void TestUiTimer::RunL() { // display the current progress TImCacheManagerProgress temp; TPckgC<TImCacheManagerProgress> paramPack(temp); const TDesC8& progBuf = iCacheManager->ProgressL(); paramPack.Set(progBuf); TImCacheManagerProgress progress=paramPack(); TBuf<128> strProgress; strProgress.Format(K_T_MIUT10_PROGRESS, progress.iMessagesProcessed, progress.iTotalMessages); test.Printf(strProgress); // write progress info to log file, too (to test DEF042552) testUtils->WriteComment(strProgress); IssueRequest(); };
void CWsClient::ConstructL() { // add ourselves to active scheduler CActiveScheduler::Add(this); // get a session going User::LeaveIfError(iWs.Connect()); // construct our one and only window group iGroup = RWindowGroup(iWs); User::LeaveIfError(iGroup.Construct(2, ETrue)); // '2' is a meaningless handle // construct screen device and graphics context iScreen = new (ELeave) CWsScreenDevice(iWs); // make device for this session User::LeaveIfError(iScreen->Construct()); // and complete its construction User::LeaveIfError(iScreen->CreateContext(iGc)); // create graphics context // construct redrawer iRedrawer = new (ELeave) CWsRedrawer; iRedrawer->ConstructL(this); // construct main window ConstructMainWindowL(); // request first event and start scheduler IssueRequest(); }
// ---------------------------------------------------------------------------------- // CSSYChannel::CloseChannel() // ---------------------------------------------------------------------------------- // TInt CSSYChannel::CloseChannel() { SSY_TRACE_IN(); SSY_TRACE( EExtended, "ORIENTATIONSSY:ChannelId %d", iChannelInfo.iChannelId ); TInt err( KErrNone ); if( iChannelState & KChannelCanBeClosed ) { TRAP( err, iOrientationHandler->CloseChannelL() ); if ( err == KErrNone ) { iBuffer = NULL; // Reassigned in data listening iCount = 0; iCountReceived = 0; SetChannelState( EChannelClosing ); IssueRequest(); } else { SSY_TRACE( EError, "ORIENTATIONSSY:ERROR: Trying to close a channel! err: %d, channelId: %d, state: %S", err, iChannelInfo.iChannelId, ConvertChannelStateIntoString( iChannelState ) ); } } else { SSY_TRACE( EExtended, "ORIENTATIONSSY:ERROR: Trying to close a channel in a wrong state! channelId: %d, state: %S", iChannelInfo.iChannelId, ConvertChannelStateIntoString( iChannelState ) ); err = KErrGeneral; } SSY_TRACE_OUT(); return err; }
void CEventChannel::ForceBufferFilledL( const TSensrvChannelId /*aChannelId*/ ) #endif { TBuf<16> location; location.Copy( iChannelInfo.iLocation ); COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::ForceBufferFilledL() - %S: channelId = %d" ), &location, aChannelId ) ); if( iChannelState == EChannelListening || iChannelState == EChannelBufferFilled || iChannelState == EChannelForceBufferFilled ) { COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::ForceBufferFilledL() iChannelState = EChannelForceBufferFilled" ) ) ); iChannelState = EChannelForceBufferFilled; IssueRequest(); } else { COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::ForceBufferFilledL() Incorrect channel state: %d - Leave" ), iChannelState ) ); User::Leave( KErrGeneral ); } }
// --------------------------------------------------------------------------- // CEventChannel::CloseChannel() // ?implementation_description // --------------------------------------------------------------------------- // TInt CEventChannel::CloseChannel() { TBuf<16> location; location.Copy( iChannelInfo.iLocation ); COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::CloseChannel() - %S" ), &location ) ); TInt err( KErrNone ); if( iChannelState != EChannelIdle ) { COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::CloseChannel() iChannelState = EChannelClosing" ) ) ); iChannelState = EChannelClosing; IssueRequest(); } else { COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::CloseChannel() Incorrect channel state" ) ) ); err = KErrGeneral; } COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::CloseChannel() - Return %d " ),err ) ); return err; }
void CEventChannel::StopChannelDataL( const TSensrvChannelId /*aChannelId*/ ) #endif { TBuf<16> location; location.Copy( iChannelInfo.iLocation ); COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::StopChannelDataL() - %S: channelId = %d" ), &location, aChannelId ) ); if( iChannelState == EChannelListening ) { COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::StopChannelDataL() iChannelState = EChannelStopListening" ) ) ); iChannelState = EChannelStopListening; // Stop data buffering IssueRequest(); } else { COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::StopChannelDataL() Incorrect channel state - Leave" ) ) ); User::Leave( KErrGeneral ); } }
void CEventChannel::StartChannelDataL( const TSensrvChannelId /*aChannelId*/, TUint8* aBuffer, TInt aCount) #endif { TBuf<16> location; location.Copy( iChannelInfo.iLocation ); COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::StartChannelDataL() - %S: channelId = %d" ), &location, aChannelId ) ); COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::StartChannelDataL() - aBuffer = %x, aCount = %d" ), aBuffer, aCount ) ); if( iChannelState == EChannelOpen ) { COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::StartChannelDataL() iChannelState = EChannelListening" ) ) ); iChannelState = EChannelListening; iDataBuffer = aBuffer; iMaxDataCount = aCount; iCounter = 0; if( iChannel ) { iChannel->StartDataListeningL( this, 1, 20, 10000 ); } else { User::Leave( KErrGeneral ); } IssueRequest(); } else { COMPONENT_TRACE( ( _L( "EventSsyStub - CEventChannel::StartChannelDataL() Incorrect channel state - Leave" ) ) ); User::Leave( KErrGeneral ); } }