1. Programming mobile devices Part II Programming Symbian devices with Symbian C++ Environment and building applications

2. Content The development environment Tools SDKs IDEs Simple example Building and running

3. Environment XP, 2000 or NT SDK for the device targeted IDE Device Communication suite

4. Tools An SDK for the targeted platform An IDE that is supported by the SDK Communicatio between the phone and the device –Communication suite –Communication media, such as BT or USB cable

5. SDKs Manufactures site, e.g. forum.nokia.com symbian.com On this course, Series 60, 3rd edition Our targeted device will be the Nokia N91 SDKs seem to be chubby dudes, the S60 3 ed. is almost 300 megas

6. IDEs MS Visual C++ Metrowerks Code Warrior Borland C++ Builder Carbide.c++

7. Required components The setting I created was –S60 3 edition SDK –Carbide.c++ (forum.nokia.com) –Active State Active Perl (www.activestate.com) Testing the setup –type "devices" on the command prompt

8. Application Components Application View –main window Application UI –instantiates the application view –command handler for GUI controls Application document –non-GUI data aspects –instantiates the UI class

9. Application Components Application –instantiates and starts the document class

10. Hei Maailma (Hello World) source code files: HeiMaailma.cpp HeiMaailmaApplication.cpp HeiMaailmaAppUi.cpp HeiMaailmaAppView.cpp HeiMaailmaDocument.cpp

11. Building To build from the command line: –bldmake BLDFILES –abld build wins –epoc Building from an IDE –depends on the IDE –we will use Carbide.c++ –examples in demos

12. Build environment epoc32 –include (common API classes) –build (intermediate build files) –tools (scripts, exes etc. windows tools) –gcc (compiler tools) –release (executables for supported platforms) –data/z (simulated z drive of the emulator) –wins (default location for other emulator memory drives)

13. Build targets ARM4 –32 bit ARM instruction set THUMB –16 bit ARM instruction set ARMI –ARM interchange format

14. Build files Component description file (bld.inf) Project definition file (.mmp) source (.cpp files) in src folder header files (.h and.hrh files) in inc folder

15. Emulators WINS –Microsoft WINSC –Code Warrior WINSB –Borland

16. HeiMaailma.cpp // INCLUDE FILES #include #include "HeiMaailmaApplication.h" LOCAL_C CApaApplication* NewApplication() { return new CHeiMaailmaApplication; } GLDEF_C TInt E32Main() { return EikStart::RunApplication( NewApplication ); }

17. HeiMaailmaApplication.cpp #include "HeiMaailmaDocument.h" #include "HeiMaailmaApplication.h" // ============================ MEMBER FUNCTIONS =========== // UID for the application; // this should correspond to the uid defined in the mmp file const TUid KUidHeiMaailmaApp = { 0x088C40EE }; // ----------------------------------------------------------------------------- // CHeiMaailmaApplication::CreateDocumentL() // Creates CApaDocument object // ----------------------------------------------------------------------------- // CApaDocument* CHeiMaailmaApplication::CreateDocumentL() { // Create an HeiMaailma document, and return a pointer to it return (static_cast ( CHeiMaailmaDocument::NewL( *this ) ) ); }

18. HeiMaailmaApplication.cpp // ----------------------------------------------------------------------------- // CHeiMaailmaApplication::AppDllUid() // Returns application UID // ----------------------------------------------------------------------------- // TUid CHeiMaailmaApplication::AppDllUid() const { // Return the UID for the HeiMaailma application return KUidHeiMaailmaApp; } // End of File

19. HeiMaailmaDocument.cpp // INCLUDE FILES #include "HeiMaailmaAppUi.h" #include "HeiMaailmaDocument.h" // ============================ MEMBER FUNCTIONS============ // ----------------------------------------------------------------------------- // CHeiMaailmaDocument::NewL() // Two-phased constructor. // ----------------------------------------------------------------------------- // CHeiMaailmaDocument* CHeiMaailmaDocument::NewL( CEikApplication& aApp ) { CHeiMaailmaDocument* self = NewLC( aApp ); CleanupStack::Pop( self ); return self; }

20. HeiMaailmaDocument.cpp // ----------------------------------------------------------------------------- // CHeiMaailmaDocument::NewLC() // Two-phased constructor. // ----------------------------------------------------------------------------- // CHeiMaailmaDocument* CHeiMaailmaDocument::NewLC( CEikApplication& aApp ) { CHeiMaailmaDocument* self = new ( ELeave ) CHeiMaailmaDocument( aApp ); CleanupStack::PushL( self ); self->ConstructL(); return self; }

