Download - Android Training in Bangalore By MobiGnosis
Android BootcampSESSION 9 – TOUCH EVENTS
Agenda Event Handlers & Event Listeners
Building Menus
Fling Gestures
Multi Touch events
Animation
Styles
2
Event Handlers and Event Listeners
Most user interaction with an Android device is captured by the system and sent to a corresponding callback method.
These events can be handled by extending the class and overriding the methods, called event handlers.
User interaction with View or ViewGroup objects can also support event listeners.
For example, the setOnClickListener() event listener can be registered for a button and when it is pressed, the onClick() method is called.
3
Intercepting a Physical Key Press 4
Source: Android Cookbook Text Book (Refer Handout)
Intercepting a Physical Key Press
The system first sends any KeyEvent to the appropriate callback method in the in-focus activity or view.
These callback methods are :
onKeyUp(), onKeyDown(), onKeyLongPress()—Physical key press callbacks.
onTrackballEvent(), onTouchEvent()—Trackball and touchscreen press callbacks
onFocusChanged()—Called when the view gains or loses focus
These can be overridden by the application to customize with different actions.
For example, to turn off the camera button (to avoid accidental presses), just consume the event in the onKeyDown() callback method for the Activity.
5
Intercepting a Physical Key Press
This is done by intercepting the method for the event KeyEvent.KEYCODE_CAMERA and returning true:
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_CAMERA) {
return true; // consume event, hence do nothing on camera button
}
return super.onKeyDown(keyCode, event);
}
By consuming the event, it does not get passed on to other Android components.
There are a few exceptions to this: The Power button and HOME key are intercepted by the system and do not reach the application for
customization.
The BACK, MENU, HOME, and SEARCH keys should not intercept the KeyDown but instead the KeyUp.
6
Building Menus
A developer can implement three types of menus in Android
Options menu—The main menu for an Activity that displays when the MENU key is pressed.
Context Menu—A floating list of menu items that displays when a view is long pressed.
Submenu—A floating list of menu items that displays when a menu item is pressed.
The Options menu is created the first time the MENU key is pressed in an activity.
This launches the onCreateOptionsMenu() method that usually contains Menu methods, such as:
menu.add(GROUP_DEFAULT, MENU_ADD, 0, "Add")
.setIcon(R.drawable.icon);
7
Building Menus
the onPrepareOptionsMenu() can be used if any of the menu options need to change during run-time
When an item from the options menu is clicked, the onOptionsItemSelected() method is called.
This passes the selected item ID, and a switch statement can be used to determine which option was selected.
Utilizing Search KEY
If an activity in the in-focus application is defined to be searchable, the SEARCH key invokes it.
The menu choice simply needs a call to onSearchRequested().
The searchable activity ideally should be declared as singleTop launch mode.
8
Listening for Fling Gestures
The possible gestures in the OnGestureListener interface are onDown()—Notifies when a tap down event occurs
onFling()—Notifies when a tap down, movement, and matching up event occurs
onLongPress()—Notifies when a long press occurs
onScroll()—Notifies when a scroll occurs
onShowPress()—Notifies when a tap down occurs before any movement or release
onSingleTapUp()—Notifies when a tap up event occurs
When only a subset of gestures are needed, the SimpleOnGestureListener class can be extended instead.
It returns false for any of the previous methods not explicitly implemented.
9
Listening for Fling Gestures
A fling consists of two events: a touch down (the first MotionEvent) and a release (the second MotionEvent).
Each motion event has a specified location on the screen given by an (x,y) coordinate pair, where x is the horizontal axis and y is the vertical axis.
The (x,y) velocity of the event is also provided.
10
Using Multi touch
A multi touch event is when more than one pointer (such as a finger) touches the screen at the same time.
This is identified by using a touch listener OnTouchListener, which receives multiple types of motion events: ACTION_DOWN—A press gesture has started with a primary pointer
(finger).
ACTION_POINTER_DOWN—A secondary pointer (finger) has gone down.
ACTION_MOVE—A change in press location has changed during a press gesture.
ACTION_POINTER_UP—A secondary pointer was released.
ACTION_UP—A primary pointer was released, and the press gesture has completed.
11
Style Resource
A style resource defines the format and look for a UI.
A style can be applied to an individual View (from within a layout file) or to an entire Activity or application (from within the manifest file).
file location : res/values/filename.xmlThe filename is arbitrary. The element's name will be used as the resource ID.
resource reference: In XML: @[package:]style/style_name
syntax:
<?xml version="1.0" encoding="utf-8"?><resources> <style name="style_name" parent="@[package:]style/style_to_inherit"> <item name="[package:]style_property_name" >style_value</item> </style></resources>
12
Style Resource EXAMPLE:
XML file for the style (saved in res/values/):
<?xml version="1.0" encoding="utf-8"?><resources> <style name="CustomText" parent="@style/Text"> <item name="android:textSize">20sp</item> <item name="android:textColor">#008</item> </style></resources>
XML file that applies the style to a TextView (saved in res/layout/):
<?xml version="1.0" encoding="utf-8"?><EditText style="@style/CustomText" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Hello, World!" />
13
Apply a theme to an Activity or application
To set a theme for all the activities of your application, open the AndroidManifest.xml file and edit the <application> tag to include the android:theme attribute with the style name. For example:
<application android:theme="@style/CustomTheme">
If you want a theme applied to just one Activity in your application, then add the android:theme attribute to the <activity> tag instead.
<activity android:theme="@style/CustomTheme">
Just as Android provides other built-in resources, there are many pre-defined themes that you can use, to avoid writing them yourself.
For example, you can use the Dialog theme and make your Activity appear like a dialog box:
<activity android:theme="@android:style/Theme.Dialog">
if you want the background to be transparent, use the Translucent theme:
<activity android:theme="@android:style/Theme.Translucent">
14
Android Animation
Android provides two types of animation: frame-by-frame and Tween animation.
Frame by frame animation shows a sequence of pictures in order. It enables developers to define the pictures to display, and then show them like a slideshow
Frame-by-frame animation first needs an animation-list element in the layout file containing a list of item elements specifying an ordered list of the different pictures to display.
<?xml version="1.0" encoding="utf-8"?>
<animation-list xmlns:android="http://schemas.android.com/apk/res/android"
android:oneshot="false">
<item android:drawable="@drawable/anddev1" android:duration="200" />
<item android:drawable="@drawable/anddev2" android:duration="200" />
<item android:drawable="@drawable/anddev3" android:duration="200" />
</animation-list>
15
Android Animation
To display the frame-by-frame animation, set the animation to a view’s background:
ImageView im = (ImageView) this.findViewById(R.id.myanimated);
im.setBackgroundResource(R.anim.animated);
AnimationDrawable ad = (AnimationDrawable)im.getBackground();
ad.start();
After the view background is set, a drawable can be retrieved by calling getBackground() and casting it to AnimationDrawable.Then, calling the start() method starts the animation.
16
Android Animation
Tween animation uses a different approach that creates an animation by performing a series of transformations on a single image.
In Android, it provides access to the following classes that are the basis for all the animations:
AlphaAnimation—Controls transparency changes
RotateAnimation—Controls rotations
ScaleAnimation—Controls growing or shrinking
TranslateAnimation—Controls position changes
These four Animation classes can be used for transitions between activities, layouts, views and so on.
All these can be defined in the layout XML file as <alpha>, <rotate>, <scale>,and <translate>.
They all have to be contained within an AnimationSet <set>
17