Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

Basic of Android App Development

6,310 views

Published on

This PPT is designed to give you a high level overview of Android as a development platform. It provide introduction to what the Android operating system is, how we got here, what makes it fundamentally different than any other platform, and how to take advantage of its uniqueness. By the end of this course, you will have a complete understanding of the entire operating system, at a high level

Published in: Education

Basic of Android App Development

  1. 1. BASIC OF ANDROID
  2. 2. 1. Introduction to Mobile Technologies 2. Introduction of Android 3. Android Building Blocks 4. Introduction of the Development tool “Eclipse” 5. Testing and Debugging Android Application 6. Android Activities 7. UI Design 8. Using Android system services 9. Database - SQLite 10.Broadcast
  3. 3. 1. INTRODUCTION TO MOBILE TECHNOLOGY
  4. 4. INTRODUCTION TO MOBILE TECHNOLOGIES 1.1 Background about mobile technologies 1.2 Why to use Android for mobile development?
  5. 5. 1.1 BACKGROUND ABOUT MOBILE TECHNOLOGIES • Mobile technology is the technology used for cellular communication. • Since the start of this millennium, a standard mobile device has gone from being no more than a simple two-way pager to being a mobile phone, GPS navigation device, an embedded web browser and instant messaging client, and a handheld game console.
  6. 6. 1.1 MOBILE TECHNOLOGY (CONTD.) • Many types of mobile operating systems (OS) are available for smartphones, including: Android, BlackBerry OS, IOS, Symbian, Windows Mobile and Bada. Among the most popular are the Apple iPhone, and Android.
  7. 7. ANDROID • Android is an operating system based on Linux with a Java programming interface. • Android is a mobile operating system (OS) developed by Google. Android is the first completely open source mobile OS, meaning that it is free to any cell phone carrier. • Building on the contributions of the open-source Linux community and more than 300 hardware, software, and carrier partners, Android has rapidly become the fastest-growing mobile OS.
  8. 8. ANDROID VERSIONS Version Codename API 1.6 Donut 4 2.1 Eclair 7 2.2 Froyo 8 2.3 - 2.3.2 Gingerbread 9 2.3.3 - 2.3.7 10 3.1 Honeycomb 12 3.2 13 4.0.3 - 4.0.4 Ice Cream Sandwich 15 4.1 Jelly Bean 16 4.2 17
  9. 9. ANDROID MARKET SHARE • Android Dominates Worldwide Smartphone Market, Powers 80 Percent Of All Smartphones Shipped In Q2
  10. 10. Mobile Application • A mobile application (or mobile app) is a software application designed to run on smartphones, tablet computers and other mobile devices. • Mobile apps were originally offered for general productivity and information retrieval, including email, calendar, contacts, and stock market and weather information.
  11. 11. 1.2 WHY TO USE ANDROID FOR MOBILE DEVELOPMENT? Objective-C vs. Android (Java) • First and foremost, using Java is much better than Objective-C. Private methods, inner classes, anonymous classes, generics, better function syntax, and a much wider plethora of 3rd-party code are just a small smattering of the advantages of Java. • Objective-C doesn't provide a garbage collector for iPhone while Java has lazy garbage collector
  12. 12. WHY TO USE ANDROID FOR MOBILE DEVELOPMENT? (CONTD.) • You have more control and the power of Java allows you to write stricter code that accomplishes these tasks with better software methodologies.
  13. 13. 2. INTRODUCTION OF ANDROID
  14. 14. 2. INTRODUCTION OF ANDROID 2.1 What does Android run On – Android Internals? 2.2 Introduction of DVM (Dalvic Virtual Machine) 2.3 Architecture of Android
  15. 15. 2. INTRODUCTION OF ANDROID 2.1 WHAT DOES ANDROID RUN ON – ANDROID INTERNALS?
  16. 16. 2.1 WHAT DOES ANDROID RUN ON – ANDROID INTERNALS?
  17. 17. LINUX KERNEL • Android runs on Linux • Linux provides as well as: • Hardware abstraction layer • Application Framework • Memory management • Users never see Linux sub system • The adb shell command opens Linux shell
  18. 18. LIBRARIES • Bionic, a super fast and small license-friendly libc library optimized for embedded use. • Surface Manager for composing window manager with off-screen buffering. • WebKit: library for fast HTML rendering •
  19. 19. DALVIK VM Dalvik VM is Google’s implementation of Java • Optimized for mobile devices. • Key Dalvik differences: • Register-based versus stack-based VM • Dalvik runs .dex files • More efficient and compact implementation • Different set of Java libraries than SDK
  20. 20. APPLICATION FRAMEWORK • Activation manager controls the life Applications cycle of the app • Content providers encapsulate data Application Framework that is shared (e.g. contacts) • Resource manager manages everything that is not the code. • Notification manager for events such as arriving messages, appointments, etc.
  21. 21. APPLICATION • Each Android application runs inside its own Linux process. • Additionally, each application has its own sandbox file system with its own set of preferences and its own database. • Other applications cannot access any of its data,unless it is explicitly shared. •
  22. 22. APPLICATION(CONTD) • There are three main scenarios for your app to talk to native library: • - Directly • - Via native service • - Via native daemon • It will depend on the type of app and type of native library which method works best.
  23. 23. APPLICATION FLOW
  24. 24. INTRODUCTION OF ANDROID 2.2 INTRODUCT ION OF DVM (DALVIC VIRTUAL MACHINE)
  25. 25. 2.2 INTRODUCTION OF DVM (DALVIC VIRTUAL MACHINE) • Google developed Android and chose DVM for several reasons. First, there were licensing issues with most JVMs. • DVM should be more efficient in terms of memory usage and performance on a register-based machine. • DVM is also supposed to be more efficient when running multiple instances of the DVM. Applications are given their own instance. Hence, multiple active applications require multiple DVM instances. Like most Java implementations, the DVM has an automatic garbage collector.
  26. 26. INTRODUCTION OF ANDROID 2.3 ARCHI TECTURE OF ANDROID
  27. 27. 2.3 ARCHITECTURE OF ANDROID Android Java = Java SE – AWT/Swing + Android API
  28. 28. 2.3 ARCHITECTURE OF ANDROID • Many APIs are similars but you don't have all J2SE APIs. • Many APIs are limited to Android (Contacts, Power Management, Graphics...); • No Swing, no JavaFX ... You must use XML to declare you GUI; • you can use java jars (if they use only compatible APIs) but they are converted into dalvik. • Code is compiled into Dalvik opcodes (not java byte code);
  29. 29. 3. ANDROID BUILDING BLOCKS
  30. 30. 3. ANDROID BUILDING BLOCKS 3.1 Activity 3.2 Broadcast Receiver 3.3 Content Provider 3.4 Service 3.5 Introduction of Intent
  31. 31. 3. ANDROID BUILDING BLOCKS Each building block is a different point through which the system can enter your application. Not all components are actual entry points for the user and some depend on each other, but each one exists as its own entity and plays a specific role— each one is a unique building block that helps define your application's overall behavior. Activities Services Content providers Broadcast receivers
  32. 32. 3.1 ACTIVITY • An Activity represents a single screen with a user interface. • An activity represents the visual representation of an Android application. • Activities use Views , i.e. user interface widgets as for example buttons and fragments to create the user interface and to interact with the user.
  33. 33. 3.1 ACTIVITY
  34. 34. 3.2 SERVICES • Services perform tasks without providing a user interface. They can communicate with other Android components and notify the user via the notification framework in Android. • Service is a component that runs in the background to perform long-running operations or to perform work for remote processes. • A service does not provide a user interface.
  35. 35. 3.2 SERVICES (CONTD.) • Note that services, like other application objects, run in the main thread of their hosting process. This means that, if your service is going to do any CPU intensive (such as MP3 playback) or blocking (such as networking) operations, it should spawn its own thread in which to do that work
  36. 36. 3.3 CONTENT PROVIDER • A content provider manages a shared set of application data. You can store the data in the file system, an SQLite database, on the web, or any other persistent storage location your application can access. • A content provider provides a structured interface to application data. Via a content provider your application can share data with other applications. • Android contains an SQLite database which is frequently used in conjunction with a content provider . The SQLite database would store the data, which would be accessed via the content provider
  37. 37. 3.4 BROADCAST RECEIVER • Broadcast receivers can be registered to receive messages and intents which could be system generated or application level . • A broadcast receiver gets notified by the Android system, if the specified event occurs. • For example you can register a broadcast receivers for the event that the Android system completed the boot processor or for the event that the state of the phone changes, e.g. someone is calling.
  38. 38. 3.5 INTRODUCTION TO INTENT • Intents are asynchronous messages which allow the application to request functionality from other Android components, e.g. from services or activities • An application can call a component directly ( explicit Intent ) or ask the Android system to evaluate registered components based on the intent data ( implicit intents ). For example the application could implement sharing of data via an Intent and all components which allow sharing of data would be available for the user to select. Applications register themselves to an intent via an intent Filter • Intents allow an Android application to start and to interact with components from other Android applications.
  39. 39. 4. INTRODUCTION DEVELOPMENT TOOL “ECLIPSE”
  40. 40. 4. INTRODUCTION OF THE DEVELOPMENT TOOL “ECLIPSE” 4.1 Download the latest or working version of “Eclipse” 4.2 Introduction to Android Simulator 4.3 How to create project? 4.4 First Project “Hello World” 4.5 Introduction to solution components
  41. 41. 4.1 DOWNLOAD THE LATEST OR WORKING VERSION OF “ECLIPSE” • The Android SDK provides you the API libraries and developer tools necessary to build, test, and debug apps for Android. • http://developer.android.com/sdk/index.html
  42. 42. ANDROID DEVELOPMENT TOOLS • Google provides the Android Development Tools (ADT) to develop Android applications with Eclipse. • ADT is a set of components (plug-ins) which extend the Eclipse IDE with Android development capabilities. • ADT contains all required functionalities to create, compile, debug and deploy Android applications from the Eclipse IDE. ADT also allows to create and start AVDs. • The Android Development Tools (ADT) provides specialized editors for resources files, e.g. layout files. • These editors allow to switch between the XML representation of the file and a richer user interface via tabs on the bottom of the editor.
  43. 43. 4.2 INTRODUCTION TO ANDROID SIMULATOR • To define an Android Virtual Device (ADV) open the • AVD Manager dialog via Window Android Virtual Device Manager and press the New button
  44. 44. AVD CONTINUE
  45. 45. RUN AVD
  46. 46. RUN AVD (CONTINUE)
  47. 47. 4.3 HOW TO CREATE PROJECT? • Create a very simple project • Run it on a real device • Run it on the emulator • Examine its structure
  48. 48. PACKAGE CONTENT All source code here Java code for our activity Generated Java code Helps link resources to Java code Layout of the activity Strings used in the program 52 All non-code resources Android Manifest Images
  49. 49. 4.4 FIRST PROJECT “HELLO WORLD” package com.example.helloandroid; import android.app.Activity; import android.os.Bundle; import android.widget.TextView; public class HelloAndroid extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); TextView tv = new TextView(this); tv.setText("Hello, Android – by hand"); setContentView(tv); } } Inherit from the Activity Class 53 Set the view “by hand” – from the program
  50. 50. RUN IT! 54
  51. 51. /RES/LAYOUT/MAIN.XML <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" > <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="@string/hello" /> </LinearLayout> 55 Further redirection to /res/values/strings.xml
  52. 52. /RES/VALUES/STRINGS.XML <?xml version="1.0" encoding="utf-8"?> <resources> <string name="hello">Hello World, HelloAndroid – by resources!</string> <string name="app_name">Hello, Android</string> </resources> 56
  53. 53. HELLOANDROID.JAVA 57 package com.example.helloandroid; import android.app.Activity; import android.os.Bundle; public class HelloAndroid extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } } Set the layout of the view as described in the main.xml layout
  54. 54. /GEN/R.JAVA package com.example.helloandroid; public final class R { public static final class attr { } public static final class drawable { public static final int icon=0x7f020000; } public static final class id { public static final int textview=0x7f050000; } public static final class layout { public static final int main=0x7f030000; } public static final class string { public static final int app_name=0x7f040001; public static final int hello=0x7f040000; } } 58
  55. 55. RUN IT! 59
  56. 56. 5. TESTING AND DEBUGGING ANDROID APPLICATION
  57. 57. 5. TESTING AND DEBUGGING ANDROID APPLICATION 5.1 Role and Use of Dalvik Debug Monitor Server (DDMS) 5.2 How to debug android application 5.3 Use of Step Filters, Breakpoints, Suspend and Resume 5.4 How to use LogCat (Verbose, Debug, Info, Warn, Error, Assert) 5.5 Use of Perspectives
  58. 58. 5.1 ROLE OF DDMS • Android ships with a debugging tool called the Dalvik Debug Monitor Server (DDMS), which provides port-forwarding services, screen capture on the device, thread and heap information on the device, logcat, process, and radio state information, incoming call and SMS spoofing, location data spoofing, and more.
  59. 59. 5.2 HOW TO DEBUG ANDROID APPLICATION • On Android, every application runs in its own process, each of which runs in its own virtual machine (VM). Each VM exposes a unique port that a debugger can attach to. • When DDMS starts, it connects to adb. When a device is connected, a VM monitoring service is created between adb and DDMS, which notifies DDMS when a VM on the device is started or terminated. Once a VM is running, DDMS retrieves the VM's process ID (pid), via adb, and opens a connection to the VM's debugger, through the adb daemon (adbd) on the device. DDMS can now talk to the VM using a custom wire protocol.
  60. 60. 5.3 USE OF STEP FILTERS, BREAKPOINTS, SUSPEND AND RESUME
  61. 61. 5.4 HOW TO USE LOGCAT (VERBOSE, DEBUG, INFO, WARN, ERROR, ASSERT)
  62. 62. LOGCAT VIEW
  63. 63. 5.5 USE OF PERSPECTIVES
  64. 64. 6. ANDROID ACTIVITIES
  65. 65. 6. ANDROID ACTIVITIES 6.1 Android Activity Lifecycle 6.2 Using Intents to Launch the Activities
  66. 66. ACTIVITY • An Android activity is focused on a single thing a user can do. • Most applications have multiple activities 71
  67. 67. 6.1 ANDROID ACTIVITY LIFECYCLE
  68. 68. AN ACTIVITY : THREE STATES • Resumed The activity is in the foreground of the screen and has user focus. (This state is also sometimes referred to as "running".) • Paused Another activity is in the foreground and has focus, but this one is still visible. That is, another activity is visible on top of this one and that activity is partially transparent or doesn't cover the entire screen. A paused activity is completely alive (the Activity object is retained in memory, it maintains all state and member information, and remains attached to the window manager), but can be killed by the system in extremely low memory situations. 73
  69. 69. AN ACTIVITY : THREE STATES (CONTD.) • Stopped The activity is completely obscured by another activity (the activity is now in the "background"). A stopped activity is also still alive (the Activity object is retained in memory, it maintains all state and member information, but is not attached to the window manager). However, it is no longer visible to the user and it can be killed by the system when memory is needed elsewhere. • If an activity is paused or stopped, the system can drop it from memory either by asking it to finish (calling its finish() method), or simply killing its process. When the activity is opened again (after being finished or killed), it must be created all over. 74
  70. 70. TASKS AND BACK STACK • Each activity should be designed around a specific kind of action the user can perform and can start other activities. • For example, an email application might have one activity to show a list of new email. When the user selects an email, a new activity opens to view that email. 75
  71. 71. 6.2 USING INTENT TO LAUNCH THE ACTIVITIES • Intent are asynchronous messages which allow the application to request functionality from other Android components, e.g. from services or activities • An application can call a component directly (explicit Intent ) or ask the Android system to evaluate registered components based on the intent data ( implicit intents). For example the application could implement sharing of data via an intent and all components which allow sharing of data would be available for the user to select. Applications register themselves to an intent via an intentFilter . • Intents allow an Android application to start and to interact with components from other Android applications.
  72. 72. • There are separate methods for activating each type of component: • You can start an activity (or give it something new to do) by passing Intent to startActivity() or startActivityForResult() . • You can start a service (or give new instructions to an ongoing service) by passing an Intent tostartService(). Or you can bind to the service by passing an Intent to bindService(). • You can initiate a broadcast by passing an Intent to methods like sendBroadcast(),sendOrderedBroadcast(), or sendStickyBroadcast(). • You can perform a query to a content provider by calling query() on a ContentResolver. 77 INTENT (CONTD.)
  73. 73. 7. UI DESIGN
  74. 74. 7. UI DESIGN 7.1 Fundamental Android UI Design 7.2 Introducing Layouts 7.3 Different UI widgets available in Android 7.4 Event driven Programming in Android
  75. 75. 7.1 FUNDAMENTAL ANDROID UI DESIGN • Layouts is important for good Android application design. • We provide an overview of how layouts fit into the Android application architecture. • We also explore some of the specific layout controls available for organizing application screen content in a variety of interesting ways
  76. 76. WHAT IS A LAYOUT? • Android developers use the term layout to mean one of two things. Both definitions apply to this tutorial, and are, unfortunately used interchangeably in the Android development community. The two definitions of layout are: • A type of resource that defines what is drawn on the screen. Layout resources are stored as XML files in the /res/layout resource directory for the application. A layout resource is simply a template for a user interface screen, or portion of a screen, and contain. • A type of View class whose primary purpose is to organize other controls. These layout classes (LinearLayout, RelativeLayout, TableLayout, etc. ) are used to display child controls, such as text controls or buttons or images on the screen.
  77. 77. 7.2 INTRODUCING LAYOUTS • Frame Layout • Liner Layout • Relative Layout • Table Layout
  78. 78. FRAMELAYOUT • Frame layouts are one of the simplest layout types used to organize controls within the user interface of an Android application. • They are used less often than some other layouts, simply because they are generally used to display only one view, or views which overlap.
  79. 79. FRAMELAYOUT (CONTD.) When to Use Frame Layouts • The efficiency of a frame layout makes it a good choice for screens containing few view controls (home screens, game screens with a single canvas, and the like). • Sometimes other inefficient layout designs can be reduced to a frame layout design that is more efficient, while other times a more specialized layout type is appropriate. Frame layouts are the normal layout of choice when you want to overlap views.
  80. 80. LINER LAYOUT • Linear layouts are one of the simplest and most common types of layouts used by Android developers to organize controls within their user interfaces. • The linear layout works much as its name implies: it organizes controls linearly in either a vertical or horizontal fashion. • When the layout’s orientation is set to vertical, all child controls within it are organized in a single column; when the layout’s orientation is set to horizontal, all child controls within it are organized in a single row.
  81. 81. LINER LAYOUT(CONTD.) Some specific attributes apply to linear layouts. Some of the most important attributes you’ll use with linear layouts include: • The orientation attribute (required), which can be set to vertical or horizontal • The gravity attribute (optional), which controls how all child controls are aligned and displayed within the linear layout (class: LinearLayout) • The layout_weight attribute (optional, applied to each child control) specifies each child control’s relative importance within the parent linear layout (class: LinearLayout.LayoutParams)
  82. 82. LINER LAYOUT(CONTD.) Also, general ViewGroup-style attributes apply to linear layouts. These include: • Generic Layout Parameters such as layout_height (required) and layout_width (required) • Margin Layout Parameters such as margin_top, margin_left, margin_right and margin_bottom • Layout Parameters such as layout_height and layout_width (
  83. 83. RELATIVE LAYOUT • The relative layout works much as its name implies: it organizes controls relative to one another, or to the parent control itself. • What does this mean? It means that child controls, such as ImageView, TextView ,and Button controls, can be placed above, below, to the left or right, of one another. Child controls can also be placed in relation to the parent (the relative layout container), including placement of controls aligned to the top, bottom, left or right edges of the layout
  84. 84. RELATIVE LAYOUT(CONTD.) • Attributes that help configure a relative layout and its child controls. Some specific attributes apply to relative layouts-namely the child rules, including: • Rules for child control centering within the parent layout, including: center horizontally, center vertically, or both. • Rules for child control alignment within the parent layout, including: align with top, bottom, left or right edge of another control. • Rules for child control alignment in relation to other child controls, including: align with top, bottom, left or right edge. • Rules for child control placement in relation to other child controls, including: placement to the left or right of a specific control, or above or below another control.
  85. 85. RELATIVE LAYOUT(CONTD.) Also, general ViewGroup-style attributes apply to relative layouts. These include: • Generic Layout Parameters such as layout_height (required) and layout_width (required) • Margin Layout Parameters such as margin_top, margin_left, margin_right and margin_bottom • Layout Parameters such as layout_height and layout_width
  86. 86. TABLE LAYOUT • A table layout is exactly what you might expect: a grid of made up of rows and columns, where a cell can display a view control. From a user interface design perspective, a TableLayout is comprised of TableRow controls—one for each row in your table. • The contents of a TableRow are simply the view controls that will go in each “cell” of the table grid.
  87. 87. TABLELAYOUT CONCERNS • Although table layouts can be used to design entire user interfaces, they usually aren’t the best tool for doing so, as they are derived from LinearLayout and not the most efficient of layout controls. • If you think about it, a TableLayout is little more than an organized set of nested LinearLayouts, and nesting layouts too deeply is generally discouraged for performance concerns. • However, for data that is already in a format suitable for a table, such as spreadsheet data, table layout may be a reasonable choice.
  88. 88. 7.3 DIFFERENT UI WIDGETS AVAILABLE IN ANDROID • Text View • Edit Text • List View • Spinner • Button • Check Box • Radio Button • Scroll View
  89. 89. TEXT VIEW • Displays text to the user and optionally allows them to edit it. A TextView is a complete text editor, however the basic class is configured to not allow editing.
  90. 90. EDIT TEXT • EditText is a thin veneer over TextView that configures itself to be editable.
  91. 91. LISTVIEW • The display of elements in a lists is a very common pattern in mobile applications. The user sees a list of items and can scroll through them. • ListView is a view group that displays a list of scrollable items. The list items are automatically inserted to the list using an Adapter that pulls content from a source such as an array or database query and converts each item result into a view that's placed into the list.
  92. 92. LISTVIEW
  93. 93. SPINNERS • Spinners provide a quick way to select one value from a set. In the default state, a spinner shows its currently selected value. Touching the spinner displays a dropdown menu with all other available values, from which the user can select a new one. 99
  94. 94. CHECK BOX • Checkboxes allow the user to select one or more options from a set. Typically, you should present each checkbox option in a vertical list. 100
  95. 95. RADIO BUTTONS • Radio buttons allow the user to select one option from a set. You should use radio buttons for optional sets that are mutually exclusive if you think that the user needs to see all available options side-by-side. 101
  96. 96. SCROLLVIEW • The ScrollView class can be used to contain one View that might be to big too fit on one screen. ScrollView will is this case display a scroll bar to scroll the context. • A ScrollView is a FrameLayout, meaning you should place one child in it containing the entire contents to scroll; this child may itself be a layout manager with a complex hierarchy of objects. A child that is often used is a LinearLayout in a vertical orientation, presenting a vertical array of top-level items that the user can scroll through.
  97. 97. TOGGLE BUTTONS • A toggle button allows the user to change a setting between two states. • You can add a basic toggle button to your layout with theToggleButton object 103
  98. 98. EVENT DRIVEN PROGRAMMING IN ANDROID There is a simple truth: • Android (and other smartphone) programming isn’t like desktop programming. • Android applications aren’t really applications at all, they are more like plugins into an existing application. They don’t own execution and they really shouldn’t do anything in the UI thread if they can help it.
  99. 99. 7.4 EVENT DRIVEN PROGRAMMING IN ANDROID • At OS boot, a process called the Zygote is created. This process waits for incoming requests for app startups. Once it receives a request, it forks a VM instance based on the Zygote VM itself. Thus every app is its own process with it's own sandboxed VM. • It is this VM process that starts the onCreate() (and other relevant methods) which subsequently start the app.
  100. 100. 8.1 MENUS 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. • Options menu and action bar • Context menu and contextual action mode • Popup menu 106
  101. 101. OPTIONS MENU AND ACTION BAR The options menu is the primary collection of menu items for an activity. It's where you should place actions that have a global impact on the app, such as "Search," "Compose email," and "Settings.“ • On Android 3.0 and higher, items from the options menu are presented by the action bar as a combination of on-screen action items and overflow options. Beginning with Android 3.0, theMenu button is deprecated (some devices don't have one), so you should migrate toward using the action bar to provide access to actions and other options. 107
  102. 102. CONTEXT MENU AND CONTEXTUAL ACTION MODE A context menu is a floating menu that appears when the user performs a long-click on an element. It provides actions that affect the selected content or context frame. @2013 Training 108
  103. 103. POPUP MENU A popup menu displays a list of items in a vertical list that's anchored to the view that invoked the menu. It's good for providing an overflow of actions that relate to specific content or to provide options for a second part of a command. 109
  104. 104. CREATING CONTEXTUAL MENUS • A contextual menu offers actions that affect a specific item or context frame in the UI. You can provide a context menu for any view, but they are most often used for items in a ListView, GridView, or other view collections in which the user can perform direct actions on each item. There are two ways to provide contextual actions: • floating context menu. A menu appears as a floating list of menu items (similar to a dialog) when the user performs a long-click (press and hold) on a view that declares support for a context menu. • In the contextual action mode. This mode is a system implementation ofActionMode that displays acontextual action bar at the top of the screen 110
  105. 105. CREATING A POPUP MENU • A PopupMenu is a modal menu anchored to a View. It appears below the anchor view if there is room, or above the view otherwise. It's useful for: • Providing an overflow-style menu for actions that relate to specific content Note: This is not the same as a context menu, which is generally for actions that affect selected content. For actions that affect selected content. • Providing a second part of a command sentence (such as a button marked "Add" that produces a popup menu with different "Add" options). • Providing a drop-down similar to Spinner that does not retain a persistent selection. 111
  106. 106. 8.2 WHAT IS DIALOG? HOW TO CREATE AN ALERT DIALOG? • A dialog is a small window that prompts the user to make a decision or enter additional information. A dialog does not fill the screen and is normally used for modal events that require users to take an action before they can proceed.
  107. 107. DIALOG A dialog is a small window that prompts the user to make a decision or enter additional information. A dialog does not fill the screen and is normally used for modal events that require users to take an action before they can proceed. • AlertDialogA dialog that can show a title, up to three buttons, a list of selectable items, or a custom layout. • DatePickerDialog or TimePickerDialogA dialog with a pre-defined UI that allows the user to select a date or time. 113
  108. 108. • These classes define the style and structure for your dialog, but you should use a DialogFragment as a container for your dialog. TheDialogFragment class provides all the controls you need to create your dialog and manage its appearance, instead of calling methods on the Dialog object. 114 DIALOG
  109. 109. CREATE AN ALERT DIALOG? Creating alert dialog is very easy : AlertDialog alertDialog = new AlertDialog.Builder( AlertDialogActivity.this).create(); // Setting Dialog Title alertDialog.setTitle("Alert Dialog"); // Setting Dialog Message alertDialog.setMessage("Welcome to AndroidHive.info"); // Setting Icon to Dialog alertDialog.setIcon(R.drawable.tick); // Setting OK Button alertDialog.setButton("OK", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { // Write your code here to execute after dialog closed Toast.makeText(getApplicationContext(), "You clicked on OK", Toast.LENGTH_SHORT).show(); } }); // Showing Alert Message alertDialog.show();
  110. 110. 8.3 WHAT IS TOAST IN ANDROID? • A toast provides simple feedback about an operation in a small popup. • It only fills the amount of space required for the message and the current activity remains visible and interactive.
  111. 111. TOAST(CONTD.) Sample Code : Context context = getApplicationContext(); CharSequence text = "Hello toast!"; int duration = Toast.LENGTH_SHORT; Toast toast = Toast.makeText(context, text, duration); toast.show();
  112. 112. 8.4 LIST VIEW • ListView is a view group that displays a list of scrollable items. • The list items are automatically inserted to the list using an Adapter that pulls content from a source such as an array or database query and converts each item result into a view that's placed into the list
  113. 113. ADAPTERS • An Adapter acts as a bridge between an ListView and the underlying data for that view. • The Adapter provides access to the data items. • The Adapter is also responsible for making a View for each item in the data set System/Native Adapter available in Android • ArrayAdapter • CursorAdapter • SimpleCursorAdapter
  114. 114. ARRAYADAPTER • A concrete BaseAdapter that is backed by an array of arbitrary objects. • By default this class expects that the provided resource id references a single TextView. • If you want to use a more complex layout, use the constructors that also takes a field id. That field id should reference a TextView in the larger layout resource
  115. 115. CURSORADAPTER • Adapter that exposes data from a Cursor to a ListView widget. The Cursor must include a column named "_id" or this class will not work
  116. 116. SIMPLECURSOR ADAPTER • An easy adapter to map columns from a cursor to TextViews or ImageViews defined in an XML file. • You can specify which columns you want, which views you want to display the columns, and the XML file that defines the appearance of these views.
  117. 117. 8.5 NOTIFICATION MANAGER • Class to notify the user of events that happen. This is how you tell the user that something has happened in the background. Notifications can take different forms: • A persistent icon that goes in the status bar and is accessible through the launcher, (when the user selects it, a designated Intent can be launched), • Turning on or flashing LEDs on the device, or • Alerting the user by flashing the backlight, playing a sound, or vibrating.
  118. 118. NOTIFICATION MANAGER • Each of the notify methods takes an int id parameter and optionally a String tag parameter, which may be null. • These parameters are used to form a pair (tag, id), or (null, id) if tag is unspecified. This pair identifies this notification from your app to the system, so that pair should be unique within your app. • If you call one of the notify methods with a (tag, id) pair that is currently active and a new set of notification parameters, it will be updated
  119. 119. 8.6 PENDING INTENT • A PendingIntent is a token that you give to a foreign application (e.g. NotificationManager, AlarmManager, Home Screen AppWidgetManager, or other 3rd party applications), which allows the foreign application to use your application's permissions to execute a predefined piece of code. • If you give the foreign application an Intent, and that application sends/broadcasts the Intent you gave, they will execute the Intent with their own permissions. But if you instead give the foreign application a PendingIntent you created using your own permission, that application will execute the contained Intent using your application's permission.
  120. 120. 8.7 NOTIFICATION • 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. To see the details of the notification, the user opens the notification drawer. 126
  121. 121. • A notification in normal view appears in an area that's up to 64 dp tall. Even if you create a notification with a big view style, it will appear in normal view until it's expanded. This is an example of a normal view: The callouts in the illustration refer to the following: 1. Content title 2. Large icon 3. Content text 4. Content info 5. Small icon 6. Time that the notification was issued. You can set an explicit value with setWhen(); if you don't it defaults to the time that the system received the notification. 127
  122. 122. 9. USING ANDROID SYSTEM SERVICES
  123. 123. 9. SERVICE INTRO • A Service is a component which runs in the background, without interacting with the user. • Services support true multitasking for Android, as they can run in their own process. • If you use threads in Activities their are still connected to the life-cycle of Activities and the Android system may decide to terminate them at any point in point. • You can declare your own Service to perform long running operations without user interaction or to supply functionality to other applications. 129
  124. 124. • A Service needs to be declared in the AndroidManifest.xml via a <service android:name="yourclasss"> </service> and the implementing class must extend theService class or one of its subclasses. • A Service will not automatically run in its own thread. Without the process attribute, they run the main thread of their hosting process. Therefore you should run performance intensive tasks in the background. 130 SERVICE INTRO(CONTD.)
  125. 125. RUNNING A SERVICES IN ITS OWN PROCESS • You can also specify that your Service runs in a separate process via the android:process =":process_description" attribute. • This way the service gets its own process and has its own memory. Any long running operation in theService, e.g. a garbage collection, will not affect the user interface of your Activity. • The colon prefix before the name tells Android that the Service is private to its declaring application. If the colon is not used the Service would be a global process and can be used by other components. 131
  126. 126. • <service android:name="WordService" android:process=":my_process" android:icon="@drawable/icon" android:label="@string/service_name" > </service> • The colon prefix before the name tells Android that the Service is private to its declaring application. If the colon is not used the Service would be a global process and can be used by other components. • Additionally, you can ensure that your service is private to your application only if you include theandroid:exported attribute and set it to "false". 132
  127. 127. FORMS OF SERVICE • Started: A service is "started" when an application component (such as an activity) starts it by calling startService(). Once started, a service can run in the background indefinitely, even if the component that started it is destroyed. Usually, a started service performs a single operation and does not return a result to the caller. • Bound :A service is "bound" when an application component binds to it by calling bindService(). A bound service offers a client-server interface that allows components to interact with the service, send requests, get results, and even do so across processes with interprocess communication (IPC). A bound service runs only as long as another application component is bound to it. 133
  128. 128. INTENTSERVICE • The IntentService is used to perform a certain task in the background. Once done, the instance of IntentService terminate itself automatically. Examples for its usage would be to download a certain resources from the Internet. • The IntentService class offers the onHandleIntent() method which will be asynchronously called by the Android system. 134
  129. 129. SERVICE LIFECYCLE 135 To stop the service when its work is done, by calling stopSelf() orstopS ervice().
  130. 130. SERVICE LIFECYCLE • onCreate()The system calls this method when the service is first created, to perform one-time setup procedures (before it calls eitheronStartCommand() or onBind()) • onStartCommand()The system calls this method when another component, such as an activity, requests that the service be started, by calling startService(). • onBind()The system calls this method when another component wants to bind with the service (such as to perform RPC), by callingbindService(). • onDestroy()The system calls this method when the service is no longer used and is being destroyed. Your service should implement this to clean up any resources such as threads, registered listeners, receivers, etc
  131. 131. SERVICE (CONTD.) • Just like an activity, a service can define intent filters that allow other components to invoke the service using implicit intents. By declaring intent filters, components from any application installed on the user's device can potentially start your service if your service declares an intent filter that matches the intent another application passes to startService(). • An application component such as an activity can start the service by calling startService() and passing an Intent that specifies the service and includes any data for the service to use. The service receives this Intent in the onStartCommand() method. 137
  132. 132. 10. DATABASE - SQLITE
  133. 133. 10. DATABASE - SQLITE 10.1 Introducing SQLite 10.2 SQLiteOpenHelper and creating a database 10.3 Opening and closing a database 10.4 Working with cursors Inserts, updates, and deletes
  134. 134. 10.1 DATABASE - SQLITE • SQLite is an Open Source database. • SQLite supports standard relational database features like SQL syntax, transactions and prepared statements. The database requires limited memory at runtime (approx. 250 KByte) which makes it a good candidate from being embedded into other runtimes.
  135. 135. SQLITE IN ANDROID • SQLite is embedded into every Android device. Using an SQLite database in Android does not require a setup procedure or administration of the database. • You only have to define the SQL statements for creating and updating the database. Afterwards the database is automatically managed for you by the Android platform. • Access to an SQLite database involves accessing the file system. This can be slow. Therefore it is recommended to perform database operations asynchronously • If your application creates a database, this database is by default saved in the directoryDATA/data/APP_NAME/databases/FILENAME.
  136. 136. 10.2 SQLITEOPENHELPER AND CREATING A DATABASE • To create and upgrade a database in your Android application you create a subclass of the SQLiteOpenHelper class. In the constructor of your subclass you call the super() method of SQLiteOpenHelper, specifying the database name and the current database version
  137. 137. SQLITEOPENHELPER In this class you need to override the following methods to create and update your database. • onCreate() - is called by the framework, if the database is accessed but not yet created. • onUpgrade() - called, if the database version is increased in your application code. This method allows you to update an existing database schema or to drop the existing database and recreate it via the onCreate() method.
  138. 138. SQLITEDATABASE SQLiteDatabase is the base class for working with a SQLite database in Android and provides methods to open, query, update and close the database. • More specifically SQLiteDatabase provides the insert(), update() and delete() methods. • In addition it provides the execSQL() method, which allows to execute an SQL statement directly. • The object ContentValues allows to define key/values. The key represents the table column identifier and the value represents the content for the table record in this column. ContentValues can be used for inserts and updates of database entries.
  139. 139. SQLITEDATABASE • Queries can be created via the rawQuery() and query() methods or via the SQLiteQueryBuilder class . • rawQuery() directly accepts an SQL select statement as input. • query() provides a structured interface for specifying the SQL query. • SQLiteQueryBuilder is a convenience class that helps to build SQL queries.
  140. 140. RAWQUERY() rawQuery() Example The following gives an example of a rawQuery() call. • Cursor cursor = getReadableDatabase().rawQuery("select * from todo where _id = ?", new String[] { id });
  141. 141. QUERY() query() Example The following gives an example of a query() call. • return database.query(DATABASE_TABLE, new String[] { KEY_ROWID, KEY_CATEGORY, KEY_SUMMARY, KEY_DESCRIPTION }, null, null, null, null, null);
  142. 142. 10.3 OPENING AND CLOSING A DATABASE SQLiteDatabase db = this.getWritableDatabase(); //Opening DatabaseConnection ContentValues values = new ContentValues(); values.put(KEY_NAME, contact.getName()); // Contact Name values.put(KEY_PH_NO, contact.getPhoneNumber()); // Contact Phone Number // Inserting Row db.insert(TABLE_CONTACTS, null, values); db.close(); // Closing database connection
  143. 143. WORKING WITH CURSORS INSERTS, UPDATES, AND DELETES Cursor • A query returns a Cursor object. A Cursor represents the result of a query and basically points to one row of the query result. This way Android can buffer the query results efficiently; as it does not have to load all data into memory. • To get the number of elements of the resulting query use the getCount() method. • To move between individual data rows, you can use the moveToFirst() and moveToNext() methods. The isAfterLast() method allows to check if the end of the query result has been reached.
  144. 144. 10.4 WORKING WITH CURSORS INSERTS, UPDATES, AND DELETES • Cursor provides typed get*() methods, e.g. getLong(columnIndex), getString(columnIndex) to access the column data for the current position of the result. The "columnIndex" is the number of the column you are accessing. • Cursor also provides the getColumnIndexOrThrow(String) method which allows to get the column index for a column name of the table. • A Cursor needs to be closed with the close() method call.
  145. 145. INSERT ContentValues values = new ContentValues(); values.put(MySQLiteHelper.COLUMN_COMMENT, comment); long insertId = database.insert(MySQLiteHelper.TABLE_COMMENTS, null, values); cursor.close(); return newComment;
  146. 146. DELETE database.delete(MySQLiteHelper.TABLE_COMMENTS, MySQLiteHelper.COLUMN_ID + " = " + id, null);
  147. 147. CONTENT PROVIDER AND SHARING DATA • A SQLite database is private to the application which creates it. If you want to share data with other applications you can use a content provider. • A content provider allows applications to access data. In most cases this data is stored in an SQlite database. • While a content provider can be used within an application to access data, its is typically used to share data with other application. As application data is by default private, a content provider is a convenient to share you data with other application based on a structured interface. • A content provider must be declared in the AndroidManifest.xml file.
  148. 148. ACCESSING A CONTENT PROVIDER The access to a content provider is done via an URI. The basis for the URI is defined in the declaration of the ContentProvider in the AndroidManifest.xml file via the android:authorities attribute. • To create your own ContentProvider you have to define a class which extendsandroid.content.ContentProvider. • You also declare your ContentProvider in the AndroidManifest.xmlfile. This entry must specify the android:authorities attribute which allows to identify the ContentProvider. This authority is the basis for the URI to access data and must be unique.
  149. 149. 11. BROADCAST
  150. 150. 11 .BROADCAST 11.1 System broadcast 11.2 User defined broadcast
  151. 151. BROADCAST • A broadcast receiver (receiver) can be registered to receive system messages and intents. A receiver gets notified by the Android system, if the specified event occurs. • For example you can register a receiver for the event that the Android system finished the boot process. Or you can register for the event that the state of the phone changes, e.g. someone is calling.
  152. 152. BROADCAST • A receiver can be registered via the AndroidManifest.xml file. • Alternatively to this static registration, you can also register a broadcast receiver dynamically via the Context.registerReceiver() method. • The implementing class for a receiver extends the BroadcastReceiver class. • If the event for which the broadcast receiver has registered happens the onReceive() method of the receiver is called by the Android system.
  153. 153. LIFECYCLE OF A BROADCAST RECEIVER • After the onReceive() of the BroadcastReceiver has finished, the Android system can recycle the BroadcastReceiver. • Before API 11 you could not perform any asynchronous operation in the onReceive() method because once the onReceive() method is finished the Android system was allowed to recyled that component. If you have potentially long running operations you should trigger a service for that
  154. 154. 11.1 SYSTEM BROADCAST • Several system events are defined as final static fields in the Intent class. Other Android system classes also define events, e.g. the TelephonyManager defines events for the change of the phone state. The following table lists a few important system events. • Intent.ACTION_BOOT_COMPLETED : Boot completed. Requires the android.permission.RECEIVE_BOOT_COMPLETED permission. • Intent.ACTION_POWER_CONNECTED : Power got connected to the device. • Intent.ACTION_POWER_DISCONNECTED : Power got disconnected to the device. • Intent.ACTION_BATTERY_LOW : Battery gets low, typically used to reduce activities in your app which consume power. • Intent.ACTION_BATTERY_OKAY : Battery status good again.
  155. 155. 11.2 USER DEFINED BROADCAST • You can register a receiver for your own customer actions. The following AndroidManifest.xml file shows a broadcast receiver which is registered to a custom action. <receiver android:name="MyReceiver" > <intent-filter> <action android:name="de.vogella.android.mybroadcast" /> </intent-filter> </receiver>
  156. 156. SENDING BROADCAST INTENTS The sendBroadcast() method from the Context class allows you to send intents to your registered receivers. The following coding show an example. Intent intent = new Intent(); intent.setAction("de.vogella.android.mybroadcast"); sendBroadcast(intent); // handler for received Intents for the "my-event" event private BroadcastReceiver mMessageReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { // Extract data included in the Intent String message = intent.getStringExtra("message"); Log.d("receiver", "Got message: " + message); } };

×