21. HeiMaailmaDocument.cpp // ----------------------------------------------------------------------------- // CHeiMaailmaDocument::ConstructL() // Symbian 2nd phase constructor can leave. // ----------------------------------------------------------------------------- // void CHeiMaailmaDocument::ConstructL() { // No implementation required } // ----------------------------------------------------------------------------- // CHeiMaailmaDocument::CHeiMaailmaDocument() // C++ default constructor can NOT contain any code, that might leave. // ----------------------------------------------------------------------------- // CHeiMaailmaDocument::CHeiMaailmaDocument( CEikApplication& aApp ) : CAknDocument( aApp ) { // No implementation required }

22. HeiMaailmaDocument.cpp // CHeiMaailmaDocument::~CHeiMaailmaDocument() Destructor. // --------------------------------------------------------------------------- // CHeiMaailmaDocument::~CHeiMaailmaDocument() { // No implementation required } // CHeiMaailmaDocument::CreateAppUiL() // Constructs CreateAppUi. // --------------------------------------------------------------------------- // CEikAppUi* CHeiMaailmaDocument::CreateAppUiL() { // Create the application user interface, and return a pointer to it; // the framework takes ownership of this object return ( static_cast ( new ( ELeave ) CHeiMaailmaAppUi ) ); }

23. HeiMaailmaDocument.cpp // CHeiMaailmaDocument::~CHeiMaailmaDocument() Destructor. // --------------------------------------------------------------------------- // CHeiMaailmaDocument::~CHeiMaailmaDocument() { // No implementation required } // CHeiMaailmaDocument::CreateAppUiL() // Constructs CreateAppUi. // --------------------------------------------------------------------------- // CEikAppUi* CHeiMaailmaDocument::CreateAppUiL() { // Create the application user interface, and return a pointer to it; // the framework takes ownership of this object return ( static_cast ( new ( ELeave ) CHeiMaailmaAppUi ) ); }

24. HeiMaailmaAppUi.cpp // INCLUDE FILES #include #include "HeiMaailma.pan" #include "HeiMaailmaAppUi.h" #include "HeiMaailmaAppView.h" #include "HeiMaailma.hrh" _LIT( KFileName, "C:\\private\\088C40EE\\HeiMaailma.txt" ); _LIT( KText, "Hei Maailma!");

25. HeiMaailmaAppUi.cpp // ----------------------------------------------------------------------------- // CHeiMaailmaAppUi::ConstructL() // Symbian 2nd phase constructor can leave. // ----------------------------------------------------------------------------- // void CHeiMaailmaAppUi::ConstructL() { // Initialise app UI with standard value. BaseConstructL(); // Create view object iAppView = CHeiMaailmaAppView::NewL( ClientRect() ); // Create a file to write the text to RFs fsSession; User::LeaveIfError(fsSession.Connect()); CleanupClosePushL( fsSession );

