Docstoc

port android to wp7 app

Document Sample
port android to wp7 app Powered By Docstoc
					Windows Phone 7
Guide for Android
Application
Developers




  Microsoft
  6/6/2011
  Rev 1.0
Windows Phone 7 Guide for Android Application Developers




About this Document ............................................................................ 4
Target Audience ................................................................................... 4
Conventions Used in this Document ........................................................ 4
Chapter 1: Introducing Windows Phone 7 Platform to Android Application
Developers .......................................................................................... 5
 The Developer Tools ........................................................................... 5
 Windows Phone 7 Architecture ............................................................. 5
 Comparing the Programming Stack of Windows Phone 7 with Android ...... 7
 Summary ........................................................................................ 11
 Related Resources ............................................................................ 11
Chapter 2: User Interface Guidelines..................................................... 12
 Designing the Application Interface .................................................... 13
 Application User Interface Design ....................................................... 14
 Comparing Windows Phone 7 and Android Navigation ........................... 18
 Windows Phone 7 Frame and Page Structure ....................................... 19
 Application Templates ....................................................................... 21
 Summary ........................................................................................ 21
 Related Resources ............................................................................ 21
Chapter 3: The Developer and Designer Tools ........................................ 23
 A Comparison of Android and Windows Phone 7 Tools .......................... 23
 Development Life Cycle and Windows Phone 7 Developer Tools ............. 24
 The UI Design Tools ......................................................................... 26
 Building Applications ........................................................................ 33
 Debugging ...................................................................................... 34
 Summary ........................................................................................ 38
Chapter 4: C# programming ................................................................ 39
 Managed Programming ..................................................................... 40
 A Comparison between C# Features and Java Classes .......................... 41
 A Comparison of Important Class Libraries .......................................... 51
 The New features of C# .................................................................... 54
 Comparing API Documentation Tools .................................................. 58
 NDoc .............................................................................................. 58
 NDocs vs. Javadoc ........................................................................... 61
 Summary ........................................................................................ 61
 Related Resources ............................................................................ 62




                                                                                                     2
Windows Phone 7 Guide for Android Application Developers



Chapter 5: A Comparison of Application Life Cycles in Windows Phone 7 and
Android ............................................................................................. 63
 Multitasking in Android and Windows Phone 7...................................... 63
 Tombstoning of Applications in Windows Phone 7 ................................. 64
 Life Cycle of a Windows Phone 7 Application ........................................ 64
 Role of Handlers in an Application‟s Life Cycle ...................................... 66
 Comparing Life-cycle Methods ........................................................... 68
 Tombstoning and Windows Phone 7 Life Cycle ..................................... 69
 Summary ........................................................................................ 74
 Related Resources ............................................................................ 74
Chapter 6: Storing Data and Preferences ............................................... 75
 Isolated Storage in Windows Phone 7 ................................................. 75
 Use Cases ....................................................................................... 78
 Managing the IsolatedStorage Space .................................................. 79
 Why Windows Phone 7 Does Not Use External Storage ......................... 80
 Managing Content across Applications ................................................ 81
 Comparing Intent API with Launchers and Choosers API ....................... 82
 Summary ........................................................................................ 85
 Related Resources ............................................................................ 85
Chapter 7: XML Parsing in Windows Phone 7 and Android ........................ 86
 XML Parsing in Windows Phone 7 ....................................................... 86
 XML Namespaces for Windows Phone 7 ............................................... 86
 XML Parsing Using XMLReader ........................................................... 86
 TRAVERSING XML ............................................................................ 95
 Summary ........................................................................................ 99
 Related Resources ............................................................................ 99




                                                                                                      3
Windows Phone 7 Guide for Android Application Developers




About this Document
If you have been developing Android applications and are interested in building
your applications for Windows Phone 7, this guide is for you.
The guide covers what you need to know to add Windows Phone 7 development to
your skill set, while leveraging what you have already learned building Android
applications.




Target Audience
This document is for Android application developers willing to develop applications
for Windows Phone 7.




Conventions Used in this Document

Term                             Abbreviation

Windows Phone 7                  WP7

Application Programming
                                 API
Interface

Integrated Development           IDE
Environment




                                                                                      4
Windows Phone 7 Guide for Android Application Developers



Chapter 1: Introducing Windows
Phone 7 Platform to Android
Application Developers
Ever since the release of Windows Phone 7 (WP7) platform, developers from around
the globe rushed to develop applications for this platform. Now, WP7 devices are
available with manufacturers all over the world. A large number of applications are
already available in the WP7 marketplace.
For WP7, Microsoft went back to the drawing board to figure out what phone users
really want, and built a phone from the ground up. The operating system, the user
experience, and the application development platform have all been engineered
with users in mind. The revenue opportunities in the Windows Phone marketplace,
accompanied by a great set of development tools, make WP7 a very attractive
destination for developers to build applications and games.


The Developer Tools
Microsoft recommends using these tools for WP7 application development. This
toolset is free and can be downloaded from here. The toolset includes:
An IDE (for developers): Visual Studio Express for Windows Phone
      A user interface design tool (for designers): Express Blend for Windows
       Phone
      Silverlight for Windows Phone and XNA Game Studio for Windows Phone
      Windows Phone 7 emulator to test and debug applications
The tools are designed to let you develop consumer applications, business
applications, and games.


Windows Phone 7 Architecture
WP7 utilizes a layered architecture. Like Android OS, WP7 runs on multiple phones.
To provide a consistent user experience and features that you can rely on, WP7
defines a minimum set of hardware specifications that all phones must meet. They
include:
      ARM7 CPU
      A DirectX capable GPU
      Camera
      Multi-touch capacitive display
      Standard sensors include:
         o A-GPS
                                                                                    5
Windows Phone 7 Guide for Android Application Developers

          o   Accelerometer
          o   Compass
          o   Proximity and light sensors
There are three standard buttons on the phone: Back, Start, and Search. As we will
see in a subsequent section, these buttons provide an easy and natural navigation
model for the user.
In WP7, Microsoft provides most of the device driver code. A device manufacturer
has to write very little code specific to their device. This improves the consistency
and quality across various devices. WP7 takes advantage of hardware acceleration
through encapsulation layers, such as DirectX or XNA.




WP7 applications use managed programming and run within sandboxed
environments. For more details about WP7 architecture, watch the MIX‟10
presentation by Istvan Cseri, a WP7 architect.




                                                                                        6
Windows Phone 7 Guide for Android Application Developers


Comparing the Programming Stack of Windows Phone 7
with Android
The Application Model shown above provides services, such as installation and
update, for managing the application lifecycle. The UI model helps to manage
application user interface. Applications are built using various WP7 frameworks.
This table gives an overview of the WP7 frameworks that provide features
comparable to the Android programming layers.



Android                  Functionality                 Windows Phone 7
Frameworks                                             Frameworks

                         Application UI, Device        Windows Phone 7 Phone
Android Application
                         integration (sensors,         Framework, Silverlight
Framework
                         camera)                       controls

                                                       XNA for games or Silverlight
Android Application
                         Graphics, Animation, Media    media and graphics for
Framework
                                                       others

                         Base services, Networking,
Android Libraries                                      Common Base Library
                         Text, XML, storage

Android runtime
                                                       Windows Phone 7
(Dalvik)+ Linux kernel




                                                                                   7
Windows Phone 7 Guide for Android Application Developers


Android and Windows Phone 7 Stacks Side by Side
This table compares the Android and WP7 Frameworks side by side.


  Android Frameworks                                               Windows Phone 7 Frameworks

                             Multi-tasking




                                                                                                                    integration
                                                                                                                    UI and Phone
  Application UI and Phone




                                                                                                                      Application
                                                  Java


                                                         C# or VB.NET
                             Application UI                             Application UI
                             Device integration                         Device integration
                             Browser Control                            Browser Control
                             Notifications                              Notifications

                             Peer to Peer                                                              Gamer




                                                                                         Silverlight




                                                                                                                                Two Application Types
                                                                                                                    XNA
                             Gaming                                                                    Services
                             Controls &                                 Controls &
                             Gestures                                   Gestures                       Media
                             Telephony                                  Media
                             Media Framework
  Media




                             Animations                                 Animations                     Animations
                             Graphics                                   Graphics                       Graphics
                             OpenGL-ES                                  Isolated                       Content
                             File System                                Storage
  Core Libraries




                             SQLLite




                                                                                                                          Library
                                                                                                                            Base Class
                             Location                                   Location
                             XML                                        XML, LINQ
                             Networking                                 Networking, Windows
                                                                        Communication Foundation
       Libc, Dalvik VM                                                  CLR Base Classes
  Android runtime +                                                     Windows Phone 7                                       OS
  Linux kernel

Managed Code
In Android, every application runs in its own process, with its own instance of the
Dalvik virtual machine. WP7 only supports “managed code” applications using C# or
VB.net; there is no native access available to the system or the phone hardware.
.NET Common Language Runtime (CLR) manages the execution of such code. CLR
provides garbage collection and there is no memory management to worry about or
pointers to take care of. The WP7 application stack is built on the .NET compact
framework 3.7. As Dalvik virtual machine is optimized for mobile devices, the .NET
compact framework is optimized for resource constrained devices and is designed
to be portable across various hardware platforms.



                                                                                                                                                        8
Windows Phone 7 Guide for Android Application Developers


Base Services
WP7 Base Class Library classes roughly correspond to those provided in the Android
Core Libraries.
      Android core libraries include:
      Media framework for audio and video codec support
      SQLite for database
      Opengl-ES
      SGL for graphics and animation
      Networking stack
      Libc for embedding with Linux kernel
      Dalvik VM
The WP7 Base Class Library layer also includes:
      Networking stacks: such as HTTP and the Windows Communication
       Foundation (WCF). WCF provides an easy interface with XML and SOAP
       services across the Web, with features supporting the XML data transfer,
       serialization, deserialization and XML parsing.
      Database support: WP7 does not have a local database, such as SQLLite.
       You can write SQL-like queries in C# using Language Integrated Query
       (LINQ) to query XML data, stored in isolated storage (see below), or in
       remote databases such as SQL Azure.

Application UI and Device Integration
You can develop WP7 applications using two libraries: Silverlight and XNA.
Silverlight contains the visual components same as Android standard widgets.
Generally, it is recommended that you use Silverlight for consumer or business
applications and XNA for games. However, you can certainly develop great games
using Silverlight animation.




                                                                                  9
Windows Phone 7 Guide for Android Application Developers




Android applications                     Windows Phone 7 counterparts


UI using activity(contains                    Silverlight applications with pages
widgets) with navigation                      connected by flows
between them




2D or 3D games built                          XNA games with 2D / 3D graphics
with Opengl-ES                                and Xbox connectivity




XNA for Games
For a high performance game, XNA is the right option. XNA framework, originally
developed for XBOX, provides hardware accelerated 2D and 3D rendering and
bitmap graphics. XNA also provides gamer services such as authentication and
connectivity with XBOX Live, as well as Profiles and Leaderboards.

Silverlight Controls and Media
If you use Android activities and widgets, you will find a large set of Silverlight UI
controls specifically designed for the OS. WP7 UI components are designed for
multi-touch. Silverlight uses a declarative language called Extensible Application
Markup Language (XAML) to specify user interfaces. You can use separate code-
behind files, written in C# or VB.NET, to respond to events or manipulate the
controls.
Silverlight provides high performance audio and video with variety of CODECs. It
supports both vector and bitmap graphics with hardware acceleration. As opposed
to a file system, Silverlight provides sandboxed storage, called isolated Storage, to
store the application-specific data. With the isolation of storage, one application
cannot affect other applications that are running on the phone.

Windows Phone Frameworks
If you need to use HTML in your application, you can use the Internet Explorer
based browser control in your application for HTML UI. Windows Phone Framework
layer also provides interfaces to various sensors, such as the accelerometer or the

                                                                                         10
Windows Phone 7 Guide for Android Application Developers

camera. Microsoft provides a push notification service, called Microsoft Push
Notification Service.
In Android, multitasking is supported. In WP7, support for multitasking will be
provided in the next release. In Android, you need to use third-party platforms like
ADMob to publish advertisements in applications. Microsoft has made this task
easier in WP7 by introducing Microsoft Advertising SDK for WP7.
For more information, visit:
Microsoft Advertising SDK for Windows Phone 7


Summary
In this chapter we looked at the WP7 architecture and the Android and WP7
programming stacks. Now that you have a high-level idea of how the WP7
programming stack maps to the Android stack, we are now going to go one level
deeper. In the next section, we will look at the user interface guidelines of WP7
applications.


Related Resources
To learn more about the topics covered in this blog, visit:
      App Hub – Central Place for Windows Phone 7 development. Getting started,
       download tools and read all about Windows Phone 7 development
       MIX ‟10 presentation on Windows Phone 7 Architecture by Istvan Cseri
      Windows Phone 7 Development for Absolute Beginners. Video series that will
       help aspiring Windows Phone 7 developers get started.
      App Hub Jump Start Tutorials
      Introduction to WP7 programming on Codeproject.com
Other Resources you may find useful:
      Overview of the Windows Phone 7 Application Platform
      Windows Phone 7 Team Blog
      Windows Phone 7 Programming




                                                                                    11
Windows Phone 7 Guide for Android Application Developers



Chapter 2: User Interface Guidelines
Microsoft‟s Windows Phone 7 (WP7) uses a novel user interface called Metro. WP7
sets itself apart with its clean and simple design and emphasizes on color and
typography.
In contrast to the application-focused design of Android, WP7 uses an information-
centric design. Instead of an array of application icons, the start screen of a WP7
consists of dynamic tiles that display critical information at a glance to the user.
The tiles are dynamic and they continuously display the up-to-date status of the
applications. For example, they show you the next appointment on your calendar,
or the number of new emails waiting for your attention. Users can personalize their
phones by pinning the tiles that they care most about.
WP7 introduces a new paradigm called hubs. Hubs bring related information
together. There are six hubs, People, Pictures, Music + Videos, Marketplace, Office,
and Games. The People hub, in the instance shown below, aggregates your address
book contacts and Facebook friends.




                                                                                  12
Windows Phone 7 Guide for Android Application Developers


Designing the Application Interface
While the design of the WP7 user interface is different from that of the Android, the
core design principles are very similar. Like Android, in WP7 you need to keep in
mind the compact screen, lower CPU, and limited memory while designing the
applications. In WP7, users use one application at a time, with just one screen
visible.

Similar Application Design Goals
Usability and UI design are not after thoughts, but are the primary goals behind
applications on both the Android and WP7. Applications need to be simple and focus
on key scenarios that most users care about.

