Android Apps with Kotlin: Tools and Testing

Learn the skills necessary to assure quality software through testing by learning to effectively use the single most important tool for Android developers, Android Studio.
Course info
Level
Beginner
Updated
Aug 30, 2018
Duration
3h 42m
Table of contents
Course Overview
Working with the Core Tools and Features
Debugging Your App and Resolving Errors
Understanding Android Build Process, KTX, and Support Libraries
Implementing Local Unit Tests
Understanding Automated UI Tests
Creating More Complete Automated UI Tests
Description
Course info
Level
Beginner
Updated
Aug 30, 2018
Duration
3h 42m
Description

With any craftsman, knowing how to use your tools is a critical part of doing a job well. Android Studio is the single most important tool for Kotlin Android developers and it includes a wide variety of features that empower developers to work effectively and assure software quality through testing. In this course, Android Apps with Kotlin: Tools and Testing, you'll learn the skills necessary to work efficiently as a Kotlin Android app developer and assure quality software through testing. First, you'll start by exploring Android Studio productivity tools such as refactoring, automatic code generation, and converting Java code to Kotlin. Next, you'll see how to identify and resolve application problems using the debugger. From there, you'll learn how to incorporate more expansive feature support into your applications using Android Support Libraries, Android KTX, and the Gradle build system. Finally, you'll explore how to assure software quality and reliability through the combination of local unit tests, Android instrumented tests, and automated UI tests. By the end of this course, you'll have the necessary skills and knowledge to efficiently utilize Android Studio to create your own high-quality Kotlin Android applications.

About the author
About the author

Jim Wilson is president of JW Hedgehog, Inc., a consulting firm specializing in solutions for the Android, iOS, and Microsoft platforms. Jim has over 30 years of software engineering experience, with the past 15 years heavily focused on creating mobile device and location-based solutions.

More from the author
More courses by Jim Wilson
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi everyone. My name is Jim Wilson. Welcome to my course Android Apps with Kotlin: Tools and Testing. I'm Managing Partner at JWHH, LLC, and I've had the good fortune to have been a professional software developer now for over 30 years. I've been creating apps for Android since the earliest days of the platform, and I've seen many exciting changes in that time, but none more so than the addition of Kotlin as an Android development language. Kotlin's a game changer. It tremendously simplifies the task of creating Android apps and includes a number of features that reduce the likelihood of our apps encountering problems at runtime. But even with all the great features that Kotlin provides, we, as developers, are the ones who are ultimately responsible for assuring that we deliver high-quality apps, and that's the focus of this course. So the major topics we cover include Android Studio productivity features for Kotlin developers, debugging and resolving errors in our Kotlin apps, incorporating Kotlin libraries into our app build process, implementing local JVM unit tests with Kotlin, and performing automated user interface testing with Kotlin. By the end of this course, you'll have the necessary skills and knowledge to efficiently utilize Android Studio to create your own high-quality Android apps using Kotlin. To get the most out of this course, you should already have a basic understanding of how to create Android apps with Kotlin. This course is part of a series and builds on the content covered in my course Android Apps with Kotlin: Build Your First App. I hope you'll join me as we learn to develop high-quality Android apps using Kotlin with the course Android Apps with Kotlin: Tools and Testing, at Pluralsight.

Working with the Core Tools and Features
Welcome to the Pluralsight course, Android Apps with Kotlin: Tools and Testing. In this module, we'll look at how we work with the core tools and features of Android development. Now, throughout this course, we'll get a variety of tools related to developing our Android applications. We'll start out by looking at those core tools and features related to creating our applications. We'll then look at how we can debug our applications and resolve unhandled errors. We'll then dig into the Android build process and review some of the key libraries, including KTX and the Android support libraries. From there, we'll get into testing. We'll first look at how we can run local unit tests on our application, and then we'll see how to automate user interface tests. So now in this module, we're focused on the core tools and features that we use when we're developing our applications. But in order to look at those tools, the first thing we need to understand is the demo project we'll be using throughout this course. From there, we'll look at an overview of the features and capabilities provided by Android Studio. We'll then look at some of the features of Android Studio that really help improve developer productivity. From there, we'll see how we can convert Java code into Kotlin. And then we'll finish up. We'll look at an Android Studio feature known as Instant Run.

Debugging Your App and Resolving Errors
Welcome to our next module, Debugging Your App and Resolving Errors. This is part of the Pluralsight course Android Apps with Kotlin: Tools and Testing. My name is Jim Wilson. In this module, we'll look at some of the tools that are available to help us to resolve errors and other issues that might occur within our program. We'll start out, we'll look at breakpoints that allow us to pause execution of our program at a particular statement, along with some of the options we have for stepping through individual statements within our program. We'll see how to set breakpoints that only occur when a particular condition is met. We'll see how to view the values contained within variables and properties. We'll see how we can deal with unhandled exceptions and how to resolve the cause of those exceptions. And then we'll finish up. We'll look at the Android logging system known as logcat.

Understanding Android Build Process, KTX, and Support Libraries
Welcome to our next module, Understanding Android Build Process, KTX, and Support Libraries. This is part of the Pluralsight course Android Apps with Kotlin: Tools and Testing. My name is Jim Wilson. In this module, we'll look at how to manage the build process of our applications. So we'll start out with an overview of the Android build process and the important role of a tool called Gradle. We'll then look at how we modify Gradle parameters. We'll see how to specify dependencies for our application in Gradle. We'll then look at the important role of something called the Android Support Library, and then we'll look at two new libraries called AndroidX and Android KTX.

Implementing Local Unit Tests
Welcome to our next module, Implementing Local Unit Tests. This is part of the Pluralsight course Android Apps with Kotlin: Tools and Testing. My name is Jim Wilson. In this module, we'll start to look at how we can use testing to assure that we deliver quality applications. So we'll start out, we'll look at some of the basic concepts of app testing, we'll then take a look at some of the features that Android Studio provides to allow us to efficiently run our unit tests, we'll see how to create unit tests, we'll take a look at one of the important classes we use in unit testing called the Assert class, and then we'll finish up with a look at how we can assure that our tests run consistently.

Understanding Automated UI Tests
Welcome to our next module, Understanding Automated User Interface Tests. This is part of the Pluralsight course Android Apps with Kotlin: Tools and Testing. My name is Jim Wilson. Incorporating testing that occurs within the Android environment is critical to assuring app quality. As part of assuring that app quality, we need to also incorporate testing that includes interacting with the user interface. However, manually testing the user interface can be time prohibitive, so for this sort of testing to be effective, we need a way to automate it, and that's where instrumented testing comes in. So in this module, we'll start out with an overview of instrumented testing, we'll then see how to implement instrumented tests, we'll see how to set up automated user interface tests, and then we'll finish up with a look at some basic user interface test interactions.

Creating More Complete Automated UI Tests
Welcome to the module Creating More Complete Automated User Interface Tests. This is part of the Pluralsight course Android Apps with Kotlin: Tools and Testing. My name is Jim Wilson. In this module, we're going to continue building our automated user interface testing knowledge so we can build richer, more sophisticated user interface tests. So we'll start out, we'll look at how we write tests that interact with AdapterViews, we'll see how to interact with our device's Back button, we'll see how to verify our test behavior, that's both logic verification, as well as user interface verification, and then we'll finish up with a brief look at the Espresso Test Recorder.