Android Development with Kotlin, Part 1 - Introduction

St. Pölten University of Applied SciencesSt. Pölten University of Applied Sciences
Platzhalter für möglichen
Bildeinsatz
Android Development with Kotlin, Part 1
Introduction
Andreas Jakl
Digital Healthcare
FH St. Pölten
Platzhalter für möglichen
Bildeinsatz
Version 1.3

Andreas Jakl
▪ Focus areas
▪ AR / VR, mobile apps, sensors, interaction
technology, software architecture, open source
developer (NFC, Bluetooth Beacons)
▪ Microsoft MVP (Most Valuable Professional)
▪ mobility.builders community: Mobile Developer
After-Work Events
▪ Previous Experience
▪ Tieto, Start-up (Mopius), Nokia (Finland),
Siemens Mobile (Munich), FH Hagenberg
(Mobile Computing)
Android Development with Kotlin, Part 1 | 2018 | Andreas Jakl | FH St. Pölten
https://www.andreasjakl.com/
@andijakl
andreas.jakl@fhstp.ac.at
2

Contents
▪ Hybrid & Native Apps
▪ Native Android Development
▪ Android & SDK Versions
▪ Hello World
▪ Emulators, Devices & ADB
▪ Android Emulators & Build Process
▪ Kotlin Android Extensions
▪ App Lifecycle
▪ Saving App State
▪ Debugging
▪ Code Style + Documentation
▪ Activities & Intents
▪ Implicit Intents
Android Development with Kotlin, Part 1 | 2018 | Andreas Jakl | FH St. Pölten 3

Android Studio
▪ If you have not already:
▪ Install Android Studio now!
▪ It’ll take some time …
▪ https://developer.android.com/studio/index.html
▪ Already includes JDK
▪ Troubleshooting
▪ https://docs.google.com/document/d/1w1Xn_hnSAODAAtdRDp7haYPBtEwX
_l7Htpf8Wpgbu6w/pub?embedded=true

NATIVE APPS
Web vs Hybrid vs Native

Web Apps
Multi-platform
Web UI / UX
Run in browser (can be offline)
Slower performance
Less system integration
Native Apps
Single platform
Native UI / UX
Run directly on OS
Fast performance, best system
integration. More expensive.
Hybrid Apps
Multi-platform
Hybrid UI / UX
Parts in HTML, parts native

Web Apps
Native Apps
Hybrid Apps
Cost
User Experience

Additional Materials
▪ Free Android Courses by Google & Udacity
▪ Java Programming Basics: https://www.udacity.com/course/java-programming-
basics--ud282#
▪ Android Basics: User Interface: https://www.udacity.com/course/android-basics-
user-interface--ud834#
▪ Developing Android Apps: https://www.udacity.com/course/new-android-
fundamentals--ud851#
▪ Kotlin for Android Developers: https://www.udacity.com/course/kotlin-for-
android-developers--ud888
▪ Quick Kotlin overview for Java Android devs:
https://developer.android.com/kotlin/index.html

NATIVE ANDROID DEVELOPMENT

Android Development
Java Kotlin C++
Frame-
works
(Unity, Xamarin,
Qt, …)
Web
Android Studio
Visual Studio
Specific
tools
Visual
Studio
Code,
WebStorm,
etc.
IntelliJ IDEA

Android Web / Hybrid Apps
Image source: Google,
https://developer.android.com/guide/webapps/index.html

Android Web / Hybrid Apps
Cordova
Native
functionality
(Java, C++, …)
Image source: Google,
https://developer.android.com/guide/webapps/index.html

