TB10.1 Example Applications: examples/Base/IPC/Async/Fibonacci2/Fibonacci2.cpp Source File

00001 // Copyright (c) 2000-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 in a separate thread.
+00016 // This is NOT the recommended way and serves only to compare with the 
+00017 // Fibonacci3 example which performs the calculation as
+00018 // a background active object.
+00019 //
+00020 
+00021 
+00022 #include <e32std.h>
+00023 #include <e32cons.h>
+00024 #include <e32base.h>
+00025 
+00026 //
+00027 // Common literals
+00028 //
+00029 _LIT(KTxtFibThread,"FibThread");
+00030 
+00031 
+00032 LOCAL_D CConsoleBase* console;
+00033 
+00034 _LIT(KTxtMainInstructions,"\n\nPress 'F' to start\n      'ESC' to exit\n      'C' to cancel, anytime\n");
+00035 
+00037 //
+00038 // -----> CActiveConsole (definition)
+00039 //
+00040 // An abstract class which provides the facility to issue key requests. 
+00041 //
+00043 class CActiveConsole : public CActive
+00044         {
+00045 public:
+00046           // Construction
+00047         CActiveConsole(CConsoleBase* aConsole);
+00048         void ConstructL();
+00049 
+00050           // Destruction
+00051         ~CActiveConsole();
+00052 
+00053           // Issue request
+00054         void RequestCharacter();
+00055         
+00056           // Cancel request.
+00057           // Defined as pure virtual by CActive;
+00058           // implementation provided by this class.
+00059         void DoCancel();
+00060 
+00061           // Service completed request.
+00062           // Defined as pure virtual by CActive;
+00063           // implementation provided by this class,
+00064         void RunL();
+00065 
+00066           // Called from RunL() - an implementation must be provided
+00067           // by derived classes to handle the completed request
+00068         virtual void ProcessKeyPress(TChar aChar) = 0; 
+00069           
+00070 protected:
+00071           // Data members defined by this class
+00072         CConsoleBase* iConsole; // A console for reading from
+00073         };
+00074 
+00075 
+00077 //
+00078 // -----> CExampleScheduler (definition)
+00079 //
+00081 
+00082 class CExampleScheduler : public CActiveScheduler
+00083         {
+00084 public:
+00085         void Error (TInt aError) const;
+00086         void WaitForAnyRequest();
+00087         void SetActiveObject(CActiveConsole* aActiveConsole);
+00088 private:
+00089           // data members defined for this class
+00090         CActiveConsole* iActiveConsole;
+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         void Calculate (TInt aTerms) ;
+00106 
+00107         TUint iResult ;
+00108         } ;
+00109 
+00110 
+00112 //
+00113 // -----> TFibonacciParameters (definition)
+00114 //
+00115 // This class provides for passing parameters to the thread 
+00116 //
+00118 
+00119 class TFibonacciParameters
+00120         {
+00121 public:
+00122         TInt iVar1 ;
+00123         TAny* iVar2 ;
+00124         TUint iResult ;
+00125         } ;
+00126 
+00127 
+00129 //
+00130 // -----> CFibonacciThreadHandler (definition)
+00131 //
+00132 // This class encapsulates the fibonacci thread that runs the fibonacci engine
+00133 //
+00135 
+00136 class CFibonacciThreadHandler : public CActive
+00137         {
+00138 public:
+00139         CFibonacciThreadHandler(CConsoleBase* aConsole, CFibonacciEngine* aFibonacciEngine) ;
+00140         ~CFibonacciThreadHandler() ;
+00141 
+00142         void CalculateFibonacciL(TInt aIterations) ;
+00143 
+00144 private:
+00145         void DoCancel() ;
+00146         void RunL() ;
+00147         static TInt FibonacciThread(TAny* aParameters) ;
+00148 
+00149 private:
+00150         CConsoleBase* iConsole ;
+00151         TFibonacciParameters iFibonacciParameters ;
+00152         CFibonacciEngine* iFibonacciEngine ;
+00153         };
+00154 
+00155 
+00157 //
+00158 // -----> CFibonacciKeyHandler (definition)
+00159 //
+00160 // This class encapsulates the fibonacci keyboard handler
+00161 //
+00163 
+00164 class CFibonacciKeyHandler : public CActiveConsole
+00165         {
+00166 public:
+00167         CFibonacciKeyHandler(   CConsoleBase* aConsole, 
+00168                                                         CFibonacciThreadHandler* iThreadHandler) ;
+00169         void ConstructL();
+00170 
+00171           // Static construction
+00172         static CFibonacciKeyHandler* NewLC(CConsoleBase* aConsole, CFibonacciThreadHandler* aHandler) ;
+00173 
+00174           // service request
+00175         void ProcessKeyPress(TChar aChar) ;
+00176 
+00177 private:
+00178         CConsoleBase* iConsole ;
+00179         CFibonacciThreadHandler* iThreadHandler ;
+00180         };
+00181 
+00182 
+00183 
+00184 
+00186 //
+00187 // -----> CActiveConsole (implementation)
+00188 //
+00190 CActiveConsole::CActiveConsole( CConsoleBase* aConsole) 
+00191         : CActive(CActive::EPriorityUserInput)
+00192           // Construct high-priority active object
+00193         {
+00194         iConsole = aConsole;
+00195         }
+00196 
+00197 void CActiveConsole::ConstructL()
+00198         {
+00199           // Add to active scheduler
+00200         CActiveScheduler::Add(this);
+00201         }
+00202 
+00203 CActiveConsole::~CActiveConsole()
+00204         {
+00205         // Make sure we're cancelled
+00206         Cancel();
+00207         }
+00208 
+00209 void  CActiveConsole::DoCancel()
+00210         {
+00211         iConsole->ReadCancel();
+00212         }
+00213 
+00214 void  CActiveConsole::RunL()
+00215         {
+00216           // Handle completed request
+00217         ProcessKeyPress(TChar(iConsole->KeyCode()));
+00218         }
+00219 
+00220 void CActiveConsole::RequestCharacter()
+00221         {
+00222           // A request is issued to the CConsoleBase to accept a
+00223           // character from the keyboard.
+00224         iConsole->Read(iStatus); 
+00225         SetActive();
+00226         }
+00227 
+00228 
+00230 //
+00231 // -----> CExampleScheduler (implementation)
+00232 //
+00234 void CExampleScheduler::Error(TInt aError) const
+00235         {
+00236         _LIT(KTxtSchedulerError,"CExampleScheduler - error");
+00237         User::Panic(KTxtSchedulerError,aError);
+00238         }
+00239 
+00240 
+00241 void CExampleScheduler::WaitForAnyRequest()
+00242         {
+00243         if (!(iActiveConsole->IsActive()))
+00244                 iActiveConsole->RequestCharacter();     
+00245         CActiveScheduler::WaitForAnyRequest();
+00246         }
+00247 
+00248 void CExampleScheduler::SetActiveObject(CActiveConsole* aActiveConsole)
+00249         {
+00250         iActiveConsole = aActiveConsole;
+00251         }
+00252 
+00253 
+00254 
+00255 
+00256 
+00258 // CFibonacciKeyHandler support routine
+00259 //   uses up arrow & down arrow to change number, Enter to select
+00261 
+00262 TInt GetValueFromKeyboard (TInt aInitial, TInt aStep, TInt lowerLimit, TInt upperLimit, const TDesC& aPrompt, CConsoleBase* aConsole)
+00263         {
+00264         TChar input ;
+00265         TInt value = aInitial ;
+00266 
+00267         aConsole->Printf(aPrompt) ;
+00268         do
+00269                 {
+00270                 aConsole->SetPos(0);
+00271                 _LIT(KFormat1,"%d  ");
+00272                 aConsole->Printf(KFormat1, value);
+00273                 input = aConsole->Getch() ;
+00274                 if (input == EKeyUpArrow && value < upperLimit) value = value + aStep ;
+00275                 if (input == EKeyDownArrow && value > lowerLimit) value = value - aStep ;
+00276                 }
+00277         while (input != EKeyEnter) ;
+00278 
+00279         return value ;
+00280         }
+00281 
+00282 
+00284 //
+00285 // -----> CFibonacciKeyHandler (implementation)
+00286 //
+00288 
+00289 
+00290 CFibonacciKeyHandler::CFibonacciKeyHandler(CConsoleBase* aConsole, CFibonacciThreadHandler* aThreadHandler )
+00291         : CActiveConsole(aConsole)
+00292           // construct zero-priority active object
+00293         {
+00294         iConsole = aConsole ;
+00295         iThreadHandler = aThreadHandler ;
+00296           // Add to active scheduler
+00297         CActiveScheduler::Add(this);
+00298           // Make this the active object
+00299         ((CExampleScheduler*)(CActiveScheduler::Current()))->SetActiveObject(this);
+00300         } 
+00301 
+00302 
+00303 void CFibonacciKeyHandler::ProcessKeyPress(TChar aChar)
+00304         {
+00305           // if key is ESC 
+00306           //   cancel any outstanding request
+00307           //   stop the scheduler
+00308         if (aChar == EKeyEscape)
+00309                 {
+00310                 CActiveScheduler::Stop();
+00311                 return;
+00312                 }
+00313 
+00314           // If key is "f" or "F"
+00315           //   cancel any outstanding request
+00316           //   issue a fibonacci request.
+00317         if (aChar == 'f' || aChar == 'F') 
+00318                 {
+00319                 _LIT(KTxtStartingFibonacci,"\nStarting Fibonacci....  \n");
+00320                 iConsole->Printf(KTxtStartingFibonacci);
+00321                 _LIT(KTxtReturnTermNumber,"\nENTER selects num\nUP    arrow increases num\nDOWN  arrow decreases num\n\n");
+00322                 TInt iterations = GetValueFromKeyboard(5,1,2,46, KTxtReturnTermNumber, iConsole) ;
+00323                 TRAPD(err,iThreadHandler->CalculateFibonacciL(iterations));
+00324                 if(err)
+00325                         {
+00326                                 _LIT(KFormat4,"CalculateFibonacciL failed: leave code=%d");
+00327                                 console->Printf(KFormat4, err); 
+00328                         }
+00329                 return;
+00330                 }
+00331 
+00332       // If key is "c" or "C" 
+00333           //    cancel any outstanding request  
+00334         if (aChar == 'c' || aChar == 'C')
+00335                 {
+00336                 _LIT(KTxtCancelFibonacci,"\nCancelling Fibonacci....  \n");
+00337                 iConsole->Printf(KTxtCancelFibonacci);
+00338                 iThreadHandler->Cancel();
+00339                 iConsole->Printf(KTxtMainInstructions);
+00340                 return;
+00341                 }
+00342 
+00343         _LIT(KTxtNotRecognised,"\nUnwanted key pressed");
+00344         iConsole->Printf(KTxtNotRecognised);
+00345         iConsole->Printf(KTxtMainInstructions);
+00346         }
+00347 
+00348 
+00350 //
+00351 // -----> CFibonacciThreadHandler (implementation)
+00352 //
+00354 
+00355 CFibonacciThreadHandler::CFibonacciThreadHandler(CConsoleBase* aConsole, CFibonacciEngine* aFibonacciEngine)
+00356 //
+00357 // Constructor
+00358 //
+00359         : CActive(EPriorityStandard)
+00360         {
+00361         iConsole = aConsole ;
+00362         iFibonacciEngine = aFibonacciEngine ;
+00363         CActiveScheduler::Add(this);
+00364         };
+00365 
+00366 
+00367 // destructor
+00368 CFibonacciThreadHandler::~CFibonacciThreadHandler() 
+00369         {
+00370         // cancel any requests and tell server 
+00371         Cancel() ;
+00372         }
+00373 
+00374 
+00375 void CFibonacciThreadHandler::DoCancel() 
+00376         {
+00377         // cancel the active object request 
+00378         RThread thread ;
+00379         thread.Open(KTxtFibThread) ;
+00380         thread.Close() ;
+00381         }
+00382 
+00383 
+00384 void CFibonacciThreadHandler::RunL() 
+00385         {
+00386         // handle requests - print out result and flag as handled (ie not cancelled)
+00387         _LIT(KFormat2,"    Result : %u \n");  //not used
+00388         iConsole->Printf(KFormat2, iFibonacciParameters.iResult) ;
+00389         iConsole->Printf(KTxtMainInstructions);
+00390         }
+00391 
+00392 
+00393 // initiate a request
+00394 void CFibonacciThreadHandler::CalculateFibonacciL(TInt aIterations)
+00395         {
+00396         const TInt KHeapSize = 0x800 ;
+00397         
+00398         _LIT(KTxtFibRequested,"\nFibonacci requested ...  ");
+00399         iConsole->Printf(KTxtFibRequested);
+00400 
+00401 
+00402         RThread thread ;
+00403 
+00404         // set up parameters to thread
+00405 
+00406         iFibonacciParameters.iVar1 = aIterations ;
+00407         iFibonacciParameters.iVar2 = iFibonacciEngine ;
+00408 
+00409         // generate thread, leave if fails
+00410         
+00411         TInt result = thread.Create(KTxtFibThread,(TThreadFunction)FibonacciThread, KDefaultStackSize,
+00412                                                                 KMinHeapSize, KHeapSize, &iFibonacciParameters, EOwnerThread) ;
+00413         User::LeaveIfError(result) ;
+00414 
+00415         // log on to thread -   sets iStatus to KRequestPending 
+00416         //                                              requests notification of thread completion
+00417         thread.Logon(iStatus) ;
+00418 
+00419         // give thread low priority 
+00420         thread.SetPriority(EPriorityMuchLess) ;
+00421 
+00422         // resume thread (wake it up sometime after this function returns)
+00423         thread.Resume() ;
+00424 
+00425         thread.Close() ;
+00426 
+00427         // ensure scheduler checks status 
+00428         SetActive() ;
+00429         
+00430         _LIT(KTxtOK,"OK  \n");
+00431         iConsole->Printf(KTxtOK);
+00432         }
+00433 
+00434 
+00436 //  Thread routine that sorts out parameters & calls engine
+00438 
+00439 TInt CFibonacciThreadHandler::FibonacciThread(TAny* aParameters)
+00440         {
+00441         // cast the parameters pointer
+00442         TFibonacciParameters* parameters = (TFibonacciParameters*) aParameters ;
+00443 
+00444         // get variables from parameters class
+00445         TInt iterations = parameters->iVar1 ;
+00446         CFibonacciEngine* fibonacciEngine = (CFibonacciEngine*)parameters->iVar2 ;
+00447 
+00448         // call the engine
+00449         fibonacciEngine->Calculate(iterations) ;
+00450 
+00451         // store result
+00452         parameters->iResult = fibonacciEngine->iResult ;
+00453 
+00454         return KErrNone ;
+00455 }
+00456 
+00457 
+00459 //
+00460 // -----> CFibonacciEngine (implementation)
+00461 //
+00463 
+00464 void CFibonacciEngine::Calculate (TInt aTerms) 
+00465         {
+00466         TInt iterations = aTerms ;
+00467 
+00468         TInt currentTotal = 1 ;
+00469         TInt previousTotal = 0 ;
+00470         _LIT(KTxtTooManyIterations,"Too many iterations");
+00471         __ASSERT_ALWAYS(iterations<47,User::Panic(KTxtTooManyIterations,iterations));
+00472 
+00473 
+00474         // if limit not yet reached
+00475         while (iterations-- > 0)        
+00476                 {
+00477                 // calculate next number in series
+00478                 TInt newTotal = currentTotal + previousTotal ;
+00479 
+00480                 // update variables
+00481                 previousTotal = currentTotal ;
+00482                 currentTotal = newTotal ;
+00483 
+00484                 // introduce a delay
+00485                 User::After(1000000) ;
+00486                 }  
+00487 
+00488         iResult = currentTotal ;
+00489 
+00490 //UserHal::ModifyLedMask(1,2);
+00491         } 
+00492 
+00493 
+00495 // This section deals with initialisation and ensuring we have a console active
+00497 
+00498 void doExampleL () ;
+00499 
+00500 void SetupConsoleL();
+00501 
+00502 GLDEF_C TInt E32Main()                          // main function called by E32
+00503     {
+00504         CTrapCleanup* cleanup=CTrapCleanup::New();              // get clean-up stack
+00505         TRAPD(error,SetupConsoleL());                                   // more initialization, then do example
+00506         _LIT(KTxtFibonacciExampleError,"Fibonacci example error");
+00507         __ASSERT_ALWAYS(!error,User::Panic(KTxtFibonacciExampleError,error));
+00508         delete cleanup;                                                                 // destroy clean-up stack
+00509         return 0;                                                                               // and return
+00510     }
+00511 
+00512 void SetupConsoleL()                             // initialize and call example code under cleanup stack
+00513     {
+00514         _LIT(KTxtFibActObjInThread,"Active Object and thread");
+00515         console=Console::NewL(KTxtFibActObjInThread,TSize(KConsFullScreen,KConsFullScreen));
+00516         CleanupStack::PushL(console);
+00517         console->Printf(KTxtMainInstructions) ;
+00518         TRAPD(error, doExampleL());                                                     // perform example function
+00519         if (error)
+00520                 {
+00521                 _LIT(KFormat3,"failed: leave code=%d");
+00522                 console->Printf(KFormat3, error);
+00523                 }
+00524         _LIT(KTxtPressAnyKey,"[Press any key to exit]");
+00525         console->Printf(KTxtPressAnyKey);
+00526         console->Getch();                                                               // get and ignore character
+00527         CleanupStack::PopAndDestroy(console);                                   // close console
+00528     }
+00529 
+00530 
+00532 //
+00533 // Do the example
+00534 //
+00536 void doExampleL()
+00537     {
+00538           // Construct and install the active scheduler; push onto cleanup stack.
+00539         CExampleScheduler*  exampleScheduler = new (ELeave) CExampleScheduler;
+00540         CleanupStack::PushL(exampleScheduler);
+00541          
+00542           // Install as the active scheduler
+00543         CActiveScheduler::Install(exampleScheduler);
+00544 
+00545         // Create CFibonacciEngine active object; push onto cleanup stack.
+00546         CFibonacciEngine* fibEngine = new (ELeave) CFibonacciEngine ;
+00547     CleanupStack::PushL(fibEngine);
+00548 
+00549           // Create CFibonacciThreadHandler active object; push onto cleanup stack.
+00550         CFibonacciThreadHandler* fibThreadHandler = new (ELeave) CFibonacciThreadHandler(console, fibEngine);
+00551     CleanupStack::PushL(fibThreadHandler);
+00552         
+00553           // Create CFibonacciKeyHandler active object; push onto cleanup stack.
+00554         CFibonacciKeyHandler* fibKeyHandler = new (ELeave) CFibonacciKeyHandler(console, fibThreadHandler);
+00555     CleanupStack::PushL(fibKeyHandler); 
+00556 
+00557           // issue initial request; push onto cleanup stack
+00558         fibKeyHandler->RequestCharacter() ;
+00559                         
+00560         // Main part of the program:
+00561         //    wait loop that cycles until ActiveScheduler::Stop called
+00562         CActiveScheduler::Start();
+00563 
+00564         // Remove from the cleanup stack and destroy:
+00565         CleanupStack::PopAndDestroy(4); 
+00566         }
+00567 
+00568 
+00569 
+00570 
+