Home / autocar news / Android Two

Android Two

Android Two.Trio APIs

Reference

For developers, the Android Two.Three ( GINGERBREAD )platform is available as a downloadable component for the Android SDK. The downloadable platform includes an Android library and system photo, as well as a set of emulator skins and more. To get embarked developing or testing against Android Two.Trio, use the Android SDK Manager to download the platform into your SDK.

API Overview

The sections below provide a technical overview of what’s fresh for developers in Two.Trio, including fresh features and switches 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 suggest voice calling features without having to manage sessions, transport-level communication, or audio – these are treated 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 announcing <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 Google Play, 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.

For more information, read the SIP developer guide.

Near Field Communications (NFC)

Android Two.Trio 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, brainy posters, and even other devices.

The platform provides the underlying NFC services that work with the device hardware to detect 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 treat targeted tags and messages. For example, after receiving a tag by Intent, applications extract the NDEF messages, store them, alert the user, or treat 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 inbetween 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 collective 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 proclaiming <uses-permission android:name=”android.permission.NFC”> in their manifest files.

Additionally, developers can request filtering on Google Play, 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 Two.Three adds platform and API support for several fresh sensor reading types – gyroscope, rotation vector, linear acceleration, gravity, and barometer. Developers can use the fresh sensor readings to create applications that react quickly and slickly to precise switches in device position and movability. The Sensor API reports gyroscope and other sensor switches 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 on Google Play, such that their applications are not discoverable to users whose devices do not suggest 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 .

Numerous cameras support

Applications can now make use of any cameras that are available on a device, for either photo or movie capture. The Camera lets applications query for the number of cameras available and the unique characteristics of each.

  • Fresh Camera.CameraInfo class stores a camera’s positional characteristics (orientation, front-facing or back-facing).
  • Fresh getNumberOfCameras() and getCameraInfo() methods in the Camera class let applications query for the cameras available and open the camera that they need.
  • Fresh get() method lets applications retrieve a CamcorderProfile for a specific camera.
  • Fresh 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:

  • Fresh parameters for cameras, including concentrate distance, concentrate mode, and preview fps maximum/minimum. Fresh 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 fresh per-track or global audio effects, including bass boost, headphone virtualization, equalization, and reverb.

  • Fresh android.media.audiofx package provides the API to access audio effects.
  • Fresh AudioEffect is the base class for controlling audio effects provided by the Android audio framework.
  • Fresh audio session ID that lets an application associate a set of audio effects with an example of AudioTrack or MediaPlayer .
  • Fresh AudioTrack class constructor that lets you create an AudioTrack with a specific session ID. Fresh attachAuxEffect() , getAudioSessionId() , and setAuxEffectSendLevel() methods.
  • Fresh 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:

  • Fresh support for altitude tag in EXIF metadata for JPEG files. Fresh method getAltitude() method to retrieve the value of the EXIF altitude tag.
  • Fresh setOrientationHint() method lets an application tell MediaRecorder of the orientation during movie capture.

Download manager

