Introduction to Android Development

Owain Lewis [email protected] @Ow_Zone

Goals of this session

Give an overview of the Android Ecosystem Explain the core components of an Android App Drink beer Create a simple working Android Application Drink more beer

Order of Service
Part 1: Introduction to Android Development (45mins) Beer Break Part 2: Live Coding (45mins - or until it compiles) Socialise

Android VM != JVM
Android Apps are: Written in java (mostly) Compiled to bytecode Converted to .dex files Run on the Dalvik VM

Whats inside an App

Compiled Java source code Library dependencies e.g. MIME type lib XML Files UI layouts, fragments etc. Images, sounds, videos etc. AndroidManifest.xml

Application Security

Each App is assigned a user in Android linux Each linux process has its own VM Each Application runs in 1 process. Applications can request permissions to system resources etc. - but user must agree.

App Fundamentals: UI

App Fundamentals: UI

UI Design... Wrong talk

Application Resources
Additional files and static content that your code uses Layouts for different types of devices and device orientations. Images for different screen sizes and densities

Referenced by unique ID within code Allow easy localization

Application Components

ApplicationManifest.xml
Defines application components Identifies required permissions Defines required API level Definers hardware/software features required API libs to link against (e.g. maps API) Components not in the manifest arent usable

Application Components

Intro to Activities
Single screen with UI Multiple activities exist in same app Activities work together but each is stand alone Any app can trigger any activity in any app (if allowed) More on that later

Intro to Services
Services generally run in the background Perform work that a user isnt aware of Multiple components can make use of a running service Example: GPS service, mp3 playing

Intro to Content Providers

Mechanism to allow apps to interact with data Create, Query, Store, Update Can store data in multiple ways File System, DB, network storage, or anywhere else the App can get to.

Apps can query any Content Provider if they have permission

Intro to Broadcast Receivers

A listener for system wide events No UI component Tend to be lightweight and do little work Example: Low battery handler

Intro to Intents
Intent binds components to each other at runtime (e.g. Event mechanism) Explicit Intent = message to activate specific component by name Implicit Intent = message to activate type of component Components define which Intent Types they pick up with Intent Filters

Component Interoperability
Any app can start any other apps component e.g. use the camera app activity to capture pictures
Don't need that code in your app Components run in the process of the holder app (e.g. camera take pic activity runs under camera process). Android apps don't have single entry point (main method)

Activating a component in another app is not allowed by system permissions - so use Intent.

Activating Components
Activity: pass Intent to startActivity() startActivityForResult() - gets a result Service: pass Intent to startService() or bindService() if running already Broadcast: pass Intent to sendBroadcast(),
sendOrderedBroadcast() sendStickyBroadcast()

Content: call query() on a ContentResolver

Make sense so far?

Activities
One main per app identified by Intent type Each new Activity pushes previous to back stack Back button destroys current and pops previous Callback methods are how the system interacts with Activities can be triggered by Intents.

Activities States
Resumed/Running: up front and has focus Paused: Another Activity is on top of this one but this is still visible. Stopped: Backgrounded - still alive, not attached to window manager The OS can kill activities without focus but will restart if possible.

Activities - Lifecycle

Activities
Must be declared in Manifest Can declare IntentFilters how other apps can use the activity E.g. Action=MAIN and Category=LAUNCHER tells Android this can be launched.

Activities - Manifest

Activities Starting
Explicit Intent to start Activity:
Intent intent = new Intent(this, SignInActivity.class); startActivity(intent);

Implicit Intent to start Activity:

Intent intent = new Intent(Intent.ACTION_SEND); intent.putExtra(Intent.EXTRA_EMAIL, recipientArray); startActivity(intent);

Need a result?
Call startActivityForResult() then implement onActivityResult() callback Get the result in an Intent

Activities - Stopping
Call finish() To shutdown an activity you start call finishActivity() but Android will do this for you. Saving State: onSaveInstanceState() Rotating the screen destroys current Activity so good way to test restore logic.

Activities - Advanced
Fragments
Sub Activity with own lifecycle Can be an invisible worker

Loaders (3.0 +)
Async pull data into Activity Views

Services
Long running operations - no UI.
e.g. play music

Service can run forever, but should know how to stop itself Started service = runs in background - does it's own thing until it stops Bound service = allows interaction/feedback. Destroyed when all components unbind. Determine type of Activity by implementing callbacks

Services - Callbacks
onCreate() onStartCommand() onBind()
which returns IBinder = the defined interface for comms.

onDestroy()

Services Start/Stop
startService(Intent) stopSelf() bindService (Intent service, ServiceConnection conn, int flags) System destroys bound service when clients disconnect.

Note that system can kill service without warning - but will restart it

