×
Namespaces

Variants
Actions
(Difference between revisions)

Archived:Change a synchronous Symbian C++ method to act like an asynchronous one

From Nokia Developer Wiki
Jump to: navigation, search
hamishwillee (Talk | contribs)
hamishwillee (Talk | contribs)
m (Hamishwillee - Bot update - Merge KB into wiki)
Line 1: Line 1:
[[Category:Symbian C++]][[Category:Code Examples]][[Category:S60 3rd Edition]][[Category:Code Snippet]]
+
{{Archived|timestamp=20120313124756|user=roy.debjit| }}
__NOTOC__
+
[[Category:Symbian C++]][[Category:Code Snippet]][[Category:S60 3rd Edition (initial release)]][[Category:Code Snippet]]
__NOEDITSECTION__
+
{{ArticleMetaData <!-- v1.2 -->
{{KBCS}}
+
{{ArticleMetaData
+
|id=CS001010
+
|platform=S60 3rd Edition, MR
+
|devices=Nokia N95
+
|category=Symbian C++
+
|subcategory=Code Examples
+
|creationdate=June 10, 2008
+
|keywords=CActiveSchedulerWait, CActive, TRequestStatus
+
 
+
 
|sourcecode= <!-- Link to example source code (e.g. [[Media:The Code Example ZIP.zip]]) -->
 
|sourcecode= <!-- Link to example source code (e.g. [[Media:The Code Example ZIP.zip]]) -->
 
|installfile= <!-- Link to installation file (e.g. [[Media:The Installation File.sis]]) -->
 
|installfile= <!-- Link to installation file (e.g. [[Media:The Installation File.sis]]) -->
|sdk=<!-- SDK(s) built and tested against (e.g. [http://linktosdkdownload/ Nokia Qt SDK 1.1]) -->
+
|devices= Nokia N95
|devicecompatability=<!-- Compatible devices (e.g.: All* (must have GPS) ) -->
+
|sdk= <!-- SDK(s) built and tested against (e.g. [http://linktosdkdownload/ Nokia Qt SDK 1.1]) -->
|signing=<!-- Empty or one of Self-Signed, DevCert, Manufacturer -->
+
|platform= S60 3rd Edition, MR
|capabilities=<!-- Capabilities required (e.g. Location, NetworkServices. -->)
+
|devicecompatability= <!-- Compatible devices (e.g.: All* (must have GPS) ) -->
|author=[[User:Tepaa]]
+
|dependencies= <!-- Any other/external dependencies e.g.: Google Maps Api v1.0 -->
 +
|signing= <!-- Empty or one of Self-Signed, DevCert, Manufacturer -->
 +
|capabilities= <!-- Capabilities required by the article/code example (e.g. Location, NetworkServices. -->
 +
|keywords= CActiveSchedulerWait, CActive, TRequestStatus
 +
|language= <!-- Language category code for non-English topics - e.g. Lang-Chinese -->
 +
|translated-by= <!-- [[User:XXXX]] -->
 +
|translated-from-title= <!-- Title only -->
 +
|translated-from-id= <!-- Id of translated revision -->
 +
|review-by= <!-- After re-review: [[User:username]] -->
 +
|review-timestamp= <!-- After re-review: YYYYMMDD -->
 +
|update-by= <!-- After significant update: [[User:username]]-->
 +
|update-timestamp= <!-- After significant update: YYYYMMDD -->
 +
|creationdate= 20080527
 +
|author= [[User:Tepaa]]
 +
<!-- The following are not in current metadata -->
 +
|subcategory= Code Examples
 +
|id= CS001010
 
}}
 
}}
{{Archived|timestamp=20120313124756|user=roy.debjit| }}
 
 
    
 
    
 
==Overview==
 
==Overview==
Line 26: Line 31:
  
 
There are two different methods:
 
There are two different methods:
* <tt>void LongRunningTaskL(TInt& aResult)</tt> is a synchronous method that acts like an asynchronous one but returns when the task has been completed.
+
* {{Icode|void LongRunningTaskL(TInt& aResult)}} is a synchronous method that acts like an asynchronous one but returns when the task has been completed.
* <tt>void LongRunningTaskL(MMySynchronousTaskDone* aObserver)</tt> is a synchronous method that acts like an asynchronous method. Note that the method returns right after it has been started and notifies of task completion via <tt>MMySynchronousTaskDone</tt>.
+
* {{Icode|void LongRunningTaskL(MMySynchronousTaskDone* aObserver)}} is a synchronous method that acts like an asynchronous method. Note that the method returns right after it has been started and notifies of task completion via {{Icode|MMySynchronousTaskDone}}.
  
 
==MMP file==
 
==MMP file==
 
The following capabilities and libraries are required:
 
The following capabilities and libraries are required:
 
<code cpp>
 
<code cpp>
CAPABILITY   None
+
CAPABILITY None
LIBRARY       euser.lib
+
LIBRARY euser.lib
 
</code>
 
</code>
  
Line 84: Line 89:
 
          
 
          
 
     private:
 
     private:
         EState                 iRunningState;
+
         EState iRunningState;
 
         CActiveSchedulerWait*  iSchedulerWait;
 
         CActiveSchedulerWait*  iSchedulerWait;
         TInt                   iSomeLongRunningTask;
+
         TInt iSomeLongRunningTask;
 
         MMySynchronousTaskDone* iObserver;
 
         MMySynchronousTaskDone* iObserver;
 
     };
 
     };
Line 267: Line 272:
  
 
==See also==
 
==See also==
[[CS000982 - Using CActiveSchedulerWait]]
+
[[Using CActiveSchedulerWait]]
  
[[Change_asynchronous_method_into_synchronous]]
+
[[Change asynchronous method into synchronous]]

Revision as of 09:15, 13 June 2012

Archived.pngArchived: This article is archived because it is not considered relevant for third-party developers creating commercial solutions today. If you think this article is still relevant, let us know by adding the template {{ReviewForRemovalFromArchive|user=~~~~|write your reason here}}.

Article Metadata
Tested with
Devices(s): Nokia N95
Compatibility
Platform(s): S60 3rd Edition, MR
S60 3rd Edition (initial release)
Article
Keywords: CActiveSchedulerWait, CActive, TRequestStatus
Created: tepaa (27 May 2008)
Last edited: hamishwillee (13 Jun 2012)

Contents

Overview

This code snippet shows how to modify a synchronous method to behave like an asynchronous method.

There are two different methods:

  • void LongRunningTaskL(TInt& aResult) is a synchronous method that acts like an asynchronous one but returns when the task has been completed.
  • void LongRunningTaskL(MMySynchronousTaskDone* aObserver) is a synchronous method that acts like an asynchronous method. Note that the method returns right after it has been started and notifies of task completion via MMySynchronousTaskDone.

MMP file

The following capabilities and libraries are required:

CAPABILITY None
LIBRARY euser.lib

Header

#include <e32base.h>
 
class MMySynchronousTaskDone
{
public:
virtual void TaskDone(TInt aRet) = 0;
};
 
class CMySynchronousClass : public CActive
{
enum EState
{
EIdle = 0,
EStarted,
ERunningTask1,
ERunningTask2,
ERunningTask3,
EEnd
};
 
public:
static CMySynchronousClass* NewL();
virtual ~CMySynchronousClass();
 
public:
// Synchronous method that acts like an asynchronous one
// but returns when task completed.
void LongRunningTaskL(TInt& aResult);
 
// Synchronous method that acts like an asynchronous one
// note that the method returns right after it has been started
// and notifies of task completion via MMySynchronousTaskDone
void LongRunningTaskL(MMySynchronousTaskDone* aObserver);
 
private: // From CActive
void RunL();
TInt RunError(TInt aError);
void DoCancel();
 
private:
CMySynchronousClass();
void ConstructL();
void GiveTimeToOthers();
void DoLongRunningTask();
 
private:
EState iRunningState;
CActiveSchedulerWait* iSchedulerWait;
TInt iSomeLongRunningTask;
MMySynchronousTaskDone* iObserver;
};

Source

CMySynchronousClass* CMySynchronousClass::NewL()
{
CMySynchronousClass* self = new (ELeave) CMySynchronousClass();
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop();
return self;
}
 
CMySynchronousClass::CMySynchronousClass():CActive(EPriorityStandard)
{
}
 
void CMySynchronousClass::ConstructL()
{
CActiveScheduler::Add(this);
iSchedulerWait = new (ELeave) CActiveSchedulerWait();
}
 
CMySynchronousClass::~CMySynchronousClass()
{
Cancel();
delete iSchedulerWait;
}
 
// This method returns after synchronous task completion
void CMySynchronousClass::LongRunningTaskL(TInt& aResult)
{
if (iRunningState == EIdle)
{
iSomeLongRunningTask = 0;
iRunningState = EStarted;
 
GiveTimeToOthers();
iSchedulerWait->Start();
 
// Continues here after CActiveSchedulerWait::AsyncComplete() is called
if (iStatus.Int() != KErrNone)
{
User::Leave(iStatus.Int());
}
aResult = iSomeLongRunningTask;
}
else
{
User::Leave(KErrNotReady);
}
}
 
// This method returns right after the synchronous task is started
void CMySynchronousClass::LongRunningTaskL(MMySynchronousTaskDone* aObserver)
{
if (iRunningState == EIdle)
{
iObserver = aObserver;
iSomeLongRunningTask = 0;
iRunningState = EStarted;
GiveTimeToOthers();
}
else
{
User::Leave(KErrNotReady);
}
 
}
 
void CMySynchronousClass::DoLongRunningTask()
{
// TODO: Here is a synchronous method call.
// Try to split call in small parts.
iSomeLongRunningTask++;
}
 
void CMySynchronousClass::GiveTimeToOthers()
{
TRequestStatus* status = &iStatus;
User::RequestComplete( status, KErrNone );
SetActive();
}
 
void CMySynchronousClass::RunL()
{
switch (iRunningState)
{
case EIdle:
{
break;
}
case EStarted:
{
iRunningState = ERunningTask1;
// TODO: Call synchronous method
DoLongRunningTask();
 
GiveTimeToOthers();
break;
}
case ERunningTask1:
{
iRunningState = ERunningTask2;
// TODO: Call synchronous method
DoLongRunningTask();
 
GiveTimeToOthers();
break;
}
case ERunningTask2:
{
iRunningState = ERunningTask3;
// TODO: Call synchronous method
DoLongRunningTask();
 
GiveTimeToOthers();
break;
}
case ERunningTask3:
{
iRunningState = EEnd;
// TODO: Do some end processing if needed
 
GiveTimeToOthers();
break;
}
case EEnd:
{
// Done
iRunningState = EIdle;
if (iObserver)
{
iObserver->TaskDone(iSomeLongRunningTask);
}
if (iSchedulerWait->IsStarted())
{
iSchedulerWait->AsyncStop();
}
break;
}
default:
{
if (iSchedulerWait->IsStarted())
{
iSchedulerWait->AsyncStop();
}
break;
}
};
}
 
TInt CMySynchronousClass::RunError(TInt aError)
{
if (iObserver)
{
iObserver->TaskDone(aError);
}
return KErrNone;
}
 
void CMySynchronousClass::DoCancel()
{
if (iObserver)
{
iObserver->TaskDone(KErrCancel);
}
if (iSchedulerWait->IsStarted())
{
iSchedulerWait->AsyncStop();
}
}

Postconditions

The synchronous method acts like an asynchronous one.

See also

Using CActiveSchedulerWait

Change asynchronous method into synchronous

124 page views in the last 30 days.
×