Visual Elements and Direct Manipulation
Like Android, visual elements and direct manipulation of objects by touch are the
key characteristics of the WP7 application. WP7 provides a complete set of UI
controls designed for the phone.
WP7 utilizes the same set of core multi-touch gestures as the Android with similar
semantics, these include: tap, double tap, pan, flick, touch and hold, and pinch and
stretch.

Implications of the Similarities for the Developers
For the most part, the application planning process is similar on both the platforms.
While designing your WP7 application, you will focus on the same information that
is critical to the user. Your key design principles from the Android application will
get carried over: metaphors and direct manipulation with multi-touch. The need for
immediate feedback and aesthetic appeal remains the same.




                                                                                    13
Windows Phone 7 Guide for Android Application Developers


Application User Interface Design
While there are similarities in the design principles of the applications on both
platforms, pay close attention to the user interface of the application for the WP7. It
is best to take advantage of the unique features and strengths of WP7 platform.
For the interface to provide a consistent experience across applications, applications
on WP7 need to adopt the new Metro design guidelines.

XML and XAML
Android uses XML for mapping purposes. A part of the compilation reads the XML,
performs translations, and generates Java. For example, in layout XMLs of Android,
you need to set it as content view in Activity, after defining the whole UI.
In WP7, XAML act as an instantiation language. XAML does not act as a mapping
medium in WP7 as XML does in Android. The XML in a XAML document in WP7
contains the actual code needed for UI and needs not be transformed into code, as
in case of Android.

Controls and the Application Interface
The WP7 development tools and SDK include a rich collection of Silverlight controls
that are designed specifically for usability and aesthetics. While you can create your
own controls, it is best to use the standard controls wherever possible. These
standard controls respond to theme changes and provide a consistent user
interface.
The following table shows the mapping between WP7 Silverlight controls and
corresponding Android controls.

Android control            Windows Phone 7 control

Border                     Border

ButtonView                 Button

AbsoluteLayout             Canvas

CheckBox                   CheckBox

GridView                   Grid

                           HyperlinkButton

ImageView                  Image

ListView                   ListBox

MediaController            MediaElement


                                                                                    14
Windows Phone 7 Guide for Android Application Developers


Android control          Windows Phone 7 control

                         MultiScaleImage

ViewGroup                Panel

EditText                 PasswordBox

ProgressBar              ProgressBar

RadioButton,             RadioButton
RadioGroup

ScrollView               ScrollViewer

SeekBar                  Slider

LinearLayout             StackPanel

EditText                 TextBlock

EditText                 TextBox

MapView                  Map

WebView                  WebBrowser

                         Panorama

                         Pivot

TimePicker               Timepicker

DatePicker               Datepicker

ExpandableListView

Gallery

ImageSwitcher

Spinner

TableLayout

TextSwitcher

ViewFlipper


                                                           15
Windows Phone 7 Guide for Android Application Developers


Android control            Windows Phone 7 control

ZoomControl

TabHost

SlidingDrawer

RatingBar

Toggle button              ToggleSwitch*

* ToggleSwitch and Datepicker/Timepicker control are part of the Silverlight for
Windows Phone Toolkit available on Codeplex:
http://silverlight.codeplex.com/releases/view/55034
As you can see, WP7 offers controls that correspond to almost all Android controls.
While the look and feel is different, they provide similar functionality.

New Controls in Windows Phone 7
WP7 introduces a few novel controls that have no counterpart on the Android. Here
are some of the examples:
      A multi-scale image, with image data at various resolutions, is appropriate
       for allowing the user when zooming into a photo.
      Panorama control is a multi-screen page and allows a page to span
       horizontally beyond the width of the phone.
      The people hub is another great example. It allows a large amount of related
       information to be presented.
      Pivot control, a novel control that is useful to manage views and display
       information that is logically divided in sections.




                                                                                   16
Windows Phone 7 Guide for Android Application Developers




Notifications
Both Android and WP7 have notification services, but notifications play a key role in
WP7. The tiles are used to display non-critical information without disrupting what
the user is doing. If you are using status bar notifications in Android, you can use
tile notification as a replacement in WP7 to show critical information.
The notification service also display toast notifications that provide time sensitive
information, such as an SMS. The toast notifications are shown for about 10
seconds, but the user may choose to ignore them. These are the same as Android
toast notification.

Android            Functionality                           Windows Phone
                                                           7

Status bar         Non-critical information that user      Tile notifications
notification       may not respond to. That is
                   informative to user

Toast              Time sensitive data that user may       Toast Notifications
notification       not respond to

Alerts             Modal alerts that the user must         Application
                   respond to                              notifications




                                                                                    17
Windows Phone 7 Guide for Android Application Developers




Tool and Tab Bar vs. Application Bar
WP7 features a versatile application bar. The application bar can include up to 4 of
the most common views or application tasks. You can also use application bar
menus for additional context-sensitive tasks. If you are using action sheets in your
Android application, application bar menus give you similar functionality.

Android                      Functionality          Windows Phone 7

Status bar                   Information about      Status bar
                             device

Title bar: to show title     Navigation, Title,     Back button for back
of application or activity   Buttons for views or   navigation
                             actions
                                                    Page title

                                                    View and actions on
                                                    Application bar



Comparing Windows Phone 7 and Android Navigation
WP7 application is a collection of multiple pages. Like on the Android, the user
navigates through different Activities using widgets such as buttons and links.
Like Android, on WP7 the Back button on the phone allows the user to navigate
back between pages within an application, or across applications. It behaves much
like the Back button in a browser. The Back button also closes menus and dialogs.
As a developer, you should consider what the Back button means to your user and
plan to override it appropriately. For example, you may decide to pause a game by
using the Back button on the Phone.
The other two hardware buttons on the WP7 phone, namely, Search and Home,
have fixed behavior.




                                                                                   18
Windows Phone 7 Guide for Android Application Developers


Windows Phone 7 Frame and Page Structure
Each WP7 application has a single frame, and it includes areas for:
      A page where application content is rendered. This is the content where
       widgets or graphics are rendered.
      A reserved space for the system tray and application bar. It also exposes
       certain properties, such as orientation to the application.




System Tray and Application Bar
On WP7, the system tray includes indicators for various system-level status
information. The application bar includes the area for the most common application
menus, which may include various data views or tasks.




                                                                                   19
Windows Phone 7 Guide for Android Application Developers


Page Structure of Windows Phone 7 Application
The following diagram shows the structure of a typical WP7 data-bound application,
which resembles a navigation-based Android application.




When the user first starts the application, he or she is presented with a splash
screen, designed to welcome the user, as well as to create the perception of fast
response. Splash screens are usually an image file of the entire size of the display.
Usually the application starts with the home page, the main navigation page, with
links for search, and other page widgets. Consider an application that shows
information about baseball teams and their players. The primary content page,
marked as the widgets page in the above diagram, have the content of interest. For
example, a list of all baseball teams. However, depending on requirement, the
home page can also be the primary content page.
This is a possible application usage scenario:
      A user clicks one of the team links to visit the team details page (“Widget
       Details Page”) which can provide multiple views. The team details page may
       employ a pivot control or panorama to display different views such as the
       team summary and the list of all players (“List of Gadgets Page”) from that
       team

      A user selects one of the baseball players and the application takes the user
       to the page with player statistics (“Gadget Details page”). The player
       statistics page uses controls such as textblocks, multi-scale images, or other
       multimedia using a MediaElement control

      A user can also use the search widget to search and directly access the team
       page (“Widget Details Page”) or the player page (“Gadget Details Page”)


                                                                                    20
Windows Phone 7 Guide for Android Application Developers


Application Templates
Eclipse does not provide the project template for Android applications. But Visual
Studio provides numerous templates for WP7 application development to make
your life easier.

Functionality                 Visual Studio Template Eclipse

Information drilldown         Data-bound applications        Not available
applications

Utility applications. For     Windows Phone 7 utility        Not available
example, Bubble Level         applications

Games                         Windows Phone 7 Game           Not available
                              (XNA) applications

Flexible template to design   General Windows Phone 7        Not available
any application               applications

You can choose the Windows Phone application template to either create an
application with functionality similar to the view-based or the window-based
Android application type. Lastly, the XNA based games application template gives
you functionality like the OpenGL-ES application.


Summary
In this chapter we looked at the similarities between the application design goals of
the Android platform and the WP7 platform. When you plan your WP7 application,
you will be able to leverage your existing work on Android applications.
We also looked at the application interface design to make sure you are taking
advantage of the WP7 metro design that uses WP7 interface guidelines. You will
find that the WP7 tools offer a large library of controls and gestures that have close
counterparts on the Android.
This chapter also showed you the use of innovative controls like panorama, and
explore the use of live tiles to build an engaging WP7 experience.


Related Resources
To go deeper into the topic discussed, visit:
       Windows Phone 7 User Interface Guidelines
       Windows Phone 7 Developer Tools
       Silverlight for Windows Phone toolkit on CodePlex
       Design resources for Windows Phone

                                                                                     21
Windows Phone 7 Guide for Android Application Developers

Other Resources that you may find useful:
      Application Page Model for Windows Phone 7
      Frame and Page Navigation Overview for Windows Phone




                                                              22
Windows Phone 7 Guide for Android Application Developers



Chapter 3: The Developer and
Designer Tools
With the release of the Windows Phone 7 (WP7) developer tools, Microsoft brings
the user-friendly, high productivity Visual Studio Development environment to WP7.
As Android application developers you are familiar with Eclipse, and you can quickly
migrate to WP7 developer tools and work with ease.


A Comparison of Android and Windows Phone 7 Tools
Visual Studio 2010 Express for Windows Phone is a full-featured Integrated
Development Environment (IDE). Visual Studio 2010 facilitates designing,
developing, and debugging of Windows Phone 7 applications. The other WP7 tools
that help you in the development cycle of the Windows Phone application are:
       Expression Blend
       XNA Game Studio
       Windows Phone Emulator
The WP7 developer tools offer the complete functionality that is provided by the
Android application developer tools. The following table gives an overview of the
functionality of each of these tools. The table also indicates the equivalent tools you
use for Android application development.


 Functionality      Audience        Android          Windows Phone 7 tools
                                    tools

 Primary UI         UI designers    Defined in       Expression Blend
 design: Colors,                    XML, any XML
 gradients, and                     tool
 animation
                                       ADT UI
 UI design          UI designers                     Visual Studio 2010 Express
                                        plug-in
                    and                              and Expression Blend for
                                       Third-
                    programmer                       Windows Phone
                                        party tool
                    s
                                        like
                                        DroidDraw
 Application        Programmers     Eclipse          Visual Studio 2010 Express
 development                                         for Windows Phone
 (coding)

 Game               Programmers     Eclipse          XNA Game Studio
 development
                                                                                    23
Windows Phone 7 Guide for Android Application Developers

 (coding)

 Testing /          Testers        Android          Windows Phone Emulator in
 Emulation                         Emulator         Visual Studio 2010 Express

You can use the Android team structure and overall development process to build
applications for Windows Phone 7. The WP7 toolset ensures that the entire team of
designers, developers, and testers familiar with Android development tools will find
it easy to migrate to the WP7 toolset.


Development Life Cycle and Windows Phone 7 Developer
Tools
Expression Blend 4 and Visual Studio facilitate a close collaboration between
designers and developers.
Both these tools share the same file structure and source files. Expression Blend
uses XAML for UI design and the XAML is consumed by Visual Studio. This system
allows separation of responsibilities between the designer and the developer while
allowing them to work together seamlessly.




Project Management for Windows Phone 7
Like Eclipse, Visual Studio 2010 Express for WP7 is a fully-featured IDE. Visual
Studio 2010 Express allows you to:
      Manage the entire structure of the development project, the source, and the
       resource files
      Configure the application codebase, known as Visual Studio Solution, as a
       collection of projects in a separate functional unit
With Visual Studio 2010 Express, you can manage source files, share code, and
manage the work among team members. Visual Studio integrates a compiler and a

                                                                                   24
Windows Phone 7 Guide for Android Application Developers

debugger. You can access both the compiler and the debugger either from the GUI
or the command line.
To create a sample application, do the following:
   1. Start Visual Studio Express for WP7 from Start menu.
   2. In Visual Studio Express, click File.
   3. Click New Project.
   4. In the New Project dialog box, select Windows Phone Application.
   5. In the Name of the project text box, enter ShoppingList as the name of
      the project, and click OK. Visual Studio Express creates the new project.
The Solution Explorer pane displays the solution that you created. This example
solution has only the ShoppingList project. The project contains the sources,
resources, and properties.




Note: Visual Studio Express for WP7 does not provide integration with source
control systems. The Visual Studio Professional edition provides features such as
integration with various source control systems like Subversion. You can also use
Visual Studio Team System, which is designed for greater communication and
collaboration among the development teams.




                                                                                    25
Windows Phone 7 Guide for Android Application Developers


The UI Design Tools
The WP7 developer tools include:
      Expression Blend
      Visual Studio UI Designer
WP7 uses Silverlight and a specific XML markup language for the UI specification.
Visual Studio UI design tool is equivalent to the Eclipse ADT UI plug-in. As Android
application developers you are familiar with Eclipse ADT UI plug-in and you will find
it easy to use this tool. In our example, the main page for the ShoppingList
solution, MainPage.xaml, is already open in the Visual Studio UI Designer tool for
editing.
To change the titles of the application and the current page, do the following:
   1. Right-click the title MY APPLICATION and select Properties.
   2. In the Properties window, select Text and enter SHOPPING LIST.
You can also change the title of the page by entering my list in the Text property of
the title.
To change the title of a page, do the following:




   1. Drag a Text box from the Toolbox and place it above the textblock.
   2. Update the Text box‟s Text property to delete any existing entry.
                                                                                    26
Windows Phone 7 Guide for Android Application Developers

   3. Below Properties, click TextBox1, and enter txtItem to change the ID of
      the textbox to txtItem.
   4. Resize the Text box by dragging its lower right corner so that its width is
      300.
   5. Drag a Button to the right of the TextBox.
   6. Change the button‟s Content property to Add, and its ID to btnAdd.
   7. Resize the button so that its width is 140.
   8. Drag another TextBox and place it underneath the txtItem textbox.
   9. Resize the new TextBox so that it covers the rest of the phone screen.
   10.Update the ID of the new TextBox to txtList.
   11.Update the Text property of the new TextBox to Nothing here yet!.
Your application looks as shown below:




   12.To start debugging, compile the application and launch, press F5 or click
      Debug
The application starts the WP7 emulator, deploys, and runs the ShoppingList
application. You can click Add. But the application does not respond because there
is no code for the button you inserted in the previous steps.




                                                                                    27
Windows Phone 7 Guide for Android Application Developers




Note: You can use the context menus to add the event handlers or to set the
control properties. The emulator‟s integration with Visual Studio allows for a direct
manipulation of controls and makes it easy to add logic to the UI controls.

