Read more after the jump.

Over the past few months, we’ve been giving you some important information and tools to help you learn about Timescape™ extensions, including articles on how to develop Timescape™ extensions and use the Extension Development Kit, along with special sections on Developer Word dedicated to Timescape extensions and the Extension Development Kit (EDK). In case you missed all of this, you will get a new chance now as Robert Helmbro will guide you in how to create your very own Timescape™ extension – an excellent way to get visibility in Sony Ericsson phones. 

Starting with the 2011 Xperia™ phones and the updated software on the Xperia™ X10, you’ll be able to develop your own extensions for the Timescape™ application, Sony Ericsson’s unique feature that displays Facebook™, Twitter™, text messages, e-mails and alerts from your contacts as a flowing column on the home screen. And to help you develop your own Timescape™ app extension, we’ve got the Extension Development Kit (EDK) that includes all the necessary tools and documentation.

Robert Helmbro, Software Engineer at Sony Ericsson

If you already have a bit of Android™ development knowledge, you’ll find it fairly easy to create your own Timescape™ extensions. If you’re still a bit new to Android™ development, no worries, just familiarise yourself first with the Android development documentation mentioned below.

What is a Timescape™ extension?

For those of you who are new to the Timescape™ world, a Timescape™ extension is an Android™ application that provides Timescape™ connected UIs with content through a specified API.

The API is called Event Stream API, which can be thought of as a database of time-centric content. The extensions put content into the database. Then the visualisation application, such as the Timescape™ application, Infinite view or Timescape™-widget, presents the content to the user in an integrated way.

Prerequisites for creating a Timescape™ extension

You should have basic knowledge about Android™ application development. Such things as intents, broadcast events and content providers are central concepts in extension development. It is also assumed that Eclipse with the Android development tools (ADT) plug-in is up and running.

Documentation and sample code

Now, let’s get to the heart of this tutorial. First, download some documentation and code examples. This is, and more information about it, is available from the EDK developer section on Developer World. Download the Timescape™ code examples and documentation to get started. Once you’ve extracted the zip file, you’ll find the following content:

• RSSExtension – A sample extension with some attached documentation, intended for RSS type of extensions.
• SocialNetworkSample – A sample extension with some attached documentation. This sample is made to give an example of how a social network example can be made.
• SampleExtension – A sample extension with some attached documentation.
• EventStream_API.zip – Javadocs for the Event Stream API.
• Introduction_Timescape_extensions.pdf – Contains some basic information.
• SEMC_Xperia_Events_overview.pdf – Documentation about the visualisation application Xperia™ Events.
• Timescape_icon_design_guideline.pdf – Guidelines about icons needed in an extension.

A good starting point is to read the Javadoc for the Event Stream API. Extract the EventStream_API.zip. Go to the EventStream_API folder and open the index.html file in your favourite browser. Read carefully about the EventStream class. This will give you a good overview of how Timescape™ extensions work.

Downloading the Extension Development Kit

You are now probably excited for some hands on programming. Maybe you’re ready to look at the sample extensions and start modifying the code to try out your ideas, but hang on a little while longer.

As mentioned before, Sony Ericsson has created the Extension Development Kit (EDK) that can be used while developing extensions. The EDK consists of an emulator add-on containing, among other things, the Event Stream API and two visualization applications – Xperia™ Events and Infinite view. You can find out more about these applications later in the text. To install the EDK and create an Android Virtual Device (AVD), follow the “Installing the EDK” instructions on the EDK developer section.

You should now be able to start an emulator with your newly created configuration (AVD) by following the steps below:

1. In Eclipse, press Window > Android SDK and AVD Manager.
2. Select your new AVD and press Start.
3. Wait for the emulator to boot up and then scroll the main menu and you will find the application Xperia™ Events.

Xperia™ Events is a tool for testing Timescape™ extensions. Events are shown in a similar way as they will be shown on a real device. Now launch Xperia™ Events. You will only see an almost empty screen, since there are no extensions installed yet.

 Using the Social network sample extension

In order to fill Xperia™ Events with some content, let’s try out the Social network sample extension.

