Introductory Android App Development Week
CommonsWare offers a week-long introductory Android app development course. This
is ideal for quickly getting a team “up to speed” on building Android apps.
Monday: Welcome to Kotlin!
Modern Android apps tend to be written in Kotlin, as opposed to Java. Google is
pushing developers towards writing Kotlin code, and Kotlin offers greater flexibility
for using that code across multiple platforms.
This day’s material will teach your team the basics of the Kotlin language, leveraging
of lecture and attendees experimenting with Kotlin in a “sandbox” environment.
In particular, we will examine:
- Basic Types and Expressions
- Collections and Lambdas
- If, When, and While
- Basic Classes
- Visibility and Scope
- Abstract Classes and Interfaces
- Data Class
- Nested Objects and Classes
- Enums and Sealed Classes
- Scope Functions
- Functional Programming
- Extension Functions
- Java Interoperability
Tuesday-Friday: Welcome to Android!
Here is the roster of topics that will be covered in the course. Note, though, that
there may be some minor changes to accommodate changes in Android, development tools,
The structure of these days will be to alternate short periods of lecture with
hands-on work. The hands-on portions will be structured step-by-step tutorials,
designed to allow developers to work at their own pace to build up an Android app.
While there will be time during the course week for attendees to do the hands-on
work, not everybody will work at the same speed. As a result, the tutorials are also designed
to be used on their own, after the course, for attendees who do not have time to finish them.
- What are the major components of an Android app?
- What tools do we use to build an Android app?
- What is the app itself — is it a file or something?
- What is Android Studio?
- How do we create an app project with Android Studio?
- What are the key features of Android Studio that we will use on a daily basis?
A Quick Project Tour
- What is Gradle and why do we care?
- What are dependencies? What sorts of dependencies do we have an in Android app?
- What is the manifest, and what goes in there instead of in Gradle files?
- What are resources, and what are some of the common types of resources?
- What are assets, and why do we have both assets and resources?
- Do we create Android apps using Java, Kotlin, or both?
- Why do we have three sets of source:
- How do we run our Android project? How do we debug it?
- What do we do with those tests?
- What is inside the compiled APK?
Making Basic Changes
- How do we change our Gradle build files? What sorts of changes should we make?
- How do we change our manifest? What sorts of changes should we make?
- What is a “merged manifest”, and what is merged to make it?
- Where does our app’s primary (“launcher”) icon come from? How can we change it?
- How do we add, change, or update the dependencies of our app?
Building a Simple UI
- What is an activity? What goes inside it?
- What are the common types of widgets?
- What are common properties that we configure on widgets and containers?
- What is
- How do we use the Android Studio graphical layout editor to work with
- What is a
Toolbar? What is an “app bar”? What is the “action bar”? What is the “status bar”? What is the “navigation bar”? And why does Android have so many bars?
- What are themes, and how do they affect what the action bar looks like?
- How do we add overflow menu items or toolbar buttons to the action bar?
Making More Screens
- How do we add our second activity?
- How do we pass control to that activity?
- What is WebView, and what powers it?
- How do we load HTML content into a WebView?
- What is a fragment? And why are we only talking about these now?
- How do we create a fragment?
- How do we add a fragment to our UI?
- What is data binding? Why would we want it? How do we use it?
- What is the Jetpack Navigation component? Why would we use it?
- How do we add the Navigation component to our app?
- How do we navigate between fragments using the Navigation component?
- How can we use these things to build up several screens in an app?
Adding Some Architecture
- What are common problems in Android app development that an architecture is designed to address?
- How does our app related to OS processes? When do processes get forked and terminated?
- What are configurations? Why would they change?
- What is dependency injection?
- How do we inject dependencies in Android?
- What is a
ViewModel, and why would we want one?
- How does
ViewModel tie into dependency injection?
- What is
LiveData, and what do we get from it?
- What are common UI architecture patterns in Android?
- How does one implement the MVI “unidirectional data flow” architecture?
- How can we use Kotlin’s coroutines for asynchronous work in Android?
Testing Our Work
- What sorts of tests do we write?
- How do we decide what can be a unit test and what must be an instrumented test?
- How do we write unit tests?
- How do we write instrumented tests?
- What is Espresso? How do we use it for UI testing?
- What other options are there for testing in the Android SDK?
Storing Our Data
- What is SQLite? Is it a database server or something?
- What is Room, and how does it relate to SQLite?
- How can we store and retrieve data in our app using Room?
- How do we work with files on Android?
- What are permissions in Android, and why do we need them?
- What are runtime permissions, and how do we ask for them?
- Where can we store content on Android, and how do we do it?
- What are preferences? Where are they stored, and how do we collect them?
- What about the Internet? Can we store things there?
What Else Do We Need to Know?
- What are the other types of components in Android, besides activities?
- What other things are there in Android… and is it a really long list?
- How do we learn about those things?
- What has changed in recent versions of Android?
- How do we keep track of what is changing in Android?
- Do we have all the answers now? If not, where do we turn for help?
If you find this to be interesting, or if you have questions,