Android Pie SDK is more compatible with Kotlin

[[240538]]

One of the most common pain points when using the Java programming language is that when accessing a null reference member, the system will report a NullPointerException. Kotlin can effectively avoid this problem by incorporating nullable types and non-nullable types into the type system, helping you eliminate NullPointerException errors in your code, thereby improving the overall quality of your app. When Kotlin code calls an API written in the Java language, it relies on the nullability annotations in the above API to determine the nullability of each parameter and the return value type. Unannotated parameters and return value types will be treated as platform types, weakening Kotlin's null safety guarantees.

The latest Android 9 includes an update to the Android SDK that adds nullability annotations to a range of the most commonly used APIs. Your Kotlin code retains null safety guarantees when calling any annotated API in the SDK. Even when using the Java programming language, you can still benefit from these annotations by using Android Studio to detect nullability protocol violations.

As part of the Android 9 release, the new Android SDK includes nullability annotations for some commonly used APIs. When Kotlin calls any annotated API in the SDK, it can reserve null-safety guarantees. Developers using Java can also use Android Studio to capture nullable contract violations, thereby effectively utilizing these nullability annotations.

Small changes, big improvements

Normally, violations of nullability protocols in Kotlin result in compilation errors. To ensure that APIs that already contain annotations are compatible with your existing code, we use an internal mechanism provided by the Kotlin compiler team to annotate the ***-annotated APIs. Newly annotated APIs only trigger warnings and do not cause errors in the Kotlin compiler. This requires the use of Kotlin plugin 1.2.60 or later.

The recently added nullability annotations will only generate warnings instead of errors, but in the next year's Android SDK, we will increase the severity of the errors. The purpose of this move is to give developers enough time to adjust their code.

How to use an SDK that is more compatible with Kotlin

First, in Android Studio, select Tools > SDK Manager. Select "Android SDK" in the left column and make sure the "SDK Platforms" tab is open.

Check Android 8.+ (P) and click OK. This step will install the Android SDK Platform Level 28 Release 6 if it is not already installed. After that, set the project's compile SDK version to API level 28 to activate the nullability annotations of the new Android Pie SDK.

If your current Kotlin plugin has not been updated to the latest version, you need to update it through Android Studio. Please select "Tools Kotlin > Configure Kotlin Plugin Updates" to check and make sure the Kotlin plugin version is 1.2.60 or later.

Once the configuration is set up, your project will display warnings if your code violates the nullability protocols in the Android SDK.

In addition, if the Android API you call does not meet the nullability requirements, the Android Studio code editor will also display a warning. The specific example is as follows:

Leveraging Nullability Annotations in the Java Programming Language

Even if your code is written in the Java programming language, you can still benefit from the new nullability annotations. By default, Android Studio will display warnings for violations of the nullability protocol, as shown below:

To make sure you have this inspection activated, visit the IDE's settings page and search for the "Constant conditions & exceptions" inspection and make sure it is checked.

If you are using the Java programming language, violations of the nullability protocol will not generate any compiler warnings or errors. Only the code inspection features of the IDE can detect these problems.

Additionally, you can inspect code across your entire project and review the overall results. Click Analyze>Inspect Code... to start the process.

Next step

There are many interfaces in the Android SDK API. So far, we have only annotated a small part of the API, and there is still a lot of work waiting for us. In the next few Android SDK versions to be released, we will continue to add nullability annotations to existing Android APIs and ensure that all new APIs are also annotated.

With a more Kotlin-friendly Android SDK, nullability annotations in AndroidX (part of the Jetpack series), and Android KTX, we will continue to improve the Android API for developers using Kotlin. If you haven't tried Kotlin yet, we hope you give it a try. Kotlin will not only make your code more concise, but also improve the stability of your app.