some words from technology briefcase

 MobileSchool is now ready for you… and the Italian Developer can improve their knowledge through it!
Now the subscriptions are open!
Subscribe yourself to one of the stages of the Mobile Revolution; the tour starts in October from Palermo (Sicily) and get to Milan in various stages to disseminate the mobile knowledge.
You can learn more from the website that speaks about it, such as RabenBlog (visible at: http://rabenblog.eraben.com/w/index.php/difficolta/saputello/sviluppare-applicazioni-android-con-mobileschool/) that wrote a beautiful post about Francesco Lo Truglio and his role in the MobileSchool!
and now, what do you want to do? Do you want to stand outside and watch this revolution? Join it!
http://www.mobileschool.it

Hey guys!

Have you an idea for a mobile app? or do you want to learn how to make a mobile app?
Join the challenge and explore the mobileschool contest, the first traveling mobile school!

Hello to everybody,

after more than a two year on Android platform, we have a new powerful framework to develop tablet based application.
Android HoneyComb! what is ? i cannot spend a lot of words on this but you can read the specs on another post of mine (honeycomb), because in this post i want describe the most important news, needed to have a first approach to this developing environment!
The language and the tools are the same (eclipse, java …and so on!) but the approach need to be different, in honeycomb we have the “Fragment”.
The Fragments be a great way to display content, and allow easier navigation of tablet devices, they are similar to the activity but they are only a piece of the global activity. A Fragment object is something between a View and and Activity: It can be part of a layout, but it isn’t a subclass of View. It implements the ComponentCallbacks interface, and it has a lifecycle, but that lifecycle is dependent on the Activity the Fragment object belongs to. Let’s see what it can do for us in a tablet-sized user interface.
There are four important thing that the fragment do for you:

Dialogs: there is a Fragment called DialogFragment that makes it easy to show a Dialog that is managed as part of the Activity lifecycle.

This replaces Activity’s “managed dialog” APIs.
ListActivity: Another kind of Fragment called ListFragment makes it easy to show a list of data.

This is similar to the existing ListActivity (with a some new features), but answer to the common question about how to show a list with some other data.
State and restoring: all fragments currently attached to an activity are saved for you by the framework in the activity’s saved instance state and restored for you when it restarts. With this you get help on saving (and restoring) the state of the single fragment.
History and Navigation: The backstack of all the fragment object loaded is managed by the framework; so it is very easy the use of the activity back button, and you can integrate the existing activity to the fragment backstack! This kind of state is also saved and restored for you automatically.

Now we are ready to begin! follow us, in a couple of day we will prepare a complete example regarding a first honeycomb application to interact with facebook!
Stay tuned!

All ready for May 24 when at ITIS Vittorio Emanuele III (via Duca della Verdura, 48 – Palermo) starting at 3 pm will take place another GTUG (Google Technology User Group) event called “News from Google I/O 2011″.

We will talk about last technologies and solutions shown in the biggest Google I/O event in San Francisco on 10-11 May. Here the full program:


News from Google I/O 2011
Case study on Chrome Webstore: developing tools and best practices
Palermo GTUG members developed Android apps showcases
Introducing Android Tablet “ASUS Eee Pad Transformer” by Infograf sas company
Google Jobs: recruitment and applications collection
Question time







Main speaker will be Claudio Cherubino from Sicily, Developer Programs  Engineer at Google’s offices in London, he works on Google Apps API and on  Google Apps Marketplace.

He worked also as software developer, technology  evangelist, community manager, consultant, technical translator and several open-source projects got his contributes like MySQL, PHP,  WordPress, Songbird and Voldemort Project.

To see his developer profile just click here http://code.google.com/intl/it-IT/team/.
We will also show our current project and our ideas about all mobile world, especially about the growing Android world that is getting more importance day by day among middle-low profile mobile users.
We also will talk about our starting project referred to our mobile schools in all Italy and all its mobile developing opportunities.
Free entry.

This event is organized by Palermo Google Tecnology User Group in partnership with ITIS Vittorio Emanuele III.

Yes this week starts the Formula 1 Gran Prix, the first battle will be in Australia..and we for the event have released a new Iphone/Ipad App colled “f1 Matrix” this is a nice simple app that allow you to see the results since the 2009 to today, follow your favourite pilots and store into your mobile the result for evaluations!
You can find the app on the apple store (this is the link : http://itunes.apple.com/us/app/f1matrix/id425724035 )
The major feature is the simplicity, but you can track the results, compare the pilots and store the results!
visit the wwebsite to see the full description and the other F1 Gran Prix related issues!

Finally for you the Exploro geoLocalisation project is online!

follow the event on http://www.primaonline.it/2011/03/24/90553/tecnologia-con-exploro-italia-a-portata-di-touch/
or read more on www.exploro.it
Exploro is a mobile application that runs on Android, Iphone, Symbian and other device that show you what is around you!

Google officially announced Android 3.0, known as Honeycomb (Google tends to name their Android builds after sweet, delicious desserts).
this firmware born directly for combating the Apple iPad head-on, more and more Honeycomb-powered tablets are being leaked or revealed. (continue reading…)

Nice news for .net developer that want develop on Android…

The mono android frameworks reach the 2.0 edition in which some “strange” bugs are solved
http://monodroid.net/

Finally…only for developers, the Android 2.3 platform is available as a downloadable component for the Android SDK. The downloadable platform includes an Android library and system image, as well as a set of emulator skins and more. The downloadable platform includes no external libraries.
there are many new feature but the most interesting one (i think) is thise:
Near Field Communications (NFC)
Android 2.3 includes an NFC stack and framework API that lets developers read NDEF tags that are discovered as a user touches an NFC-enabled device to tag elements embedded in stickers, smart posters, and even other devices.
The platform provides the underlying NFC services that work with the device hardware to discover tags when they come into range. On discovering a tag, the platform notifies applications by broadcasting an Intent, appending the tag’s NDEF messages to the Intent as extras. Applications can create Intent filters to recognize and handle targeted tags and messages. For example, after receiving a tag by Intent, applications extract the NDEF messages, store them, alert the user, or handle them in other ways.
The NFC API is available in the android.nfc package. The key classes are:

NfcAdapter, which represents the NFC hardware on the device.
NdefMessage, which represents an NDEF data message, the standard format in which “records” carrying data are transmitted between devices and tags. Applications can receive these messages from ACTION_TAG_DISCOVERED Intents.
NdefRecord, delivered in an NdefMessage, which describes the type of data being shared and carries the data itself.

NFC communication relies on wireless technology in the device hardware, so support for the platform’s NFC features on specific devices is determined by their manufacturers. To determine the NFC support on the current device, applications can call isEnabled() to query theNfcAdapter. The NFC API is always present, however, regardless of underlying hardware support.
To use the NFC API, applications must request permission from the user by declaring <uses-permission android:name="android.permission.NFC"> in their manifest files.
Additionally, developers can request filtering on Android Market, such that their applications are not discoverable to users whose devices do not support NFC. To request filtering, add <uses-feature android:name="android.hardware.nfc" android:required="true">to the application’s manifest.
To look at a sample application that uses the NFC API, see NFCDemo.
for the full feature list take a look here: http://developer.android.com/sdk/android-2.3.html

API Level: 9
For developers, the Android 2.3 platform is available as a

downloadable component for the Android SDK. The downloadable platform includes

an Android library and system image, as well as a set of emulator

skins and more. The downloadable platform

includes no external libraries.
To get started developing or testing against Android

2.3, use the Android SDK Manager to

download the platform into your SDK. For more information,

see Adding SDK

Components. If you are new to Android, download the SDK Starter Package

first.
For a high-level introduction to Android 2.3, see the Platform Highlights.
Revisions
The sections below provide notes about successive releases of

the Android 2.3 platform component for the Android SDK, as denoted by

revision number. To determine what revision(s) of the Android

2.3 platforms are installed in your SDK environment, refer to

the “Installed Packages” listing in the Android SDK and AVD Manager.
//

Android 2.3, Revision 1 (December 2010)

 


Dependencies:
Requires SDK Tools r8 or higher.





API Overview
The sections below provide a technical overview of what’s new for developers

in 2.3, including new features and changes in the framework

API since the previous version.
SIP-based VOIP
The platform now includes a SIP protocol stack and framework API that lets

developers build internet telephony applications. Using the API, applications can offer

voice calling features without having to manage sessions, transport-level

communication, or audio — these are handled

transparently by the platform’s SIP API and services.
The SIP API is available in the android.net.sip

package. The key class is SipManager, which applications

use to set up and manage SIP profiles, then initiate audio calls and receive

audio calls. Once an audio call is established, applications can mute calls,

turn on speaker mode, send DTMF tones, and more. Applications can also use the

SipManager to create generic SIP connections.
The platform’s underlying SIP stack and services are available on devices at

the discretion of the manufacturer and associated carrier. For this reason,

applications should use the  isApiSupported() method to check whether SIP support is available, before

exposing calling functionality to users.
To use the SIP API, applications must request permission from the user by

declaring <uses-permission

android:name="android.permission.INTERNET"> and <uses-permission

android:name="android.permission.USE_SIP"> in their manifest files.
Additionally, developers can request filtering on Android Market, such that

their applications are not discoverable to users whose devices do not include

the platform’s SIP stack and services. To request filtering, add <uses-feature

android:name="android.software.sip"

android:required="true"> and <uses-feature

android:name="android.software.sip.voip"> to the application manifest.
To look at a sample application that uses the SIP API, see SIP Demo.
Near Field Communications (NFC)
Android 2.3 includes an NFC stack and framework API that lets developers

read NDEF tags that are discovered as a user touches an NFC-enabled device

to tag elements embedded in stickers, smart posters, and even other devices.
The platform provides the underlying NFC services that work with the device

hardware to discover tags when they come into range. On discovering a tag, the

platform notifies applications by broadcasting an Intent, appending the tag’s

NDEF messages to the Intent as extras. Applications can create Intent filters to

recognize and handle targeted tags and messages. For example, after receiving a

tag by Intent, applications extract the NDEF messages, store them, alert the

user, or handle them in other ways.
The NFC API is available in the android.nfc package. The key classes are:

NfcAdapter, which represents the NFC hardware on the device.
NdefMessage, which represents an NDEF data message,

the standard format in which “records” carrying data are transmitted between

devices and tags. Applications can receive these messages from ACTION_TAG_DISCOVERED Intents.
NdefRecord, delivered in an

NdefMessage, which describes the type of data being shared and

carries the data itself.

NFC communication relies on wireless technology in the device hardware, so

support for the platform’s NFC features on specific devices is determined by

their manufacturers. To determine the NFC support on the current device,

applications can call isEnabled() to

query the NfcAdapter. The NFC API is always present,

however, regardless of underlying hardware support.
To use the NFC API, applications must request permission from the user by

declaring <uses-permission

android:name="android.permission.NFC"> in their manifest files.
Additionally, developers can request filtering on Android Market, such that

their applications are not discoverable to users whose devices do not support

NFC. To request filtering, add

<uses-feature android:name="android.hardware.nfc"

android:required="true"> to the application’s manifest.
To look at a sample application that uses the NFC API, see

NFCDemo.
Gyroscope and other sensors
Android 2.3 adds platform and API support for several new sensor reading

types — gyroscope, rotation vector, linear acceleration, gravity, and barometer.

Developers can use the new sensor readings to create applications that respond

quickly and smoothly to precise changes in device position and motion. The

Sensor API reports gyroscope and other sensor changes to interested

applications, whether they are running on the application framework or in native

code.
Note that the specific set of hardware sensors available on any given device

varies at the discretion of the device manufacturer.
Developers can request filtering in Android Market, such that their

applications are not discoverable to users whose devices do not offer a

gyroscope sensor. To do so, add <uses-feature

android:name="android.hardware.sensor.gyroscope"

android:required="true"> to the application manifest.
For API details, see Sensor.
Multiple cameras support
Applications can now make use of any cameras that are available on a device,

for either photo or video capture. The Camera lets

applications query for the number of cameras available and the unique

characteristics of each.

New Camera.CameraInfo class stores a camera’s

positional characteristics (orientation, front-facing or back-facing).
New getNumberOfCameras(), getCameraInfo(), and

getNumberOfCameras() methods in the Camera class let applications query for the cameras available

and open the camera that they need.
New get() method lets

applications retrieve a CamcorderProfile for a specific camera.
New getJpegEncodingQualityParameter() lets applications obtain the still-image

capture quality level for a specific camera.

To look at sample code for accessing a front-facing camera, see CameraPreview.java

in the ApiDemos sample application.
The Camera API also adds:

New parameters for cameras, including focus distance, focus mode, and

preview fps maximum/minimum. New getFocusDistances(), getPreviewFpsRange(), and getSupportedPreviewFpsRange() for getting camera parameters, as well as setPreviewFpsRange() for setting preview framerate.

Mixable audio effects
The platform’s media framework adds support for new per-track or global audio effects,

including bass boost, headphone virtualization, equalization, and reverb.

New android.media.audiofx package provides the

API to access audio effects.
New AudioEffect is the  base class

for controlling audio effects provided by the Android audio framework.
New audio session ID that lets an application associate a set of audio

effects with an instance of AudioTrack or MediaPlayer.
New AudioTrack class constructor that lets you create an AudioTrack with a specific session ID. New attachAuxEffect(), getAudioSessionId(), and setAuxEffectSendLevel()

methods.
New attachAuxEffect(), getAudioSessionId(), setAudioSessionId(int), and setAuxEffectSendLevel()

methods and supporting types.

To look at sample code for audio effects, see

AudioFxDemo.java

in the ApiDemos sample application.
The media framework also adds:

New support for altitude tag in EXIF metadata for JPEG files. New method

getAltitude() method to

retrieve the value of the EXIF altitude tag.
New setOrientationHint() method lets an application tell MediaRecorder of the orientation during video capture.

Download manager
The platform includes a new DownloadManager system service

that handles long-running HTTP downloads. Applications can request that a URI be

downloaded to a particular destination file. The DownloadManager

will conduct the download in the background, taking care of HTTP interactions

and retrying downloads after failures or across connectivity changes and system

reboots.

Applications can obtain an instance of the DownloadManager

class by calling getSystemService(String) and passing

DOWNLOAD_SERVICE. Applications that request

downloads through this API should register a broadcast receiver for ACTION_NOTIFICATION_CLICKED, to appropriately

handle when the user clicks on a running download in a notification or from the

Downloads UI.
The DownloadManager.Request class lets an

application provide all the information necessary to request a new download,

such as request URI and download destination. A request URI is the only required

parameter. Note that the default download destination is a shared volume where

the system can delete your file if it needs to reclaim space for system use. For

persistent storage of a download, specify a download destination on external

storage (see setDestinationUri(Uri)).
The DownloadManager.Query class provides methods that let

an application query for and filter active downloads.

StrictMode
To help developers monitor and improve the performance of their applications,

the platform offers a new system facility called StrictMode.

When implemented in an application, StrictMode catches and notifies the

developer of accidental disk or network activity that could degrade application

performance, such as activity taking place on the application’s main thread

(where UI operations are received and animations are also taking place).

Developers can evaluate the network and disk usages issues raised in StrictMode

and correct them if needed, keeping the main thread more responsive and

preventing ANR dialogs from being shown to users.

StrictMode is the core class and is the main integration

point with the system and VM. The class provides convenience methods for

managing the thread and VM policies that apply to the instance.
StrictMode.ThreadPolicy and StrictMode.VmPolicy hold the policies that you define and apply to

thread and VM instances.

For more information about how to use StrictMode to optimize your

application, see the class documentation and sample code at android.os.StrictMode.
UI Framework

Support for overscroll

New support for overscroll in Views and Widgets. In Views, applications can

enable/disable overscroll for a given view, set the overscoll mode, control the

overscroll distance, and handle the results of overscrolling.
In Widgets, applications can control overscroll characteristics such as

animation, springback, and overscroll distance. For more information, see android.view.View and android.widget.OverScroller.
ViewConfiguration also provides methods getScaledOverflingDistance() and getScaledOverscrollDistance().
New overScrollMode, overScrollFooter, and

overScrollHeader attributes for <ListView> elements,

for controlling overscroll behavior.


Support for touch filtering

New support for touch filtering, which lets an application improve the

security of Views that provide access to sensitive functionality. For example,

touch filtering is appropriate to ensure the security of user actions such as

granting a permission request, making a purchase, or clicking on an

advertisement. For details, see the View class

documentation.
New filterTouchesWhenObscured attribute for view elements,

which declares whether to filter touches when the view’s window is obscured by

another visible window. When set to "true", the view will not

receive touches whenever a toast, dialog or other window appears above the

view’s window. Refer to View security

documentation for details.

To look at sample code for touch filtering, see

SecureView.java

in the ApiDemos sample application.

Improved event management

New base class for input events, InputEvent. The class

provides methods that let applications determine the meaning of the event, such

as by querying for the InputDevice from which the event orginated. The KeyEvent and MotionEvent are subclasses of

InputEvent.
New base class for input devices, InputDevice. The

class stores information about the capabilities of a particular input device and

provides methods that let applications determine how to interpret events from an

input device.


Improved motion events

The MotionEvent API is extended to include “pointer ID”

information, which lets applications to keep track of individual fingers as they

move up and down. The class adds a variety of methods that let an application

work efficiently with motion events.
The input system now has logic to generate motion events with the new

pointer ID information, synthesizing identifiers as new pointers are down. The

system tracks multiple pointer IDs separately during a motion event, and

ensures proper continuity of pointers by evaluating at the distance

between the last and next set of pointers.


Text selection controls

A new setComposingRegion method lets an application mark a

region of text as composing text, maintaining the current styling. A

getSelectedText method returns the selected text to the

application. The methods are available in BaseInputConnection, InputConnection, and InputConnectionWrapper.
New textSelectHandle, textSelectHandleLeft,

textSelectHandleRight, and textSelectHandleWindowStyle

attributes for <TextView>, for referencing drawables that will be

used to display text-selection anchors and the style for the containing

window.


Activity controls

ActivityInfo adds new constants for managing

Activity orientation:

SCREEN_ORIENTATION_FULL_SENSOR,

SCREEN_ORIENTATION_REVERSE_LANDSCAPE,

SCREEN_ORIENTATION_REVERSE_PORTRAIT,

SCREEN_ORIENTATION_SENSOR_LANDSCAPE,

and

SCREEN_ORIENTATION_SENSOR_PORTRAIT.
New constant IMPORTANCE_PERCEPTIBLE for

the importance field

in ActivityManager.RunningAppProcessInfo. The value

indicates that a specific process is running something that is considered to be

actively perceptible to the user. An example would be an application performing

background music playback.
The setPersistent(boolean) method to mark an

Activity as persistent is now deprecated and the implementation is a no-op.


Notification text and icon styles

New TextAppearance.StatusBar.EventContent,

TextAppearance.StatusBar.EventContent.Title,

TextAppearance.StatusBar.Icon, and

TextAppearance.StatusBar.Title for managing

notification style.


WebView

New setUseWebViewBackgroundForOverscrollBackground() method lets a WebView specify whether to use its own background for the

overscroll background.



Extra Large Screens
The platform now supports extra large screen sizes, such as those that might

be found on tablet devices. Developers can indicate that their applications are

designed to support extra large screen sizes by adding a <supports

screens ... android:xlargeScreens="true"> element to their manifest

files. Applications can use a new resource qualifier, xlarge, to

tag resources that are specific to extra large screens. For

details on how to support extra large and other screen sizes, see Supporting Multiple

Screens.
Graphics

Adds remaining OpenGL ES 2.0 methods glDrawElements() and

glVertexAttribPointer() in the android.opengl.GLES20 class.
Adds support for YV12 pixel format, a

planar 4:2:0 YCrCb format.

Content Providers

New AlarmClock provider class for setting an alarm

or handling an alarm. The provider contains a ACTION_SET_ALARM Intent

action and extras that can be used to start an Activity to set a new alarm in an

alarm clock application. Applications that wish to receive the

SET_ALARM Intent should create an activity that requires the

the SET_ALARM permission. Applications that wish to create a new

alarm should use Context.startActivity(), so that the user has the option of choosing

which alarm clock application to use.
MediaStore supports a new Intent action, PLAY_FROM_SEARCH, that lets an application search for music media and

automatically play content from the result when possible. For example, an

application could fire this Intent as the result of a voice recognition command

to listen to music.
MediaStore also adds a new MEDIA_IGNORE_FILENAME flag that tells the media

scanner to ignore media in the containing directory and its subdirectories.

Developers can use this to avoid having graphics appear in the Gallery and

likewise prevent application sounds and music from showing up in the Music

app.
The Settings provider adds the new Activity actions

APPLICATION_DETAILS_SETTINGS and MANAGE_ALL_APPLICATIONS_SETTINGS, which let an application show the details

screen for a specific application or show the Manage Applications screen.
The ContactsContract provider adds the ContactsContract.CommonDataKinds.SipAddress data kind, for

storing a contact’s SIP (Internet telephony) address.

Location

The LocationManager now tracks application

requests that result in wake locks or wifi locks according to

WorkSource, a system-managed class that identifies the

application.

The LocationManager keeps track

of all clients requesting periodic updates, and tells its providers

about them as a WorkSource parameter, when setting their minimum

update times.

The network location provider uses WorkSource to track the

wake and wifi locks initiated by an application and adds it to the application’s

battery usage reported in Manage Applications.
The LocationManager adds several new methods that

let an Activity register to receive periodic or one-time location updates based

on specified criteria (see below).
A new  Criteria class lets an application specify a

set of criteria for selecting a location provider. For example, providers may be

ordered according to accuracy, power usage, ability to report altitude, speed,

and bearing, and monetary cost.

Storage

Android 2.3 adds a new StorageManager that

supports OBB (Opaque Binary Blob) files. Although platform support for OBB is

available in Android 2.3, development tools for creating and managing OBB files

will not be availble until early 2011.
The Android 2.3 platform adds official support for devices that do not

include SD cards (although it provides virtual SD Card partition, when no

physical SD card is available). A convenience method, isExternalStorageRemovable(), lets applications

determine whether a physical SD card is present.

Package Manager

New constants for declaring hardware and software features. See the list in

the New Feature Constants section, below.
PackageInfo adds new firstInstallTime and lastUpdateTime fields that store the time of the

package installation and last update.
New getProviderInfo() method for retrieving all of the information known about

a particular content provider class.

Telephony

The TelephonyManager adds the constant NETWORK_TYPE_EVDO_B for specifying the CDMA

EVDO Rev B network type.
New getPsc() method returns

the primary scrambling code of the serving cell on a UMTS network.

Native access to Activity lifecycle, windows
Android 2.3 exposes a broad set of APIs to applications that use native

code. Framework classes of interest to such applications include:

NativeActivity is a new type of Activity class, whose

lifecycle callbacks are implemented directly in native code. A

NativeActivity and its underlying native code run in the system

just as do other Activities — specifically they run in the Android

application’s system process and execute on the application’s main UI thread,

and they receive the same lifecycle callbacks as do other Activities.
New InputQueue class and callback interface lets native

code manage event queueing.
New SurfaceHolder.Callback2 interface lets native code

manage a SurfaceHolder.
New takeInputQueue and takeSurface() methods in Window let native code manage

events and surfaces.

For full information on working with native code or to download the NDK,

see the Android NDK page.
Dalvik Runtime

dalvik.system

removes several classes that were previously deprecated.
Dalvik core libraries:

New collections: ArrayDeque, NavigableMap,

ConcurrentSkipListMap,

LinkedBlockingDeque
New Arrays utilities: binarySearch(),

copyOf(), copyOfRange(), and others.
CookieManager for HttpURLConnection.
More complete network APIs: InterfaceAddress,

NetworkInterface and IDN
File read and write controls
String.isEmpty()
Normalizer and Normalizer.Form
Improved javax.net.ssl server sockets.



New manifest elements and attributes

New xlargeScreens attribute for <supports-screens>

element, to indicate whether the application supports

extra large screen form-factors. For details, see Supporting Multiple

Screens.
New values for android:screenOrientation attribute of

<activity> element:


"reverseLandscape" — The Activity would like to have the

screen in landscape orientation, turned in the opposite direction from normal

landscape.
"reversePortait" — The Activity would like to have the

screen in portrait orientation, turned in the opposite direction from normal

portrait.
"sensorLandscape" — The Activity would like to have the

screen in landscape orientation, but can use the sensor to change which

direction the screen is facing.
"sensorPortrait" — The Activity would like to have the

screen in portrait orientation, but can use the sensor to change which direction

the screen is facing.
"fullSensor" — Orientation is determined by a physical

orientation sensor: the display will rotate based on how the user moves the

device. This allows any of the 4 possible rotations, regardless of what the

device will normally do (for example some devices won’t normally use 180 degree

rotation).



New Permissions

com.android.permission.SET_ALARM — Allows an application

to broadcast an Intent to set an alarm for the user. An Activity that handles

the SET_ALARM Intent action

should require this permission.
android.permission.USE_SIP — Allows an application to use

the SIP API to make or receive internet calls.
android.permission.NFC — Allows an application to use the

NFC API to make or receive internet calls.

New Feature Constants
The platform adds several new hardware features that developers can declare

in their application manifests as being required by their applications. This

lets developers control how their application is filtered, when published on

Android Market.

android.hardware.audio.low_latency — The application uses a low-latency

audio pipeline on the device and is sensitive to delays or lag in sound input or

output.
android.hardware.camera.front — The application uses a front-facing

camera on the device.
android.hardware.nfc

— The application uses NFC radio features in the device.
android.hardware.sensor.barometer — The application uses the device’s

barometer.
android.hardware.sensor.gyroscope — The application uses the device’s

gyroscope sensor.
android.software.sip

— The application uses the SIP API on the device.
android.software.sip.voip — The application uses a SIP-based VOIP

service on the device.
android.hardware.touchscreen.multitouch.jazzhand — The application uses

advanced multipoint multitouch capabilities on the device screen, for tracking

up to five points fully independently.

For full information about how to declare features and use them for

filtering, see the documentation for <uses-feature>.
API differences report
For a detailed view of all API changes in Android 2.3 (API

Level 9), see the API

Differences Report.
API Level
The Android 2.3 platform delivers an updated version of

the framework API. The Android 2.3 API

is assigned an integer identifier —

9 — that is

stored in the system itself. This identifier, called the “API Level”, allows the

system to correctly determine whether an application is compatible with

the system, prior to installing the application.
To use APIs introduced in Android 2.3 in your application,

you need compile the application against the Android library that is provided in

the Android 2.3 SDK platform. Depending on your needs, you might

also need to add an android:minSdkVersion="9"

attribute to the <uses-sdk> element in the application’s

manifest. If your application is designed to run only on Android 2.3 and higher,

declaring the attribute prevents the application from being installed on earlier

versions of the platform.
For more information about how to use API Level, see the API Levels document.
Built-in Applications
The system image included in the downloadable platform provides these

built-in applications:





Browser
Calculator
Camera
Clock
Contacts
Cusom Locale
Dev Tools
Downloads
Email




Gallery
IMEs for Japanese, Chinese, and Latin text input
Messaging
Music
Phone
Search
Settings
Spare Parts (developer app)
Speech Recorder





Locales
The system image included in the downloadable SDK platform provides a variety of

built-in locales. In some cases, region-specific strings are available for the

locales. In other cases, a default version of the language is used. The

languages that are available in the Android 2.3 system

image are listed below (with language_country/region locale

descriptor).





Arabic, Egypt (ar_EG)
Arabic, Israel (ar_IL)
Bulgarian, Bulgaria (bg_BG)
Catalan, Spain (ca_ES)
Czech, Czech Republic (cs_CZ)
Danish, Denmark(da_DK)
German, Austria (de_AT)
German, Switzerland (de_CH)
German, Germany (de_DE)
German, Liechtenstein (de_LI)
Greek, Greece (el_GR)
English, Australia (en_AU)
English, Canada (en_CA)
English, Britain (en_GB)
English, Ireland (en_IE)
English, India (en_IN)
English, New Zealand (en_NZ)
English, Singapore(en_SG)
English, US (en_US)
English, Zimbabwe (en_ZA)
Spanish (es_ES)
Spanish, US (es_US)
Finnish, Finland (fi_FI)
French, Belgium (fr_BE)
French, Canada (fr_CA)
French, Switzerland (fr_CH)
French, France (fr_FR)
Hebrew, Israel (he_IL)
Hindi, India (hi_IN)



Croatian, Croatia (hr_HR)
Hungarian, Hungary (hu_HU)
Indonesian, Indonesia (id_ID)
Italian, Switzerland (it_CH)
Italian, Italy (it_IT)
Japanese (ja_JP)
Korean (ko_KR)
Lithuanian, Lithuania (lt_LT)
Latvian, Latvia (lv_LV)
Norwegian-Bokmol, Norway(nb_NO)
Dutch, Belgium (nl_BE)
Dutch, Netherlands (nl_NL)
Polish (pl_PL)
Portuguese, Brazil (pt_BR)
Portuguese, Portugal (pt_PT)
Romanian, Romania (ro_RO)
Russian (ru_RU)
Slovak, Slovakia (sk_SK)
Slovenian, Slovenia (sl_SI)
Serbian (sr_RS)
Swedish, Sweden (sv_SE)
Thai, Thailand (th_TH)
Tagalog, Philippines (tl_PH)
Turkish, Turkey (tr_TR)
Ukrainian, Ukraine (uk_UA)
Vietnamese, Vietnam (vi_VN)
Chinese, PRC (zh_CN)
Chinese, Taiwan (zh_TW)




Note: The Android platform may support more

locales than are included in the SDK system image. All of the supported locales

are available in the Android Open Source

Project.
Emulator Skins
The downloadable platform includes a set of emulator skins that you can use

for modeling your application in different screen sizes and resolutions. The

emulator skins are:

 QVGA (240×320, low density, small screen)
 WQVGA400 (240×400, low density, normal screen)
 WQVGA432 (240×432, low density, normal screen)
 HVGA (320×480, medium density, normal screen)
 WVGA800 (480×800, high density, normal screen)
 WVGA854 (480×854 high density, normal screen)

For more information about how to develop an application that displays

and functions properly on all Android-powered devices, see Supporting Multiple

Screens.