Let us help you find the training program you are looking for.

If you can't find what you are looking for, contact us, we'll help you find it. We have over 800 training programs to choose from.


Course Skill Level:

Intermediate to Advanced

Course Duration:

5 day/s

  • Course Delivery Format:

    Live, instructor-led.

  • Course Category:

    Mobile Development

  • Course Code:


Who should attend & recommended skills:

Basic Java and XML experienced participants

Who should attend & recommended skills

  • Those who wish to learn the basics to create Android applications from scratch Java programming: Basic (1-2 years’ experience) required XML understanding: Basic (1-2 years’ experience) required

About this course

Are you trying to start a career in Android programming, but haven’t found the right way in? Do you have a great idea for an app, but don’t know how to make it a reality? Or maybe you’re just frustrated that to learn Android, you must already know Kotlin. If so, then this course is for you.
Introduction to Android Programming with Kotlin will be your guide to creating Android applications from scratch. We will introduce you to all the fundamental concepts of programming in an Android context, from the basics of Kotlin to working with the Android API. All examples are created within Android Studio, the official Android development environment, which helps supercharge your application development process.

Skills acquired & topics covered

  • After this crash course, we’ll dive deeper into Android programming, and you’ll learn how to create applications with a professional-standard UI through fragments and store your user’s data with SQLite.
  • By the end of this course, you’ll be ready to start building your own custom applications in Android and Kotlin.

Course breakdown / modules

  • Why use Kotlin and Android?
  • The beginner's first stumbling block
  • How Kotlin and Android work together
  • Setting up Android Studio
  • What makes an Android app?
  • The structure of Android's code
  • Our first Android app
  • Deploying the app so far

  • Examining the log output
  • Exploring the project's Kotlin code and the main layout's XML code
  • Adding buttons to the main layout file
  • Leaving comments in our Kotlin code
  • Coding messages to the user and the developer
  • Writing our first Kotlin code

  • A quick guided tour of Android Studio
  • Project Explorer and project anatomy
  • The Basic Activity project
  • Exploring the Android emulator

  • Material design
  • Exploring Android UI design
  • Layouts
  • Creating the Exploring Layouts project
  • Building a menu with LinearLayout
  • Wiring up the UI with the Kotlin code (part 1)
  • Adding layouts within layouts
  • Making the layout look pretty
  • Wiring up the UI with the Kotlin code (part 2)
  • Building a precise UI with ConstraintLayout
  • Laying out data with TableLayout

  • Attributes – a quick summary
  • Building a UI with CardView and ScrollView
  • Themes and material design
  • Creating a tablet emulator

  • The life and times of an Android app
  • A simplified explanation of the Android lifecycle
  • How we handle the lifecycle phases
  • The lifecycle demo app
  • Some other overridden functions
  • The structure of Kotlin code – revisited

  • Learning the jargon
  • More on code comments
  • Variables
  • Operators and expressions
  • The express yourself demo app

  • Making decisions in Kotlin
  • Repeating code with loops
  • While loops
  • Do-while loops
  • Ranges
  • For loops
  • Controlling loops with break and continue
  • Sample code

  • Function basics and recap
  • Table of Contents
  • Making functions flexible

  • Introducing OOP
  • Basic classes
  • Visibility modifiers
  • Constructors
  • Basic classes app and using the init block
  • Introduction to references

  • OOP and inheritance
  • Using inheritance with open classes
  • More polymorphism
  • Classes using the Inheritance example app

  • All the Android UI elements are classes too
  • Kotlin interfaces
  • Using buttons and TextView widgets from our layout with a little help from interfaces
  • Nullability – val and var revisited

  • Declaring and initializing the objects from the layout
  • Creating UI widgets from pure Kotlin without XML
  • Exploring the palette – part 1
  • Lambdas
  • Exploring the palette – part 2, and more lambdas
  • The widget exploration app
  • Coding the widget exploration app
  • Running the Widget Exploration app
  • Converting layouts to ConstraintLayout

  • Dialog windows
  • The Note to self app

  • A random diversion
  • Handling large amounts of data with arrays
  • A simple mini-app array example
  • Getting dynamic with arrays
  • ArrayLists
  • Arrays and ArrayLists are polymorphic
  • Hashmaps
  • The Note to self app

    • Inner classes
    • RecyclerView and RecyclerAdapter
    • Adding RecyclerView, RecyclerAdapter, and ArrayList to the Note to Self project
    • Running the app

  • The Android Intent class
  • Adding a settings page to Note to self
  • Persisting data with SharedPreferences
  • Reloading data with SharedPreferences
  • Making the Note to self settings persist
  • More advanced persistence
  • Backing up user data in Note to self

  • Introducing the model-view-controller pattern
  • Android design guidelines
  • Real-world apps
  • Device detection mini app
  • Configuration qualifiers
  • Fragments
  • Our first fragment app
  • Fragment reality check

  • The Angry Birds classic swipe menu
  • Building an image gallery/slider app
  • Kotlin companion objects
  • Building a Fragment Pager/slider app

  • Introducing the NavigationView
  • Examining the Age Database app
  • Starting the Age Database project
  • Exploring the auto-generated code and assets
  • Coding the Fragment classes and their layouts
  • Using the Fragment classes and their layouts

  • Database 101
  • The SQL syntax primer
  • The Android SQLite API
  • Coding the database class
  • Coding the Fragment classes to use the DataManager class
  • Running the Age Database app