Cross-Platform Engines
▪ Usually specialized for app types
▪ Unity
▪ Games, 2D / 3D graphical apps
▪ Cross-platform
▪ Graphical editor, code with C#
▪ Xamarin
▪ Apps
▪ iOS, Android, Windows
▪ Cross-platform C# APIs, with Xamarin.Forms also UI. Specific native code possible
▪ Qt
▪ Apps and embedded
▪ Cross-platform
▪ UI with JavaScript / QML, native code with C++
Image sources:
Unity Logo, by Unity Technologies
Public domain, https://en.wikipedia.org/wiki/File:Unity_Technologies_Logo.svg
Xamarin Logo, by Xamarin Inc. / Microsoft
Public domain, https://en.wikipedia.org/wiki/File:Xamarin-logo.svg
Qt Logo, by The Qt Company
Public domain, https://en.wikipedia.org/wiki/File:Qt_logo_2016.svg

Android C++
▪ Native Development Kit (NDK)
▪ C and C++ code
▪ Why?
▪ Reuse existing C++ code & libraries
▪ Extra performance, less latency
▪ Combine: communication Java <> C++
▪ Java Native Interface (JNI)
▪ https://developer.android.com/ndk/guides/index.html
Image credits: logo for C++ created by Jeremy Kratz
Licensed for use of any purpose by the Standard C++ Foundatino
https://en.wikipedia.org/wiki/File:ISO_C%2B%2B_Logo.svg

Java (for Android)
▪ Java: Source code > Byte code > executed by Java Virtual Machine (JVM)
▪ License
▪ OpenJDK
▪ GPL v2 license
▪ De-facto reference implementation of Java by Oracle / Sun, basis for Oracle JDK
▪ Used in Android since Nougat
▪ Android uses recent Java. By default part of Android Studio: C:android-studiojre
▪ Trial Google vs. Oracle
▪ Use of Java = fair use? Switch to OpenJDK as a result
(before: Apache Harmony, re-implementation of copyrighted Java APIs)
▪ http://www.zdnet.com/article/oracle-vs-google-just-as-you-thought-java-android-row-was-over-it-all-kicks-off-again/
Image credits: Duke, the mascot used by Java.
Copyright Sun Microsystems Inc., BSD license
https://en.wikipedia.org/wiki/File:Duke_(Java_mascot)_waving.svg

Kotlin
▪ Programming language, “improved Java”
▪ Runs on Java JVM
▪ Interoperable with Java code + libraries
▪ Possible to mix Kotlin + Java in same project
▪ But can also be compiled to JavaScript + native (C)
▪ Created by JetBrains
▪ Open source language (Apache 2 license): https://github.com/JetBrains/kotlin
▪ https://kotlinlang.org/
Image credits: Kotlin Logo, by JetBrains.
https://commons.wikimedia.org/wiki/File:Kotlin-logo.svg

Kotlin & Android
▪ Android
▪ Integrated in Android Studio 3+
▪ Fully supported programming language for Android
▪ Kotlin Android Extensions:
https://kotlinlang.org/docs/tutorials/android-
plugin.html
Image credits: Kotlin Logo, by JetBrains.
https://commons.wikimedia.org/wiki/File:Kotlin-logo.svg

Android Studio
▪ Official IDE
▪ Customized from JetBrain’s IntelliJ IDEA
▪ Windows, Mac OS, Linux

ANDROID PLATFORM
Versions & Structure

Android Versions
▪ Version Distribution:
https://developer.android.com/about/dashboards/index.html#Platform
▪ More features in newer versions
▪ But: partly backported
▪ Reduces fragmentation
▪ Support Library (AppCompat)
▪ Google Play Services

Android Versions

SDK Versions
▪ MinSDK
▪ Lowest OS your app can run on
▪ Restricts features and APIs you can use
▪ TargetSDK
▪ Version you tested the app on
▪ Generally forward compatible: if behavior changes in new version, new Android will still “simulate” behavior
of old TargetSDK version (e.g., Runtime permissions with Android M)
▪ https://developer.android.com/reference/android/os/Build.VERSION_CODES.html
▪ Use the latest version when starting a new project
▪ CompileSDK
▪ Not part of the manifest, only relevant for developer
▪ Generally use latest version -> allows using latest APIs if needed