Expression Blend for Windows Phone 7
Expression Blend for WP7 is a visual UI design tool that is suitable for designers.
There is no exact equivalent to Expression Blend in Android development toolset.
Expression Blend is like VS Design. With Expression Blend, you can:
       Drag and drop UI elements to design the UI
       You can layout the controls accurately up to pixels. You can easily create
        and use color palettes and gradients
       Add special effects, such as reflections and shadows
       Import Photoshop files and Android application resources to the Windows
        Phone application
       Create fine application behavior and animations without any programming




                                                                                      28
Windows Phone 7 Guide for Android Application Developers




Expression Blend is for UI designers and Visual Studio Design is for programmers.
Programmers can also use Visual Studio Design to integrate the application logic to
the UI design. You can also use the Visual Studio UI design tool to design UI for
applications.
Both Expression Blend and Visual Studio Design have:
      A single control set that provides accurate fidelity to their run-time visual
       representation. This feature allows you to easily visualize the application.
      Same project structure and share the same source files for designers and
       developers.
      Use or produce XAML, which is a Silverlight XML declarative markup
       language used for interface design. This feature allows a designer to work on
       the design using Expression Blend while the developer uses Visual Studio to
       design the logic behind the application. You can establish a smooth design
       and development workflow.




                                                                                 29
Windows Phone 7 Guide for Android Application Developers


Visual Studio
Visual Studio has a simple to use, full-featured, and a configurable source editor.
The editor tool has various features that are familiar to Eclipse users. The features
of the editor include:
       Flexible search
       Rich editing
       Format code
       Auto-completion of code
       Outline or hide code
To add logic to the application, do the following:
    1. To stop the running application, click Debug.
    2. Click Stop Debugging.
    3. Double click Add. The dialog displays MainPage.xaml.cs with a method
       btnAdd.
    4. Click the MainPage class.




    5. To add logic to the items that are added to the shopping list, edit the
       btnAdd_click method.
    6. Enter the following code: string tStr = txtItem.Text;.
Note: When you enter t for txtItem, Visual Studio displays the auto-completion
dialog box. The Visual Studio equivalent for Eclipse auto-completion is called
content assistant.


                                                                                    30
Windows Phone 7 Guide for Android Application Developers




   7. Enter the following code in the btnAdd_click method:
       if (!String.IsNullOrEmpty(tStr))
Note: When you type String, Visual Studio displays the auto-completion dialog box.
When you type Is, Visual Studio displays the class methods of the String class.




VS IntelliSense in Visual Studio
VS IntelliSense is a feature of the IDE which uses history, code context, and .NET
reflection for intelligent auto-completion. VS IntelliSense can suggest and complete
variable names, parameters, classes, and method names. VS IntelliSense can also
generate appropriate code where needed, as shown in the code below:



To complete the event hookup, Visual Studio generates an empty stub for the event
handler button1_click method.




                                                                                  31
Windows Phone 7 Guide for Android Application Developers


Code Snippets in Visual Studio
Code Snippets in Visual Studio is equivalent to code templates in Eclipse. Code
Snippets allows you to insert code fragments with a few clicks. Visual Studio
contains a large number of snippets. These snippets help you to create their own
snippets. You can also create an index and search for the code snippets by using
the self-defined terms.
To use a code snippet, do the following:
    1. To start the Insert Snippet prompt, press CTRL+K CTRL+X
    2. To insert a code snippet for an if statement in the code, select Visual C#
       followed by i




The inserted snippet shows the parts of the code that you need to complete.
private void btnAdd_Click(object sender, RoutedEventArgs e)
{
      string tStr = txtItem.Text;
      if (!String.IsNullOrEmpty(tStr))
      {
             if (true)
             {
             }
      }
    3. To complete writing the code for the method, enter the required code so
       that the body of the method is complete as follows:


string tStr = txtItem.Text;
      if (!String.IsNullOrEmpty(tStr))
      {
            if (txtList.Text == “Nothin here yet”)
            {
                  txtList.Text = “”;
            }
            txtList.Text += txtItem.Text + “\n”;
            txtItem.Text = “”;
      }
Visual Studio supports various refactoring mechanisms. You can select any piece of
code and right-click the code to access the refactoring menu.
                                                                                    32
Windows Phone 7 Guide for Android Application Developers


Visual Studio Editor
Visual Studio editor is customizable. Visual Studio editor allows you to define
various keyboard shortcuts or create your own macros. Macros help you to
automate repetitive actions by combining a series of commands and instructions.
You can easily customize Visual Studio Editor to use shortcuts and keyboard
combinations with which they are familiar.
Instead of opening a separate window for each file, as in Eclipse, the default view in
Visual Studio uses tabbed windows. You can change this behavior to suit your need.
You can change the way in which various windows are docked within Visual Studio
Shell.


Building Applications
Visual Studio Express for WP7 allows you to build the Visual Studio solution on
demand. It allows you to separately build each project to make a part of the
complete solution.
Visual Studio uses an XML based, declarative build system called MSBuild. MSBuild
is equivalent to Ant and Nant. You can access the builds either from the GUI or by
using the command line for batch processing. MSBuild is flexible and allows you to
create a specific target either as a debug build or as a release build.




Windows Phone 7 Emulator
The WP7 Emulator provides a virtualized environment in which you can deploy,
debug, and test applications. The WP7 Emulator is designed to provide a
comparative performance of an actual device and meets the peripheral
specifications required for application development.
To access the WP7 Emulator from Visual Studio, do any of the following:
      From Deploy menu, click Deploy Solution
      Press F5 in the key board, this starts the Emulator along with the debugger
      Press CTRL+F5, this start only the Emulator

                                                                                   33
Windows Phone 7 Guide for Android Application Developers

The WP7 Emulator is like the Android Simulator. However, these differences are
there:
      In Android emulator you can have access to all the system application like
       Phone Dialer, Contacts, Mail, and Media Gallery. But the WP7 Emulator the
       system applications are not directly accessible to you. Though it can be
       accessed by the Launchers and Choosers.
      Android supports various display height and width. Likewise, you can
       customize the Android emulator for parameters like Screen Height, Width,
       RAM size, and Sensors. As WP7 have specific hardware requirements, you
       cannot modify the WP7 Emulator for these hardware parameters.


Debugging
Visual Studio Express Phone 7 includes a symbolic debugger that you can use with
the WP7 EMULATOR or with a remote device. Once the application loads in the
debugger, you can view the variables in the application and control their execution.
To work with debugger, do the following:
   1. To start the debugger, press F5
   2. In Textbox you previously created, enter napkins and click Add. Refer to
      the image below.




Note: napkins is added after Nothing here yet!
   3. In Visual Studio, click the light blue area to the left of the string tStr =
      txtItem.Text; line.

       Visual Studio inserts a breakpoint at that line.

                                                                                     34
Windows Phone 7 Guide for Android Application Developers




    4. Launch the debugger again using F5. When the application loads into the
       debugger, rest the mouse pointer over txtItem in the code
    5. Click + in the pop-up to view the variable txtItem.

Tracking Variables
You can view the details of the variables such as the Type, Fields, and Properties.
The dialog below shows how you can scroll up and down the Type Hierarchy to
inspect the objects.




You can set a watch on certain variables to keep them under observation
continuously.
To track variables, do the following:
    1. Right-click txtList, and click Add Watch.
       The watch window displays the variable txtList.
    2. Click + icon near txtList, to expand txtList.



                                                                                      35
Windows Phone 7 Guide for Android Application Developers




   3. To ensure that the control does not enter the if statement, press F10 to step
      through the code.
if (txtList.Text == "Nothing here yet")
                 {
                     txtList.Text = "";
                 }


You can observe in the Watch window that the value of txtList.Text is Nothing here
yet. But it gets compared with Nothing here yet (with no exclamation point.) This is
a bug in the code.
Change the statement as shown below to add the exclamation point:
if (txtList.Text == "Nothing here yet!")


Note: While in the debugger, you can use the VS immediate mode where you can
write the managed code instructions to modify or view the variables or execute
code to help with debugging.




   4. Update the code and re-launch the debugger by pressing F5.
   5. To test the application, add items to the shopping list.




                                                                                 36
Windows Phone 7 Guide for Android Application Developers




A Note about Debugging
You will observe that you can easily debug a WP7 application using the managed
programming environment. Like Eclipse, the debugging in WP7 application is done
entirely at the application level using the C# code and types.
Note: The .NET framework includes two classes called Debug and Trace, which help
you to write run-time debug messages to the output window. C# also supports an
assert statement, which is evaluated at run time. If the statement returns true,
Visual Studio does not respond. But if the statement returns false, the program
enters the debugger.




                                                                              37
Windows Phone 7 Guide for Android Application Developers


Summary
In this chapter we looked at the Windows Phone 7 Developer Toolset. The Toolset
includes the rich tools that are designed to support every step in the entire
application development lifecycle. The design, development, and the testing tools
are equivalent to the existing Android team roles and processes. The tight
integration between the WP7 tools helps you to streamline the design, develop the
workflow, and test the workflow. These tools provide an end-to-end functionality
and are highly customizable.




                                                                                38
Windows Phone 7 Guide for Android Application Developers



Chapter 4: C# programming
This chapter discusses the C# features that map to the most common Java
features. This chapter includes the code snippets, which help you to work faster
with C# code. It describes important C# features that help you write safe code and
enhance productivity.
The chapter discusses the following features of C# programming:
      Managed Programming
      Class Declaration
      Strong Typing
      Class Constructors
      Properties
      Parameter Types
      Access Privileges
      Methods with multiple Parameters
      Inheritance
      Protected Access
      Instance vs. Class Level Access
      Abstract Classes
      Interfaces
      Polymorphism
      Structs
      Object Lifecycle: Creation and Deletion of Objects
      Type Checking vs. Reflection
      Exception Handling




                                                                                39
Windows Phone 7 Guide for Android Application Developers


Managed Programming
WP7 supports managed programming in C# and VB.NET.




The C# compiler (and similarly, the VB compiler) compiles the C# (or VB.NET) code
in an intermediate language (IL) byte code and metadata. The Common Language
Runtime (CLR) executes the bytecode. The C# uses metadata to manage type
safety, exception handling, and array bounds. CLR also manages memory and
performs garbage collection. In Android, the Java code is compiled in a .class file,
and the file is converted to a .dex file. The .dex file is optimized for low foot print
on memory. The .dex file is then converted to an apk file, which is executed on an
android platform.




                                                                                    40
Windows Phone 7 Guide for Android Application Developers


A Comparison between C# Features and Java Classes
Class Declaration
Like Java, C# does not separate class definition from class implementation. The
compiler derives the metadata about the classes from class implementation. As in
Java we can define multiple class definition in same file. C# also defines the
multiple classes in same file.
using System;             // In java this is similar to import
namespace FirstApplication   // scope for classes. Same like package declaration in Java
{
class Person                  // only uses class implementation
{
        private DateTime birthDate; // a private field accessible to this class
        private int ageOn(DateTime date) // a private method
        {
            TimeSpan span = date.Subtract(birthDate); //uses a .notation to invoke
            return span.Days;
        }
        public int age                // this is a property.
        {
            Get                       // just a getter; it’s a read-only property
            {
                return this.ageOn(DateTime.Now);
                 }
        }

       public Person( DateTime dob)   // instance constructor. Same like Java
        {                              // it combines allocation and initialization
            birthDate = dob;
             }
}
class Program   // Same like Java, another class in the same file.
{
     static void Main(string[] args) // main entry point into the program
     {
         Person p = new Person(new DateTime(1973,11,12)); //construct an instance
         System.Console.WriteLine("The age is is" + p.age.ToString());
         DateTime dt = p.birthDate; //error in compilation birthDate is private
        }
    }
}



The following example shows the public signature of the class Person that consists
of property, age, and constructor.
Instead of using the import statement in Java, C# employs a using statement to
refer to the metadata of other classes. The namespace declaration that is shown at
the top of the file is used to declare the scope and to organize the code. You can
access classes in other namespaces by referring to a fully-qualified name. You can
refer to System.Console.WriteLine in the example above, where the console is in
the System namespace.
C# uniformly uses the “ ” notation for referring to all methods, fields, and
properties.

Strong Typing


                                                                                           41
Windows Phone 7 Guide for Android Application Developers

C# is a strongly typed language like Java. The types must be specified for variables
and input/output parameters. The compiler enforces the types. In the section on
generics, you can see how C# uses strong typing for collection classes.
Strong typing works similarly for all classes. The code example below shows the
strong typing for primitive types.


int a = 5;
int b = a + 2; //OK
bool test = true; // OK
int c = a + test; // Error. Operator '+' cannot mix type 'int' and
'bool'.

Class Constructors
Like Java, C# uses instance constructors to create and initialize instances. For
example: p is an instance of the Person class. You can construct and initialize p
with a given birthdate, in a single statement.
Person p = new Person(new DateTime(1973,11,12));

Properties
You often need to decide about whether to implement a member as a property or a
method. In this case, the design pattern is identical for both Java and C#. As a
general rule, use properties when you need to access data. To take any action on
the data, use methods.
Properties helps to abstract away from directly accessing the members of a class.
This technique is similar to using accessors (getters) and modifiers (setters) in
Java. You can make the property read-only by providing the getter, write-only by
providing the setter, or read-write by providing both getter and setter.

Parameter Types
Like Java, C# uses the value parameters by default. C# does not have pointers. But
C# allows the passing of parameters by using the ref modifier. Instead of pointers,
you can use parameters with ref where you want to achieve an additional
functionality in a method. In some cases, you need to use the reference parameters
for better efficiency since they avoid data copying.


void Foo (ref int x, int y)
{
      x = 0;
      y = 0;
}
..
                                                                                    42
Windows Phone 7 Guide for Android Application Developers

int a = 5;
int b = 8;
Foo (ref a, b);
//a is zero and b is still 8
C# also provides the parameters with an out modifier. This out modifier represents
the parameters that must be initialized by the called method before returning. This
design pattern is often used to return the error in addition to the value of the
function.

Access Privileges
Like Java, C# allows the access privileges on fields (for example, birthDate),
properties (for example, age) and methods (for example, ageOn). C# uses public,
private, and protected as modifiers to denote the three different levels of access
privileges.
In the above example, the compiler gives an error response on p.birthDate since
that variable is private. Therefore p.birthDate is not accessible from the Program
class. Similarly, the ageOn method is also private and inaccessible from the
Program class.

Methods with Multiple Parameters
Both Java and C# support methods with multiple parameters. While C# traditionally
uses positional and unnamed parameters, the latest version of C# has introduced
the named parameters. The following example shows the comparative syntax for
Java and C#.

Java                                      C#
void addEmployee(string name, int         void addEmployee(string name, int
id, int age);                             id, int age);

 Off.addEmployee("Phil",2345, 23);        Off.addEmployee("Phil",2345, 23);
                                          Off.addEmployee(name: "Phil",
                                          age:23, id:2345);

Like Java, C# explicitly supports method overloading. C# differentiates between the
methods that have the same name by using information about the parameter
types. The following code sample shows how C# differentiates between methods
that have the same name.
void insert (myClass obj, int index);
void insert (myClass obj, myClass before);
The method insert may be called with both these signatures:
list.insert (myObj1, 4);
list.insert (myClass obj, myClass before);

                                                                                     43
Windows Phone 7 Guide for Android Application Developers

The following code sample shows another example of method overloading:
using System;
namespace SecondApplication
{
    struct Point                              // In contrast Java where struct not
supported, C# structs are closer
    {                                         // classes.
        public double x;                      // struct fields can also have access
modifiers
        public double y;
        public Point(double p1, double p2)    //a constructor for the struct
        {
            x = p1;
            y = p2;
        }
    }
    interface IThreeDShape                    // an interface, like an Java interface
    {                                         // defines the behavior
        double volume
        {
            get;                              // Volume is a read-only property. no
setter
        }
    }
    abstract class Shape                      // this class is marked abstract, i.e. may
not be instantiated.
    {
        protected Point origin;               //only derived classes may access
        protected static int counter = 0;     // Similar to protected variables in Java
        public string ID;
        protected Shape()                     //a constructor. Same name as the class
name
{
            counter++;                        // class variable being updated
        }
        public Point Origin                   // similar to Java class
variables
        {
            set
            {
                 origin = value;
            }
        }
        public abstract double Area           //denotes that this property must be
overridden
        {                                     // in a derived class
            get;
        }
        public abstract bool contains(Point   p);   // this method must also be
overridden
    }

   class Rectangle : Shape                 //Similar to Java, single iinheritance
   {
       public double length;               //field accessible from others
       public double width;
       public Rectangle(Point o, double l, double w)   //a public constructor
         {
           ID = "Rectangle_" + counter.ToString();
           origin = o;
           length = l; width = w;
       }


                                                                                        44
Windows Phone 7 Guide for Android Application Developers

         public Rectangle(double l, double w) // one constructor using another
constructor
                                  //creates a rectangle at the origin
             : this(new Point(0, 0), l, w)
         {
         }
         public override double Area          // unlike Java, overridden method must
         {                                    // use override keyword
             get
             {
                 return length * width;
             }
         }
         public override bool contains(Point p)
         {
             if ((origin.x < p.x && origin.x + length > p.x) || (origin.x > p.x &&
origin.x - length < p.x))
                 if ((origin.y < p.y && origin.y + length > p.y) || (origin.y > p.y &&
origin.y - length < p.y))
                     return true;
             return false;
         }
    }
    class Square : Rectangle
    {
         public double side;
         public Square(double s)
             : base(s, s) //constructor
         {
             ID = "Square_" + counter.ToString();
             side = s;
         }
    }
class Cube : Shape, IThreeDShape            //similar to Java, class implements
interface
    {
         public double side;
         public Cube(double s)
         {
             ID = "Cube_" + counter.ToString();
             side = s;
         }
         public override double Area
         {
             get
             {
                 return 6 * side * side;
             }
         }
         public double volume
         {
             get
             {
                 return side * side * side;
             }
         }
         public override bool contains(Point p)
       …
    }
    class SecondProgram
    {
         static void printVolume(IThreeDShape tdShape)
         {
             Console.WriteLine("The volume is " + tdShape.volume);
                                                                                     45
Windows Phone 7 Guide for Android Application Developers

          }
          }
              static void Main(string[] args)
          {
            Rectangle r = new Rectangle(5.0, 3.0);
            Cube c = new Cube(4.0);
            SecondProgram.printVolume(c);
            double a = r.Area;
            Console.WriteLine("The area of rectangle " + r.ID + " is " +
a.ToString());
            bool b = r.contains(new Point(1, 2));
            Console.WriteLine("The point is in " + b.ToString());    // will print
TRUE
        }
    }
}


