You are previewing Beginning Nokia Apps Development: QT and HTML5 for Symbian and MeeGo.
O'Reilly logo
Beginning Nokia Apps Development: QT and HTML5 for Symbian and MeeGo

Book Description

While buzz often circulates around iPhone and Android, Nokia still leads the pack in terms of world market share. Symbian, for instance, remains the most widely used mobile operating system. With the emergence of Nokia's open development platforms, the opportunities available for mobile developers to target these vastly popular operating systems are clear.

Beginning Nokia Apps Development is step-by-step guide that introduces mobile development using Nokia's variety of open platforms like Mobile Qt, OpenSymbian, and MeeGo. This book brings beginners up to speed and shows experienced developers how to work on a mobile platform.

  • Symbian, the most widely used operating system in the world, as well as MeeGo, the Intel/Nokia platform for mobile devices, both use Qt as a cross platform development framework. Utilizing Qt, a developer can easily target both platforms.

  • Web Runtime applications can also be developed for both Symbian and MeeGo platforms, and additionally run with little modifications on other mobile platforms. This book explains how.

  • New Qt developers learn the basics of Qt with a mobile slant, giving them the ability to target both desktop and mobile platforms.

Table of Contents

  1. Copyright
  2. Foreword
  3. About the Authors
  4. About the Technical Reviewers
  5. Acknowledgments
  6. Introduction
    1. Why Should You Read This Book?
    2. How Should You Read This Book?
    3. A Word on Conventions We Use in This Book
  7. I. Design
    1. 1. Introducing Nokia's Software Platform
      1. 1.1. Why Nokia?
      2. 1.2. Introducing Nokia's Hardware Platforms
        1. 1.2.1. Series 40
        2. 1.2.2. Symbian
        3. 1.2.3. MeeGo
      3. 1.3. Choosing a Development Platform
        1. 1.3.1. Qt
        2. 1.3.2. HTML5
        3. 1.3.3. Hybrid Applications
      4. 1.4. Distributing Your Application
      5. 1.5. Wrapping Up
    2. 2. Designing Your Application
      1. 2.1. Designing for Mobile
        1. 2.1.1. User Context
        2. 2.1.2. Mobile Interaction Considerations
        3. 2.1.3. Technical Considerations
        4. 2.1.4. Cultural Considerations
      2. 2.2. The Design Process
        1. 2.2.1. Getting Started
        2. 2.2.2. Design Research
        3. 2.2.3. Conceptual Design
        4. 2.2.4. Interaction Design and Prototyping
        5. 2.2.5. Documentation
        6. 2.2.6. Flowella
          1. 2.2.6.1. Installing Flowella
          2. 2.2.6.2. Create Views
          3. 2.2.6.3. Create the Project
          4. 2.2.6.4. Create the Connections
          5. 2.2.6.5. Export and Interact
        7. 2.2.7. Visual and Information Design
          1. 2.2.7.1. Screen Size
          2. 2.2.7.2. Scalable UI
          3. 2.2.7.3. Selecting the Correct Orientation
          4. 2.2.7.4. Full-Screen Usage
          5. 2.2.7.5. Fonts
          6. 2.2.7.6. Colors
          7. 2.2.7.7. Graphics
          8. 2.2.7.8. Animations
        8. 2.2.8. Testing and Evaluation
        9. 2.2.9. Additional Topics: Gestalt and Unity
      3. 2.3. Usability Guidelines
        1. 2.3.1. Navigation
        2. 2.3.2. Entering Information
        3. 2.3.3. Information Presentation
        4. 2.3.4. Connectivity
        5. 2.3.5. Usability for Enterprise Applications
        6. 2.3.6. Usability and Security
        7. 2.3.7. Advertising
        8. 2.3.8. Platform Components
      4. 2.4. Checklists
      5. 2.5. Summary
  8. II. Developing Your Application
    1. 3. Working with the Nokia Qt SDK
      1. 3.1. Choosing an IDE
        1. 3.1.1. Introducing the Nokia Qt SDK
      2. 3.2. Getting Started with the Nokia Qt SDK
        1. 3.2.1. Installing the Nokia Qt SDK
          1. 3.2.1.1. Configuring a Symbian Device to Work with the Nokia Qt SDK
          2. 3.2.1.2. Configuring a MeeGo Device to Work with the Nokia Qt SDK
        2. 3.2.2. Finding Your Way around the Nokia Qt SDK
        3. 3.2.3. Creating a Qt Application
        4. 3.2.4. Compiling and Running Your Code on a Device
      3. 3.3. Debugging Your Application
      4. 3.4. Wrapping Up
    2. 4. Beginning Qt Development
      1. 4.1. Understanding the Qt Object Model
        1. 4.1.1. Understanding Signals and Slots
        2. 4.1.2. Making the Most of Hierarchical Ownership
        3. 4.1.3. Defining Object Properties
        4. 4.1.4. Casting at Run Time
        5. 4.1.5. Managing Resources and Localization
        6. 4.1.6. Understanding Qt's Collection Classes
      2. 4.2. Using Signals and Slots
      3. 4.3. Performing Input and Output
      4. 4.4. Managing Multiple Threads
      5. 4.5. Using Item Views with the Model-View-Controller Paradigm
        1. 4.5.1. Understanding Qt's Model Classes
        2. 4.5.2. Using Qt's View Classes
      6. 4.6. Putting It All Together
        1. 4.6.1. Implementing the Application User Interface
        2. 4.6.2. Using the Network to Obtain Data
        3. 4.6.3. Parsing the USGS Data Feed
        4. 4.6.4. Displaying the Results
      7. 4.7. Wrapping Up
    3. 5. Doing More with Qt
      1. 5.1. Using Application Resources
        1. 5.1.1. Including Resources in Your Applications
        2. 5.1.2. Accessing Application Resources
      2. 5.2. Incorporating User Actions
        1. 5.2.1. Introducing the Qt Main Window
        2. 5.2.2. Attaching Actions to the Main Window
      3. 5.3. Implementing a Custom Widget
        1. 5.3.1. Subclassing QWidget
        2. 5.3.2. Specifying Your Widget's Size Hints and Policies
        3. 5.3.3. Handling Incoming Events
        4. 5.3.4. Handling Incoming Gestures
        5. 5.3.5. Painting Your Widget's Contents
      4. 5.4. Integrating Qt Objects with Web Content
        1. 5.4.1. Linking Your Application with QtWebKit
        2. 5.4.2. Displaying Web Content with QtWebKit
        3. 5.4.3. Embedding C++ Objects in QtWebKit's JavaScript Runtime
        4. 5.4.4. Embedding Qt Widgets into QtWebKit Pages
      5. 5.5. Extending Application Functionality with Qt Mobility
        1. 5.5.1. Using the Qt Mobility APIs
        2. 5.5.2. Managing Bearer Networks
        3. 5.5.3. Obtaining and Working with Device Location Information
        4. 5.5.4. Sending and Receiving Messages
        5. 5.5.5. Playing and Recording Multimedia
        6. 5.5.6. Obtaining System Information
      6. 5.6. Putting It All Together
        1. 5.6.1. Looking inside the Application Controller
        2. 5.6.2. Changes to the Network Request
        3. 5.6.3. Determining the Device Position
        4. 5.6.4. Drawing the Map
      7. 5.7. Wrapping Up
    4. 6. Introducing Qt Quick
      1. 6.1. Declaring Your User Interface
        1. 6.1.1. Introducing QML
        2. 6.1.2. Handling Signals in QML
        3. 6.1.3. Performing Animations in QML
        4. 6.1.4. Reviewing the Available Qt Quick Elements
      2. 6.2. Programming for the Web with QML
        1. 6.2.1. Creating the User Interface
        2. 6.2.2. Downloading the Data
      3. 6.3. Integrating C++ with QML
        1. 6.3.1. Displaying QML within a C++ Application
        2. 6.3.2. Mingling QObjects with QML
      4. 6.4. Wrapping Up
    5. 7. Developing with HTML5
      1. 7.1. HTML5 Is an Industry Standard
      2. 7.2. Hello World in HTML5
        1. 7.2.1. Hello World on a Handset
        2. 7.2.2. Using the HTML5 Application Cache
      3. 7.3. Hybrid Apps
        1. 7.3.1. Accessing Your HTML5 Content from the Local File System
        2. 7.3.2. Storing the HTML5 Content as an Application Resource
      4. 7.4. More HTML5 Features
        1. 7.4.1. Canvas
        2. 7.4.2. Transitions and Transformations
          1. 7.4.2.1. Transitions
          2. 7.4.2.2. Transformations
        3. 7.4.3. Local Storage
          1. 7.4.3.1. Web Storage
          2. 7.4.3.2. Web Database
      5. 7.5. Putting It All Together: Implementing Shake in HTML5
        1. 7.5.1. Adding UI Components to the Views
        2. 7.5.2. Fetching and Parsing the Data
        3. 7.5.3. Packaging the App
      6. 7.6. Links for further information
      7. 7.7. Wrapping Up
  9. III. Distribute
    1. 8. Testing Your Application
      1. 8.1. Preparing to Test
      2. 8.2. Using Qt's Test Framework
        1. 8.2.1. Introducing the QTest Test Framework
        2. 8.2.2. Unit Testing the QuakeEvent Class
        3. 8.2.3. Testing Signals and Slots Using QTest
        4. 8.2.4. Testing User Interface Code Using QTestEventList
      3. 8.3. Wrapping Up
    2. 9. Deploying Your Application
      1. 9.1. Preparing a Deployment Checklist
      2. 9.2. Packaging Your Application
        1. 9.2.1. Including Other Files within Your Application on Symbian Devices
        2. 9.2.2. Including Other Files within Your Application on MeeGo Devices
        3. 9.2.3. Including an Application Icon with Symbian Applications
        4. 9.2.4. Including an Application Icon with MeeGo Applications
        5. 9.2.5. Providing a UID for Qt Applications on Symbian
        6. 9.2.6. Providing a Desktop File for MeeGo
        7. 9.2.7. Putting It All Together
      3. 9.3. Signing Your Qt Application for Symbian Devices
      4. 9.4. Publishing with the Ovi Store
        1. 9.4.1. Registering with the Ovi Store
        2. 9.4.2. Publishing Your Application
        3. 9.4.3. QA in the Ovi Store
      5. 9.5. Marketing Your Application through the Ovi Store
      6. 9.6. Wrapping Up