HELLO WORLD
Your First Android App

Create New Project

Project Structure
See: https://developer.android.com/studio/build/index.html

Views
▪ Android user interface (UI) composed of views
▪ TextView
▪ ImageView
▪ Button
▪ Etc.
▪ All managed by a layout
▪ Positioning of views on the screen

Design
TextView
ImageView
Button
Toggle: Design / Text (XML)

XML
<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context="com.andreasjakl.helloworld.MainActivity"
tools:layout_editor_absoluteY="81dp">
<TextView
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginBottom="8dp"
android:layout_marginEnd="8dp"
android:layout_marginStart="8dp"
android:layout_marginTop="8dp"
android:text="Hello World!"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<ImageView
android:id="@+id/imageView"
android:layout_marginStart="8dp"
app:layout_constraintEnd_toEndOf="@+id/textView"
app:layout_constraintStart_toStartOf="@+id/textView"
app:layout_constraintTop_toBottomOf="@+id/textView"
app:srcCompat="@android:drawable/btn_star_big_on" />
<Button
android:id="@+id/button"
android:text="Button"
app:layout_constraintEnd_toEndOf="@+id/imageView"
app:layout_constraintStart_toStartOf="@+id/imageView"
app:layout_constraintTop_toBottomOf="@+id/imageView" />
</android.support.constraint.ConstraintLayout>
TextView
ImageView
Button

Activity & Views
▪ Activity’s onCreate():
▪ R class
▪ Dynamically identify contents in res folder
▪ setContentView()
▪ Inflates the layout XML file
setContentView(R.layout.activity_main)

SDK Manager
▪ Android Studio > File > Settings > Appearance &
Behavior > System Settings > Android SDK, or:
▪ Install all “SDK platforms” you need
▪ SDK Tools: ensure you have at least
▪ Android SDK Build-Tools
▪ Android Emulator
▪ Android SDK Platform-Tools
▪ Android SDK Tools
▪ Google Play Services
▪ Google USB Driver (on Windows)
▪ Intel x86 Emulator Accelerator (HAXM installer)
▪ Support Repository

Running the App
▪ Press “Play” arrow
▪ Select deployment target
▪ Connected phones or emulator
▪ “Create New Virtual Device”

Android Debug Bridge (ADB)
▪ ADB manages connections to phones & emulators
▪ Debugging
▪ Installing apps
▪ Windows: add to path (next slide)
▪ “adb.exe” usually in C:Androidplatform-tools
▪ Powershell: “adb devices –l” to show all connected devices
Emulator + phone connected

Windows: Add ADB to Environment Variables

Android Emulators
▪ Freely choose device configuration
▪ Screen size, OS, memory, etc.
▪ Hardware Acceleration
▪ Intel HAXM, but only for Intel. Conflict with Hyper-V
https://developer.android.com/studio/run/emulator-
acceleration.html#accel-vm
▪ Alternative: Microsoft Android emulator
https://www.visualstudio.com/vs/msft-android-
emulator/

Deploy to Android Phone
▪ Enable Developer Options
▪ Settings > (System) > About Phone > tap 7x on
“Build Number”
▪ Enable “USB debugging”
▪ Connect phone via USB
▪ Ensure debugging is active
▪ Device shows up in “adb devices”

Gradle
▪ Build automation system
▪ Used by Android Studio
▪ Can be run manually from command line
▪ Converts code to installable package
▪ Configuration: build.gradle
▪ You define: dependencies, versions, etc.
▪ https://developer.android.com/studio/build
/index.html
Image credits: Gradle Logo copyright Gradle, Inc.
Build process copyright Google,
https://developer.android.com/studio/build/index.html

Android Build Process
▪ Gradle settings
▪ settings.gradle (project root directory)
▪ Which modules to include. Usually only one line
include ':app'

