The document discusses various types of user input events and gestures in Android, including:
- Basic input events like key events, touch events, and focus changes.
- Common gestures like click, long click, scroll, and how to detect them using classes like GestureDetector and OnGestureListener.
- More advanced gestures involving multiple touches like pinch to zoom, which can be detected using ScaleGestureDetector.
- Drag and drop functionality, how it works, and the workflow involving OnDragListeners.
- How to handle menu creation and selection via XML menu resources and Java code overrides.
So in summary, it provides an overview of handling different types of user input and gestures
A comprehensive guide on developing responsive and common react filter componentKaty Slemon
A blog that will help you develop a responsive and common React Filter Component for both desktop and mobile views to maintain consistency across the UI.
This document provides a tutorial on using the Action Bar in Android applications. It discusses what the Action Bar is, how to add actions and menu items, customize the Action Bar, use navigation features like tabs and dropdown menus, and more advanced topics like custom views, contextual action modes, and action providers. Code examples are provided throughout to demonstrate various Action Bar features and capabilities.
The document discusses the basic components of an Android app. It explains that an Android app consists of components like activities, services, broadcast receivers, and content providers. Activities provide the main user interface and common ones include launching the app and navigating within it. The app manifest file defines these components. The document also covers activities and intents, explaining how activities are launched via explicit and implicit intents and how data can be passed between activities.
There are three main types of menus in Android: context menus, options menus, and submenus. Context menus appear with a long press on a view and don't support icons. Options menus appear when the device menu button is pressed and support icons. Submenus are used to organize related menu items under a title. It is best to define menus in XML resource files rather than creating them programmatically in code.
Android development - Activities, Views & IntentsLope Emano
Activities provide screens for user interaction and have lifecycles to manage memory. The lifecycle involves states like active, paused, stopped which trigger callbacks like onCreate(), onStart(), onPause(). Views are UI components like TextView and occupy a rectangular area, with attributes like width, height. ViewGroups arrange views and include LinearLayout and RelativeLayout. Input events like clicks are handled via listeners. Intents launch other activities by specifying the class and optional data.
The document discusses different types of views and view groups in Android user interface development. It describes layouts like LinearLayout, RelativeLayout and FrameLayout that extend the ViewGroup class. These layouts allow arranging views in different orientations using attributes like layout_width, layout_height, layout_weight etc. The document also talks about defining views and layouts in XML files or programmatically at runtime.
A comprehensive guide on developing responsive and common react filter componentKaty Slemon
A blog that will help you develop a responsive and common React Filter Component for both desktop and mobile views to maintain consistency across the UI.
This document provides a tutorial on using the Action Bar in Android applications. It discusses what the Action Bar is, how to add actions and menu items, customize the Action Bar, use navigation features like tabs and dropdown menus, and more advanced topics like custom views, contextual action modes, and action providers. Code examples are provided throughout to demonstrate various Action Bar features and capabilities.
The document discusses the basic components of an Android app. It explains that an Android app consists of components like activities, services, broadcast receivers, and content providers. Activities provide the main user interface and common ones include launching the app and navigating within it. The app manifest file defines these components. The document also covers activities and intents, explaining how activities are launched via explicit and implicit intents and how data can be passed between activities.
There are three main types of menus in Android: context menus, options menus, and submenus. Context menus appear with a long press on a view and don't support icons. Options menus appear when the device menu button is pressed and support icons. Submenus are used to organize related menu items under a title. It is best to define menus in XML resource files rather than creating them programmatically in code.
Android development - Activities, Views & IntentsLope Emano
Activities provide screens for user interaction and have lifecycles to manage memory. The lifecycle involves states like active, paused, stopped which trigger callbacks like onCreate(), onStart(), onPause(). Views are UI components like TextView and occupy a rectangular area, with attributes like width, height. ViewGroups arrange views and include LinearLayout and RelativeLayout. Input events like clicks are handled via listeners. Intents launch other activities by specifying the class and optional data.
The document discusses different types of views and view groups in Android user interface development. It describes layouts like LinearLayout, RelativeLayout and FrameLayout that extend the ViewGroup class. These layouts allow arranging views in different orientations using attributes like layout_width, layout_height, layout_weight etc. The document also talks about defining views and layouts in XML files or programmatically at runtime.
Android App Development - 02 Activity and intentDiego Grancini
1. An Intent is used to communicate between components in Android and can be explicit or implicit. It contains an action, data, and optional extras.
2. An Activity provides a visual user interface and is started using an Intent. Each Activity has a lifecycle that must be managed by the developer.
3. The system uses Intent filters declared in the manifest to match Activities to Intents and start the correct Activity.
The document discusses the four main components of an Android application: Activities, Services, Broadcast Receivers, and Content Providers. Activities provide user interfaces and handle user interactions. Services run in the background performing long-running tasks. Broadcast Receivers listen for system-wide broadcast announcements. Content Providers manage access to structured data between applications. Each component has a defined lifecycle and purpose for building Android applications.
The document discusses various types of user interfaces in Android. It describes the view hierarchy in Android using ViewGroups and Views as the basic building blocks. It explains common layouts like LinearLayout, RelativeLayout, TableLayout, GridLayout and ListView that can be used to arrange views. Key classes involved include View, ViewGroup, and different view subclasses that serve as widgets. The document also compares Java and Android approaches to designing user interfaces.
Raman Pandey's presentation discusses the basics of Android app development, including:
- Android is an open source operating system for mobile devices based on Linux.
- Java programming knowledge and software like Java JDK, Android SDK, and Android Studio are prerequisites.
- The Android architecture includes layers like applications, application framework, libraries and the Linux kernel.
- Application components, resources, intents, fragments, UI layouts and the emulator are discussed as fundamental concepts.
The document discusses the basic components of Android applications:
- Activities represent single screens and user interfaces. The first activity launched is the entry point.
- Services run in the background for long-running tasks like playing music.
- Broadcast receivers respond to messages from other apps and the system, like downloading completion.
- Content providers manage shared app data stored in files, databases, and more.
UI layouts define the structure and organization of elements in an Android activity's user interface. There are two main options for declaring layouts: in XML files or programmatically in Java code. Common layout types include LinearLayout, RelativeLayout, TableLayout, and FrameLayout. Layout files use a tree structure with attributes like ID, width, height, and weight to position child views. This allows separation of UI design from activity code.
This set of slides introduces the reader to the concepts of Android Activities and Views. After presenting these two concepts in general terms, it continues with a detailed description of the activity lifecycle. It follows a discussion on how to structure the user interface in terms of View and ViewGroup objects. Finally, the presentation shows how to frame Android application development within the dictates of the Model-View-Controller (MVC) pattern.
Android activity, service, and broadcast recieversUtkarsh Mankad
The document provides an overview of creating a basic "Hello World" Android application. It discusses creating a new Android project, the typical project file structure including the src, res, assets, and AndroidManifest.xml files. It also summarizes the purpose of activities, services, and broadcast receivers as core Android application components.
The action bar is a window feature that identifies the application and user location, and provides user actions and navigation modes. A notification is a message you can display to the user outside of your application's normal UI. When you tell the system to issue a notification, it first appears as an icon in the notification area. In this unit we will discuss about the action bar and notification usage in Android.
The document discusses various Android widgets such as TextView, ImageView, EditText, CheckBox, and RadioButton. It provides code examples for how to implement each widget in an Android application. For TextView, it demonstrates how to display simple text. For ImageView, it shows how to display an image. For EditText, it explains how to create an editable text field. For CheckBox, it provides an example of a checkbox that can be checked or unchecked. And for RadioButton, it discusses using radio buttons within a RadioGroup so that only one can be selected at a time.
An app widget allows users to interact with an app's key functionality directly from their home screen. This document discusses what app widgets are, how the app widget framework works, and the steps to create an app widget, including declaring an AppWidgetProvider in the manifest, creating AppWidgetProviderInfo metadata and layout XML files, writing the AppWidgetProvider class, and optionally adding an app widget configuration activity.
Android offers three types of application menus: options menus which appear when the user presses the menu button and contains the primary menu items for an activity; context menus which open with a long press on a view; and submenus which are nested menus that appear when an options menu item is selected. Options menus can be icon menus displaying the first six items or expanded menus showing additional items, and Android provides methods for creating, updating, and responding to selection of menu items. Context menus also allow registering views for long press context menus and handling item selection.
An Android activity presents a visual user interface for a focused task. It contains a hierarchy of views that provide the visual content and user interaction. Each activity has a default window and a content view hierarchy set with setContentView(). An application can contain multiple activities, with one specified as the initial activity in the manifest. Activities transition between running, paused, and stopped states, notifying the activity of changes through callback methods like onCreate(), onStart(), onResume(), etc. Activities are managed in a stack, with new activities placed on top and previous activities remaining below until the top activity exits.
This document summarizes key concepts about graphical elements, intents, and activities in Android app development:
I. Views and ViewGroups are the basic graphical elements in Android. Views occupy screen space while ViewGroups are invisible containers that define element placement. Layouts like LinearLayout are ViewGroups that organize widgets.
II. An example app interface is created with buttons, text views, and inputs. Buttons can define click behavior via listeners, methods, or implementing interfaces. Text fields read and modify content.
III. Intents pass actions and data between app components. ExplicitIntents specify started components while ImplicitIntents declare actions. Data is passed via extras. Activities can start each other and return results via
In this tutorial we take you through creating several simple custom components
from scratch using Java Swing as the implementation platform. It is hoped that readers
will get a better understanding of the MVC architecture from this document as well as
find within it a cook-book for creating MVC style custom GUI components for Java
Swing.
The presentation introduces the reader to the principles of user interaction in Android applications. First, events are introduced, together with the related concepts of callbacks and event listeners. It follows a discussion on how to handle events in a declarative fashion via the XML layout file.
Android is a mobile operating system based on the linux and kernel. It's maintained by Google, and comes in a few different versions. At the time of writing, mobile phones run a variant of version
This document discusses menus and dialogs in Android. It provides instructions on:
1) Adding a menu to an activity by defining menu resources and overriding lifecycle methods. It also describes how to add icons to menu items.
2) Adding menus to fragments, which requires setting a flag and uses a different callback signature.
3) Implementing an up button to navigate up the activity stack, which requires setting attributes and specific intent flags.
4) Creating simple and more complex dialogs by using AlertDialog.Builder and DialogFragment.
The document describes steps to create an Android application that allows user registration and login authentication using a database. It includes code snippets to:
1. Design activity layouts with input fields for registration and login.
2. Define a database and user table to store user details.
3. Insert initial user records and authenticate login details entered by the user against the database records.
4. Display appropriate dialogs like success or failed login based on authentication result.
Android App Development - 02 Activity and intentDiego Grancini
1. An Intent is used to communicate between components in Android and can be explicit or implicit. It contains an action, data, and optional extras.
2. An Activity provides a visual user interface and is started using an Intent. Each Activity has a lifecycle that must be managed by the developer.
3. The system uses Intent filters declared in the manifest to match Activities to Intents and start the correct Activity.
The document discusses the four main components of an Android application: Activities, Services, Broadcast Receivers, and Content Providers. Activities provide user interfaces and handle user interactions. Services run in the background performing long-running tasks. Broadcast Receivers listen for system-wide broadcast announcements. Content Providers manage access to structured data between applications. Each component has a defined lifecycle and purpose for building Android applications.
The document discusses various types of user interfaces in Android. It describes the view hierarchy in Android using ViewGroups and Views as the basic building blocks. It explains common layouts like LinearLayout, RelativeLayout, TableLayout, GridLayout and ListView that can be used to arrange views. Key classes involved include View, ViewGroup, and different view subclasses that serve as widgets. The document also compares Java and Android approaches to designing user interfaces.
Raman Pandey's presentation discusses the basics of Android app development, including:
- Android is an open source operating system for mobile devices based on Linux.
- Java programming knowledge and software like Java JDK, Android SDK, and Android Studio are prerequisites.
- The Android architecture includes layers like applications, application framework, libraries and the Linux kernel.
- Application components, resources, intents, fragments, UI layouts and the emulator are discussed as fundamental concepts.
The document discusses the basic components of Android applications:
- Activities represent single screens and user interfaces. The first activity launched is the entry point.
- Services run in the background for long-running tasks like playing music.
- Broadcast receivers respond to messages from other apps and the system, like downloading completion.
- Content providers manage shared app data stored in files, databases, and more.
UI layouts define the structure and organization of elements in an Android activity's user interface. There are two main options for declaring layouts: in XML files or programmatically in Java code. Common layout types include LinearLayout, RelativeLayout, TableLayout, and FrameLayout. Layout files use a tree structure with attributes like ID, width, height, and weight to position child views. This allows separation of UI design from activity code.
This set of slides introduces the reader to the concepts of Android Activities and Views. After presenting these two concepts in general terms, it continues with a detailed description of the activity lifecycle. It follows a discussion on how to structure the user interface in terms of View and ViewGroup objects. Finally, the presentation shows how to frame Android application development within the dictates of the Model-View-Controller (MVC) pattern.
Android activity, service, and broadcast recieversUtkarsh Mankad
The document provides an overview of creating a basic "Hello World" Android application. It discusses creating a new Android project, the typical project file structure including the src, res, assets, and AndroidManifest.xml files. It also summarizes the purpose of activities, services, and broadcast receivers as core Android application components.
The action bar is a window feature that identifies the application and user location, and provides user actions and navigation modes. A notification is a message you can display to the user outside of your application's normal UI. When you tell the system to issue a notification, it first appears as an icon in the notification area. In this unit we will discuss about the action bar and notification usage in Android.
The document discusses various Android widgets such as TextView, ImageView, EditText, CheckBox, and RadioButton. It provides code examples for how to implement each widget in an Android application. For TextView, it demonstrates how to display simple text. For ImageView, it shows how to display an image. For EditText, it explains how to create an editable text field. For CheckBox, it provides an example of a checkbox that can be checked or unchecked. And for RadioButton, it discusses using radio buttons within a RadioGroup so that only one can be selected at a time.
An app widget allows users to interact with an app's key functionality directly from their home screen. This document discusses what app widgets are, how the app widget framework works, and the steps to create an app widget, including declaring an AppWidgetProvider in the manifest, creating AppWidgetProviderInfo metadata and layout XML files, writing the AppWidgetProvider class, and optionally adding an app widget configuration activity.
Android offers three types of application menus: options menus which appear when the user presses the menu button and contains the primary menu items for an activity; context menus which open with a long press on a view; and submenus which are nested menus that appear when an options menu item is selected. Options menus can be icon menus displaying the first six items or expanded menus showing additional items, and Android provides methods for creating, updating, and responding to selection of menu items. Context menus also allow registering views for long press context menus and handling item selection.
An Android activity presents a visual user interface for a focused task. It contains a hierarchy of views that provide the visual content and user interaction. Each activity has a default window and a content view hierarchy set with setContentView(). An application can contain multiple activities, with one specified as the initial activity in the manifest. Activities transition between running, paused, and stopped states, notifying the activity of changes through callback methods like onCreate(), onStart(), onResume(), etc. Activities are managed in a stack, with new activities placed on top and previous activities remaining below until the top activity exits.
This document summarizes key concepts about graphical elements, intents, and activities in Android app development:
I. Views and ViewGroups are the basic graphical elements in Android. Views occupy screen space while ViewGroups are invisible containers that define element placement. Layouts like LinearLayout are ViewGroups that organize widgets.
II. An example app interface is created with buttons, text views, and inputs. Buttons can define click behavior via listeners, methods, or implementing interfaces. Text fields read and modify content.
III. Intents pass actions and data between app components. ExplicitIntents specify started components while ImplicitIntents declare actions. Data is passed via extras. Activities can start each other and return results via
In this tutorial we take you through creating several simple custom components
from scratch using Java Swing as the implementation platform. It is hoped that readers
will get a better understanding of the MVC architecture from this document as well as
find within it a cook-book for creating MVC style custom GUI components for Java
Swing.
The presentation introduces the reader to the principles of user interaction in Android applications. First, events are introduced, together with the related concepts of callbacks and event listeners. It follows a discussion on how to handle events in a declarative fashion via the XML layout file.
Android is a mobile operating system based on the linux and kernel. It's maintained by Google, and comes in a few different versions. At the time of writing, mobile phones run a variant of version
This document discusses menus and dialogs in Android. It provides instructions on:
1) Adding a menu to an activity by defining menu resources and overriding lifecycle methods. It also describes how to add icons to menu items.
2) Adding menus to fragments, which requires setting a flag and uses a different callback signature.
3) Implementing an up button to navigate up the activity stack, which requires setting attributes and specific intent flags.
4) Creating simple and more complex dialogs by using AlertDialog.Builder and DialogFragment.
The document describes steps to create an Android application that allows user registration and login authentication using a database. It includes code snippets to:
1. Design activity layouts with input fields for registration and login.
2. Define a database and user table to store user details.
3. Insert initial user records and authenticate login details entered by the user against the database records.
4. Display appropriate dialogs like success or failed login based on authentication result.
The document discusses activities, intents, and event listeners in Android. It defines an activity as a single focused thing the user can interact with and explains the activity lifecycle including methods like onCreate, onStart, onResume, etc. It describes intents as messages that allow communication between app components and how they are used to start activities. It also defines event listeners as a way to handle user interactions and collect data on events like button presses. It provides examples of registering different types of event listeners including anonymous inner classes and having the activity implement listener interfaces.
1. The document discusses Android activities, which provide interactive screens for users to perform tasks. Activities are created by subclassing the Activity base class and implementing callback methods like onCreate.
2. The document also discusses how to navigate between activities using intents, and how activities transition through various lifecycle states like onStart and onStop. An example app with registration and login activities is provided to demonstrate navigation between activities.
3. The document explains how to use shared preferences to store persistent data in Android applications. Shared preferences can be accessed via the PreferenceManager and values can be read and written by getting and putting values with keys. An example demonstrates reading a value set in a previous app session.
This document provides an introduction to jQuery, including:
- What jQuery is and its main features like DOM manipulation, CSS manipulation, events, effects, animations, and AJAX.
- The benefits of jQuery like being browser independent and increasing coding speed.
- How to add jQuery to web pages by downloading the jQuery library, including the jQuery file, and writing jQuery code within script tags.
- jQuery selectors that allow selecting elements based on name, id, classes, attributes, and more. Common selectors include element, id, class, and universal selectors.
- jQuery events like click, change, submit, and how to attach event handler functions using methods like click(), change
This document provides an overview of ActionBar, Toasts, Notifications, and Preferences in Android app development. It discusses:
1. How to add actions to the ActionBar using a menu XML resource and reacting to clicks by overriding onOptionsItemSelected.
2. How to create and display Toast notifications for simple feedback messages using the Toast class.
3. How to build and trigger Notifications using NotificationCompat.Builder and the NotificationManager, including required notification components.
4. How to create a Preferences UI using PreferenceActivity and Preference subclasses defined in an XML preferences file.
The document discusses several new features and APIs in Android 3.0 (Honeycomb) for tablets, including fragments which allow recomposing UI based on factors like screen size, loaders for asynchronously fetching content, an enhanced action bar for navigation and menus, hardware accelerated graphics, and the new holographic UI design. It also questions what some aspects of Android 3.0 may mean for future phone releases and how to detect "tablet-y" systems.
The document provides instructions for creating an Android application to demonstrate the activity lifecycle and passing data between activities. It involves creating multiple activities and linking them together. The main activity displays buttons to launch a second activity, select a contact, and change the background color. Methods are added to each activity to log lifecycle events to the logcat. When changing color or selecting contact, data is passed back to the main activity using startActivityForResult and onActivityResult. This allows the main activity to update the UI based on the result from other activities.
The document provides instructions for creating an Android application to demonstrate the activity lifecycle and passing data between activities. It involves creating multiple activities and linking them together. The main activity displays buttons to launch a second activity, select a contact, and change the background color. Methods are added to each activity to log lifecycle events to the logcat. When changing color or selecting contact, data is passed back to the main activity using startActivityForResult and onActivityResult. This allows the main activity to update the UI based on the result from other activities.
02 programmation mobile - android - (activity, view, fragment)TECOS
This document discusses Android activities and views. It explains that an activity represents a single screen in an app that the user can interact with. The activity lifecycle and methods like onCreate, onPause, onResume are described. Views like buttons, text fields, images are covered along with their attributes. It also discusses intents for launching activities, passing data between activities, and handling activity results.
The Android user interface (UI) is composed of interactive visual elements called views and view groups. Views are used to display things on screen and can be defined in code or XML layout files. Common views include text views, buttons, and image views. Layouts organize views in different visual structures and can also be defined in code or XML. Common layouts include linear, relative, grid, and list. Interaction events like clicks are handled using listeners. Menus, dialogs, notifications, and toasts are also key UI components.
Fragments represent reusable portions of user interface in an activity. An activity can host multiple fragments that the user can navigate between. Fragment transactions allow adding, replacing, and removing fragments within an activity. Fragments can communicate with each other using interfaces to pass data between fragments hosted by the same activity.
[/SUMMARY]
This document provides a quick introduction to Android development. It discusses Android Studio as the primary IDE for Android development and its features. It also covers templates, running apps, building UIs with code and XML, using resources and the R class, basic event handling, Logcat for viewing logs, and best practices for logging.
Android Event and IntentAndroid Event and Intentadmin220812
The document discusses different ways of handling events in Android, including XML-based event handling, Java-based event handling using interfaces like OnClickListener, and anonymous classes. It provides code examples for handling click, long click, focus change, key press, touch and other events on views like buttons, edit texts, checkboxes and more. It also covers using intents to start new activities and passing extras with intents.
The document provides instructions on installing the Android SDK and setting up a development environment in Netbeans or Eclipse. It describes the basic building blocks of an Android application including activities, intents, services, and content providers. It also covers creating user interfaces with views and view hierarchies, handling click events, and building a simple form layout with widgets like text fields, buttons, and radio buttons.
This document provides an overview of WinForms GUI programming in .NET. It discusses how event-driven programming works in WinForms applications and how Visual Studio supports drag-and-drop design of WinForms. It also describes some key concepts like forms, controls, properties and events. The document explains how to set up a basic WinForms application and interact with common controls like labels, text boxes and buttons.
11.11.2020 - Unit 5-3 ACTIVITY, MENU AND SQLITE DATABASE.pptxMugiiiReee
This document provides information about activities, menus, intents, services, broadcast receivers and SQLite database in Android. It discusses the activity lifecycle and different types of activities. It explains the concept of intents and how they are used to start activities, services and broadcast receivers. It covers the different types of menus like option menu, context menu and popup menu. It discusses services, their types and lifecycle. It provides details about broadcast receivers, how they receive and respond to broadcast messages. It also gives an overview of SQLite database and how it is used in Android applications for data storage.
Menus are a common user interface component in many types of applications. To provide a familiar and consistent user experience, you should use the Menu APIs to present user actions and other options in your activities.
7. Other events
• Click
‣ Touch a clickable view
‣ Focus a view and press the action
button
‣ Call view.performClick()
• Long click
‣ Same as click. It’s just... longer
8. Other events
• Focus change
‣ Use DPad to select another view
‣ Call view.requestFocus()
• Create context menu
‣ Long click a view which is registered
for context menu
9. Handling events
• Register an event listener
OnEventListener listener = new OnEventListener() {
public void/boolean onEvent(...) {...}
};
view.setOnEventListener(listener);
10. Handling events
• Register an event listener
OnEventListener listener = new OnEventListener() {
public void/boolean onEvent(...) {...}
};
view.setOnEventListener(listener);
Key
Touch
FocusChange
CreateContextMenu
Click
LongClick
11. Handling events
• Register an event listener
OnClickListener listener = new OnClickListener() {
public void onClick(View view) {...}
};
view.setOnClickListener(listener);
Click listener example:
13. The InputEvent
object
• Holds the event parameters
• Comes in two flavors - KeyEvent and
MotionEvent
• You receive it as an argument in your
callback
• Some methods worth mentioning:
‣ getAction()
‣ getKeyCode()
‣ getX(), getY()
19. ActionBar and Menus
• The default activity in Andriod Studio is an ActionBarActivity (via
the support.v7 library)
• This provides an ActionBar and menu in the same place back
to Android 2.3.3 (api 10)
• For the purpose of this lecture, that is what I’m going to use.
We have full support for fragments, ActionBar, and menus
• There is an older menu system from api 1, that still works,
but I’m not covering it.
• Note, there is a new ToolBar (via support.v7 library) that can
replaces the ActionBar and allows more support for lollipop
APIs, which we will see later.
• Also the toolbar can be moved around the screen and
support Material Design elements.
20.
21. Menus
• Menus are created via an xml document
– First create a menu xml (normally in res/menu)
with menu as the type.
• You can add items (and sub menus). You can also group
the items as well.
22. Menu.xml example:
<group android:id="@+id/group1">
<item android:id="@+id/item1"
android:orderInCategory="5"
android:title="item1"/>
<item android:id="@+id/item2"
android:orderInCategory="10"
android:title="item2"/>
<item android:id="@+id/item3"
android:orderInCategory="1"
android:title="item3"/>
<item android:id="@+id/item4"
android:orderInCategory="3"
android:title="item4"/>
<item android:id="@+id/item5"
android:orderInCategory="2"
android:title="item5"/>
</group>
• Note the
orderInCategory
determines the order of
display, so this will
show:
Item3
Item5
Item3
Item1
item2
23. Sub menus in xml
• Create and item that
will be the submenu
heading
– Then create a menu
instead of the item tags.
<menu>
<item>
...
<menu>
...
</menu>
...
</item>
</menu>
24. Menu Java code
• Use onCreateOpensMenu and onOptionsItemSelected
• Which android studio creates for you by default
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here.
int id = item.getItemId();
if (id == R.id. item1) { //assuming previous xml document
return true; //do something here to handle the menu.
} … //handle the rest.
return super.onOptionsItemSelected(item);
}
25. Popup menus.
• Add a click listener (or longtouch, whatever) to
anything.
– We are using a TextView, so make sure it clickable
– It will then call our code, called
showPopupMenu(View v)
• Note this is not an override, just a method we are using
public void onClick(View v) {
showPopupMenu(v);
}
28. Fragments and Menus
• Fragments can contribute to the menu as well
– Including if there is no menu.
– In the OnCreate() method of the fragment, you must
add
• setHasOptionsMenu(true);
– Otherwise the menu methods will not be called.
• A note, when the fragment is showing, the menu
will be there and when the fragment is
“removed”, then those menu items are removed
as well.
– Remember, fragments are nice, because of the
encapsulation.
29. Fragments and Menus (2)
• Override the following, note the onCreateOptionsMenu is a little different
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
super.onCreateOptionsMenu(menu, inflater);
inflater.inflate(R.menu.frag2menu, menu);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.frag2item:
//do something.
return true;
}
return super.onOptionsItemSelected(item);
}
31. Menu creation
• Menu items can be changed later by
– invalidateOptionsMenu();
– Which calls the onCreateOptionsMenu method
again.
– So if you need to change, enable/disable menu
items, you can pretty easily.
33. Action Bar
• The Action bar can provide a “Back” button to
the parent Activity.
• We can also add “buttons”, except they are
menu items, via the xml
– We can also add sub menu to the ActionBar that
drop down when clicked.
34. Xml code
• From Googles page: http://developer.android.com/guide/topics/resources/menu-
resource.html
– Using the xmlns:app="http://schemas.android.com/apk/res-auto"
• app:showAsAction=
– ifRoom
• Only place this item in the Action Bar if there is room for it.
– withText
• Also include the title text (defined by android:title) with the action item. You can include this value
along with one of the others as a flag set, by separating them with a pipe |.
– never
• Never place this item in the Action Bar.
– always
• Always place this item in the Action Bar. Avoid using this unless it's critical that the item always
appear in the action bar. Setting multiple items to always appear as action items can result in them
overlapping with other UI in the action bar.
– collapseActionView
• The action view associated with this action item (as declared by android:actionLayout or
android:actionViewClass) is collapsible.
– Introduced in API Level 14.
35. Xml code example
<menu … xmlns:app="http://schemas.android.com/apk/res-auto" >
<item android:id="@+id/actionmenu_settings"
app:showAsAction="ifRoom"
android:title="@string/action_settings"/>
<item android:id="@+id/submenu"
android:title="sub menu"
app:showAsAction="always" >
<menu>
<item android:id="@+id/asubitem1"
android:orderInCategory="1"
android:title="subitem1"/>
<item android:id="@+id/asubitem2"
android:orderInCategory="2"
android:title="subitem2"/>
</menu>
</item>
<item android:id="@+id/amenuitem1"
android:title="item1"/>
<item android:id="@+id/amenuitem2"
android:title="item2"/>
</menu>
Show if room, if not show in normal
menu
Always shows and creates a
Drop menu (separate from standard
Menu)
Normal menu items
36. End result
• This shows how it can look
– The sub menu item has been clicked to show the
sub menu.
37. Action Bar
• We can also have “buttons” as well and change them
as needed, programmatically.
• This example uses the ViewPager fragment example
and adds buttons for Previous and Next
– also finish, but that doesn’t do anything
• The buttons may show at the bottom of the screen if
there is not enough space on the actionbar.
38. Java code
• We need to use the invalidateOptionsMenu();
every time the page is changed, so
– Using the ViewPager.setOnPageChangeListener(…)
• Otherwise the main work is in the
onCreateOptionsMenu(Menu menu)
39. OnCreateOptionsMenu
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
getMenuInflater().inflate(R.menu.activity_screen_slide, menu);
• Enable the previous menu item, if we are not on the first page (xml).
• menu.findItem(R.id.action_previous).setEnabled(viewPager.getCurrentItem() > 0);
• Add either a "next" or "finish" button to the action bar, depending on which page
is currently selected. Done programmatically.
MenuItem item = menu.add(Menu.NONE, R.id.action_next, Menu.NONE,
(viewPager.getCurrentItem() == mPagerAdapter.getCount() - 1)
? R.string.action_finish
: R.string.action_next);
item.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM |
MenuItem.SHOW_AS_ACTION_WITH_TEXT);
return true;
}
40. And the result looks like
• First page:
• Third page
• Last page
41. Other things xml .
• android:titleCondensed="string“
• android:icon="@[package:]drawable/drawable_resource_name“
• android:onClick="method name“
• android:actionLayout="@[package:]layout/layout_resource_name
"
• android:actionViewClass="class name"
• android:actionProviderClass="class name"
• android:alphabeticShortcut="string"
• android:numericShortcut="string"
• android:checkable=["true" | "false"]
• The layout allows you to add say a search bar to the top.
43. What is a gesture?
• A series of touch events with pre-defined
behavior
• Common gestures:
Fling Long Press Pinch Scroll
44. Detecting Gestures
• The easy way:
1. Create a gesture listener - either
implement OnGestureListener or
extend SimpleOnGestureListener
2. Create a GestureDetector with your
gesture listener
3. Pass all touch events of your view to
the GestureDetector
45. Detecting Gestures
• The hard way:
1. Handle touch events for your view
2. Inspect the history of pointer
movement and detect patterns - too
messy for this lecture
3. Make sure no one steals your events -
even messier... Involves methods like
onInterceptTouchEvent and
requestDisallowInterceptTouchEvent
47. Drag & Drop
• Available since API level 11 (Android
3.0.x)
• Only works within a single application
• Allows users to move data (and other
stuff) within your Activity layout
48. Drag & Drop Workflow
• Register OnDragListeners for each
View you want to support drag & drop
• Call view.startDrag() whenever you
decide, e.g. when view is long pressed
• Respond to the incoming drag events
through your OnDragListeners
57. Handling Common Gestures
Create a GestureDetector.OnGestureListener (Several Gestures) or a
GestureDetector.SimpleOnGestureListener (More Gestures)
Use the GestureDetecture class
Add a GestureDetector object to the View
Override View.onTouchEvent method to pass MotionEvent on to the
GestureDetector.onTouchEvent method
Override the callback methods for onScroll, onLongPress, onFling,
onSingleTapConfirmed, etc.
58. Motion Event
Motion events describe movements in terms of an action code and a set of
axis values. The action code specifies the state change that occurred such as
a pointer going down or up. The axis values describe the position and other
movement properties.
For example, when the user first touches the screen, the system delivers a
touch event to the appropriate View with the action code ACTION_DOWN
and a set of axis values that include the X and Y coordinates of the touch
and information about the pressure, size and orientation of the contact
area.
Some devices can report multiple movement traces at the same time. Multi-
touch screens emit one movement trace for each finger. The individual
fingers or other objects that generate movement traces are referred to as
pointers. Motion events contain information about all of the pointers that
are currently active even if some of them have not moved since the last
event was delivered.
59. Simple Gesture Demo
App that listens for simple gestures
Updates lower TextView in call back methods
61. Gesture Demo
Here, simply pass event on to the GestureDetectorCompat object.
◦ It will call back methods
@Override
public boolean onTouchEvent(MotionEvent event) {
gestureDetectorCompat.onTouchEvent(event);
return super.onTouchEvent(event);
}
62. Callback methods for
OnGestureLitener
@Override
public boolean onDown(MotionEvent e) {
gesture.setText("Down");
return true;
}
@Override
public void onShowPress(MotionEvent e) {
gesture.setText("Show Press");
}
@Override
public boolean onSingleTapUp(MotionEvent e) {
gesture.setText("Single Tap Up");
return true;
}
66. Multi Touch Gestures
Multiple fingers (pointers) touch screen at the same time
Handled via MotionEvents
Each pointer has a MotionEvent
Track via index (an array of MotionEvents) or ID
MotionEvent object sent to onTouch contains number of “pointers”
involved
67. Displaying Multitouch data
Using methods of MotionEventCompat class
@Override
public boolean onTouchEvent(MotionEvent event) {
if(event.getPointerCount() > 1){
gesture.setText("Multi TouchnEvent");
int action = event.getAction();
int index = event.getActionIndex();
gesture.append("n"+ actionToString(action)+"n Pointer Index: "+index);
}
gestureDetectorCompat.onTouchEvent(event);
return super.onTouchEvent(event);
}
69. Scale Gestures
Create a class that implements
◦ ScaleGestureDetector.OnScaleGestureListener
OR a class that extends
◦ ScaleGestureDetector.SimpleOnScaleGestureListener
◦ Implement methods with dummy methods
◦ Override only the methods you care about
Create a ScaleGestureDetector with listener
Pass MotionEvents from onTouch
70. Scaling Example
public class MainActivity extends Activity implements ScaleGestureDetector.OnScaleGestureListener{
private TextView textView;
private float scale = 1f;
private float onScaleBegin = 0;
private float onScaleEnd = 0;
private ScaleGestureDetector detector;
String TAG = "DBG";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
textView = findViewById(R.id.textView);
detector = new ScaleGestureDetector(this, this);
}
public boolean onTouchEvent(MotionEvent event) {
detector.onTouchEvent(event);
return super.onTouchEvent(event);
}
@Override
public boolean onScale(ScaleGestureDetector detector) {
scale *= detector.getScaleFactor();
// Don't let the object get too small or too large.
scale = Math.max(0.1f, Math.min(scale, 5.0f));
textView.setText(“Scale Factor:”+scale);
return true;
}
@Override
public boolean onScaleBegin(ScaleGestureDetector detector) {
Log.d(TAG, "onScaleBegin");
onScaleBegin = scale;
return true;
}
@Override
public void onScaleEnd(ScaleGestureDetector detector) {
Log.d(TAG, "onScaleEnd");
onScaleEnd = scale;
if (onScaleEnd > onScaleBegin) {
Toast.makeText(getApplicationContext(), "Scaled Up by a factor of " + String.valueOf(onScaleEnd /
onScaleBegin), Toast.LENGTH_SHORT).show();
}
if (onScaleEnd < onScaleBegin) {
Toast.makeText(getApplicationContext(), "Scaled Down by a factor of " + String.valueOf(onScaleBegin /
onScaleEnd), Toast.LENGTH_SHORT).show();
}
}
}
72. Complex Gestures
Gesture Builder App on your device(Real
or Emulator)
◦ To define custom gestures you want your
app to recognize
Open the Gesture Builder App and
create your custom gestures as shown in
the gif image
◦ Each gesture is associated with a name
◦ Limited to single pointer
◦ Multiple gestures can have same name
◦ Variations on same gesture, better chance of
recognizing
Note: To see the image start slide show
73. Custom Gestures
After create above custom gestures, the app will create a file which
name is gesture.txt in the emulator to store the two gesture info. The
file is saved in
directory /storage/emulated/0/Android/data/pack.GestureApp.
Although it has a txt suffix, but the file is a binary file in fact.
To get above gesture.txt file, open Device File Explorer as shown below.
74. Contd.
Navigate to the directory
/storage/emulated/0/Android/data/pack.GestureApp, right click on
gesture.txt and save it as gesture.txt in the raw folder within your app’s
res folder.
Now you can use your defined custom gestures in your application
75. Recognize Custom Gesture In
Android Source Code
Recognize gestures via GestureOverlayView
◦ This widget is kind of a simple drawing board that shows and
captures user gestures.
When gesture is completed GestureLibrary is queried to see if
gesture is recognized
Predictions are made between entered gesture and those in
the library
76. Steps
Add a widget of GestureOverlayView class in layout xml file.
Create a class that implements
GestureOverlayView.OnGesturePerformedListener interface
◦ override it’s onGesturePerformed method
Create an instance of the class just created and
invoke GestureOverlayView‘s addOnGesturePerformedListener metho
d to set it.
Then when you start the app, gesture overlay view widget will capture
any gesture you performed and use the custom listener to response to
it.
82. Navigation Drawer
• Provides a slider window that allows you have
navigation, like a listview, but not always on
screen.
Closed Opened
83. Navigation Drawer
• It uses a Drawer layout that takes two “views”
– Both views are likely layouts or fragments
– View/layout 1 is the main content.
– The one that shows when the drawer is closed.
– View/layout 2 is the drawer content.
– What shows when the drawer is open.
» Mostly like has a listview as well.
84. Navigation Drawer xml code
<android.support.v4.widget.DrawerLayout … android:id="@+id/drawer_layout"
android:layout_width="match_parent" android:layout_height="match_parent">
<!-- As the main content view -->
<…Layout
android:layout_width="match_parent"
android:layout_height="match_parent">
<!-- whatever views/widgets needed -->
</…Layout>
<!– drawer content view -->
<ListView android:id="@+id/left_drawer"
android:layout_gravity="start" //default left to right and switch for right to left
languages.
android:choiceMode="singleChoice"/>
</android.support.v4.widget.DrawerLayout>
85. DrawerLayout Java
• The listview is setup like normal
– Except on a selection, we also close the drawer.
mDrawerLayout = (DrawerLayout) findViewById(R.id.drawer_layout);
In the setOnItemClickListener use mDrawerLayout.closeDrawers();
• We need to tie the drawer to the actionbar, so
the icons show, uses the
ActionBarDrawerToggle.
86. DrawerLayout Java (2)
• enable ActionBar app icon to behave as action to toggle nav drawer
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
getSupportActionBar().setHomeButtonEnabled(true);
• ActionBarDrawerToggle ties together the proper interactions between the sliding drawer and the action
bar app icon
mDrawerToggle = new ActionBarDrawerToggle(this, /* host Activity */
mDrawerLayout, /* DrawerLayout object */
R.string.drawer_open, /* "open drawer" description for accessibility */
R.string.drawer_close /* "close drawer" description for accessibility */
) {
public void onDrawerClosed(View view) {
getSupportActionBar().setTitle(R.string.app_name); //change the title back , when closed.
invalidateOptionsMenu(); // creates call to onPrepareOptionsMenu()
}
public void onDrawerOpened(View drawerView) {
getSupportActionBar().setTitle("Categories"); //change the name, when opened.
invalidateOptionsMenu(); // creates call to onPrepareOptionsMenu()
} };
mDrawerLayout.setDrawerListener(mDrawerToggle);
87. DrawerLayout Java (3)
• Lastly, these two or it doesn’t drawer correctly in the actionbar.
/**
* When using the ActionBarDrawerToggle, you must call it during
* onPostCreate() and onConfigurationChanged()...
*/
@Override
protected void onPostCreate(Bundle savedInstanceState) {
super.onPostCreate(savedInstanceState);
// Sync the toggle state after onRestoreInstanceState has occurred.
mDrawerToggle.syncState();
}
@Override
public void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
// Pass any configuration change to the drawer toggls
mDrawerToggle.onConfigurationChanged(newConfig);
}
88. DrawerLayout Java (4)
• Lastly, a fix to the menu as well.
public boolean onOptionsItemSelected(MenuItem item) {
// The action bar home/up action should open or
close the drawer.
// ActionBarDrawerToggle will take care of this.
if (mDrawerToggle.onOptionsItemSelected(item)) {
return true;
}
…
89. Demos
• The NavDrawerFragDemo
– Uses the Shakespeare fragments from listview demos
in the Drawerlayout
• Not the ListFragment, since you need to change the text
color correctly, for a dark background and light text color.
• Also changing the listview rowlayout.
• NavDrawer is google example, show a listview and
fragment.
– Some corrections for the newer version of the
drawerlayout.
90. ToolBar
• The ToolBar is a replacement for the ActionBar
– Basically everything works the same, but uses a
support.v7.widget.Toolbar.
– It’s better suited to cover with Lollipop and
Material Design lecture.