TB10.1 Example Applications: examples/Base/IPC/Async/AcceptInput1/AcceptInput1.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 // Asynchronous keyboard processing with messenger program.
+00015 // A single CKeyMessengerProcessor active object (derived from
+00016 // class CActiveConsole) which accepts input from keyboard, but does not
+00017 // print it.
+00018 // This object contains a CMessageTimer object which it activates if the
+00019 // user inputs the character "m" and cancelled if the user inputs "c".
+00020 //
+00021 
+00022 #include "CommonFramework.h"
+00023 
+00024 //
+00025 // Common literal text
+00026 //
+00027 _LIT(KTextEsc,"\n");
+00028 
+00029 // panics
+00030 enum
+00031         {
+00032         EPanicAlreadyActive=1000,
+00033         };
+00034 
+00035 
+00037 //
+00038 // -----> CTimedMessenger (definition)
+00039 //
+00041 class CTimedMessenger : public CTimer
+00042         {
+00043 public:
+00044           // Construction
+00045         CTimedMessenger();
+00046       // Destruction
+00047         ~CTimedMessenger();
+00048 
+00049 public:
+00050           // Static construction
+00051         static CTimedMessenger* NewLC(const TDesC& aGreeting,
+00052                                           TInt aTicksRequested,
+00053                                                                   TInt aTicksInterval
+00054                                                                  );
+00055         static CTimedMessenger* NewL(const TDesC& aGreeting,
+00056                                          TInt aTicksRequested,
+00057                                                                  TInt aTicksInterval
+00058                                                                 );
+00059 
+00060 public:
+00061           // Second phase construction
+00062         void ConstructL(const TDesC& aGreeting,
+00063                             TInt aTicksRequested,
+00064                                         TInt aTicksInterval
+00065                                    );
+00066 
+00067           // issue request
+00068         void IssueRequest(); 
+00069 
+00070           // Cancel request
+00071           // Defined as pure virtual by CActive;
+00072           // implementation provided by this class.
+00073         void DoCancel();
+00074 
+00075           // service completed request.
+00076           // Defined as pure virtual by CActive;
+00077           // implementation provided by this class.
+00078         void RunL();
+00079 
+00080 public:
+00081           // data members defined by this class
+00082         TBufC<20> iGreeting;   // Text of the greeting.
+00083         TInt iTicksRequested;  // Total number of greetings CTimedMessenger
+00084                                // will emit.
+00085         TInt iTicksInterval;   // Number of seconds between each greeting.
+00086         TInt iTicksDone;       // Number of greetings issued so far.
+00087         };
+00088 
+00089 
+00091 //
+00092 // -----> CExampleScheduler (definition)
+00093 //
+00095 class CExampleScheduler : public CActiveScheduler
+00096         {
+00097 public:
+00098         void Error (TInt aError) const;
+00099         };
+00100 
+00101 
+00103 //
+00104 // -----> CActiveConsole (definition)
+00105 //
+00106 // An abstract class which provides the facility to issue key requests. 
+00107 //
+00109 class CActiveConsole : public CActive
+00110         {
+00111 public:
+00112           // Construction
+00113         CActiveConsole(CConsoleBase* aConsole);
+00114         void ConstructL();
+00115 
+00116           // Destruction
+00117         ~CActiveConsole();
+00118 
+00119           // Issue request
+00120         void RequestCharacter();
+00121         
+00122           // Cancel request.
+00123           // Defined as pure virtual by CActive;
+00124           // implementation provided by this class.
+00125         void DoCancel();
+00126 
+00127           // Service completed request.
+00128           // Defined as pure virtual by CActive;
+00129           // implementation provided by this class,
+00130         void RunL();
+00131 
+00132           // Called from RunL() - an implementation must be provided
+00133           // by derived classes to handle the completed request
+00134         virtual void ProcessKeyPress(TChar aChar) = 0; 
+00135           
+00136 protected:
+00137           // Data members defined by this class
+00138         CConsoleBase* iConsole; // A console for reading from
+00139         };
+00140 
+00141 
+00143 //
+00144 // -----> CWriteKeyProcessor (definition)
+00145 //
+00146 // This class is derived from CActiveConsole. 
+00147 // Request handling: accepts input from the keyboard and outputs it 
+00148 // to the console.
+00149 //
+00151 class CWriteKeyProcessor : public CActiveConsole
+00152         {
+00153 public:
+00154           // Construction
+00155         CWriteKeyProcessor(CConsoleBase* aConsole);
+00156 
+00157 public:
+00158           // Static constuction
+00159         static CWriteKeyProcessor *NewLC (CConsoleBase* aConsole);
+00160         static CWriteKeyProcessor *NewL(CConsoleBase* aConsole);
+00161 
+00162           // Service request
+00163         void ProcessKeyPress(TChar aChar);
+00164         };
+00165 
+00166 
+00168 //
+00169 // -----> CTimedMessenger (implementation)
+00170 //
+00172 CTimedMessenger::CTimedMessenger()
+00173         : CTimer(CActive::EPriorityStandard)
+00174           // Construct  zero-priority active object
+00175         {};
+00176 
+00177 CTimedMessenger* CTimedMessenger::NewLC(const TDesC& aGreeting,
+00178                                                                                 TInt aTicksRequested,
+00179                                                                                 TInt aTicksInterval
+00180                                                                            )
+00181         {
+00182         CTimedMessenger* self=new (ELeave) CTimedMessenger;
+00183         CleanupStack::PushL(self);
+00184         self->ConstructL(aGreeting,aTicksRequested,aTicksInterval);
+00185         return self;
+00186         }
+00187 
+00188 CTimedMessenger* CTimedMessenger::NewL(const TDesC& aGreeting,
+00189                                                                    TInt aTicksRequested,
+00190                                                                            TInt aTicksInterval
+00191                                                                           )
+00192         {
+00193         CTimedMessenger* self = NewLC(aGreeting,aTicksRequested,aTicksInterval);
+00194         CleanupStack::Pop();
+00195         return self;
+00196         }
+00197 
+00198 void CTimedMessenger::ConstructL(const TDesC& aGreeting,
+00199                                                                  TInt aTicksRequested,
+00200                                                                  TInt aTicksInterval
+00201                                                                 )
+00202         {
+00203           // Base class second-phase construction.
+00204         CTimer::ConstructL();
+00205           // Set members from arguments
+00206         iGreeting       = aGreeting;       // Set greeting text.
+00207         iTicksRequested = aTicksRequested; // Ticks requested
+00208         iTicksInterval  = aTicksInterval;  // Interval between ticks
+00209           // Add active object to active scheduler
+00210         CActiveScheduler::Add(this); 
+00211         }
+00212 
+00213 
+00214 CTimedMessenger::~CTimedMessenger()
+00215         {
+00216           // Make sure we're cancelled
+00217         Cancel();
+00218         }
+00219 
+00220 void CTimedMessenger::DoCancel()
+00221         {
+00222           // Base class
+00223         CTimer::DoCancel(); 
+00224           // Reset this variable - needed if the object is re-activated later
+00225         iTicksDone = 0;
+00226           // Tell user
+00227         _LIT(KMsgCancelled,"Outstanding Messenger request cancelled\n");
+00228         console->Printf(KMsgCancelled); 
+00229         }
+00230 
+00231 void CTimedMessenger::IssueRequest()
+00232         {
+00233           // There should never be an outstanding request at this point.
+00234         _LIT(KMsgAlreadyActive,"Is already Active");
+00235         __ASSERT_ALWAYS(!IsActive(),User::Panic(KMsgAlreadyActive,EPanicAlreadyActive));
+00236           // Request another wait
+00237         CTimer::After( iTicksInterval*1000000);
+00238         }
+00239 
+00240 void CTimedMessenger::RunL()
+00241         {
+00242           // Handle request completion
+00243           // One more tick done
+00244         iTicksDone++;
+00245           // Print greeting
+00246         _LIT(KFormatString1,"%S \n");
+00247         console->Printf(KFormatString1,&iGreeting);
+00248           // Issue new request, or stop if we have reached the limit
+00249         if (iTicksDone  < iTicksRequested)
+00250                 {
+00251                 IssueRequest();
+00252                 }
+00253         else
+00254                 {
+00255                 _LIT(KMsgFinished,"Messenger finished \n");
+00256                 console->Printf(KMsgFinished);
+00257                   // Reset this variable - needed if the object is re-activated later
+00258                 iTicksDone=0;
+00259                   // Can now stop the active scheduler
+00260                 CActiveScheduler::Stop();
+00261                 }
+00262         }
+00263 
+00264 
+00266 //
+00267 // -----> CExampleScheduler (implementation)
+00268 //
+00270 void CExampleScheduler::Error(TInt aError) const
+00271         {
+00272         _LIT(KMsgSchedErr,"CExampleScheduler-error");
+00273         User::Panic(KMsgSchedErr,aError);
+00274         }
+00275 
+00276 
+00278 //
+00279 // -----> CActiveConsole (implementation)
+00280 //
+00282 CActiveConsole::CActiveConsole( CConsoleBase* aConsole) 
+00283         : CActive(CActive::EPriorityUserInput)
+00284           // Construct high-priority active object
+00285         {
+00286         iConsole = aConsole;
+00287         }
+00288 
+00289 void CActiveConsole::ConstructL()
+00290         {
+00291           // Add to active scheduler
+00292         CActiveScheduler::Add(this);
+00293         }
+00294 
+00295 CActiveConsole::~CActiveConsole()
+00296         {
+00297         // Make sure we're cancelled
+00298         Cancel();
+00299         }
+00300 
+00301 void  CActiveConsole::DoCancel()
+00302         {
+00303         iConsole->ReadCancel();
+00304         }
+00305 
+00306 void  CActiveConsole::RunL()
+00307         {
+00308           // Handle completed request
+00309         ProcessKeyPress(TChar(iConsole->KeyCode()));
+00310         }
+00311 
+00312 void CActiveConsole::RequestCharacter()
+00313         {
+00314           // A request is issued to the CConsoleBase to accept a
+00315           // character from the keyboard.
+00316         iConsole->Read(iStatus); 
+00317         SetActive();
+00318         }
+00319 
+00320 
+00322 //
+00323 // -----> CWriteKeyProcessor (implementation)
+00324 //
+00326 CWriteKeyProcessor::CWriteKeyProcessor(CConsoleBase* aConsole)
+00327         : CActiveConsole(aConsole)
+00328           
+00329         {};
+00330 
+00331 CWriteKeyProcessor* CWriteKeyProcessor::NewLC(CConsoleBase* aConsole)
+00332         {
+00333         CWriteKeyProcessor* self=new (ELeave) CWriteKeyProcessor(aConsole);
+00334         CleanupStack::PushL(self);
+00335         self->ConstructL();
+00336         return self;
+00337         }
+00338 
+00339 CWriteKeyProcessor* CWriteKeyProcessor::NewL(CConsoleBase* aConsole)
+00340         {
+00341         CWriteKeyProcessor* self=NewLC(aConsole);
+00342         CleanupStack::Pop();
+00343         return self;
+00344         }
+00345 
+00346 void CWriteKeyProcessor::ProcessKeyPress(TChar aChar)
+00347         {
+00348           // "Esc" character prints a new line and stops the scheduler
+00349         if (aChar == EKeyEscape)
+00350                 {
+00351                 iConsole->Printf(KTextEsc);
+00352                 CActiveScheduler::Stop();
+00353                 return;
+00354                 }
+00355 
+00356           // "Enter" prints a new line character
+00357           // An alphabetic or space is printed as a character;
+00358           // anything else is printed as an integer.
+00359         if (aChar == EKeyEnter)
+00360                 iConsole->Printf(KTextEsc);
+00361         else
+00362                 {
+00363                 _LIT(KFormatString2,"%c");
+00364                 _LIT(KFormatString3,"%d");
+00365                 if (aChar.IsAlphaDigit()|| aChar.IsSpace())
+00366                         iConsole->Printf(KFormatString2,TUint(aChar));
+00367                 else
+00368                         iConsole->Printf(KFormatString3,TUint(aChar));
+00369                 }
+00370 
+00371           // Issue another request 
+00372         RequestCharacter();
+00373         }
+00374 
+00375 
+00377 //
+00378 // -----> CMessageKeyProcessor (definition)
+00379 //
+00380 // This class is derived from CActiveConsole. 
+00381 // Request handling:
+00382 //   if key is "m", a message timer request is issued.
+00383 //   if key is "c", any outstanding message timer request is cancelled.
+00384 //   If key is ESC, the wait loop is terminated.
+00385 //
+00387 class CMessageKeyProcessor : public CActiveConsole
+00388         {
+00389 public:
+00390           // Construction
+00391         CMessageKeyProcessor(CConsoleBase* aConsole, CTimedMessenger* iMessenger);
+00392         void ConstructL();
+00393 
+00394 public:
+00395           // Static construction
+00396         static CMessageKeyProcessor* NewLC(CConsoleBase* aConsole,
+00397                                                CTimedMessenger* iMessenger
+00398                                                                           );
+00399         static CMessageKeyProcessor* NewL(CConsoleBase* aConsole,
+00400                                               CTimedMessenger* iMessenger
+00401                                                                          );
+00402 
+00403 public:
+00404           // service request
+00405         void ProcessKeyPress(TChar aChar);
+00406 
+00407 private:
+00408           // Data members defined by this class
+00409         CTimedMessenger* iMessenger;
+00410         };
+00411 
+00413 //
+00414 // -----> CMessageKeyProcessor (implementation)
+00415 //
+00417 CMessageKeyProcessor::CMessageKeyProcessor(CConsoleBase* aConsole,
+00418                                                                                    CTimedMessenger* aMessenger
+00419                                                                                   )
+00420         : CActiveConsole(aConsole)
+00421           // construct zero-priority active object
+00422         {
+00423         iMessenger = aMessenger;
+00424         } 
+00425 
+00426 CMessageKeyProcessor* CMessageKeyProcessor::NewLC(CConsoleBase* aConsole,
+00427                                                                                                   CTimedMessenger* aMessenger
+00428                                                                                                  )
+00429         {
+00430         CMessageKeyProcessor* self=new (ELeave) CMessageKeyProcessor(aConsole,
+00431                                                                          aMessenger
+00432                                                                                                                                 );
+00433         CleanupStack::PushL(self);
+00434         self->ConstructL();
+00435         return self;
+00436         }
+00437 
+00438 CMessageKeyProcessor* CMessageKeyProcessor::NewL(CConsoleBase* aConsole,
+00439                                                                                                  CTimedMessenger* aMessenger
+00440                                                                                                 )
+00441         {
+00442         CMessageKeyProcessor* self = NewLC(aConsole, aMessenger);
+00443         CleanupStack::Pop();
+00444         return self;
+00445         }
+00446 
+00447 void CMessageKeyProcessor::ConstructL()
+00448         {
+00449           // Add to active scheduler
+00450         CActiveScheduler::Add(this);
+00451         }
+00452 
+00453 void CMessageKeyProcessor::ProcessKeyPress(TChar aChar)
+00454         {
+00455           // if key is ESC 
+00456           //   cancel any outstanding request
+00457           //   stop the scheduler
+00458         if (aChar == EKeyEscape)
+00459                 {
+00460                 iMessenger->Cancel();
+00461                 CActiveScheduler::Stop();
+00462                 return;
+00463                 }
+00464 
+00465           // If key is "m" or "M"
+00466           //   cancel any outstanding request
+00467           //   reset the tick counter
+00468           //   issue a message timer request.
+00469         if (aChar == 'm' || aChar == 'M') 
+00470                 {
+00471                 _LIT(KMsgStarting,"Starting Messenger....  \n");
+00472                 iConsole->Printf(KMsgStarting);
+00473                 iMessenger->Cancel();
+00474                 iMessenger ->IssueRequest();
+00475                 }
+00476 
+00477       // If key is "c" or "C" 
+00478           //    cancel any outstanding request  
+00479         if (aChar == 'c' || aChar == 'C')
+00480                 iMessenger->Cancel();
+00481         
+00482           // Ask for another character.
+00483         RequestCharacter();
+00484         }
+00485 
+00486 
+00488 //
+00489 // Do the example
+00490 //
+00492 LOCAL_C void doExampleL()
+00493     {
+00494           // Construct and install the active scheduler
+00495         CExampleScheduler*  exampleScheduler = new (ELeave) CExampleScheduler;
+00496 
+00497           // Push onto the cleanup stack
+00498         CleanupStack::PushL(exampleScheduler);
+00499          
+00500           // Install as the active scheduler
+00501         CActiveScheduler::Install(exampleScheduler);
+00502 
+00503           // Create a CTimedMessenger active object which will emit
+00504           // 3 messages with an interval of 2 seconds between messages.
+00505         _LIT(KMsgGoodMorning,"Good Morning!");
+00506         CTimedMessenger* messenger = CTimedMessenger::NewLC(KMsgGoodMorning, 3, 2);
+00507 
+00508           // Create aCMessageKeyProcessor active object.
+00509         _LIT(KMsgTitleA,"A single CKeyMessengerProcessor active object which contains a CMessageTimer.\n");
+00510         console->Printf(KMsgTitleA);
+00511         _LIT(KMsgTitleB,"Press 'm' to activate messenger; Press 'c' to cancel it.\nPress ESC to end.\n\n");
+00512         console->Printf(KMsgTitleB);
+00513         CMessageKeyProcessor* keyProcesser = CMessageKeyProcessor::NewLC(console,
+00514                                                                              messenger
+00515                                                                                                                                          );
+00516           
+00517           // Issue the first request
+00518         keyProcesser->RequestCharacter();
+00519         
+00520           // Main part of the program is a wait loop
+00521         CActiveScheduler::Start();
+00522 
+00523         // Remove from the cleanup stack and destroy:
+00524         // 1. the CTimedMessenger active object
+00525         // 2. the CMessageKeyProcessor active object.
+00526         // 3. exampleScheduler
+00527         CleanupStack::PopAndDestroy(3); 
+00528         }
+00529 
+