Inheritance
Like Java, C# also uses a single inheritance mechanism. Inheritance is specified by
listing the parent class after the class name as shown below. In this example, the
class Rectangle inherits from the class Shape, whereas the class Square inherits
from the class Rectangle.
class Rectangle : Shape
class Square : Rectangle
In C#, the constructor of the base class is automatically invoked when you
construct an instance of a derived class. However, a derived class can invoke a
specific constructor of the base class if needed. This you can see in the constructor
of the Square class.
public Square(double s): base(s, s) //constructor. Calls parent
constructor explicitly
Like Java, a C# derived class may not override a method by redefining it. The class
must use the keyword override in its method definition.
public override bool contains(Point p)
{
      …
}

Protected Access
Like Java, in C#, you can use protected modifier to control access to fields,
properties, and methods. You can implement protected variables in C# by using the
protected access modifier, as shown in the code sample below:
protected Point origin;
      protected static int counter=0;

Instance vs. Class Level Access


                                                                                     46
Windows Phone 7 Guide for Android Application Developers

Like Java, C# uses a static modifier to denote class level methods, fields, and
properties. Everything else is at an instance level. In the above code example, the
counter is a class level variable.

protected static int counter=0;

Abstract Classes
The abstract classes are classes that cannot be instantiated. Java provides a syntax
for an abstract class. The class Shape defined in the above C# code sample is an
abstract class. The abstract classes requires that both Area and the method it
contains must be overridden in any derived classes.
abstract class Shape
  {
      public abstract double Area
      {
          get;
      }
      public abstract bool contains(Point p);

Interfaces
The Java and the C# interfaces are similar. In the sample code shown below,
IThreeDShape defines an interface that is implemented by the Cube class.
interface IThreeDShape
  {
      double volume
      {
          ...
      class Cube : Shape, IThreeDShape

Polymorphism
The working of polymorphism is the same in both Java and C#. You can pass a C#
derived class as a parameter to a method that expects a base class. Similarly, you
can pass a class that implements a particular interface, as a parameter to the
method. The following sample code shows how to pass an object of the class Cube
as a parameter, where the method expects an object of the class IThreeDShape.
static void printVolume(IThreeDShape tdShape)
  {
      Console.WriteLine(“The volume is ” + tdShape.volume);
  }
      …
                                                                                  47
Windows Phone 7 Guide for Android Application Developers

  Cube c = new Cube(4.0);
  SecondProgram.printVolume(c);

Structs
C# structs are like classes. C# structs can access modifiers and have constructors,
methods, and properties. While a struct is a value, a class is a reference.
struct Point
   {
       public double x;
       public double y;




                                                                                 48
Windows Phone 7 Guide for Android Application Developers


Object Lifecycle: Creation and Deletion of Objects
The memory management in both Java and C# are similar. Both Java and C#
performs automatic memory management. Instead of allocating memory, C# allows
you to use the new operator to create objects and initialize them. When a code no
longer accesses an object, the object becomes eligible for garbage collection. The
.NET CLR garbage collector in C# periodically frees up the memory for such objects.
With C#, you don‟t have to track the free memory usage.
In rare circumstances, you may need to perform a cleanup at the time the object is
destroyed. C# allows the use of destructors, but in practice this is rare.

Type Checking vs. Reflection
Java Reflection is a versatile feature that you can find both in C# and Java. You can
use reflection to:
      Get information type from an existing object
      Dynamically create an instance of a type
      Bind the type to an existing object, access its methods, and access its fields
       and properties.
The following table maps the dynamic type checking in Java with its corresponding
C# reflection features.

Java Reflection         Explanation            C# Reflection

Class1 instanceOf       Is Object a subclass   type.IsSubclassOf(typeof(BaseClass))
BaseClass               or member?

object.getClass()       Is Object a member     object.getType() or typeof
                        of

search from             Does the object        type.GetMethod(MethodName)
                        implement the
Method[] methods =
                        method?
c.getMethods();

                        Does the class         type.GetMethod(MethodName)
                        respond to the
                        method?

Method.invoke(..)       Invoke a method        type.InvokeMember(…)


Exception Handling
Exception handling is similar in both C# and Java. You use a use block to handle
exceptions. You can also use either catch specific exceptions or a catch-all
statements. The syntax for exception handling is similar in Java and C#.



                                                                                   49
Windows Phone 7 Guide for Android Application Developers

try
      {
            //block of code
      }
      //Most specific:
      catch (ArgumentNullException e)
      {
            Console.WriteLine(“{0}First exception caught.”, e);
      }
      //Least specific
      catch (Exception e)
      {
            Console.WriteLine(“{0}First exception caught.”, e);
      }




                                                                  50
Windows Phone 7 Guide for Android Application Developers


A Comparison of Important Class Libraries
Strings
C# provides a comprehensive string class, which offers you all the features that you
associate with this class.

Java          C#                                   Notes
Feature

String        String greeting = “Hello WP7!”;
              Int length = greeting.Length;



Comparison    String color = “pink”;               Strings are compared using ==.
              If (color == “red”)                  They are compared
                                                   lexicographically using compare.
              System.Console.WriteLine(“Matchin
              g colors!”);
              string name = “Joe”;
              if (string.compare(name, “Jack”)
              > 0)
                System.Console.WriteLine(name +
              “ comes later”);

Concatenation System.Console.WriteLine             Strings can be concatenated
              (greeting + " You rock!")            with the „+‟ operator. (This is
                                                   called operator overloading.)

Splitting     string rainbow = "Violet, Indigo,
              Blue, Green, Yellow, Orange,
              Red";
              string[] rainbowColors =
              rainbos.Split(',');
              foreach (string color in
              rainbowColors)
                  System.Console.WriteLine
              (color);




                                                                                     51
Windows Phone 7 Guide for Android Application Developers


Arrays
Arrays in C# are almost like arrays in Java.

Java Feature      C#                                       Notes

Arrays of          int[] table;                            Array size is not a part of
primitive types    table = new int[3];                     the array declaration.
such as int, float string[] names = new string[3]
                                                           Arrays are explicitly
                  {"Peter", "Paul", "Mary"};               initialized.

Multi-dim arrays Int[,] mAray;                             C# supports jagged
of primitive types Int[][] jaggedArray;                    arrays, or arrays of
                  string[][] singers = {new string[]
                                                           arrays, and they need not
                  {"Peter", "Paul", "Mary"}, new           be rectangular.
                  string[]{“Paul”,“Art”}};                 Note: Arrays of strings,
                                                           i.e. objects, work the
                                                           same way.

Mutable array of List<string> colors = new                 You can use Lists as a
objects          List<string>; //list of strings           replacement for mutable
                  Colors.Add(“Red”);                       arrays.
                  Colors.Add(“Green”);
                  Colors.Insert(1,”White”);                You may also use
                  String myColor = Colors[0]; //”Red” ArrayLists.
                  Colors[colors.IndexOf(“Red”)] =
                  “Pink”; // replace Red with pink


Dictionaries
C# provides a generic dictionary class that is similar to the HashTable functionality
in Java. The generic dictionary class allows you to add, lookup, and remove objects
from the dictionary. Since the dictionary class uses Generics, it also utilizes strong
typing.




                                                                                      52
Windows Phone 7 Guide for Android Application Developers


Java                 C#                                Notes

                     Dictionary<string, int> d = new   You can use Dictionary as
                     Dictionary<string, int>();        a replacement for
                     d.Add("Honda", 124);              NSMutableDictionary.
                     d.Add("Toyota", 95);
                     d.Add("Ford", 135);


                     // See if Dictionary contains
                     string
                     if (d.ContainsKey("Ford")) //
                     True
                     {
                          int v = d["Ford"];
                          Console.WriteLine(v);
                     }




                                                                             53
Windows Phone 7 Guide for Android Application Developers


The New features of C#
This section covers the following:
      Generics
      Operator Overloading
      Delegates
      Events
      Generics

Generics
Generics introduce the notion of type parameters that make it possible to design
classes that are type safe, even though the actual type is deferred till the object‟s
instantiation. For example, the following code shows how to define a generic stack:


Stack<int> intStack = new Stack<int>();                   // intStack is a stack
of int
intStack.Push(1);                                         // OK
intStack.Push(2);                                         // OK
int number = intStack.Pop();                              // this is a type safe
assignment
Stack<string> strStack = new Stack<string>();             //the type of strStack
is different from type of intStack
strStack.Push("green");                                   // OK
strStack.Push(23);
The Stack<T> uses T as a type parameter, thus allowing you to instantiate a stack
of any type. For example: Stack<int> or Stack<string>. You can use them in a
type safe manner. The use of generics is like generics in Java.




                                                                                   54
Windows Phone 7 Guide for Android Application Developers


Operator Overloading
Operator Overloading allows you to define the implementation of user-defined
operators for user-defined classes. Consider the following example of a complex
number struct. Operator Overloading allows you to define a + operation by using a
natural syntax.


public struct Complex
    {
         public int real;
         public int imaginary;
        // Declare which operator to overload (+), define how it is
computed
         public static Complex operator +(Complex c1, Complex c2)
         {
            return new Complex(c1.real + c2.real, c1.imaginary +
c2.imaginary);
         }
     …
    Complex c1 = new Complex(3.0, 4.0);
    Complex c2 = new Complex(4.0, 5.0);
    Complex cSum = c1 + c2;




                                                                               55
Windows Phone 7 Guide for Android Application Developers


Delegates
The functionality of delegates in C# is like the function pointers in C. In this design
pattern, a class delegates another class even if which is not known at compile time.
using System;
namespace DelegateExample
{
    public class ConsoleLogger
    {
         public static void WriteString(string s)
         {
             Console.WriteLine("Writing to console log: {0}", s);
         }
    }
    public class FileLogger
    {
         public static void LogString(string s)
        {
             Console.WriteLine("Logging to file log: {0}", s);
         }
    }
public class DelegatesTest
    {
         public delegate void StringDelegate(string s);
         public static void Main()
         {
             StringDelegate Writer, Logger;             // define twp
StringDelegate objects
         Writer = new StringDelegate(ConsoleLogger.WriteString); //
Create delegates with appropriate methods
             Logger = new StringDelegate(FileLogger.LogString);
             Writer("Warning message 1\n");             // Send to
Console Writer delegate method
             Logger("Warning message 2\n");             // Send to File
Logger delegate method
             StringDelegate MultiLogger;                // to act as
      the multicast delegate
             MultiLogger = Writer + Logger;             // combine the
two delegates,
             MultiLogger("Warning message 3");          // This should
get sent to both delegates
         }
    }
}
In the above code example, StringDelegate is defined as a function that takes a
string as a parameter and returns void. Writer, logger, and multiLogger are
constructed by passing methods that have the same signature as the
StringDelegate declaration.
Calling Writer invokes the writeString method of ConsoleLogger to print the
message to the console. Calling Logger invokes the logString method of FileLogger

                                                                                     56
Windows Phone 7 Guide for Android Application Developers

to log the message to the file. Delegates achieve indirection while providing type
safety. Delegates may be concatenated as shown by MultiLogger, which logs the
message to both loggers.

Events
Events in C# are useful in the pub-sub (publisher and subscriber) design pattern.
Events are powerful design patterns that are used for asynchronous programming.
An object can publish a set of events that a subscriber can subscribe. When a
publisher raises an event, all subscribers are notified. The publisher raises the
event, but does not know who listens to it. The events are built by using delegates.
using System;
namespace DelegateExample
{
    public class ConsoleLogger
    {
        public void WriteString(string s)
        {
            Console.WriteLine("Writing to console log: {0}", s);
        }
    }
    public class FileLogger
    {
        public void LogString(string s)
        {
            Console.WriteLine("Logging to file log: {0}", s);
        }
    }
    public class DelegatesTest
    {
        public delegate void LogEventHandler(string s);                              //
definition of the delegate.
        public static event LogEventHandler logEvent;                                //
the signature of the event.
        public static void Main()
        {
            ConsoleLogger cl = new ConsoleLogger();                                  //
create the first subscriber
            FileLogger fl = new FileLogger();                                        //
the second subscribe

            logEvent += new LogEventHandler(cl.WriteString);                         //
subscribe the event and hook up the
            logEvent += new LogEventHandler(fl.LogString);                           //
event handlers
            logEvent("A new event");                                                 //
raise event which will invoke handlers
            Console.ReadLine();
        }
    }
}

                                                                                     57
Windows Phone 7 Guide for Android Application Developers


Comparing API Documentation Tools
JDK contains an API documentation generation tool called Javadoc. Javadoc
automatically generates documentation from the comments that are added to the
java source code file.
There are a variety of document generation tools that are available for .NET:
      NDoc
      Sandcastle
      Doxygen
      Doc-O-Matic


NDoc
NDoc is a code documentation generator for Common Language Infrastructure.
NDoc uses pluggable documenters to generate documentation in several formats,
including:
      MSDN style HTML Help format (.chm)
      Visual Studio .NET Help format (HTML Help 2)
      MSDN online style web pages


Using NDoc


To use NDocs to generate documentation, do the following:
   1. Open your Windows Phone 7 project.
   2. Select the class library for which you want to create documentation.
   3. Right-click the class library, and click Properties.




                                                                                58
Windows Phone 7 Guide for Android Application Developers




   4. In the left pane, click Build.




                                                           59
Windows Phone 7 Guide for Android Application Developers

        5. Select the XML documentation file check box.
        6. Enter the file name.

Note: NDoc uses this file for creating documentation.

Build your class library, the documentation file is saved in the Debug or Release
folder depending on your build configuration. You can see the documentation file in
the XML format.
You can use NDoc‟s help to get a fair idea of documenting your class library more
effectively.

Generating Better Documentation
To generate better documentation, follow these tips:
           Write elaborate code comments for your code. Elaborate comments make
            your documentation descriptive.
           Each Public type and the Public and Protected members of the Public types
            should have an item describing the members.
           The VS.NET C# code editor has a feature that makes it easy to create the
            basic code comments for each type and member.
            Consider the following code snippet:
public class MyClass() {
public MyClass(string s ) {}
}




Place your cursor just above the MyClass constructor, and press the '/' character
three times. Visual Studio.NET creates the skeleton of a code comment block for
that member:

public class MyClass() {
///<summary>
///
///</summary>
///<param name=”s”></param>
Public MyClass(string s) {}
    }
You can use this method to any type or member that have code comment tags.
NDoc supports a large number of documentation tags. You can use the tags to
meet your requirements.


                                                                                    60
Windows Phone 7 Guide for Android Application Developers

In a code comment block, when you press the '<' key to start a new tag, Visual
Studio.NET displays an Intellisense selector. This selector shows a list of code
comment tags. This list does not display the additional tags that NDoc supports.
You must add the additional tags manually.


Using the NDoc GUI Utility


To use the NDoc GUI Utility, do the following:
   1. Double-click NDocGui.exe, to start NDocGUI.
   2. Click Project, then click New.
   3. In the section Select and Configure Documenter, select documentation
      type from the Documentation Type list.
   4. Under Select and Configure Documenter, specify the parameters, such
      as Copyright text and Output directory.
Note: The most important settings are in the Visibility section. Here you can
configure the elements that you want to document, such as private variables,
protected variables, and Namespaces without summaries.
   5. Click Add.
   6. In the Add Assembly Filename and XML Documentation Filename
      dialog, select the required EXE or DLL.
      NDoc processes the XML documentation file based on your selection.
After building your project, find the compiled documentation for your class library in
the output directory that is specified in the output message.


NDocs vs. Javadoc

      A Javadoc tool can be run on Windows, Mac OS, Unix, and BSD. However,
       NDoc can run only on Windows.
      A Javadoc tool is for generating documents from java source files. The tool
       therefore accepts text as an input. NDoc accepts only binary files as an
       input.
      A Javadoc tool generates documents in an HTML format by default. You need
       a third-party tool called Doclet to generate an output in other formats, such
       as CHM, RTF, PDF, and postscript. NDoc can generate documents in various
       formats, such as MSDN, Linear HTML, and JavaDoc.


Summary

                                                                                   61
Windows Phone 7 Guide for Android Application Developers

In this chapter, we looked at C# programming from the perspective of a Java
developer. C# is a strongly typed, object-oriented programming language that uses
static binding. Several C# concepts are similar to the Java concepts. The knowledge
of Java and object oriented programming will help you to master C# quickly. We
also looked at NDocs, which is the API documentation tool for Windows Phone 7.


Related Resources

To go deeper into C# and Java, visit:

      http://www.25hoursaday.com/CsharpVsJava.html

To go deeper into NDocs, visit:

      http://ndoc.sourceforge.net/

      http://shfb.codeplex.com/ – Sandcastle Summary




                                                                                62
Windows Phone 7 Guide for Android Application Developers



Chapter 5: A Comparison of
Application Life Cycles in Windows
Phone 7 and Android
The Windows Phone 7 (WP7) execution model improves user experience by cutting
down on response time and offering seamless navigation among applications. To
achieve this, WP7 prioritizes the foreground application and tombstones other open
applications. Android on the other hand, saves all the application states and
displays only the foreground application.
Android suspends an open application when a user starts another application. The
suspended application remains alive in the phone memory. WP7 activates and
deactivates applications dynamically to enable seamless navigation by limiting the
phone to run one application at a time.
The WP7 execution model provides users with a consistent navigation experience
between applications.
In Android, users open applications using the launcher screen. On the launcher
screen, all the applications are listed as icons. In WP7, users navigate forward by
launching applications from the installed Applications List or from a tile on the
Start screen.
In WP7, users can use the Back button on the phone to navigate backwards to a
page in a running application. With this Back button, users can also navigate
through a stack of previously running applications. This WP7 functionality is similar
to Android‟s backward navigation. All Android devices have the Back button on the
phone. A user can navigate to previous screens of applications until he reaches the
home screen of phone.
The Android applications consist of various components, such as Activity, Services,
ContentProvider, and Broadcast receivers. These components are not available in
WP7 except for an Activity which can be mapped to a Page in WP7.


Multitasking in Android and Windows Phone 7
Android supports multitasking and provides seamless navigation between
applications. WP7 achieves seamless navigation using application tombstoning.
Android puts applications in the background using the Service component. The
Service component runs in the background even if your application is not in
foreground until the application‟s task finishes or stopService is called.
The upcoming version of WP7 will support multitasking. The WP7 navigation model
allows natural navigation, similar to a browser‟s Back button. The last accessed


                                                                                      63
Windows Phone 7 Guide for Android Application Developers

application state is preserved as a user navigates across applications using the Back
button on the phone.


Tombstoning of Applications in Windows Phone 7
Tombstoning is a process by which WP7 deactivates an application when a user
navigates away from this application. WP7 keeps a record of the tombstoned
application and stores the latest data accessed by this application. If the user
returns to a tombstoned application, WP7 reactivates this application. The user can
access the reactivated application by using a phone‟s Back button.
Consider the following example. A user is composing a blog with WordPress. He
pressed the Start button to go to the Start screen. WP 7 deactivated the WordPress
application. The user then accessed Facebook. While in Facebook, the user pressed
the Back button. The Start screen appeared. When the user pressed the Back
button again, WordPress appeared exactly in the same way as she had viewed it
the last time.
The following table describes the user events and compares the corresponding
behavior in Android and Windows Phone 7.

User Action or Event         Android Behavior             Windows Phone 7
                                                          Behavior

An incoming phone call or    Running application is       Running application is
SMS                          moved to the background      deactivated
                             but is still in the memory

User presses the Home        Running application is       Running application is
button on the phone          moved to the background,     deactivated
                             current activity will be
                             paused but the application
                             is still in memory

User starts another          Background application is    The upcoming version of
application from the         moved to foreground with     WP7 will support
multitasking menu            the earlier saved state      multitasking

User navigates between       No navigation occurs         Deactivated or
applications using the       when Back button is          tombstoned application is
Back button on the phone     pressed when user is at      activated to the earlier
                             the home screen of the       saved state
                             phone.



Life Cycle of a Windows Phone 7 Application

                                                                                   64
Windows Phone 7 Guide for Android Application Developers

There is no similarity between the Android life-cycle stages with the WP7‟s Page
stage. Activity is the only component that can be mapped with a Page in WP7.
The following events take place during the life cycle of a WP7 application:

Launching
An application is launched when it is started by all other means except when the
user navigates to it using the Back button.
Whenever a user opens an application, WP7 creates a new instance of the
application. In Android, when an application launches a new process a new instance
of Dalvik VM is allocated to the application. The application runs within that
process. Each application runs in its own process and VM instance.
Do not store the state data when the launching event is raised. The launching event
is raised even before application is visible to the user. Storing data at this stage
may increase the startup time of the application.

Running
After launching, the application goes into the running stage. In this stage, the
application manages its own state as the user navigates through the different pages
of the application.
In the running stage, settings and the persisted data are saved. This reduces the
data that you need to save when the application‟s stage changes. However, the
decision to save data in this stage is optional. If the size of the persisted data is not
large, you need not save the data.

Closing
Your application comes across this event when the user presses the Back button on
the phone, when he is in the application‟s first page.
In the handler for this event, you can save data to an isolated storage. This action
is similar to handling the Destroyed() method in Android.
In Android, you cannot close an application after launching. Each activity in the
application can be finished but the application process remains in the memory.

Deactivating
WP7 deactivates your application in the following scenarios:
       A user opens another application
       A user locks the phone screen
       An event accesses the Launcher or Chooser APIs
       A user presses the Windows button to open the Start screen on the phone
       A user presses the Search button on the phone
In the handler for this event, you must save the transient data to the state property
and the persistent data to the isolated storage. This helps maintaining consistent
user experience after the user activates the application again.

                                                                                      65
Windows Phone 7 Guide for Android Application Developers

Android suspends a current application‟s activity when a new application comes to
the foreground.

Activating
WP7 raises this event:
       If a user returns to a deactivated application using the Back button on the
        phone
       If a user returns to a tombstoned application, which was deactivated by
        Launcher or Chooser
This event is similar to resuming an Activity in Android. However, WP7 creates a
new instance of the application when a user starts the application from:
       A phone‟s Applications List
       An application‟s tile on the Start screen
       A toast notification
In the handler for this event, you restore all the transient data of the application.
The transient data restores the application to the state before the application was
deactivated.
You must avoid accessing the isolated storage or network resources in this event
handler. When you access an isolated storage or network resources, an
application's launch time may increase.


Role of Handlers in an Application‟s Life Cycle
In WP7, your applications transition between the active and inactive states. You can
implement handlers for an application‟s life-cycle events to save and restore
application states.
A WP7 application‟s life cycle offers users consistency while working with
applications. The users feel that the application is running in the background when
it is not visible to him.
In Android, you save application state when an activity is paused. You can use the
method onSaveInstanceState to access the event, and use the method
onRestoreInstanceState to restore the event to previous state.




                                                                                        66
Windows Phone 7 Guide for Android Application Developers




Figure: Windows Phone 7 Application Life Cycle




                                                           67
Windows Phone 7 Guide for Android Application Developers


Comparing Life-cycle Methods
As mentioned in the earlier sections, a Page in WP7 is similar to an Activity in
Android. We can compare the Android lifecycle method with WP7‟s state-change
events and Page methods.

 Windows            Windows Phone 7           Windows Phone 7 Android
 Phone 7            Application Events        Page Methods    Methods
 Stage

 Launching          Application_Launching      InitializeComponent() onCreate()

 Running                                                              onStart(),
                                                                      onResume()

 Deactivated        Application_Deactivated    NavigatedFrom          onStop(),
                                                                      onPause()

 Activation         Application_Activated      NavigatedTo            onResume()

 Closing Event      Application_Closing                               onDestroy()

In Android, you can use the onCreate() method to initialize the variables, such as
the view components, the database connection, and a GPS provider. In WP7, you
can use the InitializeComponent() method in the constructor of the Page class to
initialize variables. You also need to get the application_launching event to define
the global variables in InitializeComponent() method.
In Android, if a user launches a new application, the current application activity
calls the onPause and onStop methods. In this scenario, you can commit the
application data to the database. But in WP7, if a user launches a new application,
the current application is deactivated. At the time of deactivation, WP7 calls the
Application_Deactivated function. You need to save the application‟s state-data in
the Application_Deactivated function.
In Android, a user can see the running application on a phone by keeping the Home
button on the phone pressed for some time. The user can also resume a running
application from the running applications list. In this scenario, Android calls the
application activities on the Start and onResume lifecycle methods. With these
methods, you can restore the data from a previous state. In WP7, when a user
starts a tombstoned application, the Application_activated function is called. You
can restore the data from the previous state of the application to this function.
In Android, when one Activity replaces another, the current Activity calls the
onPause and onStop methods. This behavior is similar to the Page to Page
navigation in WP7. In WP7, While moving from one page to another, the current
page raises the NavigatedFrom() event and the new page raises the NavigatedTo()
event.



                                                                                       68
Windows Phone 7 Guide for Android Application Developers


Tombstoning and Windows Phone 7 Life Cycle
Consider a simple example that illustrates the WP7 application life cycle stage
transitions and tombstoning. Here is a single page example application called
Shopping List. In this application, the user can add items to a shopping list. When
the user leaves the application, the shopping list is saved automatically.

Saving the Application State Data
In Android, you can save application state data in a number of different ways. For
example, using SharedPreferences, using files in the internal storage/external
storage, or using SQLLite.
To save the persistent state data of an application on WP7 you can use
IsolatedStorage. IsolatedStorage is a safe storage space that is accessible only to
that application to which the space is allocated. One application cannot affect
another application‟s data. To save the stage data, you need to get the
IsolatedStore for the application. After that, create a file in IsolatedStorage, to save
the persistent state. In our example of the Shopping List application, you can
serialize the list and save it to the file.
public static void SaveShoppingList(ShoppingListInfo shoppingListInfo, string
fileName)
{
     //Get the isolatedStore for this application
     using (IsolatedStorageFile isf =
IsolatedStorageFile.GetUserStoreForApplication())
     {
          // create a new file
          using (IsolatedStorageFileStream fs = isf.CreateFile(fileName))
          {
               //and serialize data and save it
              XmlSerializer xmlSer = new
XmlSerializer(typeof(ShoppingListInfo));
               xmlSer.Serialize(fs, shoppingListInfo);
          }
     }
}


WP7 provides another class called PhoneApplicationService.State to save the
transient stage data.

Terminating Applications


                                                                                     69
Windows Phone 7 Guide for Android Application Developers

When the user uses the back button to leave an open application, WP7 terminates
the application. Depending on the nature of your application, you may need to save
certain data when WP7 terminate your application.
In the example of the Shopping List application, you can save the application data
without confirmation from the user. This ensures that the shopping list is intact,
when the user get opens the application next time. In this example, you are not
saving any item that the user is typing in the Item text box. You can use the
helper method to save the shopping list. Your application can perform such cleanup
and state saving operations in response to the Application_Closing event instead of
OnBackKeyPress.
protected override void OnBackKeyPress(System.ComponentModel.CancelEventArgs
e)
{
     base.OnBackKeyPress(e);
     //do not save what is in the item, i.e. it is transient
     txtItem.Text = "";
     //preserve data in persistent store
     Utils.SaveShoppingList((App.Current.RootVisual as
PhoneApplicationFrame).DataContext as ShoppingListInfo,
                  "ShoppingListInfo.dat");
     }
}



Application Launching
When the user starts an application from the Start screen, the application receives
the Application_Launching event.
During launch, you can examine whether any persistent data is available. In the
Shopping List application, if you find the persistent data, load the data in the txtList
text box to launch the shopping list. You can first get the IsolatedStore for the
application. Using the IsolatedStore, check if the ShoppingListInfo.dat file exists. If
the DAT file is available, you can de-serialize the existing data and reload the
ShoppingListInfo.
You can make the fields in Shopping List application databound using the last line in
this code snippet. Now, if you run the application, you find that the shopping list is
preserved when the application is closed and presented when you launch the
application again.

         // Code to execute when the application is launching (eg, from Start)
         // This code will not execute when the application is reactivated
         private void Application_Launching(object sender, LaunchingEventArgs e)
         {
             //Trace the event for debug purposes
             Utils.Trace("Application Launching");
             //Create new data object variable
             ShoppingListInfo shoppingListInfo = null;
                                                                                     70
Windows Phone 7 Guide for Android Application Developers

            //Try to load previously saved data from IsolatedStorage
            using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForApplication())
            {
                //Check if file exits
                if (isf.FileExists("ShoppingListInfo.dat"))
                {
                    using (IsolatedStorageFileStream fs = isf.OpenFile("ShoppingListInfo.dat",
System.IO.FileMode.Open))
                    {
                        //Read the file contents and try to deserialize it back to data object
                        XmlSerializer ser = new XmlSerializer(typeof(ShoppingListInfo));
                        object obj = ser.Deserialize(fs);

                       //If successfully deserialized, initialize data object variable with it
                       if (null != obj && obj is ShoppingListInfo)
                            shoppingListInfo = obj as ShoppingListInfo;
                       else
                            shoppingListInfo = new ShoppingListInfo();
                   }
               }
               else
                   //If previous data not found, create new instance
                   shoppingListInfo = new ShoppingListInfo();
           }

            //Set data variable (either recovered or new) as a DataContext for all the pages of
the application
            RootFrame.DataContext = shoppingListInfo;
        }




Deactivating Applications
This event occurs when a user press the Start button while running an application.
Android suspends the current application‟s activity whenever a new application
comes to foreground. In WP7, the application receives the Application_Deactivated
event.
                                                                                                 71
Windows Phone 7 Guide for Android Application Developers

In response to this event, you can save the entire application state. In the example
of the Shopping List application, you need to save the shopping list as well as the
text entered in the Item text box.
You can save the transient application state by using the
PhoneApplicationService.State object.


// Code to execute when the application is deactivated (sent to background)
        // This code will not execute when the application is closing
        private void Application_Deactivated(object sender,
DeactivatedEventArgs e)
        {
              //Trace the event for debug purposes
              Utils.Trace("Application Deactivated");


              //Add current data object to Application state

PhoneApplicationService.Current.State.Add("UnsavedShoppingListInfo",
RootFrame.DataContext as ShoppingListInfo);
        }

Activating Applications
If a user returns to a deactivated application using the Back button on the phone,
WP7 raises the Application_Activated event.
In response to this event, you can load the data from the
PhoneApplicationService.State object. If you find the necessary data for launching
the application, you can populate the UI elements using that data. If you do not
find any saved data, keep the UI fields blank.
To test the Shopping List application for this code snippet, press the Home button
to leave the application and navigate back to the application using the Back button.
You will find that both the shopping item in the text box and the shopping list are
preserved.
// Code to execute when the application is activated (brought to foreground)
        // This code will not execute when the application is first launched
      private void Application_Activated(object sender, ActivatedEventArgs e)
        {
            //Trace the event for debug purposes
            Utils.Trace("Application Activated");

              //Create new data object variable
              ShoppingListInfo shoppingListInfo = null;
              //Try to locate previous data in transient state of the
application
            if
(PhoneApplicationService.Current.State.ContainsKey("UnsavedShoppingListInfo")
)
            {
                                                                                     72
Windows Phone 7 Guide for Android Application Developers

                //If found, initialize the data variable and remove in from
application's state
                shoppingListInfo =
PhoneApplicationService.Current.State["UnsavedShoppingListInfo"] as
ShoppingListInfo;


PhoneApplicationService.Current.State.Remove("UnsavedShoppingListInfo");
            }
            //If found set it as a DataContext for all the pages of the
application
            //An application is not guaranteed to be activated after it has
been tombstoned,
            //thus if not found create new data object
            if (null != shoppingListInfo)
                 RootFrame.DataContext = shoppingListInfo;
            else
                 RootFrame.DataContext = new ShoppingListInfo();
        }




                                                                              73
Windows Phone 7 Guide for Android Application Developers


Summary
In this chapter we had a look at the different stages of application life cycle in
Android and Windows Phone 7. We also compared methods for saving application
state data in Android and Windows Phone 7.


Related Resources
To know more about the execution model for Windows Phone 7, visit:
      Execution Model Overview for Windows Phone
      Execution Model Best Practices for Windows Phone
      How to: Preserve and Restore Page State for Windows Phone
      How to: Preserve and Restore Application State for Windows Phone
      Android Application Life-cycle Diagram




                                                                                     74
Windows Phone 7 Guide for Android Application Developers



Chapter 6: Storing Data and
Preferences
Windows Phone 7 (WP7) features a very comprehensive system of managing data
for your application and across all applications on the phone. This section compares
the data handling features of WP7 and Android.


Isolated Storage in Windows Phone 7
With WP7, you can store data in the device file system of your application. This
type of data storage is called IsolatedStorage.
The following diagram shows the folder structure for a storage application:




                                                                                   75
Windows Phone 7 Guide for Android Application Developers

Comparing the Data Storage Methods in Windows Phone 7 and Android

Storage            Windows Phone 7                     Android
Methods

Storage            You can store the application       You can store the application
                   data in IsolatedStorage             data in the phone‟s internal
                                                       storage, which is private to
                                                       your application

                   Windows Phone 7‟s isolated          InternalStorage enables
                   storage model allows the            applications to create and
                   managed applications to             maintain local data.
                   create and maintain the local
                   database.

Security           Windows Phone 7 does not            Neither the user nor other
                   allow the application to make       applications can access the
                   the file system calls outside       data stored in the internal
                   the isolated storage area or        storage. The internal storage
                   outside of the operating            area is private to the
                   system area. This design gives      respective application.
                   a sandbox effect to the
                   application. The advantage of
                   this design is that the
                   application cannot access the
                   data storage area of other
                   applications.

Security           Windows Phone 7 restricts all       Android prevents unauthorized
                   Input and Output (I/O)              data access by restricting I/O
                   operations to isolated storage      operations of internal storage
                   and prevents the I/O                to the same application.
                   operations from accessing the       However, you have an option
                   operating system files. This        to make this data public by
                   Windows Phone 7 feature             writing data to external
                   prevents unauthorized access        storage.
                   and data corruption.

Installation       When you update an                  Android does not delete the
                   application after it is available   application data after
                   in the market, Windows Phone        uninstalling or reinstalling.
                   7 does not modify the isolated      While updating the applications
                   storage folder. You need to         that are already in the market,
                   ensure that the data is             you need to ensure that the
                   migrated or transformed             data is updated to maintain
                   appropriately to work with the      compatibility with the updated
                   new version of the application      version of the application.

                                                                                    76
Windows Phone 7 Guide for Android Application Developers


Uninstallation     When an application is            Android deletes only the
                   uninstalled, Windows Phone 7      internal storage of an
                   deletes the uninstalled,          application when the
                   Windows Phone 7 deletes the       application is uninstalled.
                   data root, the isolated storage
                   folder, and all the data within
                   the store.

Memory Space       Windows Phone 7 does not          The internal storage limit of an
                   restrict applications from        Android application is
                   using the memory space.           dependent on the availability
                   Adequate memory is provided       of memory. Your application
                   to each application depending     must use the memory
                   on the requirement.               carefully.

Settings           Windows Phone 7 allows you        Android allows you to store an
                   to store the settings for the     application‟s settings in the
                   application in the                SharedPreference memory
                   IsolatedStorageSettings area.     space. You can store the
                   You can store key and value       primitive data types in
                   pairs of data in this memory      key/value pairs.
                   space.

To know more about the comparison between the data storage methods, visit:
       IsolatedStorage for Windows Phone
       Windows Phone 7 Series Developer General FAQ




                                                                                   77
Windows Phone 7 Guide for Android Application Developers


Use Cases
Storing the Configuration Settings and Data
Many applications need to store application settings and data, such as user name,
password, and language preference, and last login time stamp. The nature of such
data depends on the nature of the application.
In Android, you can store such application settings and data by using the
SharedPreferences class. The SharedPreferences class stores the key value pair of
primitive data types. In WP7, you can save this data by using the
IsolatedStorageSettings.ApplicationSettings property.
IsolatedStorage stores objects by using the
IsolatedStorageSettings.ApplicationSettings property. This is the most convenient
way to store simple data. You just need to add your data to the Settings store by
using the following code:
IsolatedStorageSettings.ApplicationSettings.Add(“some_property”, value);
IsolatedStorageSettings.ApplicationSettings.Save();
The value object is serialized automatically to a disk when you call the Save()
method. You can read back data by using the following code:


List<string> mydata =
(List<string>)IsolatedStorageSettings.ApplicationSettings["some_property"];



Serializing Objects to XML
You may need to serialize an entire object to the file system to save the state of
object or to save the memory. In Java, you can serialize objects by using
ObjectOutputStream. In WP7, you can serialize objects by using the StreamWriter
class.
You can store objects as XML by using the following code. This code serializes a list
of strings to the xml format and saves this format in IsolatedStorage:




                                                                                   78
Windows Phone 7 Guide for Android Application Developers

using(IsolatedStorageFile storage =
IsolatedStorageFile.GetUserStoreForApplication()){
   using(IsolatedStorageFileStream fs = storage.CreateFile(“myfile.wp”)){
       using(StreamWriter writer = new StreamWriter(fs)){
          XmlSerializer serializer = new XmlSerializer(typeof(List<string>));
          serializer.Serialize(writer, myStringList);
       }
    }
}


After storing the data in the XML format, you can use LINQ to XML to utilize the
data later. You can use this method to store any structured data on a disk.
Note: For details about LINQ to XML, see Chapter 8.
To read back the file, use the following code:
using(IsolatedStorageFile storage =
IsolatedStorageFile.GetUserStoreForApplication()){
   using(IsolatedStorageFileStream fs = storage.OpenFile(“myfile.wp”,
FileMode.Open)){
      XDocument doc = XDocument.Load(fs);
      XmlSerializer serializer = new XmlSerializer(typeof(List<string>));
      List<string> myData =
(List<string>)serializer.Deserialize(doc.CreateReader());
   }
}



Managing the IsolatedStorage Space
The Windows Phone 7 applications do not have an imposed quota size because the
requirements for each application‟s scenario are different. Also, limiting the disk
size on a per application basis can increase the response time and dilute user
experience. Therefore, ensure that your application stores only the necessary data
for a subsequent launching of the application.
The storage space in mobile phones is limited. Windows Phone 7 displays a
notification to the user when only 10% of the storage-space remains. The user
needs to delete the existing data to create the necessary storage space. From a
user‟s point of view, this is not a favorable option.

The Best Practices for Managing the IsolatedStorage Space
The following best practices help you to efficiently manage the data storage-space
in Windows Phone 7:

Temporary data and files
If your application stores any temporary data in IsolatedStorage, delete the
temporary data if the data is no longer required. For example, delete the earlier
version of the data when the updated version is available. You can implement
periodic deletion of data by creating a temporary cache folder for the data and by
clearing the cache from time to time.
                                                                                     79
Windows Phone 7 Guide for Android Application Developers


User generated data
The user generated data can be in the form of photos from the camera, or notes
and documents.
      If your application allows a user to create data, offer the user the delete
       option. For example, users should be able to take photos and delete those
       that they do not want.
      Increase the performance of an application by reducing the application‟s
       footprint. You can use techniques, such as:
          o Synchronizing or archiving data to the cloud
          o Keeping only the relevant data

Application Data
Examples of application data include:
      A list of stores or shops that are managed by a shopping list application
      Words in a dictionary
Note: If your application takes data from the cloud and stores it locally, recycle the
data based on your priorities.


Why Windows Phone 7 Does Not Use External Storage
You can save files to a shared external storage in an Android compatible device.
The shared external storage can also include the internal non-removable storage.
Android allows you to access and modify the files that are saved to the external
storage by connecting to a computer. In this type of connection, the files might get
deleted or corrupted if the connection gets disconnected during the data transfer.
You cannot make the file system calls outside the WP7 application‟s own external
space. This provides the application with a safe-sandbox, and prevents the other
applications from inadvertently affecting the application's data.

Library Recommendation for Supporting SQLite in Windows Phone
7
Android features SQLite version 3.4.0. Android also provides the API for managing
the SQLite database. This API provides the methods to create, delete, run SQL
commands, and perform the other common database management tasks. An
Android application can create a database to store and manage the structured data
on phone. The application can also share the same database with other applications
by using a ContentProvider.
WP7 does not feature SQLite. You can use a third-party library to get that
functionality in WP7.
To know more about incorporating SQLite in WP7, visit:
      http://sqlitewindowsphone.codeplex.com/
      http://wp7sqlite.codeplex.com/
                                                                                     80
Windows Phone 7 Guide for Android Application Developers


Managing Content across Applications
In Android, ContentProviders store and retrieve data and make the data accessible
to all applications. In Android, you can share data only through ContentProviders.
However, Android does not provide a common data storage area that all Android
applications can access.
Android provides you two ways to make the application data public by using
ContentProviders:
       You can create your own ContentProvider. This is the ContentProvider
        subclass.
       You can add the data to an existing provider. For this, you need a
        ContentProvider that controls similar data and the permission to write to it.
To know more about ContentProviders, visit:
http://developer.android.com/guide/topics/providers/content-providers.html
The WP7 execution model isolates every application in its own sandbox for both
running the application and for storing data. Applications cannot access information
from the common information stores, such as the contacts list. Applications also
cannot directly invoke other applications, such as the phone or messaging
applications. To enable applications to perform these common tasks, WP7 offers a
set of APIs called Launchers and Choosers. They allow applications to indirectly
access the various features of a phone.

Launchers and Choosers
The Launcher and Chooser APIs call the distinct built-in applications that replace
the currently running application.
Android has functionality similar to Launchers and Choosers. In Android, you use
the Intent filter and the Intent API to launch any built-in or installed applications to
return the data you need or to perform a task.
To know more about the Intent filters, visit:
       http://developer.android.com/guide/topics/intents/intents-filters.html

Launchers
A Launcher is an API that starts built-in applications in WP7. Your application can
complete the tasks through these built-in applications for which no data is returned
back to your application. Let‟s take the example of PhoneCallTask. Your application
can provide the PhoneCallTask Launcher with a phone number and display a name
to access the phone. When the phone displays the built-in application, the user can
choose whether to initiate the call by using the supplied parameters. When the user
closes the built-in application, your application is activated again. But the built-in
application does not return any data that result from the user‟s actions.




                                                                                      81
Windows Phone 7 Guide for Android Application Developers

Choosers
A Chooser is an API that launches the built-in applications in WP7. Your application
can complete various tasks by using these built-in applications for which your
application needs data in return.
For example, consider the PhotoChooserTask. Your application can use the
PhotoChooserTask Chooser to show the built-in Photo Chooser application. The user
can either select a photo or close the Photo Chooser. Now, WP7 activates your
application and supplies the result of the Chooser. The result indicates whether the
user completes the task. If the user completes the task, the result includes an I/O
stream that contains the image data of the photo.
After the Photo Chooser application is launched, the user can press the Start button
on the phone and select another application. In this case, WP7 does not reactivate
your application and does not return the results generated by Chooser. Your
application should handle this ambiguity properly.


Comparing Intent API with Launchers and Choosers API
This table compares the Intent API of Android with Launchers and Choosers APIs of
WP7. This section compares the mechanism of handling cross application data and
performing tasks based on data I/O in WP7 and Android platforms.

Function       Android                                Windows Phone 7

Camera         Intent intent = new                    CameraCaptureTask
               Intent("android.media.action.
               IMAGE_CAPTURE");
               startActivityForResult(intent,         cameraCaptureTask = new
               0);                                    CameraCaptureTask();

                                                      cameraCaptureTask.Completed
                                                      += new
                                                      EventHandler<PhotoResult>
                                                      (cameraCaptureTask_Complete
                                                      d);
                                                         cameraCaptureTask.Show();



Email          Intent emailIntent = new               EmailAddressChooserTask,
chooser and    Intent(android.content.Intent.ACT
                                                      EmailComposeTask,
               ION_SEND);
composer                                              EmailResult,
                                                      SaveEmailAddressTask
               emailIntent
               .setType("plain/text");
                                                      EmailComposeTask
               emailIntent
                                                      emailComposeTask = new
               .putExtra(android.content.Intent.
                                                      EmailComposeTask();
               EXTRA_EMAIL, new
               String[]{"webmaster@website.com"}      emailComposeTask.To =

                                                                                  82
Windows Phone 7 Guide for Android Application Developers


Function       Android                             Windows Phone 7
               );                                  "user@example.com";
               emailIntent                         emailComposeTask.Body =
               .putExtra(android.content.Intent.   "Email message body";
               EXTRA_SUBJECT, mySubject);
                                                   emailComposeTask.Cc =
               emailIntent                         "user2@example.com";
               .putExtra(android.content.Intent.
                                                   emailComposeTask.Subject =
               EXTRA_TEXT, myBodyText);
                                                   "Email subject";
               startActivity(emailintent);
                                                   emailComposeTask.Show();




Market         Intent market_intent = new Intent   MarketplaceHubTask,
                                                   MarketplaceDetailTask,
               (Intent.ACTION_VIEW,
                                                   MarketplaceReviewTask,
               Uri.parse("market://search?
               q=pname:com.google.somepackage")    MarketplaceSearchTask
               )
               startActivity(market_intet);        MarketplaceSearchTask
                                                   marketplaceSearchTask = new
                                                   MarketplaceSearchTask();
                                                   marketplaceSearchTask.
                                                   SearchTerms =
                                                   "accelerometer xna";
                                                   marketplaceSearchTask.Show(
                                                   );



Media player   Intent i = new                      MediaPlayerLauncher
               Intent(Intent.ACTION_VIEW);
               Uri u = Uri.parse(xpath);
               i.setData(u);                       MediaPlayerLauncher
               startActivity(i);                   mediaPlayerLauncher = new
                                                   MediaPlayerLauncher();
                                                   mediaPlayerLauncher.Media =
                                                   new Uri("MyVideo.wmv",
                                                   UriKind.Relative);
                                                   mediaPlayerLauncher.Location
                                                   = MediaLocationType.Data;
                                                   mediaPlayerLauncher.Controls
                                                   =
                                                   MediaPlaybackControls.Pause
                                                   |
                                                   MediaPlaybackControls.Stop;
                                                   mediaPlayerLauncher.Show();

Phone call     String url = "tel:3334444";         PhoneCallTask
               Intent call_intent = new Intent

                                                                               83
Windows Phone 7 Guide for Android Application Developers


Function       Android                             Windows Phone 7
               (Intent.ACTION_CALL,
               Uri.parse(url));
                                                   PhoneCallTask phoneCallTask
               startActivity(call_intent);         = new PhoneCallTask();

                                                   phoneCallTask.PhoneNumber =
                                                   number;

                                                   phoneCallTask.DisplayName =
                                                   name;
                                                       phoneCallTask.Show();




Address book   In Android you can access           PhoneNumberChooserTask,
               anything that is stored in the      PhoneNumberResult,
               address book. For example, name,
                                                   SavePhoneNumberTask
               address, and number.

                                                   phoneNumberChooserTask = new
               Intent intent = new
                                                   PhoneNumberChooserTask();
               Intent(Intent.ACTION_PICK,
               People.CONTENT_URI);                        phoneNumberChooser
                                                   Task.Completed += new
               startActivityForResult(intent,
                                                   EventHandler<PhoneNumberResu
               1);
                                                   lt>
                                                   (phoneNumberChooserTask_Comp
                                                   leted);
                                                   phoneNumberChooserTask
                                                   .show();

Photo          Intent i = new                      PhotoChooserTask,
chooser        Intent(Intent.ACTION_GET_CONTENT)
                                                   PhotoResult
               ;
                         i.setType("image/*");
                                                   photoChooserTask = new
                                                   PhotoChooserTask();
               startActivityForResult(i,4);

                                                   photoChooserTask.Completed
                                                   += new
                                                   EventHandler<PhotoResult>
                                                   (photoChooserTask_Completed)
                                                   ;


                                                   photoChooserTask.Show();



Web search     Intent search = new                 SearchTask
               Intent(Intent.ACTION_WEB_SEARCH);
               search.putExtra(SearchManager.QUE
                                                   Task searchTask = new
                                                                              84
Windows Phone 7 Guide for Android Application Developers


Function       Android                                 Windows Phone 7
               RY, "android");                         SearchTask();
                                                       searchTask.SearchQuery =
               startActivity(search);
                                                       txtInput.Text;
                                                       searchTask.Show();}



SMS            Intent sendIntent = new                 SmsComposeTask
               Intent(Intent.ACTION_VIEW);
               sendIntent.putExtra("sms_body",
                                                       SmsMessage SMSComposer = new
               "The SMS text");
                                                       SmsMessage("123456789","This
               sendIntent.setType("vnd.android-        is a sample sms");
               dir/mms-sms");                          MessagingApplication.
                                                       DisplayComposeForm(SMSCompos
               startActivity(sendIntent);
                                                       er);



Web browser    Intent myIntent = new                   WebBrowserTask
chooser        Intent(Intent.VIEW_ACTION,
               Uri.parse("http://www.google.com"
               ));                                     WebBrowserTask wb= new
                                                       WebBrowserTask();
               startActivity(i);
                                                       wb.URL =
                                                       "http://www.google.com";
                                                       wb.Show();




Summary
In this chapter we compared data storage guidelines for Windows Phone 7 and
Android. We also looked at the storage APIs in Windows Phone 7 and Android.


Related Resources
To learn more about the topics covered in this blog, visit:
      Launchers and Choosers Overview for Windows Phone
      Launchers and Choosers




                                                                                  85
Windows Phone 7 Guide for Android Application Developers



Chapter 7: XML Parsing in Windows
Phone 7 and Android
This chapter discusses the XML parsing methods in Windows Phone 7 (WP7) and
compares them with the parsing methods in Android.


XML Parsing in Windows Phone 7
In WP7, you can parse XML in two ways:
      Using XMLReader
      Using LINQ to XML
SAXParser and DOMParser are not available in WP7. However, the XMLReader and
LINQ to XML parsers function in the same way as these Android parsers.
XMLReader is a fast, forward-only, and a non-caching parser. In Android, you use
the SAXParser API when you want a fast parser and want to minimize the memory
footprint of your application. XMLReader is very similar to SAXParser.
LINQ to XML is an in-memory XML programming interface that enables you to edit
XML documents. LINQ to XML is similar to DOMParser that you use in Java. DOM
parser loads the entire XML document to memory and allows you to use the DOM
APIs to retrieve the data that you want.
You can use XMLReader to read very large XML documents. Loading large
documents to an in-memory tree uses a lot of memory and slows down
performance. You can use LINQ to XML for parsing smaller XML documents.


XML Namespaces for Windows Phone 7
In WP7, the following namespaces are available for XML processing:
      System.xml: Provides a standards-based support for processing XML
      System.xml.Schema: Contains the XML classes that provide a standards-
       based support for XML Schema Definition (XSD)
      System.xml.Linq: Contains the classes for LINQ to XML
      System.xml.Serialization: Contains the classes that are used to serialize
       objects in XML documents or streams


XML Parsing Using XMLReader
XMLReader provides a forward-only and read-only access to a stream of XML data.
XMLReader is similar to SAXParser. SAXParser parse XML node by node and

                                                                               86
Windows Phone 7 Guide for Android Application Developers

traverse a tree view from top to bottom. Here is a sample code that queries the
XML data stream to determine the current node type. This sample code uses
XMLWriter to generate output the XMLReader content.

StringBuilder output = new StringBuilder();

String xmlString =
        @"<?xml version='1.0'?>
        <!-- This is a sample XML document -->
        <Items>
          <Item>test with a child element <more/> stuff</Item>
        </Items>";
// Create an XmlReader , this is similar to creating SAXParser instance from
SAXParserFactory in Android
using (XmlReader reader = XmlReader.Create(new StringReader(xmlString)))
{
    XmlWriterSettings ws = new XmlWriterSettings();
    ws.Indent = true;


 using (XmlWriter writer = XmlWriter.Create(output, ws))
    {
        // Parse the file and display each of the node. In Android, following
iteration is done in handler implementation while using SAXParser
        while (reader.Read())
        {
            switch (reader.NodeType)
            {
                case XmlNodeType.Element: // This is similar to startElement() method
of handler in Android
                    writer.WriteStartElement(reader.Name);
                    break;
                case XmlNodeType.Text:
                    writer.WriteString(reader.Value);
                    break;
                case XmlNodeType.XmlDeclaration:
                case XmlNodeType.ProcessingInstruction:
                    writer.WriteProcessingInstruction(reader.Name, reader.Value);
                    break;
                case XmlNodeType.Comment:
                    writer.WriteComment(reader.Value);
                    break;
                case XmlNodeType.EndElement: // This is similar to endElement()
method of handler in Android

                    writer.WriteFullEndElement();
                    break;
            }
        }

    }
}



                                                                                  87
Windows Phone 7 Guide for Android Application Developers


SaxParser and XMLReader
This table shows a comparison of SAXParser and XMLReader:

SaxParser                                  XMLReader

XML data is parsed node by node            XML data is parsed node by node

XML data is not stored in the memory       XML data is not stored in the memory
node                                       node

Parsing occurs in the read-only node and   Parsing occurs in the read-only node and
the nodes cannot be inserted or deleted    the nodes cannot be inserted or deleted

Do a top to bottom traversal               Do a forward-only traversal


XML Parsing using LINQ to XML
LINQ to XML provides a versatile in-memory XML programming API. With LINQ to
XML in WP7, you can perform all the operations that you come across while reading
and manipulating XML data. LINQ to XML helps you to:
      Load the XML data into phone memory in a variety of ways, such as from a
       file or from XMLReader
      Create an XML tree from scratch
      Insert the new XML elements into an in-memory XML tree
      Delete XML elements from an in-memory XML tree
      Save XML to outputs, such as a file or XmlWriter
LINQ to XML is similar to DOMParser. However, unlike DOM, LINQ to XML provides
a new object-model that is less resource consuming and is easier to work with.
In WP7, an application‟s memory-usage, including the UI components and images,
cannot exceed 90 MB of the application's memory. Since XML parsing is resource
consuming, you need to consider your application's memory-usage while using the
LINQ to XML API. As parsing XML can be resource consuming, use memory carefully
while using the LINQ to XML API.
Note: A device whose memory exceeds 256 MB is exempted from the memory-
usage restriction. You need to include the UI components, images and any other
content that are in memory, within that 90MB limit.

LINQ to XML Class Hierarchy




                                                                                  88
Windows Phone 7 Guide for Android Application Developers




      Although XElement is at a lower level in the class hierarchy, it is the
       fundamental class in LINQ to XML. XML trees are made up of XElements.
       XAttributes are name or value pairs that are associated with an XElement.
       XDocuments are created only in certain scenarios, such as to hold a DTD or
       a top level XML processing instruction (XProcessingInstruction). All the other
       XNodes can be the leaf nodes under an XElement or Xdocument, if they
       exist at the root level.
      XAttribute and XNode are derived from the common base class XObject.
       XAttributes are not XNodes because the XML attributes are really the name-
       value pairs that are associated with an XML element and not with nodes in
       the XML tree. This behavior of XAttribute is in contrast with W3C DOM.
      XText and XCData are available in the present version of LINQ to XML.
       However, it is best to think of them as a semi-hidden implementation except
       when exposing text nodes is necessary. You can retrieve the value of the
       text within an element or attribute as a simple value, such as a string.
      XContainer is the only XNode that can have child elements. The child
       elements can be an XDocument or XElement. The only XNode that can have
       children is an XContainer. The child elements are either an XDocument or
       XElement. An XDocument can contain an XElement (the root element), an
       XDeclaration, an XDocumentType, or an XProcessingInstruction. An
       XElement can contain another XElement, an XComment, an
       XProcessingInstruction, or text. You can parse the text that is contained in
       an XElement in a variety of formats. However, you need to represent the
       text as an XML tree.
Like the Document Class in Android, the XDocument Class in WP7 represents an in-
memory XML document. See the sample code below. This sample code creates a
document, and then adds a comment and an element to the document. The sample
code also creates another document using the results of a query. The XElement
class, used in the sample code, is similar to Element class in Android.

                                                                                  89
Windows Phone 7 Guide for Android Application Developers



StringBuilder output = new StringBuilder();
XDocument srcTree = new XDocument(
     new XComment("This is a comment"),
     new XElement("Root",
         new XElement("Child1", "data1"),
         new XElement("Child2", "data2"),
         new XElement("Child3", "data3"),
         new XElement("Child2", "data4"),
         new XElement("Info5", "info5"),
         new XElement("Info6", "info6"),
         new XElement("Info7", "info7"),
         new XElement("Info8", "info8")
     )
);
XDocument doc = new XDocument(
     new XComment("This is a comment"),
     new XElement("Root",
         from el in srcTree.Element("Root").Elements()
         where ((string)el).StartsWith("data")
         select el
     )
); // In Android to parse the XML tags using DOM, equivalent code is
root.getElementsByTagName(ITEM);
output.Append(doc + Environment.NewLine);
OutputTextBlock.Text = output.ToString();


With DOMParser in Android, you write a series of statements to create an XML
document. In WP7, the coding constructs offer you flexibility and help in creating a
well-structured code more easily.
In Android, you use DOMParser to build an XML tree from the bottom-up. With
DOMParser, you create a document and elements, and then add the elements to
the document. In addition to supporting this approach for constructing an XML tree,
LINQ to XML also supports functional construction. Functional construction uses the
XElement and XAttribute constructors to build an XML tree. For example, consider
the following XML Data:




                                                                                  90
Windows Phone 7 Guide for Android Application Developers

<contacts>
<contact>
      <name>Patrick Hines</name>
      <phone type="home">206-555-0144</phone>
      <phone type="work">425-555-0145</phone>
      <address>
          <street1>123 Main St</street1>
          <city>Mercer Island</city>
          <state>WA</state>
          <postal>68042</postal>
      </address>
      <netWorth>10</netWorth>
   </contact>
   <contact>
      <name>Gretchen Rivas</name>
      <phone type="mobile">206-555-0163</phone>
      <address>
          <street1>123 Main St</street1>
          <city>Mercer Island</city>
          <state>WA</state>
          <postal>68042</postal>
      </address>
      <netWorth>11</netWorth>
   </contact>
   <contact>
      <name>Scott MacDonald</name>
      <phone type="home">925-555-0134</phone>
      <phone type="mobile">425-555-0177</phone>
      <address>
          <street1>345 Stewart St</street1>
          <city>Chatsworth</city>
          <state>CA</state>
          <postal>91746</postal>
      </address>
      <netWorth>500000</netWorth>
   </contact>
</contacts>
The following example constructs an XML tree by using LINQ to XML functional
construction:


XElement contacts =
    new XElement("Contacts",
        new XElement("Contact",
            new XElement("Name", "Patrick Hines"),
            new XElement("Phone", "206-555-0144",
                new XAttribute("Type", "Home")),
            new XElement("phone", "425-555-0145",
                new XAttribute("Type", "Work")),
            new XElement("Address",
                new XElement("Street1", "123 Main St"),

                                                                               91
Windows Phone 7 Guide for Android Application Developers

                   new XElement("City", "Mercer Island"),
                   new XElement("State", "WA"),
                   new XElement("Postal", "68042")
              )
          )
    );
After you indent the code, the XElement constructors resemble the structure of the
underlying XML. The XElement constructor enables functional construction that
takes a params object. This is an example code snippet:
public XElement(XName name, params object[] contents)




The Contents parameter is flexible and supports an object that is a child of an
XElement. The parameters can be:
        A string that is added as the text content. This is the recommended way to
         add a string as the value of an element. The LINQ to XML implementation
         creates the internal XText node.
        An XText, which can have either a string or a CData value added as child
         content. This parameter is useful for CData values since using a string is
         easy for ordinary string values.
        An XElement that is added as a child element
        An XAttribute that is added as an attribute
        An XProcessingInstruction or XComment, which is added as child content
        An IEnumerable, which is enumerated and these rules are applied
         recursively
        Anything to which the ToString() method is called and the result is added as
         the text content.
        A Null parameter, which is ignored.
In this example below, a string Patrick Hines is passed in the name XElement
constructor.
<contacts>
   <contact>
      <name>Patrick Hines</name>
      <phone type="home">206-555-0144</phone>
      <phone type="work">425-555-0145</phone>
      <address>
         <street1>123 Main St</street1>
         <city>Mercer Island</city>
         <state>WA</state>
         <postal>68042</postal>
      </address>
      <netWorth>10</netWorth>
   </contact>
   <contact>
      <name>Gretchen Rivas</name>
      <phone type="mobile">206-555-0163</phone>
      <address>
                                                                                   92
Windows Phone 7 Guide for Android Application Developers

         <street1>123 Main St</street1>
         <city>Mercer Island</city>
         <state>WA</state>
         <postal>68042</postal>
      </address>
      <netWorth>11</netWorth>
   </contact>
   <contact>
      <name>Scott MacDonald</name>
      <phone type="home">925-555-0134</phone>
      <phone type="mobile">425-555-0177</phone>
      <address>
         <street1>345 Stewart St</street1>
         <city>Chatsworth</city>
         <state>CA</state>
         <postal>91746</postal>
      </address>
      <netWorth>500000</netWorth>
   </contact>
</contacts>


Now, see the following scenario:
       This string Patrick Hines can also be a variable. For example, new XElement
        ("name", custName)

       This string Patrick Hines can also be a different type besides a string. For
        example, a new XElement("quantity", 55). This data is the result of the
        following function call:

{
...
   XElement qty = new XElement("quantity", GetQuantity());
...
}
public int GetQuantity() { return 55; }


       This string can also be an IEnumerable<XElement>. A common scenario is
        to use a query within a constructor to create the inner XML. The following
        code snippet reads contacts from an array of Person objects in a new XML
        element Contacts.
class Person
         {
               public string Name;
               public string[] PhoneNumbers;
         }
         var persons = new[] {
   new Person {
        Name = "Patrick Hines",

                                                                                       93
Windows Phone 7 Guide for Android Application Developers

           PhoneNumbers = new[] { "206-555-0144", "425-555-0145" }
      },
      new Person {
           Name = "Gretchen Rivas",
           PhoneNumbers = new[] { "206-555-0163" }
      }
};
              XElement contacts =
                 new XElement("contacts",
                      from p in persons
                      select new XElement("contact",
                          new XElement("name", p.Name),
                          from ph in p.PhoneNumbers
                          select new XElement("phone", ph)
                      )
                 );


The output of the code snippet is as follows:
<contacts>
     <contact>
          <name>Patrick Hines</name>
          <phone>206-555-0144</phone>
          <phone>425-555-0145</phone>
     </contact>
     <contact>
          <name>Gretchen Rivas</name>
          <phone>206-555-0163</phone>
     </contact>
</contacts>


Notice how the repeating phone element is generated by queries that return an
IEnumerable for:
           The inner body of the XML
           The repeating Contact element
            Each contact
You can use the functional construction to design your output document. You can
either create the subtree of XML items inline, or call out to functions to do the work.


                                                                                    94
Windows Phone 7 Guide for Android Application Developers


TRAVERSING XML
This section discusses the traditional approaches for navigating through an XML
tree. When XML is available in the in-memory, you usually have to navigate to the
required XML elements. Language-Integrated Query provides powerful options for
performing this task.

Getting the Children of an XML Element
LINQ to XML offers ways to access the child elements of an XElement. To access all
the child elements of an XElement or XDocument, you can use the Nodes() method.
This returns the IEnumerable<object> because you cannot have text along with the
other LINQ to XML types. For example, you need to load the following XML in an
XElement called contact:
<contact>
    Met in 2005.
    <name>Patrick Hines</name>
    <phone>206-555-0144</phone>
    <phone>425-555-0145</phone>
    <!--Avoid whenever possible-->
</contact>


Using the Nodes() methods, you can access all the child elements and generate the
output by using this code fragment:
foreach (c in contact.Nodes()) {
//Output the results
}


This is the output:
Met in 2005.
<name>Patrick Hines</name>
<phone>206-555-0144</phone>
<phone>425-555-0145</phone>


For a more specific output, query for the content nodes of an XElement of a
particular type. For example, consider accessing the XElement child elements only
for contact XElement. In this case, you can specify a parameterized type:


foreach (c in contact.Nodes().OfType<XElement>())




                                                                                95
Windows Phone 7 Guide for Android Application Developers

In the output, you will view only the child element:


<name>Patrick Hines</name>
<phone>206-555-0144</phone>
<phone>425-555-0145</phone>




To get all of the child elements of Contact, use this code:


foreach (x in contact.Elements())


In the output, you will view only the XElement children:


<name>Patrick Hines</name>
<phone>206-555-0144</phone>
<phone>425-555-0145</phone>


To get all the XElements with a specific name, use the Elements(XName) overload
that uses an XName as a parameter. For example, to view only the phone
XElements, use the following code:


foreach (x in contact.Elements("phone"))


In the output, you will view the entire phone XElements:


<phone>206-555-0144</phone>
<phone>425-555-0145</phone>



Querying XML using LINQ to XML
This section describes how to use Language-Integrated Query with XML. The use of
Language-Integrated Query in LINQ to XML distinguishes LINQ to XML from other
in-memory XML programming APIs.
Language-Integrated Query provides a consistent query experience across the
different data models. Language-Integrated Query also provides the ability to mix
and match data models within a single query. Here are a few examples of using
Language-Integrated Query across data models.
Standard query operators form a complete query language for IEnumerable<T>.
The standard query operators show up as extension methods on any object that
                                                                                96
Windows Phone 7 Guide for Android Application Developers

implements IEnumerable<T>. You can use Standard query operators like any other
method.
This approach of calling query methods directly is called Explicit Dot Notation. Apart
from the query operators, there are query expressions for five common query
operators:
      Where
      Select
      SelectMany
      OrderBy
      GroupBy
The LINQ to XML integration with Language-Integrated Query is apparent in three
ways:
      Leveraging Standard query operators
      Using XML Query extensions
      Using XML Transformation
Leveraging Standard query operators is common with any Language-Integrated
Query enabled data access technology and contributes to a consistent query
experience. Using XML Query extensions and Transformation, provide XML-specific
query and transform features.

Using Query Expressions with XML
This section shows a few examples of using the query expressions with LINQ to
XML. Consider the following XML:
<contacts>
 <contact>
      <name>Patrick Hines</name>
      <phone type="home">206-555-0144</phone>
      <phone type="work">425-555-0145</phone>
      <address>
         <street1>123 Main St</street1>
         <city>Mercer Island</city>
         <state>WA</state>
         <postal>68042</postal>
      </address>
      <netWorth>10</netWorth>
   </contact>
   <contact>
      <name>Gretchen Rivas</name>
      <phone type="mobile">206-555-0163</phone>
      <address>
         <street1>123 Main St</street1>
         <city>Mercer Island</city>
         <state>WA</state>
         <postal>68042</postal>
      </address>
      <netWorth>11</netWorth>
   </contact>
   <contact>
      <name>Scott MacDonald</name>

                                                                                   97
Windows Phone 7 Guide for Android Application Developers

      <phone type="home">925-555-0134</phone>
      <phone type="mobile">425-555-0177</phone>
      <address>
         <street1>345 Stewart St</street1>
         <city>Chatsworth</city>
         <state>CA</state>
         <postal>91746</postal>
      </address>
      <netWorth>500000</netWorth>
   </contact>
</contacts>


The following query retrieves all contacts from location Washington and sorts the
contacts by name. The data is returned as string and is displayed in the
IEnumerable<string> format.


from      c in contacts.Elements("contact")
where     (string) c.Element("address").Element("state") == "WA"
orderby   (string) c.Element("name")
select    (string) c.Element("name");


This query retrieves all the contacts from Washington that have an area code 206.
The result of this query is IEnumerable<XElement>.

from    c in contacts.Elements("contact"),
        ph in c.Elements("phone")
where   (string) c.Element("address").Element("state") == "WA" &&
         ph.Value.StartsWith("206")
orderby (string) c.Element("name")
select c;


In the following example, contacts that have a networth that is greater than the
average networth are retrieved.


from c in contacts.Elements("contact"),
        average = contacts.Elements("contact").
                           Average(x => (int) x.Element("netWorth"))
where (int) c.Element("netWorth") > average
select c;




                                                                                    98
Windows Phone 7 Guide for Android Application Developers


Summary
In this chapter we looked at XML parsing in Windows Phone 7. We also compared
XML parsing in Android and Windows Phone 7.


Related Resources
      To know more about XML Data and Silverlight, visit:
   http://msdn.microsoft.com/en-us/library/cc188996(v=vs.95).aspx
      To know more about LINQ to XML for Windows Phone 7, visit:
   http://msdn.microsoft.com/en-us/library/system.xml.linq(v=VS.95).aspx
      To know more about processing XML Data with LINQ to XML (Silverlight):
   http://msdn.microsoft.com/en-us/library/cc189074(v=VS.95).aspx




                                                                                99

				
DOCUMENT INFO
Shared By:
Stats:
views:159
posted:7/7/2011
language:English
pages:99