▪ Top-level build file
▪ build.gradle (project root directory)
▪ Applies to all modules
▪ buildscript: Gradle repositories &
dependencies
buildscript {
ext.kotlin_version = '1.2.10'
repositories {
google()
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.0.1'
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}

▪ Module-level build file
▪ project/module/settings.gradle
▪ Only apply to this module
▪ Custom packaging options: Android options,
module-level dependencies, product flavors
(free / paid, …)

ADDING INTERACTIVITY
Hello World 2.0

Adapt Size & Color
▪ Check Google Material Design guidelines
▪ https://material.io/guidelines/
▪ Size
▪ View: use “dp” for device-independent pixels.
Same physical view size no matter the pixel density of the screen.
▪ Text: use “sp” for scale-independent pixels. Also considers user’s settings.
▪ Color
▪ Use color tool: https://material.io/color/

Improving XML Definitions
▪ Collect text in “res/values/strings.xml”
▪ Reference from TextView & Button
▪ Easier to localize and change
▪ Give useful IDs to elements
▪ Start with “@+id/”
▪ + indicates it’s a new resource ID
▪ Rename e.g., “@+id/textView” -> “@+id/tv_hello”
<TextView
android:id="@+id/tv_hello"

Interactivity with Kotlin for Android
▪ MainActivity.kt > Change TextView text when Button is clicked
▪ Create member variables to access UI elements
▪ In onCreate(), find views:
▪ Set click listener and change TextView text
private lateinit var mChangeTextButton : Button
private lateinit var mHelloTextView : TextView
mHelloTextView = findViewById(R.id.tv_hello)
mChangeTextButton = findViewById(R.id.bt_change)
mChangeTextButton.setOnClickListener {
mHelloTextView.text = "Welcome!"
}

Interactivity with Kotlin for Android
▪ Define “Welcome!” text in strings.xml and load from Kotlin code:
mChangeTextButton.setOnClickListener {
mHelloTextView.text = getText(R.string.welcome_text)
}

Kotlin Android Extensions
▪ findViewById() – easy to make errors, lots of code to write
▪ Kotlin Android Extensions make accessing views easier
▪ build.gradle: ensure the plugin is loaded
▪ MainActivity.kt: Add import with name of xml file
▪ Directly access View elements:
apply plugin: 'kotlin-android-extensions'
import kotlinx.android.synthetic.main.activity_main.*
bt_change.setOnClickListener {
tv_hello.text = getText(R.string.welcome_text)
}

Rotating the Screen?
?
Text switches
back to original

ANATOMY OF ANDROID APPS
Lifecycle

Android Application Components
1. Activity
▪ “Single focused thing the user can do”
▪ Creates view (to draw, based on XML layout file) and receives events (touch)
2. Service
3. Content Provider
4. Broadcast Receiver

Source:https://developer.android.com/guide/components/activities/activity-lifecycle.html

Task: Check Lifecycle
▪ Override all lifecycle methods of the activity
▪ Log status message (Log.d)
▪ Create TAG to recognize your log messages
▪ Example
▪ Check output in logcat
private val TAG = MainActivity::class.java.simpleName
override fun onStart() {
super.onStart()
Log.d(TAG, "onStart")
}

Task: Check Lifecycle
▪ Rotate screen!
Rotation

Saving the State
▪ Bundle for storing small amount of data
▪ Only used when resuming apps, not for re-starts
▪ Built-in for activity: save key-value pairs
▪ Key definition
▪ Save state
▪ Restore in onCreate() + default if not set
private val KEY_TEXT = "uiText"
override fun onSaveInstanceState(outState: Bundle?) {
outState?.putString(KEY_TEXT, tv_hello.text.toString())
super.onSaveInstanceState(outState)
}
if (savedInstanceState != null) {
tv_hello.text = savedInstanceState.getString(KEY_TEXT, getText(R.string.hello_text).toString())
}

DEBUGGING
Finding and Fixing Errors

Trigger Error
▪ Create unhandled exception in onCreate()
▪ App crashes on startup
▪ Check logcat (set log level to “Error”)
throw Exception("Error!")

Debugging Android Apps
▪ Set Breakpoints & use debugging tools
▪ Run app with “Debug” mode
▪ Break on any exception
▪ Run > View Breakpoints … >
Activate “Any Exception”
▪ may include lots of others too

Android Lint
▪ Static Code Analysis: Analyze > Inspect Code…

Issues with R Class / Unknown Error Source
▪ Recheck XML in your resource files (layouts, …)
▪ Android Studio might not highlight everything, e.g. some typos
▪ Clean project to rebuild from scratch
▪ Build > Clean Project
▪ Re-Sync project with Gradle
▪ Tools > Android > Sync Project with Gradle Files
▪ Run Android Lint

Exercise: Guess-a-Number
▪ Create UI with at least 3 views:
▪ EditText (“Plain Text” or “Number”), Button, TextView
▪ Put all user-visible text in strings.xml resource
▪ Phone thinks of random number [1..100]
▪ User enters number and taps button
▪ Phone tells if number was too low, too high or correct
▪ Bonus: also add number of tries to message
▪ Bonus: reset game and create new random number
▪ Bonus: handle screen rotation

CODE STYLE
Documentation & Naming Conventions

Naming Conventions
▪ Android naming conventions & more:
▪ https://android.github.io/kotlin-guides/style.html
▪ Generic Kotlin
▪ https://kotlinlang.org/docs/reference/coding-conventions.html

Naming Conventions
▪ Package names
▪ Always lowercase
▪ Classes / Objects
▪ Start with upper case letter, camel humps
package com.andreasjakl.helloworld
class MainActivity : AppCompatActivity() {

Naming Conventions
▪ Functions, properties, local variables
▪ Start with lower case letter, camel humps, no underscores
▪ Exception: constructors (-> same name as class, uppercase starting letter)
▪ Constants
▪ Uppercase, underscore-separated
var myCounter = 3
override fun onSaveInstanceState(outState: Bundle?) {
private val KEY_TEXT = "uiText"

Documenting Code
▪ Code comments
▪ Important for classes, methods and properties (especially public)
▪ Java: JavaDoc
▪ Kotlin: KDoc – https://kotlinlang.org/docs/reference/kotlin-doc.html

KDoc Syntax
▪ Add comment directly above class / function
▪ Starts with /** , ends with */
▪ Every documentation line has * at the beginning – not part of comment
▪ Block tags
▪ Parameters: @param <name>
▪ Returns: @return

Generate Documentation: Dokka
▪ Add dokka-android plugin to app build.gradle
▪ Add gradle task “dokka” to configure documentation
▪ See: https://github.com/Kotlin/dokka/blob/master/README.md
apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
apply plugin: 'org.jetbrains.dokka-android'
dokka {
outputFormat = 'html'
outputDirectory = "$buildDir/javadoc"
}

▪ Configure docker version and dependency in module’s build.gradle
▪ Run gradle task “dokka” in terminal
▪ gradlew dokka
buildscript {
ext.kotlin_version = '1.2.10'
ext.dokka_version = '0.9.15'
repositories {
google()
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.0.1'
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
classpath "org.jetbrains.dokka:dokka-android-gradle-plugin:${dokka_version}"
}
}

▪ Generated HTML documentation in app/build/javadoc directory:

ACTIVITIES
Adding multiple pages to your app

Our Task: Passing Data

Navigation
Activity Activity
not called directly

Indirect Triggering
Activity Activity
Intents

Flexibility: Launch Various Tasks
Activity Activity
Start new
Intents
Take picture
Open browser

What is an Intent?
- Message object
- Request action from other app component
- Can include data (extras)
Image source: Android Developer Guide
https://developer.android.com/guide/components/intents-filters.html

Exercise: Create Main Activity
▪ Name: GreetingApp
▪ UI
▪ TextView, EditText, Button
▪ Use helpful ids
▪ Externalize text to strings.xml
▪ Ensure proper dynamic layout
▪ Use setOnClickListener() on button
▪ Display entered text with a toast
▪ Search for documentation!

Exercise: Create Greeting Activity

Exercise: UI for Greeting Activity
▪ UI
▪ 2x TextView with helpful IDs
▪ Check AndroidManifest.xml
▪ Shows second activity
▪ It’s not configured for MAIN / LAUNCHER

Context
▪ Global information about app environment
▪ Provided by Android system
▪ Access app-specific resources
▪ App-level operations (e.g., launching activities)

Create & Launch Intent
val welcomeIntent = Intent(this, GreetingActivity::class.java)
startActivity(welcomeIntent)
Context Activity to start
Start!

Passing Data
▪ Intents support extended data
▪ Key / Value-based
▪ Default Intent.EXTRA_TEXT for passing basic String data
welcomeIntent.putExtra(Intent.EXTRA_TEXT, et_name.text.toString())
Text from EditText

Receiving Extra Data
▪ Activity has intent property
▪ Provides access to details about Intent
// Check if the calling intent actually provided EXTRA_TEXT data
if (intent.hasExtra(Intent.EXTRA_TEXT)) {
// Retrieve String contents from EXTRA_TEXT data
var userName = intent.getStringExtra(Intent.EXTRA_TEXT)
// Apply the String to the UI
tv_name.text = userName
}

Enable Back Navigation Arrow
▪ Specify parent activity in manifest
▪ Add meta-data if targeting Android 4.0
▪ For newer versions, the parentActivityName is enough
<activity android:name=".GreetingActivity"
android:parentActivityName=".MainActivity">
<meta-data
android:name="android.support.PARENT_ACTIVITY"
android:value=".MainActivity" />
</activity>

Implicit Intent
▪ Action to be done + (optional) data
▪ Take picture
▪ Call contact
▪ Show web page
▪ …
▪ Multiple apps can handle intent?
▪ Android lets user choose
Activity
Start new
Take picture
Open browser

Open Web Site
▪ Common Intents
▪ https://developer.android.com/guide/components/
intents-common.html
▪ -> Web Browser
▪ Extend UI
▪ Second button
▪ Click listener

Resolving Intents
// Target address, converted from String to URI
val webPage = Uri.parse("https://www.andreasjakl.com/")
// Create an intent. ACTION_VIEW is generic to show data to the user
// Apps can subscribe to handle specific URIs
// See: https://developer.android.com/reference/android/content/Intent.html#ACTION_VIEW
val webIntent = Intent(Intent.ACTION_VIEW, webPage)
// Check if at least one app is installed to handle our intent
if (webIntent.resolveActivity(packageManager) != null) {
// If yes, start the activity!
startActivity(webIntent)
}

URI?
scheme:[//[user[:password]@]host[:port]][/path][?query][#fragment]
https://www.andreasjakl.com/
mailto:andreas.jakl@fhstp.ac.at?subject=Android
geo:48.214643,15.6224716
spotify:album:3hrSH1h42tH4W1ods3Cm7o

Exercise
▪ Launch another common intent
▪ https://developer.android.com/guide/components/intents-common.html
▪ Examples
▪ Map
▪ Share
▪ Email
▪ Camera
▪ Note: some activities need extra permissions in your manifest!

THANK YOU!

Android Development with Kotlin, Part 1 - Introduction

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Android Development with Kotlin, Part 1 - Introduction

Similar a Android Development with Kotlin, Part 1 - Introduction (20)

Más de Andreas Jakl

Más de Andreas Jakl (20)

Último

Último (20)

Android Development with Kotlin, Part 1 - Introduction