- Read through the Introduction to Android (it's very high signal and starts to point you to good initial resources).
- You'll install Android Studio: IntelliJ configured for Android development.
- Prime with Building Your First App, ASAP.
- Get familiar with the two primary app components: Activities and Fragments.
- pay special attention to the lifecycle stuff.
- Go through the Android Testing Codelab to get a feel for how TDD can look on Android.
- (TODO: Dagger 2)
- Pivotal machine images come with Java 6. Uninstall that and install Oracle's Java before you install Android Studio.
- When installing Android SDKs use the SDK manager from within Android Studio (because they told you to) and first expand a given SDK level and install everything from that level.
- Get a local copy of the developer docs:
Preferences
...Android SDK
>SDK Tools
>Documentaton for Android SDK
Install Sessions:
- Activities encapsulate a single screen of interaction with the user.
- which are composed from UI chunks or Fragments.
- Intents are messages sent to Activites, Services, and Broadcast Receivers. Intents are messages sent between "application components".
- the payload of an Intent is an "Action", "Category" and "Extras".
- invoking Activities can request a response (which arrives in the form of an Intent)
- Services encapsulate "backend" behavior that requires no UI.
- should be used for any work that is "long-running" (see Process and Thread Model, below.
- Broadcast Receivers responses to system-wide events (via an Intent).
- Content Providers encapsulate a data store meant to be shared with other applications (e.g. Contacts).
- App Widgets are mini applications that are meant to be used within another application (e.g. mini music player on the Home screen).
- Each application begins as a process and a single thread.
- Processes are kept alive as long as possible, but are terminated, least important to most.
- The priorities are this (most to least):
- activities, services, and broadcast receivers that are actively doing work.
- activities that are paused but still visible (or services bound to such activities)
- background services (i.e. launched with
startService()
) - backgrounded activities (i.e. that have been
onStop()
'ed.
- Practical implication: a process doing the same work through a Service will be higher priority than a process using an async task.
- Only do work within the UI thread when it costs less to do than spawning a new thread.
- Use
AsyncTask
to background work efficiently.- fully featured. Allows you to report progress and be cancelled.
- Work invoked through bound services occur not in the UI thread but from an OS-managed thread pool.
- ContentProviders process requests in within its own process (and therefore its own thread pool)
- Android is an object-oriented system, designed to support lots of little things signaling to each other.
- Design applications to operate as cooperating cells.
- Individual components (Activities, Fragments, Services, etc.) must be resilient — design to survive sudden stops and restarts (e.g. when a user rotates the device).
- AndroidManifest.xml is a public API of your "app"
- Activities and Broadcast Receivers should have very quick transaction times; anything longer should become a Service.
onCreate()
— allocate resources, start fetches,
onStart()
—onRestoreInstanceState()
— restore UI and local app stateonResume()
—onPause()
— store data that should be persisted across application launches or that might be used by an Activity taking over.onSaveInstanceState()
— save local app state (not called if app is definitely quitting)onStop()
- cancel any background tasks (e.g.
AsyncTask
instances)
- cancel any background tasks (e.g.
onDestroy()
- Using
Fragment.setRetainInstance()
can create lifeboats for active components to survive dreaded "Configuration Changes" (as described in Handling Configuration Changes with Fragments).
Out-of-The Box:
-
Most
View
s can save their own state (and will do so via the default implementation ofActivity.onSaveInstanceState()
).Tip: only widgets with an
android:id
will be saved.
- sizing dimensions:
dp
— (go-to) density-independent pixels; 1 dp = 1/160 th of the screen.sp
— (for text) dp's that are sensitive to user's scaling; all text should be in sp's.mm
,pt
,in
— useless as not all devices can scale these appropriately.