Services - Manifest
Must declare all services in your application's manifest file. Supports IntentFilters and permissions.

Services - Threads
Services use the Main UI thread this is bad. Your service should create threads it needs to handle work
If you want to handle multiple thread simultaneously you need to manage this here. You need to manage stopping the thread too

Alternative is to extend IntentService offers worker per request one at a time.

Services - IntentService
Creates a default worker thread that executes all intents delivered to onStartCommand() separate from your application's main thread. Creates a work queue that passes one intent at a time to your onHandleIntent() implementation, so you never have to worry about multi-threading. Stops the service after all start requests have been handled, so you never have to call stopSelf(). Provides default implementation of onBind() that returns null. Provides a default implementation of onStartCommand() that sends the intent to the work queue and then to your onHandleIntent() implementation.

Services User Comms

Services can communicate with the user in a limited way. Once running, a service can notify the user of events using Toast Notifications or Status Bar Notifications. Toast notification is a message that appears on the surface of the current window for a moment then disappears. Status bar notification provides an icon in the status bar with a message, which the user can select in order to take an action (such as start an activity).

Services- Advanced
Messengers AIDL

Broadcast Receivers
Component that responds to system-wide broadcast announcements Many broadcasts originate from the system Register for intents via Manifest Meant to do very little work

Broadcast Receivers
Receiving a broadcast involves:
Registering receiver in Manifest or dynamically Implementing:
onReceive(Context, Intent)

Broadcast Receivers
Normal broadcasts: Context.sendBroadcast()
Asynchronous. All receivers of the broadcast are run in an undefined order, often at the same time.

Ordered broadcasts:
Context.sendOrderedBroadcast()

Delivered to one receiver at a time. Each receiver executes in turn, and can propagate a result to the next receiver, or abort the broadcast so that it won't be passed to other receivers. Similar to Filters in JEE

Content Providers
Manage secure access to data - across process boundaries
Don't need one if you're just providing data to own app Use ContentResolver to access data in a ContentPtorvider

-Android includes ContentProviders for contacts, audio, video, images etc

Content Providers
Data can be file (video etc) or Structured (tabular) Data is provided as tables (similar to relational dbs) with primary keys (if needed) Content is referenced using a URI scheme
e.g. content://user_dictionary/words Need to ask for permission to use a provider - this is done in the manifest

Define a query to perform against the URI.

Returns a Cursor Cursor can be wrapped in a CursorAdaptor and bound to a UI element.

Content Providers - Query

Content Providers
Also can insert, update and delete. Batch access = process lots of data at a time Contract Classes = Constants used in accessing a ContentProvider.

Content Providers

Intent and IntentFilter

Activities, Services and Broadcast receivers are activated through Intents Intent is a passive bundle of information. OS figures out how to get it to the correct place. Intent is:
Optional component name Action (e.g. ACTION_BATTERY_LOW) - you can invent your own Data - URI of data and MIME type Category - type of Intent (e.g. CATEGORY_LAUNCHER) Extras - key/value pairs Flags - how to deal with the intent

Explicit Intent = named Implicit Intent = category of intents

Intent and IntentFilter

IntentFilter tells the system which type of Intent a component can handle Component can specify multiple filters Filter has fields that parallel the action, data, and category fields of an Intent object Intent must match all 3 fields to be delivered
Note that Intent may not specify a field

IntentFilter Matching
Action: Intent action must match at least one Filter action. Intent can leave action blank and match Category: Every category in the Intent object must match a category in the filter. Filter can list additional categories, but it cannot omit any that are in the intent.
android.intent.category.DEFAULT must be implimented

Data:
No data = match More complex rules for data matching if specified

IntentFilter Matching
Multiple filter match: Ask the user

Intent and IntentFilter

Processes and Threads

One process per app. One Main thread is created for the App process this talks to the UI aka UIThread General Rules:
Do not block the UI thread Do not access the Android UI toolkit from outside the UI thread

Workarounds: Create own threads and use

Activity.runOnUiThread(Runnable) View.post(Runnable) View.postDelayed(Runnable, long)

Processes and Threads

AsyncTask
AsyncTask allows you to perform asynchronous work on your user interface. It performs the blocking operations in a worker thread and then publishes the results on the UI thread, without requiring you to handle threads and/or handlers yourself. Subclass AsyncTask and implement:
doInBackground() onPreExecute, onPostExecute(), onProgressUpdate()

Run Task from UIThread by calling execute()

AsyncTask

Development Tools
Android Platform + SDK Android Developer Tools (ADT) for Eclipse

Android Studio - Based on IntelliJ IDEA Currently in Early Access release Uses Gradle
Emulators and Hardware debugging

Questions?

Beer!

Live Coding

Introduction to Android Development

Owain Lewis [email protected] @Ow_Zone