TB9.2 Example Applications: examples/Base/IPC/Async/Fibonacci3/Fibonacci3.cpp Source File

00001 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+00002 // All rights reserved.
+00003 // This component and the accompanying materials are made available
+00004 // under the terms of "Eclipse Public License v1.0"
+00005 // which accompanies this distribution, and is available
+00006 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
+00007 //
+00008 // Initial Contributors:
+00009 // Nokia Corporation - initial contribution.
+00010 //
+00011 // Contributors:
+00012 //
+00013 // Description:
+00014 // Example wraps a console in an active object and performs the 
+00015 // Fibonacci calculation as a background active object.
+00016 // The technique used is similar to, but not identical, to that used by CIdle, where
+00017 // the background active object is repeatedly called provided the other (higher priority)
+00018 // active objects are not ready to run. 
+00019 // Fibonacci Active Objects example
+00020 //
+00021 
+00022 #include <e32cons.h>
+00023 #include <e32base.h>
+00024 #include <e32std.h>
+00025 
+00027 //nclude <e32hal.h>
+00028 
+00029 
+00030 LOCAL_D CConsoleBase* console;
+00031 
+00032 _LIT(KTxtMainInstructions,"\n\nPress 'F' to start\n      'ESC' to exit\n      'C' to cancel, anytime\n");
+00033 
+00035 //
+00036 // -----> CActiveConsole (definition)
+00037 //
+00038 // An abstract class which provides the facility to issue key requests. 
+00039 //
+00041 class CActiveConsole : public CActive
+00042         {
+00043 public:
+00044           // Construction
+00045         CActiveConsole(CConsoleBase* aConsole);
+00046         void ConstructL();
+00047 
+00048           // Destruction
+00049         ~CActiveConsole();
+00050 
+00051           // Issue request
+00052         void RequestCharacter();
+00053         
+00054           // Cancel request.
+00055           // Defined as pure virtual by CActive;
+00056           // implementation provided by this class.
+00057         void DoCancel();
+00058 
+00059           // Service completed request.
+00060           // Defined as pure virtual by CActive;
+00061           // implementation provided by this class,
+00062         void RunL();
+00063 
+00064           // Called from RunL() - an implementation must be provided
+00065           // by derived classes to handle the completed request
+00066         virtual void ProcessKeyPress(TChar aChar) = 0; 
+00067           
+00068 protected:
+00069           // Data members defined by this class
+00070         CConsoleBase* iConsole; // A console for reading from
+00071         };
+00072 
+00073 
+00075 //
+00076 // -----> CExampleScheduler (definition)
+00077 //
+00079 class CActiveConsole;
+00080 
+00081 class CExampleScheduler : public CActiveScheduler
+00082         {
+00083 public:
+00084         void Error (TInt aError) const;
+00085         void WaitForAnyRequest();
+00086         void SetActiveObject(CActiveConsole* aActiveConsole);
+00087 private:
+00088           // data members defined for this class
+00089         CActiveConsole* iActiveConsole;
+00090         };
+00091 
+00092 
+00093 
+00095 //
+00096 // -----> CFibonacciEngine (definition)
+00097 //
+00098 // This class provides the fibonacci calculation engine
+00099 //
+00101 
+00102 class CFibonacciEngine : public CBase
+00103         {
+00104 public:
+00105         CFibonacciEngine() ;
+00106         void StartCalculate (TInt aTerms) ;
+00107         void StepCalculate () ;
+00108         
+00109         TUint iResult ;
+00110 
+00111         enum TEngineState {eInactive, eCalculating, eCompleted}   ;
+00112         TEngineState iState ;
+00113 
+00114 private:
+00115         TUint iCurrentTotal ;
+00116         TUint iPreviousTotal ;
+00117         TInt iTermsLeftToDo ;
+00118         } ;
+00119 
+00120 
+00122 //
+00123 // -----> CFibonacciApplication (definition)
+00124 //
+00125 // This class encapsulates the fibonacci thread that runs the fibonacci engine
+00126 //
+00128 
+00129 class CFibonacciApplication : public CActive
+00130         {
+00131 public:
+00132         CFibonacciApplication(CConsoleBase* aConsole, CFibonacciEngine* aFibonacciEngine) ;
+00133         ~CFibonacciApplication() ;
+00134 
+00135         void CalculateFibonacci(TInt aIterations) ;
+00136 
+00137 private:
+00138         void DoCancel() ;
+00139         void RunL() ;
+00140 
+00141 private:
+00142         CConsoleBase* iConsole ;
+00143         CFibonacciEngine* iFibonacciEngine ;
+00144         } ;
+00145 
+00146 
+00148 //
+00149 // -----> CFibonacciKeyHandler (definition)
+00150 //
+00151 // This class encapsulates the fibonacci keyboard handler
+00152 //
+00154 
+00155 class CFibonacciKeyHandler : public CActiveConsole
+00156         {
+00157 public:
+00158         CFibonacciKeyHandler(   CConsoleBase* aConsole, 
+00159                                                         CFibonacciApplication* aApplication) ;
+00160         void ConstructL();
+00161 
+00162           // Static construction
+00163         static CFibonacciKeyHandler* NewLC(CConsoleBase* aConsole, CFibonacciApplication* aHandler) ;
+00164 
+00165           // service request
+00166         void ProcessKeyPress(TChar aChar) ;
+00167 
+00168 private:
+00169         CConsoleBase* iConsole ;
+00170         CFibonacciApplication* iApplication ;
+00171         };
+00172 
+00173 
+00175 //
+00176 // -----> CActiveConsole (implementation)
+00177 //
+00179 CActiveConsole::CActiveConsole( CConsoleBase* aConsole) 
+00180         : CActive(CActive::EPriorityUserInput)
+00181           // Construct high-priority active object
+00182         {
+00183         iConsole = aConsole;
+00184         __DECLARE_NAME(_S("CActiveConsole"));
+00185 
+00186         }
+00187 
+00188 void CActiveConsole::ConstructL()
+00189         {
+00190           // Add to active scheduler
+00191         CActiveScheduler::Add(this);
+00192         }
+00193 
+00194 CActiveConsole::~CActiveConsole()
+00195         {
+00196         // Make sure we're cancelled
+00197         Cancel();
+00198         }
+00199 
+00200 void  CActiveConsole::DoCancel()
+00201         {
+00202         iConsole->ReadCancel();
+00203         }
+00204 
+00205 void  CActiveConsole::RunL()
+00206         {
+00207           // Handle completed request
+00208         ProcessKeyPress(TChar(iConsole->KeyCode()));
+00209         }
+00210 
+00211 void CActiveConsole::RequestCharacter()
+00212         {
+00213           // A request is issued to the CConsoleBase to accept a
+00214           // character from the keyboard.
+00215         iConsole->Read(iStatus); 
+00216         SetActive();
+00217         }
+00218 
+00219 
+00221 //
+00222 // -----> CExampleScheduler (implementation)
+00223 //
+00225 void CExampleScheduler::Error(TInt aError) const
+00226         {
+00227         _LIT(KTxtSchedulerError,"CExampleScheduler - error");
+00228         User::Panic(KTxtSchedulerError,aError);
+00229         }
+00230 
+00231 
+00232 void CExampleScheduler::WaitForAnyRequest()
+00233         {
+00234         if (!(iActiveConsole->IsActive()))
+00235                 iActiveConsole->RequestCharacter();     
+00236         CActiveScheduler::WaitForAnyRequest();
+00237         }
+00238 
+00239 void CExampleScheduler::SetActiveObject(CActiveConsole* aActiveConsole)
+00240         {
+00241         iActiveConsole = aActiveConsole;
+00242         }
+00243 
+00244 
+00245 
+00247 // CFibonacciKeyHandler support routine
+00248 //   uses up arrow & down arrow to change number, Enter to select
+00250 
+00251 TInt GetValueFromKeyboard (TInt aInitial, TInt aStep, TInt lowerLimit, TInt upperLimit, const TDesC& aPrompt, CConsoleBase* aConsole)
+00252         {
+00253         TChar input ;
+00254         TInt value = aInitial ;
+00255 
+00256         aConsole->Printf(aPrompt) ;
+00257         do
+00258                 {
+00259                 aConsole->SetPos(0);
+00260                 _LIT(KFormat1,"%d  ");
+00261                 aConsole->Printf(KFormat1, value);
+00262                 input = aConsole->Getch() ;
+00263                 if (input == EKeyUpArrow && value < upperLimit) value = value + aStep ;
+00264                 if (input == EKeyDownArrow && value > lowerLimit) value = value - aStep ;
+00265                 }
+00266         while (input != EKeyEnter) ;
+00267 
+00268         return value ;
+00269         }
+00270 
+00271 
+00273 //
+00274 // -----> CFibonacciKeyHandler (implementation)
+00275 //
+00277 
+00278 CFibonacciKeyHandler::CFibonacciKeyHandler(CConsoleBase* aConsole, CFibonacciApplication* aApplication)
+00279         : CActiveConsole(aConsole)
+00280           // construct zero-priority active object
+00281         {
+00282         iConsole = aConsole ;
+00283         iApplication = aApplication ;
+00284 
+00285         __DECLARE_NAME(_S("CFibonacciApplication"));
+00286           // Add to active scheduler
+00287         CActiveScheduler::Add(this);
+00288           // Make this the active object
+00289         ((CExampleScheduler*)(CActiveScheduler::Current()))->SetActiveObject(this);
+00290         } 
+00291 
+00292 
+00293 void CFibonacciKeyHandler::ProcessKeyPress(TChar aChar)
+00294         {
+00295           // if key is ESC, cancel any outstanding request & stop the scheduler
+00296         if (aChar == EKeyEscape)
+00297                 {
+00298                 CActiveScheduler::Stop();
+00299                 return;
+00300                 }
+00301 
+00302           // If key is "f" or "F", issue a Fibonacci request if none is in progress
+00303         if (aChar == 'f' || aChar == 'F') 
+00304                 {
+00305                 if (!(iApplication->IsActive()))
+00306                         {
+00307                         _LIT(KTxtReturnTermNumber,"\nENTER selects num\nUP    arrow increases num\nDOWN  arrow decreases num\n\n");
+00308                         TInt iterations = GetValueFromKeyboard(5,1,2,46, KTxtReturnTermNumber, iConsole) ;
+00309                         iApplication->CalculateFibonacci(iterations);
+00310                         }
+00311                 else
+00312                         {
+00313                         _LIT(KTxtAlreadyInProgress,"[Already in progress]");
+00314                         iConsole->Printf(KTxtAlreadyInProgress);
+00315                         }
+00316                 return;
+00317                 }
+00318 
+00319       // If key is "c" or "C", cancel any outstanding request   
+00320         if (aChar == 'c' || aChar == 'C')
+00321                 {
+00322                 _LIT(KTxtCancelFibonacci,"\nCancelling Fibonacci....  \n");
+00323                 iConsole->Printf(KTxtCancelFibonacci);
+00324                 iApplication->Cancel();
+00325                 iConsole->Printf(KTxtMainInstructions);
+00326                 return;
+00327                 }
+00328         
+00329         _LIT(KTxtNotRecognised,"\nUnwanted key pressed");
+00330         iConsole->Printf(KTxtNotRecognised);
+00331         iConsole->Printf(KTxtMainInstructions);
+00332         }
+00333 
+00334 
+00336 //
+00337 // -----> CFibonacciApplication (implementation)
+00338 //
+00340 
+00341 CFibonacciApplication::CFibonacciApplication(CConsoleBase* aConsole, CFibonacciEngine* aFibonacciEngine)
+00342 //
+00343 // Constructor
+00344 //
+00345         : CActive(EPriorityStandard)
+00346         {
+00347         iConsole = aConsole ;
+00348         iFibonacciEngine = aFibonacciEngine ;
+00349         CActiveScheduler::Add(this);
+00350         __DECLARE_NAME(_S("CFibonacciApplication"));
+00351         };
+00352 
+00353 
+00354 // destructor
+00355 CFibonacciApplication::~CFibonacciApplication() 
+00356         {
+00357         // cancel any requests and tell server 
+00358         Cancel() ;
+00359         }
+00360 
+00361 
+00362 void CFibonacciApplication::DoCancel() 
+00363         {
+00364         // cancel the active object request 
+00365         iFibonacciEngine->iState = CFibonacciEngine::eInactive ;
+00366         }
+00367 
+00368 
+00369 
+00370 // initiate a request
+00371 void CFibonacciApplication::CalculateFibonacci(TInt aIterations)
+00372         {
+00373         // initialize engine
+00374         // no neeed to set iStatus to KRequestPending, as request completes below
+00375         iFibonacciEngine->StartCalculate(aIterations) ;
+00376 
+00377         // schedule the request
+00378         SetActive() ;
+00379 
+00380         // send signal that this request has completed
+00381         TRequestStatus* status = &iStatus ;
+00382         User::RequestComplete(status, KErrNone) ;
+00383         }
+00384 
+00385 
+00386 
+00387 void CFibonacciApplication::RunL() 
+00388 // implements a simple state engine: {eInactive, eCalculating, eCompleted}
+00389         {
+00390         if (iFibonacciEngine->iState == CFibonacciEngine::eInactive )
+00391                 {
+00392                 _LIT(KTxtEngineNotInitialized,"Engine not initialized");
+00393                 User::Panic(KTxtEngineNotInitialized, KErrNotReady) ;
+00394                 }
+00395         else if (iFibonacciEngine->iState == CFibonacciEngine::eCalculating )
+00396                 {               
+00397                 // unnecessary - just provides feedback on progression of the calculation
+00398                 _LIT(KTxtDot,".");
+00399                 iConsole->Printf(KTxtDot) ;
+00400 
+00401                 // no neeed to set iStatus to KRequestPending, as request completes below
+00402 
+00403                 // request next step
+00404                 iFibonacciEngine->StepCalculate() ;
+00405 
+00406                 // schedule request
+00407                 SetActive() ;
+00408 
+00409                 // send signal that this request has completed
+00410                 TRequestStatus* status = &iStatus ;
+00411                 User::RequestComplete(status, KErrNone) ;
+00412                 }
+00413         else if (iFibonacciEngine->iState == CFibonacciEngine::eCompleted )
+00414                 {
+00415                 // finished calculation: print result and reset state engine
+00416                 _LIT(KFormat2,"\n    Result : %u \n");  //not used
+00417                 iConsole->Printf(KFormat2, iFibonacciEngine->iResult) ; 
+00418                 iConsole->Printf(KTxtMainInstructions) ; 
+00419                 iFibonacciEngine->iState = CFibonacciEngine::eInactive ;
+00420                 }
+00421         }
+00422 
+00423 
+00424 
+00426 //
+00427 // -----> CFibonacciEngine (implementation)
+00428 //
+00430 CFibonacciEngine::CFibonacciEngine() 
+00431         {
+00432         iState = eInactive ;
+00433         }
+00434 
+00435 
+00436 void CFibonacciEngine::StartCalculate (TInt aTerms) 
+00437         {
+00438         // initialise all internal variables to initial state
+00439         iCurrentTotal = 1 ;
+00440         iPreviousTotal = 0 ;
+00441         iResult = 0 ;
+00442         iTermsLeftToDo = aTerms + 1 ;   // first step completed in variable initialization
+00443         iState = eCalculating ;
+00444         }
+00445 
+00446 
+00447 
+00448 void CFibonacciEngine::StepCalculate () 
+00449         {
+00450 
+00451         // if full calculation not yet complete, but in progress (i.e. not cancelled)
+00452         if (--iTermsLeftToDo > 0 && iState == eCalculating)     
+00453                 {
+00454                 // calculate next number in series
+00455                 TInt newTotal = iCurrentTotal + iPreviousTotal ;
+00456 
+00457                 // update internal variables
+00458                 iPreviousTotal = iCurrentTotal ;
+00459                 iCurrentTotal = newTotal ;
+00460 
+00461                 // introduce a delay to make us a long-running service
+00462                 User::After(1000000) ;
+00463 
+00464                 // not necessary, but allows running total to be used during the calculation
+00465                 // (say for putting values into a chart or graph)
+00466                 iResult = iCurrentTotal ;
+00467                 }
+00468         else if (iTermsLeftToDo <= 0)
+00469                 {
+00470                 // flag that calculation has finished and ensure final result is available
+00471                 iState = eCompleted ;
+00472                 iResult = iCurrentTotal ;
+00473                 }
+00474         } 
+00475 
+00476 
+00477 
+00479 // This section deals with initialisation and ensuring we have a console active
+00481 
+00482 void doExampleL () ;
+00483 
+00484 void SetupConsoleL();
+00485 
+00486 GLDEF_C TInt E32Main()                          // main function called by E32
+00487     {
+00488         CTrapCleanup* cleanup=CTrapCleanup::New();              // get clean-up stack
+00489         TRAPD(error,SetupConsoleL());                           // more initialization, then do example
+00490         _LIT(KTxtFibonacciExampleError,"Fibonacci example error");
+00491         __ASSERT_ALWAYS(!error,User::Panic(KTxtFibonacciExampleError,error));
+00492         delete cleanup;                                         // destroy clean-up stack
+00493         return 0;                                                                               // and return
+00494     }
+00495 
+00496 void SetupConsoleL()                             // initialize and call example code under cleanup stack
+00497     {
+00498         _LIT(KTxtFibActObjBackground,"Background Active Object");
+00499         console=Console::NewL(KTxtFibActObjBackground, TSize(KConsFullScreen,KConsFullScreen));
+00500         CleanupStack::PushL(console);
+00501         console->Printf(KTxtMainInstructions) ;
+00502         TRAPD(error, doExampleL());                                                     // perform example function
+00503         if (error)
+00504                 {
+00505                 _LIT(KFormat3,"failed: leave code=%d");
+00506                 console->Printf(KFormat3, error);
+00507                 }
+00508         _LIT(KTxtPressAnyKey,"[Press any key to exit]");
+00509         console->Printf(KTxtPressAnyKey);
+00510         console->Getch();                                                               // get and ignore character
+00511         CleanupStack::PopAndDestroy();                                  // close console
+00512     }
+00513 
+00514 
+00516 //
+00517 // Do the example
+00518 //
+00520 void doExampleL()
+00521     {
+00522           // Construct and install the active scheduler; push onto the cleanup stack
+00523         CExampleScheduler*  exampleScheduler = new (ELeave) CExampleScheduler;
+00524         CleanupStack::PushL(exampleScheduler);
+00525          
+00526           // Install as the active scheduler
+00527         CActiveScheduler::Install(exampleScheduler);
+00528 
+00529         // Create CFibonacciEngine active object; push onto the cleanup stack
+00530         CFibonacciEngine* fibEngine = new (ELeave) CFibonacciEngine ;
+00531     CleanupStack::PushL(fibEngine);
+00532     
+00533           // Create CFibonacciApplication handler active object; push onto the cleanup stack
+00534         CFibonacciApplication* fibApplication = new CFibonacciApplication(console, fibEngine);
+00535     CleanupStack::PushL(fibApplication);
+00536 
+00537           // Create CFibonacciKeyHandler active object; push onto the cleanup stack
+00538         CFibonacciKeyHandler* fibKeyHandler = new CFibonacciKeyHandler(console, fibApplication);
+00539     CleanupStack::PushL(fibKeyHandler);
+00540 
+00541           // issue initial request
+00542         fibKeyHandler->RequestCharacter() ;
+00543                         
+00544         // Main part of the program:
+00545         //    wait loop that cycles until ActiveScheduler::Stop called
+00546         CActiveScheduler::Start();
+00547            
+00548         // Remove items from the cleanup stack and destroy them
+00549         CleanupStack::PopAndDestroy(4); 
+00550         }
+00551 
+00552 
+