Getting Started with Android Studio and Kotlin

Welcome to the series of tutorials on Android Development with Kotlin. This series is designed with the goal to help you build Android Applications using Kotlin.

We’ll start with the absolute basics of Android Development and as the series progresses you’ll gain expertise in doing Android Development with Kotlin.

In this tutorial, we’ll start with the introduction of Android Studio. If you’ve used Android Studio in the past, do go through this tutorial to know the new features and changes that Android Studio 3.0 brought in.

Getting Started with Android Studio

Android Studio is based on JetBrains’ IntelliJ IDEA software and is specifically used for Android Development. It is available for Windows, Mac, and Linux operating systems. You can download it for your relevant OS from this link.

Note: You need the Java Development Kit installed on your system to build and run Android Studio projects.

Let’s start our Android Studio IDE for the first time!

With the introduction of Android Studio 3.0, the loading screen looks cooler!

Updating Android Studio IDE
If you have an older Android Studio IDE, do update it from the menu: Android Studio -> Check For Updates.

Subsequently, update the Gradle plugin by the prompts that follow.

Your root build.gradle file looks like this:

buildscript {
    repositories {
        google()
    }

    dependencies {
        classpath 'com.android.tools.build:gradle:3.0.1'
    }
}

Android Studio Features

Android Studio 3.0 is a big update over the previous 2.3.2 and is focused on aiding the developers.
Following are the major features that have arrived with this update:

Built-in Kotlin Support
Changes in Gradle Syntax
Extended Support for Java 8
Optimizing Using Android Profiler
Android Instant App Support

1. Using Kotlin in Android Studio

For pre-Android Studio 3.0 IDE following was the procedure to enable Kotlin support in your application:

Go to Android Studio | Preferences | Plugins | Install JetBrains plugin | Kotlin.

The following screen demonstrates the same:

With the Android Studio 3.0 update, the Android SDK provides built-in Kotlin support while creating a new project as shown below.

Choose Target Devices

Note: What happens when instant support is enabled in the above window would be covered in a later section.

The root build.gradle file looks like this:

buildscript {
    ext.kotlin_version = '1.1.51'
    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.0.1'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"

    }
}

allprojects {
    repositories {
        google()
        jcenter()
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

To facilitate smaller and faster updates, Android Studio 3.0 utilizes Google’s Maven Repository google() by default instead of using the Android SDK Manager to find updates to Android Support Library, Google Play Services, and Firebase Maven dependencies.

The app module’s build.gradle is given below.

apply plugin: 'com.android.application'

apply plugin: 'kotlin-android'

apply plugin: 'kotlin-android-extensions'

android {
    compileSdkVersion 26
    defaultConfig {
        applicationId "net.androidly.androidstudiokotlin"
        minSdkVersion 16
        targetSdkVersion 26
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation"org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version"
    implementation 'com.android.support:appcompat-v7:26.1.0'
    implementation 'com.android.support.constraint:constraint-layout:1.0.2'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.1'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.1'
}

2. Changes in Gradle Syntax

With the introduction of Android Studio 3.0, the keyword compile is deprecated. implementation and api are used instead.
Typically all compile statements are replaced with implementation.
An implementation statement rebuilds only the single module whereas the api statement would rebuild all modules that are dependent on the current one. So unless your module doesn’t leak its interfaces with other modules, implementation should be used.

compile 'com.android.support:appcompat-v7:26.1.0'

//changes to

implementation 'com.android.support:appcompat-v7:26.1.0'

3. Java 8 Support

Unlike the previous versions of Android Studio wherein you had to enable third-party plugins,
apply plugin: 'me.tatarka.retrolambda' Android Studio 3.0 has inbuilt support for Java 8.

It can be enabled from File | Project Structure as shown below:

Android Profiler

The Android Profiler tool in Android Studio 3.0 replaces the Android Monitor tools. These new profiling tools provide real-time data for your app’s CPU, memory, and network activity.

To open the tool goto: View | Tool Windows | Android Profiler

The tool displays the CPU, memory, and network profiler timelines in a single frame.

4. Android Instant App Support

Android Studio 3.0 comes with the support for Instant Apps. Instant Apps allow the user to load a part of the native application without the need to install the complete application. You must have come across hyperlinks in the browser that asks you to install the application to view the contents. Instant App rescues the user from this. It allows for viewing the native app in your browser without the need to download it from the play store.

Instant App Support is available for API > 23 and can be enabled from the following window.

This is how the project structure for an instant app looks like:

Let’s look at each module separately.

Base feature module:
The fundamental module of your instant app is the base feature module. All other feature modules must depend on the base feature module. The base feature module contains shared resources, such as activities, fragments, and layout files. This creates a feature APK when built.
The build.gradle of this module looks like:

apply plugin: 'com.android.feature'

android {
    compileSdkVersion 26
    baseFeature true
    defaultConfig {
        minSdkVersion 23
        targetSdkVersion 26
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    api 'com.android.support:appcompat-v7:26.1.0'
    api 'com.android.support.constraint:constraint-layout:1.0.2'
    application project(':app')
    feature project(':feature')
}

Instant App Module:
The build.gradle of this module looks like:
```
apply plugin: 'com.android.instantapp'

dependencies {
    implementation project(':feature')
    implementation project(':base')
}
```
It builds the Instant App APK that the user views without downloading the app.
App Module:
It builds our application’s APK.
Feature Module:
This contains code for the part of application that would be shown in the instant APK

The structure of an instant app on a high level looks like:

Note: It can contain multiple features too.

Summary

Besides the above major changes, Android Studio 3.0 has wholesome other changes. Majorly, performance improvements, build speed optimizations to accelerate your development.

We love the Dark Theme in Android Studio and recommend you the same. It’s available from Preferences | Appearances | Themes | Darcula as shown below.

This brings an end to Android Studio getting started tutorial. Let’s start with our Android Studio Hello World Application Using Kotlin in our next tutorial.