This document provides an overview of Android development. It discusses the core components of an Android app including activities, services, content providers, and broadcast receivers. It also covers key concepts like the application lifecycle, intents, and processes/threads. The session aims to give an introduction to the Android ecosystem and components, explain how to create a simple app, and include socializing with beer breaks.

1. Introduction to Android
Development
Owain Lewis
owainrlewis@googlemail.com
@Ow_Zone

2. 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

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

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

6. What’s 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

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

8. App Fundamentals: UI

9. App Fundamentals: UI

10. UI Design... Wrong talk

11. 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

12. Application Components

13. 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 aren’t usable

14. Application Components

15. 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…

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

17. 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

18. 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

19. 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

20. 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.

21. 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

22. Make sense so far?

23. 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.

24. 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.

25. Activities - Lifecycle

26. 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.

27. Activities - Manifest

28. 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

29. 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.

30. Activities - Advanced
• Fragments
– Sub Activity with own lifecycle
– Can be an invisible worker
• Loaders (3.0 +)
– Async pull data into Activity Views

31. 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

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

33. 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

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

36. 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.

37. 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.

39. 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).

40. Services- Advanced
• Messengers
• AIDL

41. 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

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

43. 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

44. 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

45. 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.

46. Content Providers - Query

47. 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.

48. Content Providers

49. 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

50. 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…

51. 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

52. IntentFilter Matching
• Multiple filter match: Ask the user

53. Intent and IntentFilter

54. 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)

55. Processes and Threads

56. 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()

57. AsyncTask

58. 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

59. Questions?

60. Beer!

61. Live Coding

62. Introduction to Android
Development
Owain Lewis
owainrlewis@googlemail.com
@Ow_Zone