1. Browse to the SocialNetworkSample folder from EdkSnsSampleApp1.zip.
2. Create an Android project in Eclipse: File > New > Project… > Android > Android Project.
3. Set the ‘Create project from existing source’ checkbox and navigate to your recently extracted folder containing SocialNetworkSample.
4. Check EDK 1.1 as Build Target and press Finish.
5. Install the SocialNetworkSample to the emulator by right clicking the newly created project and press Run As > Android Application.

Now launch Xperia™ Events in the emulator again. A new tab should be present. Follow these steps: 

1. Press the new tab and then press Add account.
2. Press ‘SNS Sample extension – Register your account information’. Enter any user name and password you like and press Sign In.
3. Press back to see the dummy stream of events generated by the extension.

Try to press an event to see the detail view of it. At the bottom of the screen, it is possible to scroll all data in the database for this event entry. This is really useful when developing extensions. Also try to press the Infinite icon at the top right corner. What you should see now is the Infinite view. Infinite view is the detailed view of a contact. This shows everything related to the selected contact collected. For example, your extension gets its own tab with all events from the current friend.

Time for coding

Similar procedures could be done with the RSSExtension and SampleExtension. Some documentation is attached to all sample extensions. If you would like to create your own extension by modifying one of the sample extensions, I would recommend selecting the RSSExtension since it is most complete.

Hopefully, this has given you enough information for you to start a prototype of your own extension. When you’re ready, download the EDK and give it a go. If you have any questions, just post them in the EDK thread on Google groups, which we will monitor and get back with answers as soon as possible. Happy coding!

More information

• Learn more about Timescape extensions.
• Download the Sony Ericsson EDK.
• Download the Timescape™ extensions code example & documentation kit.
• Get an overview of the Sony Ericsson EDK.
• Ask a question though the EDK thread on Google groups
• Check out the EDK Frequently Asked Questions.
• Read more about Android application development.

Anupam Nath

Back at Google I/O, Google had announced plans to add several capabilities to help developers manage their products more effectively on Android Market™. In particular, a very helpful publishing option – multiple APK support – is now available. With multiple APK support, you can have different versions of an APK file under the same product listing. The APKs file versions are completely independent APKs that share the same product name, but contain code and resources targeted for your particular set of customers. 

This feature also resolves some of the questions and comments we frequently get from developers, such as:

• Can we use an SDK lower than 2.3 and still support Xperia™ PLAY (which runs on Android™ 2.3)?
• We want to create high graphics textures for Xperia™ PLAY but other devices don’t support it and we don’t want to upload a separate application on Android Market™. What should we do? 

The multiple APK support option helps you manage all the above tasks without uploading a separate application to Android Market™ with a different package name for Xperia™ PLAY, or other specific devices. Leverage this feature to support various devices (such as phones and tablets), Android platform versions, or screen sizes, all while keeping the application builds inside the same package and product name.

Setting up Multiple APKs 

If you’re new to publishing on Android Market™, I’d recommended first going over the Preparing to Publish checklist and publishing on Android Market page on the Android Developers reference site to understand what you need to do if you plan to publish your application. Also review the publishing concepts for Android Developers. Here you’ll find a good explanation on key concepts regarding how the Android Market publisher site works, including descriptions on active APKs, simple mode versus advanced mode and the difference between “publish” and “save”. Most importantly, this page explains exactly how multiple APKs work.

Once you’ve made the decision to use multiple APKs on Android Market™, take the following facts into consideration:

• You will have just one entry in Android Market™ for your application, and different devices might download a different APK.
• You maintain one set of product details (app description, icons, screenshots, etc.). This also means you cannot charge different prices for different APKs.
• All users see only one version of your application on Android Market™.
• If you publish different APKs for different versions of Android, then when a user’s device receives a system update that qualifies them for a different APK you’ve published, Android Market™ automatically updates the user’s application to the appropriate APK.

Publishing multiple APKs

Assuming you’ve already prepared your application for publishing (including signing and versioning your application), you should be ready to publish on Android Market.

To activate multiple APK in the Developer console for Android Market, ensure you have the following settings:

1. In the Product details tab of Edit Application screen, an Upload new APK window opens when you first begin uploading your software. Click the Choose file button to navigate to and select the APK file.

2. When your APK file is uploaded, click the Save button.

3. Go to the APK files tab of the Edit Application screen.

4. Click Switch to advanced mode.

