Development Process Overview
PC-based platform emulators are provided as part of the SDKs so that most development and testing can be performed without target hardware. Series 60 project executables can be created as debug or release variants for emulators and for target hardware (although currently some restrictions apply to on-target debugging). Additionally, when building for target devices it is possible to create executable code in various binary formats (for example, ARMI, ARM4 and Thumb, explained later in this chapter). The compilation and linking process can be performed using command-line tools or from within a variety of IDEs. The IDEs covered here are Microsoft Visual C++ version 6, Metrowerks CodeWarrior, and Borland C++Builder 6 Mobile Edition and Borland C++BuilderX Mobile.
Symbian devised a method of specifying development projects in a platform-neutral way. Two universal project files can be created (projectname.mmp and bld.inf), where projectname is the name of the component or application to be developed (HelloWorld for our example project). These two text files can then be used as a starting point for any of the build options, IDEs and platform variants.
The bld.inf file specifies the names of all the project component(s) to be built, with each component specified in its own .mmp file. Both types of file are plain text, and often you will simply have a single .mmp file that defines the application you are creating. If the project consists of multiple components, such as the application itself and specific function libraries, then each component would have its own .mmp file. Each of the libraries plus the application would have an .mmp file, and each filename would be listed in the bld.inf file for the project. The syntax of .mmp and bld.inf files is detailed in Chapter 2.
In the HelloWorld example, there are only two project specification files: bld.inf and helloworld.mmp. Using these two files, any platform-specific project and command files required can be created.
Typically you employ a Symbian tool called bldmake, using the two project specification files as input, to generate a command file called abld.bat. You can then use abld.bat, from the command prompt, to perform a number of project-related actions. For example, abld.bat can be used to generate platform- and IDE-specific project makefiles. If the project source code exists, and is complete, abld can be used to build the project for one or more platforms.
Since most development projects are built and run from within an IDE, you would usually create the project files suitable for your chosen IDE.
In the case of Microsoft Visual C++, you use abld at the command line to create the HelloWorld.dsp and HelloWorld.dsw project files. The .dsw file is the workspace file to be opened from within the IDE, and it may reference one or more .dsp files.
For Metrowerks CodeWarrior you can either create the project file from within the IDE in the usual way or import the .mmp file directly into the IDE. The import process will create the CodeWarrior specific project (HelloWorld.mcp) file required.
Similarly, the Borland C++ Builder Mobile Edition IDEs can perform an equivalent import task to the Metrowerks IDE, but by importing the bld.inf file instead of the .mmp file. Borland C++BuilderX, for example, will create a project file called HelloWorld.cbx.
Opening the IDE-specific project file will then allow you to develop, build, run and debug the application with full IDE support.
For developers who prefer working at the command-line level, abld can also be used to compile and link from a command prompt.
All of the methods for creating the IDE (or command-line) specific project files outlined are described in detail later in this chapter. In addition, Figure 1-1 illustrates the use of the two generic Symbian OS project files to generate the required platform-specific project files, either via IDE import options or using the Symbian tools.
)
Figure 1-1. Generation of IDE and platform-specific project files from generic Symbian files.
Using an IDE versus Command-Line Tools
The different options currently available to you for working with Series 60 development projects are summarized in Table 1-1. More options are becoming available all the time from Symbian, Nokia and the development tool vendors Borland and Metrowerks. However, it is likely that the Microsoft development tools, though currently viable and still widely used, will no longer be supported in the not-too-distant future.
There are currently considerable differences between the capabilities of the various IDEs from Microsoft, Borland and Metrowerks. Development to enhance the latter two development environments is ongoing. EMCC Software Ltd uses IDEs from all three vendors as the basis of its development activities. We also use the command-line tools every day—not because we want to but because we currently have to. This is primarily for building for target devices and for automating overnight builds. The C++BuilderX and CodeWarrior IDEs can now build for target devices—but not all essential build operations are covered by some variants of the IDEs.
At the time of writing, the easiest and most generic starting point for any new Series 60 project is to define a pair of bld.inf and .mmp project files. At EMCC Software, these files are used for generation of any IDE-specific project files and for use during any command-line builds needed. This approach is taken throughout the book. It is also the approach currently adopted by every single example project provided by both Symbian and Nokia in their SDKs and in the documentation they supply. Using an IDE exclusively is not currently possible on a day-to-day basis. Things will change before very much longer, but these are the current facts of life for Symbian OS and Series 60 developers.
Table 1-1. PC-Based Development Options Summarized
|
Option |
Description |
|---|---|
|
Command line building |
Using the Symbian OS tools combined with compilation and linking using the Microsoft Visual C++ compiler/linker for emulator builds invoked from a command line. Emulator can also be invoked from the command line. Source-level debugging on the PC emulator requires working from within an IDE. The GNU C++ cross compiler and linker used for ARM target device builds invoked from the command line. |
|
Microsoft Visual C++ IDE |
Compilation and linking using the Microsoft Visual C++ compiler/linker for emulator builds from within the IDE. The GNU C++ cross compiler and linker used for ARM target device builds invoked from a command prompt. |
|
Borland C++ IDE |
Two IDE options are currently available; both use the Borland C++ compiler and linker for emulator builds from within an IDE. The GNU C++ cross compiler and linker used for ARM target device builds invoked from the command line. |
|
Metrowerks CodeWarrior C++ IDE |
Using the Metrowerks compiler and linker for emulator builds from within the IDE. The GNU cross compiler and linker for ARM target device builds, either invoked from the command line or directly from within the CodeWarrior IDE. |
Through the rest of this chapter, the HelloWorld example project is used to illustrate all the steps involved in the development, debugging, and deployment process for the Series 60 emulator.
All of the other files required for the example application are provided—for example, the header (.h), source (.cpp) and user interface resource (.rss) files.
You can test the application using the Series 60 emulator, either started from within an IDE or run from a command prompt. However, debugging an application on the emulator must be performed from within an IDE.
After developing, running, testing or debugging an application on the emulator you typically will want to build and run it on a target device. So you will then be shown how to build the example application for a target device, how to deploy it and then run it on target Series 60 hardware.