26. HeiMaailmaAppUi.cpp TInt err = fsSession.MkDirAll(KFileName); if ( KErrNone != err ) { CleanupStack::PopAndDestroy(1); // fsSession return; } RFile file; err = file.Replace(fsSession, KFileName, EFileWrite ); CleanupClosePushL( file ); if ( KErrNone != err ) { CleanupStack::PopAndDestroy(2); // file, fsSession return; } RFileWriteStream outputFileStream( file ); CleanupClosePushL( outputFileStream ); outputFileStream << KText; CleanupStack::PopAndDestroy(3); // outputFileStream, file, fsSession }

27. HeiMaailmaAppUi.cpp // ----------------------------------------------------------------------------- // CHeiMaailmaAppUi::CHeiMaailmaAppUi() // C++ default constructor can NOT contain any code, that might leave. // ----------------------------------------------------------------------------- // CHeiMaailmaAppUi::CHeiMaailmaAppUi() { // No implementation required }

28. HeiMaailmaAppUi.cpp // ----------------------------------------------------------------------------- // CHeiMaailmaAppUi::~CHeiMaailmaAppUi() // Destructor. // ----------------------------------------------------------------------------- // CHeiMaailmaAppUi::~CHeiMaailmaAppUi() { if ( iAppView ) { delete iAppView; iAppView = NULL; }

29. HeiMaailmaAppUi.cpp // ----------------------------------------------------------------------------- // CHeiMaailmaAppUi::HandleCommandL() // Takes care of command handling. // ----------------------------------------------------------------------------- // void CHeiMaailmaAppUi::HandleCommandL( TInt aCommand ) { switch( aCommand ) { case EEikCmdExit: case EAknSoftkeyExit: Exit(); break; case ECommand1: { // Load a string from the resource file and display it HBufC* textResource = StringLoader::LoadLC( R_COMMAND1_TEXT ); CAknInformationNote* informationNote;

30. HeiMaailmaAppUi.cpp informationNote = new ( ELeave ) CAknInformationNote; // Show the information Note with // textResource loaded with StringLoader. informationNote->ExecuteLD( *textResource); // Pop HBuf from CleanUpStack and Destroy it. CleanupStack::PopAndDestroy( textResource ); } break; case ECommand2: { RFs fsSession; RFile rFile; // Connects a client process to the fileserver User::LeaveIfError(fsSession.Connect()); CleanupClosePushL(fsSession);

31. HeiMaailmaAppUi.cpp //Open file where the stream text is User::LeaveIfError(rFile.Open(fsSession,KFileName, EFileStreamText));//EFileShareReadersOnly));// EFileStreamText)); CleanupClosePushL(rFile); // copy stream from file to RFileStream object RFileReadStream inputFileStream(rFile); CleanupClosePushL(inputFileStream); // HBufC descriptor is created from the RFileStream object. HBufC* fileData = HBufC::NewLC(inputFileStream, 32); CAknInformationNote* informationNote; informationNote = new ( ELeave ) CAknInformationNote; // Show the information Note informationNote->ExecuteLD( *fileData);

32. HeiMaailmaAppUi.cpp // Pop loaded resources from the cleanup stack CleanupStack::PopAndDestroy(4); // filedata, inputFileStream, rFile, fsSession fsSession.Close(); } break; default: Panic( EHeiMaailmaUi ); break; }

33. HeiMaailmaAppUi.cpp // ----------------------------------------------------------------------------- // Called by the framework when the application status pane // size is changed. Passes the new client rectangle to the // AppView // ----------------------------------------------------------------------------- // void CHeiMaailmaAppUi::HandleStatusPaneSizeChange() { iAppView->SetRect( ClientRect() ); } // End of File

34. HeiMaailmaAppView.cpp // INCLUDE FILES #include #include "HeiMaailmaAppView.h" // ============================ MEMBER FUNCTIONS=========== // ----------------------------------------------------------------------------- // CHeiMaailmaAppView::NewL() // Two-phased constructor. // ----------------------------------------------------------------------------- // CHeiMaailmaAppView* CHeiMaailmaAppView::NewL( const TRect& aRect ) { CHeiMaailmaAppView* self = CHeiMaailmaAppView::NewLC( aRect ); CleanupStack::Pop( self ); return self; }

35. HeiMaailmaAppView.cpp // ----------------------------------------------------------------------------- // CHeiMaailmaAppView::NewLC() // Two-phased constructor. // ----------------------------------------------------------------------------- // CHeiMaailmaAppView* CHeiMaailmaAppView::NewLC( const TRect& aRect ) { CHeiMaailmaAppView* self = new ( ELeave ) CHeiMaailmaAppView; CleanupStack::PushL( self ); self->ConstructL( aRect ); return self; }

36. HeiMaailmaAppView.cpp // ----------------------------------------------------------------------------- // CHeiMaailmaAppView::ConstructL() // Symbian 2nd phase constructor can leave. // ----------------------------------------------------------------------------- // void CHeiMaailmaAppView::ConstructL( const TRect& aRect ) { // Create a window for this application view CreateWindowL(); // Set the windows size SetRect( aRect ); // Activate the window, which makes it ready to be drawn ActivateL(); }

37. HeiMaailmaAppView.cpp // ----------------------------------------------------------------------------- // CHeiMaailmaAppView::CHeiMaailmaAppView() // C++ default constructor can NOT contain any code, that might leave. // ----------------------------------------------------------------------------- // CHeiMaailmaAppView::CHeiMaailmaAppView() { // No implementation required } // ----------------------------------------------------------------------------- // CHeiMaailmaAppView::~CHeiMaailmaAppView() // Destructor. // ----------------------------------------------------------------------------- // CHeiMaailmaAppView::~CHeiMaailmaAppView() { // No implementation required }

38. HeiMaailmaAppView.cpp // ----------------------------------------------------------------------------- // CHeiMaailmaAppView::CHeiMaailmaAppView() // C++ default constructor can NOT contain any code, that might leave. // ----------------------------------------------------------------------------- // CHeiMaailmaAppView::CHeiMaailmaAppView() { // No implementation required } // ----------------------------------------------------------------------------- // CHeiMaailmaAppView::~CHeiMaailmaAppView() // Destructor. // ----------------------------------------------------------------------------- // CHeiMaailmaAppView::~CHeiMaailmaAppView() { // No implementation required }

39. HeiMaailmaAppView.cpp // ----------------------------------------------------------------------------- // CHeiMaailmaAppView::Draw() // Draws the display. // ----------------------------------------------------------------------------- // void CHeiMaailmaAppView::Draw( const TRect& /*aRect*/ ) const { // Get the standard graphics context CWindowGc& gc = SystemGc(); // Gets the control's extent TRect drawRect( Rect()); // Clears the screen gc.Clear( drawRect ); }

40. HeiMaailmaAppView.cpp // ----------------------------------------------------------------------------- // CHeiMaailmaAppView::SizeChanged() // Called by framework when the view size is changed. // ----------------------------------------------------------------------------- // void CHeiMaailmaAppView::SizeChanged() { DrawNow(); } // End of File

41. Screen shots