5. Click the Upload APK button and select the additional versions of the APK file to add. Select the Activate link to activate the APK.

6. When you are finished adding all the versions of your APK files for your application, click the Publish button to publish the APK files to Android Market™, or click the Save button to save your files.

The description circled below indicates which devices running a particular version of Android (in this case, API level 10 or 8-10) will be able to download this APK. The information shown in the description is automatically extracted from the manifest file.

Let us know…

We hope you take full advantage of the publishing options that the multiple APK support feature provides. If you have any questions, let us know through the Comments link at the end of this post.

More information

• Learn about multiple APK support in detail on the Android Developers site.
• Review the Preparing to Publish checklist and publishing on Android Market page on the Android Developers site.
• Read about multiple APK support on the Android Developers Blog.
• Get familar with our Xperia^TM game developer recommendations.
• Check out all of our game developer tips and tutorials.

The winning team from last year, Team HipSnip, has already benefitted from the EAA spotlight, as they have been able to secure angel funding for their business. You can read about their inspirational journey in this article on the EAA guest blogger site. Now that the doors for success have opened up for Team HipSnip, are you ready for your turn? If you are up to the challenge, take part in the first mini-challenge, which begins September 14. Learn how to get started here.

More information

• Watch this short message from Tommy Arngren, our fellow blogger from Ericsson.
• Get yourself started in the Ericsson Application Awards 2012.
• Read about EAA 2011 winners Team HipSnip.
• Check out the latest EAA news and stories at Tommy’s EAA blog.

A pinch-to-zoom code example

Now that we’ve looked at some of the basics of implementing pinch-to-zoom, let’s examine a pinch-to-zoom listener class named PinchZoomListener that puts those basics into action. The PinchZoomListener class is part of a project which you can download and use to build the application.

Download the pinch-to-zoom sample project (0.66 MB)

Remember that the application can recognize and process pinch-to-zoom gestures in Xperia™ X10 only if you install the pinch-to-zoom support in the device.

Implementing the OnTouchListener interface

The first thing to notice about PinchZoomListener is that it implements the View.OnTouchListener interface. This is indicated in the class definition, as shown below.

public class PinchZoomListener implements View.OnTouchListener {