The platform includes a fresh DownloadManager system service that treats 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 switches and system reboots.

  • Applications can obtain an example 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 treat 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 fresh download, such as request URI and download destination. A request URI is the only required parameter. Note that the default download destination is a collective 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 outward 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 spectacle of their applications, the platform offers a fresh 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 spectacle, 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 example.
  • 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
  • Fresh 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 treat 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() .
  • Fresh overScrollMode , overScrollFooter , and overScrollHeader attributes for <ListView> elements, for controlling overscroll behavior.
  • Support for touch filtering
    • Fresh support for touch filtering, which lets an application improve the security of Views that provide access to sensitive functionality. For example, touch filtering is suitable to ensure the security of user deeds such as granting a permission request, making a purchase, or clicking on an advertisement. For details, see the View class documentation.
    • Fresh filterTouchesWhenObscured attribute for view elements, which announces 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 shows up 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
      • Fresh 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 .
      • Fresh 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 movement events
        • The MotionEvent API is extended to include “pointer ID” information, which lets applications to keep track of individual fingers as they stir up and down. The class adds a diversity of methods that let an application work efficiently with movability events.
        • The input system now has logic to generate movability events with the fresh pointer ID information, synthesizing identifiers as fresh pointers are down. The system tracks numerous pointer IDs separately during a maneuverability event, and ensures decent continuity of pointers by evaluating at the distance inbetween the last and next set of pointers.
        • Text selection controls
          • A fresh setComposingRegion method lets an application mark a region of text as composing text, maintaining the current styling. A getSelectedText method comebacks the selected text to the application. The methods are available in BaseInputConnection , InputConnection , and InputConnectionWrapper .
          • Fresh 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 fresh 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 .
            • Fresh 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 Activity.setPersistent(boolean) method to mark an Activity as persistent is now deprecated and the implementation is a no-op.
            • Notification text and icon styles
              • Fresh TextAppearance.StatusBar.EventContent , TextAppearance.StatusBar.EventContent.Title , TextAppearance.StatusBar.Icon , and TextAppearance.StatusBar.Title for managing notification style.

                • 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 fresh 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 Numerous Screens.

                Graphics

                • Adds remaining OpenGL ES Two.0 methods glDrawElements() and glVertexAttribPointer() in the android.opengl.GLES20 class.
                • Adds support for YV12 pixel format, a planar Four:Two:0 YCrCb format.

                Content Providers

                • Fresh AlarmClock provider class for setting an alarm or treating an alarm. The provider contains a ACTION_SET_ALARM Intent act and extras that can be used to commence an Activity to set a fresh 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 fresh alarm should use Context.startActivity() , so that the user has the option of choosing which alarm clock application to use.
                • MediaStore supports a fresh Intent act, 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 instruction to listen to music.
                • MediaStore also adds a fresh MEDIA_IGNORE_FILENAME flag that tells the media scanner to overlook media in the containing directory and its subdirectories. Developers can use this to avoid having graphics emerge in the Gallery and likewise prevent application sounds and music from demonstrating up in the Music app.
                • The Settings provider adds the fresh Activity deeds APPLICATION_DETAILS_SETTINGS and MANAGE_ALL_APPLICATIONS_SETTINGS , which let an application showcase the details screen for a specific application or showcase 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.

                Storage

                • Android Two.Trio adds a fresh StorageManager that supports OBB (Opaque Binary Blob) files. Albeit platform support for OBB is available in Android Two.Three, development instruments for creating and managing OBB files will not be availble until early 2011.
                • The Android Two.Trio platform adds official support for devices that do not include SD cards (albeit 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

                • Fresh constants for announcing hardware and software features. See the list in the Fresh Feature Constants section, below.
                • PackageInfo adds fresh firstInstallTime and lastUpdateTime fields that store the time of the package installation and last update.
                • Fresh 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.
                • Fresh getPsc() method comes back the primary scrambling code of the serving cell on a UMTS network.

                Native access to Activity lifecycle, windows

                Android Two.Three exposes a broad set of APIs to applications that use native code. Framework classes of interest to such applications include:

                • NativeActivity is a fresh 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.
                • Fresh InputQueue class and callback interface lets native code manage event queueing.
                • Fresh SurfaceHolder.Callback2 interface lets native code manage a SurfaceHolder .
                • Fresh takeInputQueue and takeSurface() methods in Window let native code manage events and surfaces.

                For utter information on working with native code or to download the NDK, see the Android NDK page.

                Dalvik Runtime

                • dalvik.system eliminates several classes that were previously deprecated.
                • Dalvik core libraries:
                • Fresh collections: ArrayDeque , NavigableMap , ConcurrentSkipListMap , LinkedBlockingDeque
                • Fresh Arrays utilities: binarySearch() , copyOf() , copyOfRange() , and others.
                • CookieManager for HttpURLConnection .
                • More accomplish network APIs: InterfaceAddress , NetworkInterface and IDN
                • File read and write controls
                • String.isEmpty()
                • Normalizer and Normalizer.Form
                • Improved javax.net.ssl server sockets.

                Fresh manifest elements and attributes

                • Fresh xlargeScreens attribute for <supports-screens> element, to indicate whether the application supports extra large screen form-factors. For details, see Supporting Numerous Screens.
                • Fresh 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.
                • “reversePortrait” – 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 switch which direction the screen is facing.
                • “sensorPortrait” – The Activity would like to have the screen in portrait orientation, but can use the sensor to switch 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 permits any of the four possible rotations, regardless of what the device will normally do (for example some devices won’t normally use one hundred eighty degree rotation).

                Fresh Permissions

                • com.android.permission.SET_ALARM – Permits an application to broadcast an Intent to set an alarm for the user. An Activity that treats the SET_ALARM Intent act should require this permission.
                • android.permission.USE_SIP – Permits an application to use the SIP API to make or receive internet calls.
                • android.permission.NFC – Permits an application to use the NFC API to read NFC tags.

                Fresh Feature Constants

                The platform adds several fresh hardware features that developers can proclaim in their application manifests as being required by their applications. This lets developers control how their application is filtered, when published on Google Play.

                • 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 five or more points fully independently.

                For total information about how to announce features and use them for filtering, see the documentation for <uses-feature> .

                API differences report

                For a detailed view of all API switches in Android Two.Three (API Level 9), see the API Differences Report.

                API Level

                The Android Two.Three platform produces an updated version of the framework API. The Android Two.Trio API is assigned an integer identifier – 9 – that is stored in the system itself. This identifier, called the “API Level”, permits the system to correctly determine whether an application is compatible with the system, prior to installing the application.

                To use APIs introduced in Android Two.Three in your application, you need compile the application against the Android library that is provided in the Android Two.Trio 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 Two.Three and higher, announcing the attribute prevents the application from being installed on earlier versions of the platform.

                Related movie:

                http://www.youtube.com/watch?v=_Me7c71o5rU

                Leave a Reply

                Your email address will not be published. Required fields are marked *