Mobile app


Published on

  • Be the first to comment

  • Be the first to like this

No Downloads
Total views
On SlideShare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide

Mobile app

  1. 1. Mobile Application Development Dejvuth Suwimonteerabuth
  2. 2. Why mobile application development? Worldwide mobile device sales to end users totaled 1.55 billion units in 2011, a 11 percent increase from 2010 [IDC] Sales for the first quarter of 2012 [IDC]:
  3. 3. Phones get “smarter” Around 26% of worldwide sales in 2011 are smartphones, and estimated to reach 1 billion (47%) in 2015 [Gartner] In U.S., 49.7% have smartphones, the trend is accelerating [Nielsen]
  4. 4. Smartphones aren’t smart without apps More than 600,000 apps available [Business Insider]
  5. 5. Apps can make a lot of money The mobile app market will reach $15 billion by 2013 [Research2guidance]
  6. 6. Mobile applications are not ported desktop apps! Factors that need to consider when working on a mobile app: Memory Limited, and much of it is already allocated App speed Usage patterns of mobile app are different Apps need to load and work quickly Internet access Network is not always available and typically slow Display Smaller display User input Buttons, touch screen
  7. 7. A bit of history and outlook
  8. 8. Brief history of mobile devices PDA (Personal Digital Assistant)
  9. 9. PDA Phone PDA + mobile phone → PDA phone
  10. 10. Smartphones Now PDA phones are called smartphones, offering many computer-like functionalities
  11. 11. Mobile applications Applications for handheld devices such as PDA, smartphones Development environment:
  12. 12. Wars on smartphone platform (2010) [Canalys]
  13. 13. Wars on smartphone platform (2012) [Gartner, IDC]
  14. 14. Wars on smartphone platform [Nielsen]
  15. 15. Apple vs. Google Battle continues, arguments varied . . . . . . depending on who you ask A look into history: compare with Mac/PC battles Similar (many PC manufacturers, one Apple) Different (Microsoft sells Windows, Google gives away Android)
  16. 16. Apple still dominates the market, but . . .
  17. 17. Another look at recent trends In April 2011, Android added 28,000 new apps, Apple 11,000 apps [Research2guidance]
  18. 18. This course
  19. 19. This course Application development for the Android platform Introduction to iOS Emphasis on basics to make the contents robust to changes. Theories behind mobile communication Prerequisite: strong Java programming skills Important: Things change and not everything can be covered in this course. Self-learning skill is necessary. Android phone is not required
  20. 20. Topics Java refresher Key concepts of Android Designing the user interface 2D graphics Multimedia Local data storage Network access Embedded database 3D graphics in OpenGL Multi-touch Widget
  21. 21. Schedule On 10 Jun, 24 Jun, 8 Jul, 22 Jul, 19 Aug, 2 Sep, 16 Sep, 30 Sep Lecture: 08:30–12:00 Lab: 13:00–17:00 Don’t come to class late!
  22. 22. Grading Midterm exam 25% Final exam 25% Project 25% Lab 15% Attendance & Participation 10% Below 50% is fail, above 80% is A The rests are proportional
  23. 23. Project At the end of the course, each of you must program an application on Android You can program anything you want (but use your creativity!) Due date: 30 September Each of you must give a presentation on that day Make sure your program is fully tested (non-functional programs are worse than simple but functional programs)! Write down a documentation of what your program does Marks are given based on creativity, complexity, documentations, and the presentation
  24. 24. Literature The slides will be updated during the course of the lecture References: “Hello, Android – Introducing Google’s Mobile Development Platform”, Ed Burnette, 3rd Edition (2010). Any Java and Android books on the market
  25. 25. Java refresher
  26. 26. Why refresh? Android applications are written in Java Without fully understanding Java, you will not be able to write any Android applications Important: Take your time with Java, make sure you understand its concepts We will use the slides Java Refresher Course from Andrea Camesi, EPFL
  27. 27. Key Concepts
  28. 28. What is Android? An open source software stack that includes Operating system: Linux kernel, provides low level interface with hardware, memory management, and process control Middleware: A run time to execute Android applications, including Dalvik virtual machine and core libraries Key mobile apps: Email, SMS, PIM, web browser, etc API libraries for writing mobile app such as SQLite, WebKit, and OpenGL ES Open-source development platform for creating mobile apps
  29. 29. Android history Android Inc. founded in 2003. Google acquired Android Inc. in 2005 Open Handset Alliance established on 5 November 2007 Led by Google with 34 members (now 80 firms) Android is first announced on that day Code name based on a dessert item, in alphabetical order: 1.5 Cupcake, 1.6 Donut, 2.0/2.1 Eclair, 2.2 Froyo, 2.3 Gingerbread, 3.0/3.1 Honeycomb, and 4.0 Ice Cream Sandwich
  30. 30. Android SDK features No licensing, distributions, or development frees or release approval processes GSM, EDGE, and 3G networks for telephony and data transfer Full multimedia hardware control APIs for using sensor hardware including accelerometer and the compass. APIs for location based services Inter-process communication Shared data storage Background applications and processes Home screen widgets, Live Folders HTML5 WebKit-based web browser And many more . . .
  31. 31. Android SDK The Android SDK includes The Android APIs: the core of the SDK Development tools: for compiling and debugging The Android Virtual Device (AVD) Manager and Emulator Documentations Sample code There is no dedicated IDE for Android However, Android has a special plugin for Eclipse, called ADT Plugin, for creating Android projects ADT Plugin tightly integrates Eclipse with the Android Emulator and debugging tools
  32. 32. Android architecture
  33. 33. Android architecture
  34. 34. Linux kernel Android is built on top of a solid and proven foundation: the Linux kernel Created by Linus Torvalds in 1991 Linux can be found today in everything from wristwatches to supercomputer It provides the hardware abstraction layer for Android as well as memory management, process management, networking, and other operating system services Android phone user will never see Linux, and your programs will not make Linux calls directly
  35. 35. Native libraries Next layer above the kernel, written in C or C++ Compiled for the particular hardware architecture used by the phone, and preinstalled by the phone vendor Important libraries include: Surface Manager: a compositing window manager 2D and 3D graphics Media codecs for recording and playing variety of formats including AAC, AVC (H.264), H.263, MP3, and MPEG-4 SQLite database for storing persistent data WebKit: a browser engine for fast display of HTML content Libraries are not applications by themselves. They are only to be called by higher-level layers.
  36. 36. Android runtime Another layer on top of the kernel. Android runtime includes the Dalvik virtual machine (VM) and the core Java libraries. Dalvik VM is Google’s implementation of Java, optimized for mobile devices Differ from traditional Java VM: Dalvik VM runs .dex files, converted at compile time from standard .class and .jar files. Reason: .dex files are more compact. Android’s core Java libraries are different from both the Java Standard Edition (Java SE) libraries and the Java Mobile Edition (Java ME) libraries
  37. 37. Application framework Sitting above the native libraries and runtime Provides high-level building blocks for creating applications Comes pre-installed with Android, can be extend if needed Important parts are: Activity manager controls the life cycles of applications and user navigation Content providers encapsulate data that needs to be shared between applications, such as contacts Resource manager provides access to non-code resources such as localized strings, graphics, and layout files Location manager provides location information Notification manager presents messages to users
  38. 38. Applications and widgets The highest layer. They are what users see. Applications are programs that take over the whole screen and interact with users Widgets operate only in a small rectangle of the Home screen application Standard system applications: phone dialer, email, contacts, web browser, Android markets The most part of this course will cover application development. Widgets development is at the end of the course.
  39. 39. Life cycle
  40. 40. One foreground application at a time On PC, many applications running and visible at once in different windows. One of the windows has keyboard focus, but otherwise all the programs are equal. In Android, one foreground application, typically takes over the whole screen except for the status line. Users first see the Home application when turning on their phones
  41. 41. Application stack When the user runs an application, Android starts it and brings it to the foreground. From that application, the user might invoke another application, or another screen in the same application, and then another and another. All these programs and screens are recorded on the application stack by the system’s Activity Manager. At any time, the user can press the Back button to the previous screen on the stack.
  42. 42. Process = application Internally, each user interface screen is represented by an Activity class Each activity has its own life cycle An application is one or more activities plus a Linux process to contain them However, the activity life cycle is not tied to the process life cycle Processes are just disposable containers for activities, so an application can be “alive” even if its process has been killed!
  43. 43. Life cycle During its lifetime, each activity of an Android program can be in one of the following states:
  44. 44. Life cycle (cont.) Developers do not have control over what states their programs are in The system manages changes of states and notify developers when they are about to change through the onXX() method calls We override these methods in the Activity class, and Android will call them at the appropriate time: onCreate(Bundle): This is called when the activity first starts up. You can use it to perform one-time initialization such as creating the user interface. onCreate() takes one parameter that is either null or some state information previously saved by the onSaveInstanceState() method.
  45. 45. Life cycle (cont.) onStart(): This indicates the activity is about to be displayed to the user onResume(): This is called when your activity can start interacting with the user. This is a good place to start animations and music. onPause(): This runs when the activity is about to go into the background, usually because another activity has been launched in front of it. This is where you should save your program’s persistent state, such as a database record being edited. onStop(): This is called when your activity is no longer visible to the user and it won’t be needed for a while. If memory is tight, onStop() may never be called (the system may simply terminate your process).
  46. 46. Life cycle (cont.) onRestart(): Indicates that your activity is being redisplayed to the user from a stopped state onDestroy(): This is called right before your activity is destroyed. If memory is tight, onDestroy() may never be called (the system may simply terminate your process). onSaveInstanceState(Bundle): Android will call this method to allow the activity to save per-instance state, such as a cursor position within a text field. Usually you won’t need to override it because the default implementation saves the state for all your user interface controls automatically. onRestoreInstanceState(Bundle): This is called when the activity is being reinitialized from a state previously saved by the onSaveInstanceState() method. The default implementation restores the state of your user interface.
  47. 47. Caveat Activities that are not running in the foreground may be stopped, or the Linux process that houses them may be killed at any time in order to make room for new activities So, design your app with this in mind! In some cases, onPause() may be the last method called in your activity, so that’s where you should save any data you want to keep around for next time.
  48. 48. Building blocks
  49. 49. Activities An activity is a user interface screen Applications can define one or more activities to handle different phases of the program. As discussed earlier, each activity is responsible for saving its own state so that it can be restored later as part of the application life cycle
  50. 50. Intents An intent is a mechanism for describing a specific action, such as “pick a photo”, “phone home”, or “open the pod bay doors” Just about everything goes through intents, many components can be replaced or reused For example, there is an intent for “send an email”. Your app can invoke that intent to send emails. Or you can write a new email application, and register an activity to handle that intent and replace the standard mail program Next time somebody tries to send an email, they’ll get the option to use your program instead of the standard one
  51. 51. Services A service is a task that runs in the background without the user’s direct interaction For example, consider a music player. The music may be started by an activity, but you want it to keep playing even when the user has moved on to a different program. So, the code that does the actual playing should be in a service. Later, another activity may bind to that service and tell it to switch tracks or stop playing. Android comes with many services built in, along with convenient APIs to access them.
  52. 52. Content providers A content provider is a set of data wrapped up in a custom API to read and write it This is the best way to share global data between applications. For example, Google provides a content provider for contacts. All the information there—names, addresses, phone numbers, and so forth—can be shared by any application that wants to use it.
  53. 53. Resources A resource is a localized text string, bitmap, or other small piece of noncode information that your program needs. Useful for internationalization and for supporting multiple device types Inside your project, resources are stored in the res directory. Its subfolders determine the content types, e.g. PNG and JPG in res/drawable and XMLs for screen layouts in res/layout At build time all resources get compiled into the application. The compiler generates a class named R that contains identifiers that can be used to reference those resources in the program
  54. 54. The AndroidManifest.xml file Every application must have an AndroidManifest.xml file (with precisely that name) in its root directory. The manifest presents essential information about the application to the Android system Among other things, the manifest names the Java package for the application describes the components of the application—the activities, services, broadcast receivers, and content providers that the application is composed of determines which processes will host application components declares which permissions the application must have declares the minimum level of the Android API that the application requires.
  55. 55. Security As mentioned earlier, every application runs in its own Linux process The hardware forbids one process from accessing another process’s memory Furthermore, every application is assigned a specific user ID. Any files it creates cannot be read or written by other applications. Access to certain critical operations are restricted. To use them, permissions must be specifically asked in a file named AndroidManifest.xml When installing, the Package Manager either grants or doesn’t grant the permissions based on certificates and, if necessary, user prompts
  56. 56. Permissions in AndroidManifest.xml Common permissions: INTERNET: Access the Internet READ_CONTACTS: Read the user’s contacts data WRITE_CONTACTS: Write the user’s contacts data RECEIVE_SMS: Monitor incoming SMS messages ACCESS_COARSE_LOCATION: Use a coarse location provider such as cell towers or wifi ACCESS_FINE_LOCATION: Use a more accurate location provider such as GPS E.g., add the following tag to monitor incoming SMS messages: <uses-permission android:name="android.permission.RECEIVE_SMS" />
  57. 57. Designing the User Interface
  58. 58. Designing the User Interface In this section: how to design user interfaces We will learn by going through examples based on Sudoku
  59. 59. Sudoku You have a grid of 81 tiles (9 × 9) When the game starts, some numbers are already filled in You try to fill in the rest so that each column, each row, and each of the 3 × 3 sub-grids contains the numbers 1 through 9 only once
  60. 60. Procedural vs. declarative UI design Procedural design is done in code, e.g. Java Swing where code must be written to create and manipulate UI objects such as JFrame and JButton Declarative design does not involve code, e.g. HTML where you describe what you want to see, not how you want to do it Android can handle both, either in Java or XML It is recommended, however, to use XML as much as possible as it is often shorter and easier to understand, and less likely to change
  61. 61. By default, the main (declarative) UI of your program is kept in main.xml in the res/layout directory The file can be referred in the code by using the resource identifier R.layout.main Eclipse plug-in automatically generates the class from files in the res directory Values in are not objects, but simply handles that refer to the real data public static final class layout { public static final int main=0x7f030000; }
  62. 62. Layout resource Define the architecture for the UI in an Activity or a component of a UI Start with <?xml version="1.0" encoding="utf-8"?> Technically, a layout resource contains ViewGroup and View For example, <LinearLayout xmlns:android="" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" > <TextView android:id="@+id/nameTextbox" ... /> <!- ... -> </LinearLayout>
  63. 63. ViewGroup A container for View elements FrameLayout arranges its children so they all start at the top left of the screen. This is used for tabbed views and image switchers. LinearLayout arranges its children in a single column or row. This is the most common layout you will use. RelativeLayout arranges its children in relation to each other or to the parent TableLayout arranges its children in rows and columns, similar to an HTML table
  64. 64. View An individual UI component, generally referred to as a “widget”, e.g. TextView, Button, CheckBox Use @+id/name to define an ID In Java, use findViewById( to refer to the TextView nameTextBox Reference to layout resource: resource.html
  65. 65. Don’t forget to check out the reference
  66. 66. Some parameters to all layouts xmlns:android="" Defines the XML namespace for Android. You should define this once, on the first XML tag in the file. android:layout_width="fill_parent", android:layout_height="fill_parent" Takes up the entire width and height of the parent (in this case, the window) android:layout_width="wrap_content", android:layout_height="wrap_content" Just big enough to enclose its content
  67. 67. strings.xml Do not hard-code strings. Instead, define them in res/values/strings.xml. For example, <?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">Sudoku</string> <string name="main_title">Android Sudoku</string> <!- ... -> </resources> Use @string/resid to refer the the string resid app_name, used in AndroidManifest.xml, is the app name main_title can be used in main.xml, e.g. <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="@string/main_title" />
  68. 68. colors.xml Define colors in res/values/colors.xml For example, <?xml version="1.0" encoding="utf-8"?> <resources> <color name="background">#3500ffff</color> </resources> Colors are defined in Alpha-Red-Green-Blue format Use @color/resid to refer to the color resid, e.g. android:background="@color/background"
  69. 69. Activity (revisited) An activity is a single, focused thing that the user can do The Activity class takes care of creating a window. Subclasses of Activity should implement: onCreate(Bundle) initialize your activity. Call setContentView(int) with a layout resource to define UI. Use findViewById(int) to retrieve the widgets in that UI that you need to interact with programmatically. onPause() deals with the user leaving your activity. Any changes made by the user should be committed at this point.
  70. 70. Intent (revisited) An intent is an abstract description of an operation to be performed. It can be used with startActivity(Intent) to launch an Activity Declare all activities you start in AndroidManifest.xml, e.g. <activity android:name=".About" android:label="@string/about_title" > </activity> Think of an intent as a glue between activities, basically a passive data structure holding an abstract description of an action to be performed.
  71. 71. Styles A style is a collection of properties that specify the look and format for a View or window. A style can specify properties such as height, padding, font color, font size, background color, etc. Similar to cascading stylesheets (CSS) Define a style using XML in res/values/ <?xml version="1.0" encoding="utf-8"?> <resources> <style name="CodeFont" parent="@android:style/TextAppearance.Medium"> <item name="android:layout_width">fill_parent</item> <item name="android:layout_height">wrap_content</item> <item name="android:textColor">#00FF00</item> <item name="android:typeface">monospace</item> </style> </resources>
  72. 72. Styles and Themes Apply a style to a View <TextView style="@style/CodeFont" android:text="@string/hello" /> A theme is a style applied to an entire Activity or application. When applied, every View in the Activity or application will apply each style property that it supports Apply a theme to an Activity <activity android:theme="@android:style/Theme.Dialog"> The @android: prefix means this is a reference to a resource defined by Android, not one that is defined in your program
  73. 73. Options menu Define a menu using XML in res/menu/ <?xml version="1.0" encoding="utf-8"?> <menu xmlns:android=""> <item android:id="@+id/settings" android:title="@string/settings_label" android:alphabeticShortcut="@string/settings_shortcut" /> </menu> Override Activity.onCreateOptionsMenu(Menu) @Override public boolean onCreateOptionsMenu(Menu menu) { super.onCreateOptionsMenu(menu); MenuInflater inflater = getMenuInflater(); inflater.inflate(, menu); return true; } getMenuInflater() is used to read the menu definition from main.xml and turns it into a real view
  74. 74. Options menu and context menu When the user selects any menu item, onOptionsItemSelected() will be called @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case startActivity(new Intent(this, Prefs.class)); return true; // More items go here (if any) ... } return false; } Apart from options menu, a context menu can be used to provide the user access to actions that pertain to a specific item In this case, use onCreateContextMenu and onContextItemSelected instead
  75. 75. Preferences Define a preference screen using XML in res/xml/ <?xml version="1.0" encoding="utf-8"?> <PreferenceScreen xmlns:android="" > <CheckBoxPreference android:key="music" android:title="@string/music_title" android:summary="@string/music_summary" android:defaultValue="true" /> <!- ... -> </PreferenceScreen> Subclass PreferenceActivity, and override onCreate to call addPreferencesFromResource public class Prefs extends PreferenceActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.settings); } }
  76. 76. AlertDialog A Dialog that can display an array of things new AlertDialog.Builder(this) .setTitle(R.string.new_game_title) .setItems(R.array.difficulty, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialoginterface, int i) { startGame(i); } }) .show(); An array can be defined using XML in res/values <?xml version="1.0" encoding="utf-8"?> <resources> <array name="difficulty"> <item>@string/easy_label</item> <item>@string/medium_label</item> <item>@string/hard_label</item> </array> </resources>
  77. 77. Debugging The Log class provides several static methods to print messages of various severity levels to the Android system log: Log.e(): Errors Log.w(): Warnings Log.i(): Information Log.d(): Debugging Log.v(): Verbose What a Terrible Failure Open LogCat to view the logs In addition, the Eclipse debugger can be used to set breakpoints, single step, and view the state of your program. Add android:debuggable=“true” in AndroidManifest.xml
  78. 78. Graphics
  79. 79. Graphics in Android In this section: how to make graphics in Android Good graphics is very important these days Android has very powerful graphics libraries: both 2D and 3D We cover 2D graphics here, and apply it to the Sudoku example 3D graphics will be covered later
  80. 80. The basics Native 2D graphics library: package Let’s start with Color, Paint, Canvas, Path, Drawable classes
  81. 81. Color Colors are represented with four numbers: alpha, red, green, and blue (ARGB) Each has 8 bits or 256 possible values Alpha is a measure of transparency: 0 is completely transparent. Example: int b = Color.BLUE; // solid blue int c = Color.argb(127, 255, 0, 255); // translucent purple Define your colors in an XML resource file <?xml version="1.0" encoding="utf-8"?> <resources> <color name="mycolor">#1fff00ff</color> </resources> In Java, we can reference colors by their names color = getResources().getColor(R.color.mycolor);
  82. 82. Paint Hold the style and color information about how to draw geometries, text and bitmaps Examples: setColor(int): sets the paint’s color setTextSize(float): sets the paint’s text size setStyle(Paint.Style): sets the paint’s style, used for controlling how primitives’ geometries are interpreted (filled and/or stroked)
  83. 83. Path Hold a set of vector-drawing commands such as lines, rectangles, and curves Example of a circle at position x = 150, y = 150, with radius of 100 pixels. circle = new Path(); circle.addCircle(150, 150, 100, Direction.CW);
  84. 84. Canvas Represent a surface to draw upon Initially, it has no contents. Use its methods to draw lines, rectangles, circles, or other arbitrary graphics. Activity hosts View, which in turn hosts Canvas Override the method View.onDraw(Canvas) to draw your contents on the canvas Example: private static final String QUOTE = "Now is the time for all " + "good men to come to the aid of their country."; canvas.drawPath(circle, cPaint); canvas.drawTextOnPath(QUOTE, circle, 0, 20, tPaint);
  85. 85. Drawable An abstract class for “something that can be drawn” Drawables can take a variety of forms: Bitmap: the simplest drawable, a PNG or JPEG image Nine Patch: a stretchable PNG image Shape: vector-drawing commands, based on Path Layers: a container for child drawables, on top of each other States: a container that shows one of its child drawables based on its state (a bit mask) Levels: a container that shows one of its child drawables based on its level (a range of integers) Scale: a container for one child drawable that modifies its size based on the current level
  86. 86. The book’s example
  87. 87. Adding graphics to Sudoku
  88. 88. What have been done so far?
  89. 89. Now, draw the board
  90. 90. Next, draw the numbers
  91. 91. Draw the hints
  92. 92. Draw the selection
  93. 93. Multimedia
  94. 94. Multimedia Android provides support for encoding and decoding a variety of common media types Easy to integrate audio, video, and images into applications Use the package: In particular, the MediaPlayer class An object of this class can fetch, decode, and play both audio and video with minimal setup Support several media sources: Local resources Internal URIs External URLs (streaming)
  95. 95. Play audio Play from a local raw resource (in res/raw) MediaPlayer mp = MediaPlayer.create(context, R.raw.sound_file_1); mp.start(); Play from a URI, available locally in the system Uri uri = ...; // initialize Uri here MediaPlayer mp = new MediaPlayer(); mp.setAudioStreamType(AudioManager.STREAM_MUSIC); mp.setDataSource(getApplicationContext(), uri); mp.prepare(); mp.start(); Play from a remote URL via HTTP streaming String url = ...; // your URL here MediaPlayer mp = new MediaPlayer(); mp.setAudioStreamType(AudioManager.STREAM_MUSIC); mp.setDataSource(url); mp.prepare(); // might take long! (for buffering, etc) mp.start();
  96. 96. Asynchronous preparation prepare() can take a long time, because it might involve fetching and decoding media data So, never call it from UI thread Instead, use the convenient method prepareAsync(). It spawns another thread to prepare MediaPlayer and notify the main thread when done. Use MediaPlayer.OnPreparedListener for the notification
  97. 97. MediaPlayer’s state diagram
  98. 98. Releasing the MediaPlayer A MediaPlayer can consume valuable system resources So, call release() to release system resources allocated to it For example, release it in Activity.onStop() mp.release(); mp = null;
  99. 99. Using a Service with MediaPlayer Use Service to play media in the background. So, It will continue playing even the user is interacting with other applications. Use wake locks to guarantee that the service keeps playing even if the phone is idle The following will keep the CPU to remain wake mp = new MediaPlayer(); mp.setWakeMode(getApplicationContext(), PowerManager.PARTIAL_WAKE_LOCK); Acquire WifiLock, if streaming media over the network: WifiLock wifiLock = ((WifiManager) getSystemService(Context.WIFI_SERVICE)) .createWifiLock(WifiManager.WIFI_MODE_FULL, "mylock"); wifiLock.acquire(); To release: wifilock.release();
  100. 100. Data Storage
  101. 101. Data Storage Android provides several options to save persistent application data Shared preferences: store private primitive data in key-value pairs Internal storage: store private data on the device memory External storage: store public data on the shared external storage SQLite database: store structured data in a private database Network connection: store data on the web with your own network server We will cover the first three today
  102. 102. Using shared preferences The SharedPreferences class provides a general framework for saving and retrieving persistent key-value pairs of primitive data types Use getSharedPreferences() to get an object To write values: Call edit() to get a SharedPreferences.Editor Adds values with methods such as putBoolean() and putString() Commit the new values with commit() To read values, use methods such as getBoolean() and getString()
  103. 103. Example of shared preferences public class Calc extends Activity { public static final String PREFS_NAME = "MyPrefsFile"; @Override protected void onCreate(Bundle state){ super.onCreate(state); ... SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0); boolean silent = settings.getBoolean("silentMode", false); setSilent(silent); } @Override protected void onStop(){ super.onStop(); SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0); SharedPreferences.Editor editor = settings.edit(); editor.putBoolean("silentMode", mSilentMode); editor.commit(); } }
  104. 104. Using the internal storage You can save files directly on the device’s internal storage By default, files saved to the internal storage are private to your application When the application is uninstalled, these files are removed. To create and write a private file: Call openFileOutput() with the name of the file and the operating mode Write with write() Close with stream with close() To read a file: Call openFileInput() with the name of the file. It returns FileInputStream Read bytes with read () Close with stream with close()
  105. 105. Example of internal storage Example: String FILENAME = "hello_file"; String string = "hello world!"; FileOutputStream fos = openFileOutput(FILENAME, Context.MODE_PRIVATE); fos.write(string.getBytes()); fos.close(); Some useful methods: getFilesDir() – Gets the absolute path to the directory where internal files are saved getDir() – Creates (or opens an existing) directory within your internal storage space deleteFile() – Deletes a file saved on the internal storage fileList() – Returns an array of files currently saved by your application
  106. 106. Using the external storage Every Android device supports a shared “external storage” that you can use to save files This can be a removable storage media (such as an SD card) or an internal (non-removable) storage Files saved to the external storage are world-readable and can be modified by the user when they enable USB mass storage to transfer files on a computer
  107. 107. Some useful methods Before doing any work with external storage, call getExternalStorageState() to check whether the media is available Use getExternalFilesDir() to open a directory. This directory is local to the app and will be deleted when the app is uninstalled. Use getExternalStoragePublicDirectory() to open a directory. This directory is shared and will NOT be deleted when the app is uninstalled. In both cases, use e.g. DIRECTORY_MUSIC, DIRECTORY_RINGTONES, or DIRECTORY_PICTURES to specify the type of subdirectory
  108. 108. The Web
  109. 109. The Web In this chapter: connect your app to the web Two simple approaches: Open an external web browser from your app Embed a browser into your app Also include: How to connect JavaScript and Android’s Java code Web services
  110. 110. Browsing by Intent The simplest thing you can do: open a browser from your app All it takes are three lines of code! private void openBrowser() { Uri uri = Uri.parse(urlText.getText().toString()); Intent intent = new Intent(Intent.ACTION_VIEW, uri); startActivity(intent); } This code pauses your app, and starts the Browser activity with its own view Remember the app stack: when the Back key is pressed, the browser will go away, and your app will continue
  111. 111. Web with a View Android provides a wrapper around the WebKit browser engine called WebView WebView works like any other view, except that it has a few extra methods specific to the browser private void openBrowser() { webView.getSettings().setJavaScriptEnabled(true); webView.loadUrl(urlText.getText().toString()); } The loadUrl() method causes the browser engine to begin loading and display a web page. It does not wait for the loading to finish and returns immediately. To access the Internet, add this line to AndroidManifest.xml <uses-permission android:name="android.permission.INTERNET" />
  112. 112. Some WebView’s useful methods addJavascriptInterface(): Allows a Java object to be accessed from JavaScript createSnapshot(): Creates a screenshot of the current page getSettings(): Returns a WebSettings object used to control the settings loadData(): Loads the given string data into the browser loadDataWithBaseURL(): Loads the given data using a base URL loadUrl(): Loads a web page from the given URL
  113. 113. Some WebView’s useful methods (cont.) setDownloadListener(): Registers callbacks for download events, such as when the user downloads a .zip or .apk file setWebChromeClient(): Registers callbacks for events that need to be done outside the WebView rectangle, such as updating the title or progress bar or opening a JavaScript dialog box setWebViewClient(): Lets the application set hooks in the browser to intercept events such as resource loads, key presses, and authorization requests stopLoading(): Stops the current page from loading
  114. 114. Calling JavaScript from Java Use the WebView’s loadUrl() method, passing it a URL of the form javascript:code-to-execute Example: define function callJS() in assets/index.html <script language="JavaScript"> function callJS(arg) { document.getElementById(’replaceme’).innerHTML = arg; } </script> ... <p id="replaceme"></p> In Java, first load the index.html webView.loadUrl("file:///android_asset/index.html"); The function callJS() can be called by webView.loadUrl("javascript:callJS(’Hello from Android’)");
  115. 115. Calling Java from JavaScript Use the WebView’s addJavascriptInterface() method to define objects that JavaScript code can access Example: define a class to be exposed to JavaScript private class AndroidBridge { public void callAndroid(final String arg) { Runnable() { public void run() { textView.setText(arg); } }); } } Then, register it to JavaScript webView.addJavascriptInterface(new AndroidBridge(), "android");
  116. 116. Calling Java from JavaScript (cont.) For alerts or progress updates, use setWebChromeClient() webView.setWebChromeClient(new WebChromeClient() { @Override public boolean onJsAlert(final WebView view, final String url, final String message, JsResult result) { Toast.makeText(LocalBrowser.this, message, 3000).show(); result.confirm(); return true; // I handled it } }); Calls from JavaScript <a href="#" onclick="window.alert(’Alert from JavaScript’)"> Display JavaScript alert</a> <a href="#" onclick="’Hello from Browser’)"> Call Android from JavaScript</a>
  117. 117. Using web services Android fully supports for making requests to a HTTP server Example: String q = URLEncoder.encode(original, "UTF-8" ); URL url = new URL( "" + "?v=1.0" + "&q=" + q + "&langpair=" + from + "%7C" + to); // Creates a connection and set parameters con = (HttpURLConnection) url.openConnection(); con.setReadTimeout(10000 /* milliseconds */); con.setConnectTimeout(15000 /* milliseconds */); con.setRequestMethod("GET" ); con.addRequestProperty("Referer" , "" ); con.setDoInput(true); // Starts the query con.connect();
  118. 118. Using web services (cont.) However, such calls must be made asynchronously to make sure that your app remains responsive Trick: use the java.util.concurrent package Use ExecutorService to manage threads Submit an instance of Runnable or Callable An instance of the Future class is returned A Future instance represents the as-yet-unknown future value that will be returned by your task (if any)
  119. 119. An example: Google Translation API
  120. 120. GPS
  121. 121. GPS The Global Positioning System (GPS) is a constellation of 27 Earth-orbiting satellites (24 in operation + 3 extras) The US military developed it as a military navigation system, later opened up for everybody Each satellite circles the globe at about 19,300 km, making two complete rotations everyday The orbits: at any time, anywhere on Earth, there are at least four satellites visible in the sky GPS receivers locate at least four satellites, figure the distance to each, and use this information to deduce its own location. This operation is based on a simple math principle called trilateration
  122. 122. 2D Trilateration To simplify explanations: let’s start with two-dimensional trilateration Imagine that you are totally lost. You find a friendly local and ask, “Where am I?”. He says, “You are 700 km from Bangkok” You could be anywhere on a circle around Bangkok that has a radius of 700 km: Bangkok
  123. 123. Second circle You ask somebody else, and she says, “You are 640 km from Kuala Lumpur” Combining with the previous information, you know that you must be at one of the two intersection points Bangkok KL
  124. 124. Third circle If a third person tells you that you are 1000 km from Yangon, you can eliminate one of the possibilities, and know exactly where you are (can you guess where?) Yangon Bangkok KL
  125. 125. 3D Trilateration Generalize the concept to 3D: spheres instead of circles Imagine you are X miles from satellite A in the sky. You could be anywhere on the surface of an imaginary sphere with X-km radius.
  126. 126. Second sphere If you also know you are Y miles from satellite B, you can overlap the first sphere with this sphere Two spheres overlap in a circle
  127. 127. Third sphere The third satellite will give a third sphere, which intersects the circle at two points
  128. 128. Fourth sphere The Earth can act as a fourth sphere, i.e. only one of the two possible points is on the surface of the planet However, receivers generally look to four or more satellites to improve accuracy and provide precise altitude information
  129. 129. To make the calculation, GPS receiver needs to know twothings: The location of at least three satellites The distance between you and each of the satellitesIdea: determine the time delays when signals travel fromsatellites to the receiverFor this to work, clocks on the satellites and the receiver mustbe synchronized to nanosecondsQuite a few techniques involved. Anyway, details are beyondthe scope of this lectureIn this course: how to use GPS in your app!
  130. 130. Finding locations To gain access to location information, both from GPS and coarse-grained location provider such as cell tower triangulation, add the following lines to AndroidManifest.xml <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" /> <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> Get a LocationManager from your Context LocationManager mgr = (LocationManager) getSystemService(LOCATION_SERVICE); Select the best location provider. A Criteria object can be used to select a location provider based on e.g. power or accuracy (in this case, no restrictions). Criteria criteria = new Criteria(); String best = mgr.getBestProvider(criteria, true);
  131. 131. Finding locations (cont) Query the last known (possibly outdated) location Location location = mgr.getLastKnownLocation(best); Edit onResume and onPause to have Android updates locations only when your app is in the foreground (assume that your class implements LocationListener) @Override protected void onResume() { super.onResume(); mgr.requestLocationUpdates(best, 15000, 1, this); } @Override protected void onPause() { super.onPause(); mgr.removeUpdates(this); }
  132. 132. Sensors
  133. 133. Sensors Android SDK supports many different types of sensor devices TYPE_ACCELEROMETER: Measures acceleration in the x-, y-, and z-axes TYPE_LIGHT: Tells you how bright your surrounding area is TYPE_MAGNETIC_FIELD: Returns magnetic attraction in the x-, y-, and z-axes TYPE_ORIENTATION: Measures the yaw, pitch, and roll of the device TYPE_PRESSURE: Senses the current atmospheric pressure TYPE_PROXIMITY: Provides the distance between the sensor and some object TYPE_TEMPERATURE: Measures the temperature of the surrounding area
  134. 134. SensorManager Similar to LocationManager, here we use SensorManager SensorManager mgr = (SensorManager) getSystemService(SENSOR_SERVICE) Then, call registerListener() in onResume() and unregisterListener() in onPause() to start/stop getting updates The sensor service will call onSensorChanged() every time a value changes. It should look like this: public void onSensorChanged(SensorEvent event) { for (int i = 0; i < event.values.length; i++) { // ... } }
  135. 135. Sensor readings All sensors return an array of floating-point values. The size of the array depends on the particular sensor. Turning sensor readings into meaningful information can be very tricky Do experiments on what you want! Most of time it is not possible to test sensor readings on the emulator. If your application relies heavily on one of these sensors, you will need to a real device to test
  136. 136. SQLite
  137. 137. SQLite A tiny but powerful database engine, created by Dr. Richard Hipp in 2000 Widely used, e.g. in Mozilla Firefox, Skype, PHP, Adobe AIR, Mac OS X, iPhone, and of course Android Notable features: Free Small, less than 325KB Require no setup, no server, no config file, no administration An SQLite database is just a file Android stores it in /data/data/packagename/databases
  138. 138. SQL refresher A Data Definition Language (DDL) statement to create a table create table mytable ( _id integer primary key autoincrement, name text, phone text ); Note column types in SQLite are not strict. So, it’s possible to e.g. store a string in an integer column. Insert a record insert into mytable values(null, ’Steven King’ , ’555-1212’ ); Query for a record select * from mytable where(_id=3);
  139. 139. SQLiteOpenHelper Subclass SQLiteOpenHelper to manage database creation and versions public class EventsData extends SQLiteOpenHelper { private static final String DATABASE_NAME = "events.db"; private static final int DATABASE_VERSION = 1; public EventsData(Context ctx) { super(ctx, DATABASE_NAME, null, DATABASE_VERSION); } @Override public void onCreate(SQLiteDatabase db) { db.execSQL("CREATE TABLE " + TABLE_NAME + " (" + _ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + TIME + " INTEGER," + TITLE + " TEXT NOT NULL);" ); } @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME); onCreate(db); } }
  140. 140. Adding a row Use getWritableDatabase() to get a read/write handle to the events database, and then use insertOrThrow() to do the actual INSERT private void addEvents(String string) { SQLiteDatabase db = events.getWritableDatabase(); ContentValues values = new ContentValues(); values.put(TIME, System.currentTimeMillis()); values.put(TITLE, string); db.insertOrThrow(TABLE_NAME, null, values); }
  141. 141. Running a query Use getReadableDatabase() to get a read-only handle to the events database, and then use query() to do the actual SELECT private static String[] FROM = _ID, TIME, TITLE, ; private static String ORDER_BY = TIME + " DESC" ; private Cursor getEvents() { SQLiteDatabase db = events.getReadableDatabase(); Cursor cursor = db.query(TABLE_NAME, FROM, null, null, null, null, ORDER_BY); startManagingCursor(cursor); return cursor; } The method startManagingCursor() tells the activity to take care of managing the cursor’s life cycle based on the activity’s life cycle. E.g., deactivate the cursor when the activity is paused, or close it when the activity is terminated
  142. 142. Display the query results Use Cursor to iterate through all result rows while (cursor.moveToNext()) { long id = cursor.getLong(0); long time = cursor.getLong(1); String title = cursor.getString(2); ... } Alternatively, instead of using 0, 1, or 2 in getXXX(), use getColumnIndexOrThrow() to get column index numbers
  143. 143. Data binding Android provides a convenient way to display query results: Create a layout for items, call it e.g. item.xml Subclass ListActivity and use SimpleCursorAdapter private static int[] TO = {,, }; ... SimpleCursorAdapter adapter = new SimpleCursorAdapter(this, R.layout.item, cursor, FROM, TO); setListAdapter(adapter); Define your activity layout main.xml like this <ListView android:id="@android:id/list" ... /> <TextView android:id="@android:id/empty" ... /> If the list has items, android:id/list will be displayed, otherwise android:id/empty will be displayed
  144. 144. Content provider Recall that one application cannot access data own by another application A way to share data is to use ContentProvider: Processes register themselves to the system as providers of certain kinds of data. When that information is requested, they are called by Android through a fixed API to query or modify the content
  145. 145. Content provider (cont) Any piece of information managed by a ContentProvider is addressed through a URI that looks like this: content://authority/path/id where authority is the name of the provider, usually the package name path is a virtual directory within the provider id is the primary key of the requested record. Omit this to request all records. Android comes with several providers built in, including content://browser content://contacts content://media content://settings
  146. 146. Using ContentProvider Example of a valid URI: public static final String AUTHORITY = "" ; public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/" + TABLE_NAME); Adding a row getContentResolver().insert(CONTENT_URI, values); Running a query Cursor cursor = managedQuery(CONTENT_URI, FROM, null, null, ORDER_BY);
  147. 147. Implement a ContentProvider Refer to the lab!
  148. 148. Services
  149. 149. Services A service is an application component that can perform operations in the background and does not provide a UI Another application component can start a service. It will continue to run in the background, even if the user switches to another application Also, a component can bind to a service to interact with it and even perform interprocess communication (IPC) Examples: network transactions, play music, perform file I/O
  150. 150. Types of services A service can take two forms: Started when an application component call startService() Once started, a service can run indefinitely, even if the component is destroyed Usually perform a single operation, does not return a result Example: download or upload file over the network When the operation is done, it should stop itself Bound when an application component call bindService() Offer a client-server interface that allows components to interact with the service, send requests, get results, do IPC Run as long as another component is bound to it Multiple components can bind to the service at once
  151. 151. Types of services (cont.) A service can be of both types: it can be started to run indefinitely and also allow binding. Just implement both onStartCommand() and onBind() Just like an activity, a service started with an Intent Caution: a service runs in the main thread of its hosting processes, it does not create its own thread and does not run in a separate process Use a separate thread if your service can be slow
  152. 152. The basics To create a service, subclass Service and override the following callback methods: onStartCommand(): the system calls this method when another component call startService(). The service will run indefinitely unless stopSelf() or stopService() is called onBind(): the system calls this method when another component call bindService(). You must always implement this method (simply return null if binding is not allowed) onCreate(): the system calls this method when the service is first created. Use it to perform one-time setup. onDestroy(): the system calls this method when the service is being destroyed. Use it to clean up resources.
  153. 153. Declaring a service in the manifest Add a <service> element as a child of the <application> element <manifest ... > ... <application ... > <service android:name=".ExampleService" /> ... </application> </manifest> android:name is the only required attribute To make a service private, set android:exported="false" Reference: element.html
  154. 154. IntentService In most case, you can implement a service using IntentService, a subclass of Service It creates a worker thread to handle intents delivered to onStartCommand(), separate from your main thread Provides to default implementation of onStartCommand() to send one intent at a time to onHandleIntent() Stops the service after all start requests have been handled, so no need to call stopSelf() Provides default implementation of onBind() that returns null All you need to do is implement onHandleIntent()
  155. 155. References API: Service.html Fundamentals: services.html
  156. 156. A Very Brief Introduction to OpenGL
  157. 157. 3D with OpenGL Android supports high performance 3D graphics with the Open Graphics Library (OpenGL), specifically, the OpenGL ES API OpenGL is a cross-platform graphics API that specifies a standard software interface for 3D graphics processing hardware OpenGL ES is a subset of OpenGL, designed for embedded systems OpenGL ES 1.0 and 1.1 have been supported since Android 1.1 Beginning with Android 2.2, OpenGL ES 2.0 is also supported
  158. 158. GLSurfaceView Two foundational classes: GLSurfaceView: a View you can draw and manipulate objects through API calls GLSurfaceView.Renderer: an interface that defines methods required for drawing graphics in GLSurfaceView. You must implement this interface, and attach it to GLSurfaceView by using setRenderer().
  159. 159. GLSurfaceView.Renderer To implement the GLSurfaceView.Renderer interface, the following methods must be implemented: onSurfaceCreated(): The system calls this method once, when creating the GLSurfaceView. Use it to set up environment or initialize graphic objects. onDrawFrame(): The system calls this method on each redraw of the GLSurfaceView. Use it to draw graphic objects. onSurfaceChanged(): The system calls this method when the GLSurfaceView geometry changes, e.g. screen orientation change
  160. 160. Define a triangle OpenGL allows you to define objects using coordinates in three-dimensional space By default, the coordinate (0, 0, 0) is the center of the screen, (1, 1, 0) is the top right, and (−1, −1, 0) is the bottom left private void initShapes() { float triangleCoords[] = { // X, Y, Z -0.5f, -0.25f, 0, 0.5f, -0.25f, 0, 0.0f, 0.559016994f, 0 }; // initialize vertex Buffer for triangle ByteBuffer vbb = ByteBuffer.allocateDirect( // (# of coordinate values * 4 bytes per float) triangleCoords.length * 4); vbb.order(ByteOrder.nativeOrder()); // use native byte order triangleVB = vbb.asFloatBuffer(); // create fp buffer triangleVB.put(triangleCoords); // add coords to fp buffer triangleVB.position(0); // set buffer to read 1st coord }
  161. 161. Projection Problem: OpenGL assumes a square, uniform coordinate system. Androids monitors usually vary in size and shape. Solution in OpenGL ES 1.0: create a projection matrix using the geometry of the device screen public void onSurfaceChanged(GL10 gl, int width, int height) { gl.glViewport(0, 0, width, height); // make adjustments for screen ratio float ratio = (float) width / height; // set matrix to projection mode gl.glMatrixMode(GL10.GL_PROJECTION); // reset the matrix to its default state gl.glLoadIdentity(); // apply the projection matrix gl.glFrustumf(-ratio, ratio, -1, 1, 3, 7); }
  162. 162. Example: draw a rotating triangle
  163. 163. Widgets
  164. 164. App Widgets Introduced in Android 1.5 (Cupcake) App Widgets are miniature application views embedded in other applications (such as the Home screen) and received periodic updates These views are referred to as widgets An application that is able to hold App Widgets is called an App Widget host Several App Widgets are shipped with Android, e.g. analog clock, music controller, picture frame This section is about how to create your own widgets
  165. 165. Create an App Widget Create res/xml/widget.xml <?xml version="1.0" encoding="utf-8"?> <appwidget-provider xmlns:android="" android:minWidth="146dip" android:minHeight="72dip" android:updatePeriodMillis="1800000" android:initialLayout="@layout/main" /> to specify a minimum size of the widget, how often it should be updated, and a reference to its starting layout Create a BroadcastReceiver by subclassing AppWidgetProvider public class Widget extends AppWidgetProvider {}
  166. 166. Create an App Widget (cont.) Declare the broadcast receiver inside <application> in AndroidManifest.xml <receiver android:name=".Widget" android:label="@string/widget_name"> <intent-filter> <action android:name="android.appwidget.action.APPWIDGET_UPDATE" /> </intent-filter> <meta-data android:name="android.appwidget.provider" android:resource="@xml/widget" /> </receiver> To run, select Run As > Android Application as usual Widgets can be opened by pressing and holding your finger (or mouse) on the Home screen
  167. 167. Example: HelloWidget
  168. 168. Update your widget Implement onUpdate() to handle APPWIDGET_UPDATE intent, the action we declared in AndroidManifest.xml Example: private SimpleDateFormat formatter = new SimpleDateFormat( "EEEEEEEEEnd MMM yyyy"); @Override public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) { String now = formatter.format(new Date()); RemoteViews updateViews = new RemoteViews( context.getPackageName(), R.layout.main); updateViews.setTextViewText(, now); appWidgetManager.updateAppWidget(appWidgetIds, updateViews); super.onUpdate(context, appWidgetManager, appWidgetIds); }
  169. 169. Explanations & tips SimpleDateFormat is used to format the current date: day of the week, day of the month, month name, and year RemoteViews is used for the new view layout that the widget will display In this example, the same layout R.layout.main is used The update frequency is controlled by android:updatePeriodMillis in res/xml/widget.xml. The value 1800000 is 30 minutes. However, updates requested with updatePeriodMillis will not be delivered more than once every 30 minutes For more information, see
  170. 170. Calendar widget
  171. 171. Live wallpaper
  172. 172. Live wallpaper Introduced in Android 2.1 Live wallpapers are rich, animated, interactive backgrounds on home screens Similar to normal app, a live wallpaper has access to all facilities of the platform: SGL, OpenGL, GPS, accelerometers, network access, etc
  173. 173. Implementing a live wallpaper Similar to implementing a service, with an additional method onCreateEngine() to create WallpaperService.Engine The engine is responsible for handling the lifecycle and drawing of a wallpaper Drawing a wall paper can be expensive, so optimize your code as much as possible The Home application can send commands to the onCommands method of your live wallpaper: android.wallpaper.tap: when the user taps an empty space on the workspace android.home.drop: when the user drops an icon or a widget on the workspace
  174. 174. References Article: live-wallpapers.html Samples: CubeLiveWallpaper/index.html