    …

{

By implementing the View.OnTouchListener interface, PinchZoomListener is invoked when a user touches the screen.

Registering the listener

Remember that the listener needs to be registered by an activity. In the application, it is registered in an activity class, TutorialZoomActivity4, as follows:

import com.sonyericsson.zoom.ImageZoomView;
import com.sonyericsson.zoom.PinchZoomListener;
import android.view.View;

public class TutorialZoomActivity4 extends Activity {

private ImageZoomView mZoomView;
private PinchZoomListener mPinchZoomListener;

   @Override
      public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);  

         mPinchZoomListener = new PinchZoomListener(getApplicationContext());
         mZoomView.setOnTouchListener(mPinchZoomListener);
         …
      }

Notice the use of the ImageZoomView class. This class provides a View that is capable of drawing an image at different zoom levels. The ImageZoomControl class is explained in Android one finger zoom tutorial- Part 1 that was published earlier in this blog.

If you’re familiar with the one finger zoom sample project that accompanies the Android one finger zoom tutorial, you’ll notice that the pinch-to-zoom sample is architected quite similarly to the one finger zoom application. The major difference is the addition of the PinchZoomListener.

Defining listener modes

The next thing to notice in PinchZoomListener is that it defines three listener modes, each indicating a touch state. Here is the definition:

private enum Mode {
    UNDEFINED, PAN, PINCHZOOM
}

private Mode mMode = Mode.UNDEFINED;

The three listener mode constants and their meanings are:

• PAN. Indicates that the user touched the screen and moved his or her finger over the view.
• PINCHZOOM. Indicates that the user touched the screen with a second finger while continuing to touch the screen with the first finger.
• UNDEFINED. Indicates that the state is not PAN or PINCHZOOM. The user may or may not be touching the screen. Initially the listener sets the state to UNDEFINED.

Handling gestures

The core of the processing is focused on handling user gestures. Recall from Part 1 of the tutorial that the handler uses the onTouch() method in the View.OnTouchListener interface to process touch events. Here is part of the definition of the onTouch() method in PinchZoomListener.

private VelocityTracker mVelocityTracker;
public boolean onTouch(View v, MotionEvent event) {
    final int action = event.getAction() & MotionEvent.ACTION_MASK;
    final float x = event.getX();
    final float y = event.getY();
if (mVelocityTracker == null) {
    mVelocityTracker = VelocityTracker.obtain();
   }
        mVelocityTracker.addMovement(event);
   …
 }

The onTouch() method uses the getAction() method to get the action from the MotionEvent object for the touch event. To get the action code, the onTouch() method performs a bitwise AND operation on the retrieved action and the ACTION_MASK constant. Then the method gets the X and Y coordinates of the touched position on the screen.

Notice the use of the VelocityTracker class. A VelocityTracker object will be used to track the velocity of the touch events.

Handling ACTION_DOWN events

After getting the action-related information from the MotionEvent object, your application needs to handle the action. Here is how the listener processes an ACTION_DOWN event, that is, when the user touches the screen with one finger:

switch (action) {
    case MotionEvent.ACTION_DOWN:
        mZoomControl.stopFling();
        mDownX = x;
        mDownY = y;
        mX = x;
        mY = y;
        break;

As its name implies, mZoomControl controls zooming in the application. It is assigned a DynamicZoomControl object that is provided in the setZoomControl() method of the application, as shown below.

public void setZoomControl(DynamicZoomControl control) {
    mZoomControl = control;
}

The DynamicZoomControl class is fully explained in Android one finger zoom tutorial – Part 4, published earlier in this blog. The stopFling() method of DynamicZoomControl stops the animation associated with a fling gesture. A fling gesture means that the user dragged an object across the screen and then removed his or her finger from the screen. This result is an animation in which the object continues to move but slows over time. The ACTION_DOWN event invokes stopFling() to stop processing the fling gesture. This handles the situation where the user made a fling gesture before retouching the screen.

The mX and mY variables are used to record the X and Y coordinates, respectively, of the current touch on the screen. The mDownX and mDownY variables are used to record the X and Y coordinates, respectively, of the previous touch on the screen. The four variables are set to the coordinate values for the current ACTION_DOWN event.

Handling ACTION_POINTER_DOWN events

Now let’s look at the code in PinchZoomListener that processes an ACTION_POINTER_DOWN event.

case MotionEvent.ACTION_POINTER_DOWN:
    if (event.getPointerCount() > 1) {
        oldDist = spacing(event);
        if (oldDist > 10f) {
            midPoint(mMidPoint, event);
            mMode = Mode.PINCHZOOM;
        }
    }
    break;

In this case, the user should have two fingers touching the screen. If so, the listener calculates the distance between the two fingers using a spacing() method, as follows.

private float spacing(MotionEvent event) {
    float x = event.getX(0) - event.getX(1);
    float y = event.getY(0) - event.getY(1);
    return FloatMath.sqrt(x * x + y * y);

You might wonder why the distance between the fingers is tested, that is, if(oldDist > 10f) {…}. The test is needed because the support in Android for multi-touch events such as pinch-to-zoom is still not optimal (see Limitations below). For example, sometimes Android incorrectly reports that two fingers are touching in almost the same position. To guard against anomalous situations such as this, the listener ignores events where the distance between the two fingers is less than a certain threshold (in this case 10f). If the distance is greater than the threshold, the listener finds the midpoint of the distance using a midPoint() method, as shown below. The midpoint will be used as the center point of the zoom.

private void midPoint(PointF point, MotionEvent event) {
        float x = event.getX(0) + event.getX(1);
        float y = event.getY(0) + event.getY(1);
        point.set(x / 2, y / 2);

With the two fingers now touching the screen, the listener sets the mode to PINCHZOOM.

Handling ACTION_MOVE events

Next, let’s look at the code in PinchZoomListener that handles an ACTION_MOVE event, where the user moves a finger across the screen.

case MotionEvent.ACTION_MOVE:
    final float dx = (x - mX) / v.getWidth();
    final float dy = (y - mY) / v.getHeight();

    if (mMode == Mode.PAN) {
        mZoomControl.pan(-dx, -dy);
    } else if (mMode == Mode.PINCHZOOM) {
        float newDist = spacing(event);
        if (newDist > 10f) {
            final float scale = newDist / oldDist;
            final float xx = mMidPoint.x / v.getWidth();
            final float yy = mMidPoint.y / v.getHeight();
            mZoomControl.zoom(scale, xx, yy);
            oldDist = newDist;
        }
    } else {
        final float scrollX = mDownX - x;
        final float scrollY = mDownY - y;

        final float dist =
            (float)Math.sqrt(scrollX * scrollX + scrollY * scrollY);

        if (dist >= mScaledTouchSlop ){
            mMode = Mode.PAN;
        }
    }

    mX = x;
    mY = y;
    break;

Here, the listener determines if the action is part of a pan gesture or a pinch-to-zoom gesture. In either case, it uses the dynamic zoom control to handle the gesture. The zoom action is handled by the zoom() method in the DynamicZoomControl class. The method performs its actions based on the scale of the zoom, an invariant X coordinate position, and an invariant Y coordinate position. The scale of the zoom and the invariant coordinates are defined as follows:

Here, the term invariant means the zoom method ensures that the coordinate value does not change during the course of the zoom.

Notice that the listener ignores the event if the mode is PINCHZOOM and the distance between the points is less than the space threshold. Again, this is to protect against anomalous results.

If the node is not PAN or PINCHZOOM, the listener tests to see if the move distance exceeds the distance at which the movement is considered scrolling in pixels. The listener sets the threshold from the current context using the getScaledTouchSlop() method. Here is the call to getScaledTouchSlop() in the listener.

private final int mScaledTouchSlop;

public PinchZoomListener(Context context) {
    mScaledTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
    …
}

If the move distance does exceed the threshold, the listener sets the mode to PAN.

Handling ACTION_POINTER_UP events

The next event type to examine is ACTION_POINTER_UP, the case where the user releases one finger while continuing to touch the screen with the other finger. Here is the code that handles that case.

case MotionEvent.ACTION_POINTER_UP:
    if(event.getPointerCount() > 1 &&  mMode == Mode.PINCHZOOM){
       panAfterPinchTimeout = System.currentTimeMillis() + 100;
    }
    mMode = Mode.UNDEFINED;
    break;

There is no zoom processing to perform for this event, so the listener simply sets a timeout threshold that it will use if the user subsequently pans across the screen. It then sets the mode to UNDEFINED.

Handling ACTION_UP events

Last, here is the way the ACTION_UP event is handled in the PinchZoomListener.

case MotionEvent.ACTION_UP:
    if (mMode == Mode.PAN) {
        final long now = System.currentTimeMillis();
        if(panAfterPinchTimeout < now){
           mVelocityTracker.computeCurrentVelocity(1000,
                  mScaledMaximumFlingVelocity);
           mZoomControl.startFling(
                  -mVelocityTracker.getXVelocity() / v.getWidth(),
                  -mVelocityTracker.getYVelocity() / v.getHeight());
        }
        } else if(mMode != Mode.PINCHZOOM) {
                  mZoomControl.startFling(0, 0);
        }
        mVelocityTracker.recycle();
        mVelocityTracker = null;

The ACTION_UP event covers the situation where the user has one finger touching the screen and then removes it from the screen. If the user was panning across the screen before removing the finger, the listener checks to see that timeout threshold wasn’t reached. If the threshold wasn’t reached, the listener starts a fling animation by calling the startFling() method of the Dynamic ZoomControl object.

When it makes the call to startFling(), the listener specifies the velocity in the X and Y dimensions. These velocities are used by the method in calculating the physics of the animation. If the mode is not PAN or PINCHZOOM, the listener simply releases control by calling the startFling() method and specifying 0 for the velocities in the X and Y dimensions.

Limitations

Xperia™ X10 is not yet fully optimized for multi-touch. There are some cases where a pinch-to-zoom gesture generates unusual behavior. For example, a user might not see the expected zoom in or zoom out in the field of view if he or she crosses the X or Y axis during a pinch-to-zoom gesture. For instance, the zoom in or zoom out might appear jumpy, as illustrated below.

In addition, a user might not see a smooth zoom in or zoom out movement if his or her fingers are aligned along the X or Y axis, as illustrated below.

Note too that the all points addressable screen in the Xperia™ X10 consists of an intersection matrix of row and column sense elements, as illustrated below.

This arrangement is termed dual layer.

The dual layer hardware registers the touch position of a finger in terms of a row and column. For two fingers, it registers two rows and two columns. However, the hardware does not necessarily distinguish which finger is touching the screen at the registered row and column. Also, the hardware does not necessarily distinguish which recorded value represents the row and which the column. As a result, when two fingers touch the screen, as in a pinch-to-zoom gesture, there are four possibilities of how the combined event is registered.

Suppose, for example, that the first finger (let’s call it finger A) touches the screen at row 1 column 1, and the second finger (let’s call it finger B) touches the screen at row 3 column 6, as shown in the following image.

The hardware might register the fingers in any of the following four ways:

• Finger A at row 1 and column 1 and finger B at row 3 column 6.
• Finger A at row 3 column 6 and finger B at row 1 column 1.
• Finger A at row 3 column 1 and finger B at row 1 column 6.
• Finger A at row 1 column 6 and finger B at row 3 column 1.

This type of axis flipping is also a general problem reported about the multi-touch support in Android 2.1.

Beyond the axis flipping problem, Android 2.1 sometimes records touches by multiple fingers as one finger touch or as multiple fingers touching at almost the same position. So it’s important to check for anomalous results where you can, as the PinchZoomListener in this tutorial does. Recall that the PinchZoomListener tests whether the distance between the two fingers is below a specified distance (10f), and if that distance is below the threshold, the listener ignores the touch event.

If you’re interested in testing your Xperia™ X10 device for multi-touch, you can use the MultiTouch Visualizer 2 application, which you can find in Android Market.

More information

• How to take advantage of the pinch-to-zoom feature in your Xperia™ 10 apps – Part 1>>>
• Learn more about Visualizer 2 in AndroidMarket>>>
• Learn more about Android development on Developer World>>>
• See Xperia™ X10 on the consumer website>>>

Recently Sony Ericsson rolled out an update to the Android™2.1 operating system in its Xperia™ X10 phones. One of the important new features in the update is support for a multi-touch gesture called pinch-to-zoom. In this first part of a two-part tutorial, you will learn how to take advantage of the pinch-to-zoom feature in your apps. In the second part of the tutorial, you’ll examine a code example that uses the pinch-to-zoom feature.

The pinch-to-zoom feature allows users to zoom in and get a closer, more detailed view of a display, or zoom out and get a wider field of view. For example, in the side-by-side image below, the image on the left shows a display zoomed out for a wider field of view. The image on the right shows the display zoomed in for a closer view.

The pinch-to-zoom feature lets users zoom out for a wider field of view, or zoom in for a closer view.

Although not initially available in the Android 2.1 support in Xperia™ X10, pinch-to-zoom is now available as an over-the-air (OTA) enhancement. Note however that Xperia™ X10 is not yet fully optimized for multi-touch. There are some cases where a pinch-to-zoom gesture generates unusual behavior. For more information, see the Limitations section in Part 2 of the tutorial.

You can take advantage of the pinch-to-zoom feature in applications that you develop for Xperia™ X10. Two applications that are packaged with Xperia™ X10 already take advantage of the feature: the web browser and Google Maps. There are also other applications that make use of this feature, such as Angry Birds.

Below is a video that demonstrates the pinch-to-zoom feature in Xperia™ X10.

Providing pinch-to-zoom capability in your Xperia™ X10 application

Your Xperia™ X10 application needs to do the following to provide pinch-to-zoom capability:

• Detect that the user has made a pinch-to-zoom gesture, such as moving two fingers across the screen. This is further explained below in Detecting and getting information about the gesture.
• Get information about the gesture, such as what the action was and when it took place. This is further explained below in Detecting and getting information about the gesture.
• Process the gesture, that is, respond to the user’s action, as appropriate. This is further explained below in Processing the gesture.

Detecting and getting information about the gesture

When a user touches the screen, Android creates an Android™ MotionEvent object to record information about the touch event, such as the action the user performed and the time when the user performed it. Your application needs to access the object in order to detect a pinch-to-zoom gesture and get information about it. This requires the application to first import the MotionEvent class as follows:

import android.view.MotionEvent;

Processing the gesture

To process the gesture, you create a callback handler. You can use the callback handler to take actions such as get information about a pinch-to-zoom gesture. However, first you need to register the callback handler using the setOnTouchListener() method of the Android View class, as shown in the following code snippet.

import android.view.View;
import android.view.View.OnTouchListener;
…
view.setOnTouchListener(onTouchListener);

The parameter to view.setOnTouchListener represented by onTouchListener is the callback handler, that is, the touch listener that you want to register. The callback handler is attached to a specific view. Touch events that are posted to that view are processed by the associated callback handler.

The callback handler must implement Android’s View.OnTouchListener interface and use the onTouch() method defined in the interface to process the touch events. When you call the onTouch() method, you need to supply as parameters a View object and a MotionEvent object, as shown below.

public class MyPinchZoom extends Activity implements OnTouchListener {

   public boolean onTouch(View v, MotionEvent event) {
      // Process touch events
   }

}

A user starts a pinch-to-zoom gesture by touching the screen with one finger. This event is represented in the MotionEvent object by the constant ACTION_DOWN. When the user touches the screen with a second finger while continuing to touch the screen with the first finger, that event is recorded in the MotionEvent object by the constant ACTION_POINTER_DOWN. Other constants represent other actions taken during the pinch-to-zoom gesture. Here are the set of action-related constants for the pinch-to-zoom gesture:

After you register the callback handler, you can use it to call methods on the MotionEvent object to get information about a pinch-to-zoom related event. For example, the getAction() method returns the type of action performed: up down, move , or cancel. The following code snippet shows a call to the getAction() method.

// Process touch events
      int action = event.getAction();

The lowest 8 bits of the action returned by getAction() represent the action code. To access the action code, you can perform a bitwise AND operation (using the & operator). The two operands of the AND operation are the result returned by getAction() and the MotionEvent constant, ACTION_MASK. The ACTION_MASK constant is a bit mask of the part of the action code that represents the action itself. The following line of code performs a bitwise AND operation on the action returned by getAction() and the ACTION_MASK constant.

int actionCode = action & MotionEvent.ACTION_MASK;

You can get the number of pointers (fingers) associated with the event by calling the getPointerCount() method of the MotionEvent object, as shown below.

int pCount = event.getPointerCount();

You can also retrieve the X and Y coordinates associated with the touch event by calling the getX() and getY() methods of the MotionEvent object, respectively. Here is an example that retrieves first the X coordinate and then the Y coordinate.

float xcoord = event.getX;
float ycoord = event.getY;

By identifying a pointer index as a parameter to getX() and getY(), you can retrieve the X and Y coordinates of a specific pointer. The following example shows how to get the X coordinate and Y coordinate of the first pointer.

Float  xcoord = event.getX(0);   //Get the X coordinate for the first
                                 // pointer
Float  ycoord = event.getY(1);   //Get the Y coordinate for the second
                                 // pointer

More information

• How to take advantage of the pinch-to-zoom feature in your Xperia™ X10 apps – Part 2>>>
• Learn more about Android development on Developer World>>>
• See Xperia™ 10 on the consumer website>>>

Are you looking for a way to build a mobile app that can run cross-platform? Do you need help in advertising your app? Do you want to integrate social networking into your app? You can find tools and services that can help you do these things and more in the Developer resources section on Developer World.

The Developer resources section lists more than 60 tools and services grouped into 13 categories — anywhere from advisory services, to games and gaming services, to performance tracking services, to user interface design services. Within those categories, you can find tools and services that can help you perform a wide range of tasks related to making your mobile app a success. For example, If you’re a developer interested in developing a business strategy for your app, you can find various services that can help you do that in the Advisory services category. Or perhaps you need help in adding navigation and other location-based features to your app. You can find various tools to help with that in the Location-based services category. Looking for a service to help monetize your app? You can find monetization-related services in the Billing services category.

The list of tools and services in the Developer resources section is dynamic and growing. You can contribute to that growth. If you have any suggestions or recommendations for additional tools and services that you found interesting or useful for your projects, let us know at DeveloperServices at sonyericsson.com.

Note that the tools and services listed in the Developer resources section are for informational purposes only. Sony Ericsson does not make any representation as to the suitability or usefulness of these resources.

More information

• Get information tools and services in the Developer resources section on Developer World>>>
• Learn about Sony Ericsson phones, technologies and tools in the Technology page on Developer World>>>