Things needed to download to make android app

Save to shared storage. Save data in a local database. Sharing simple data. Sharing files. Sharing files with NFC. Printing files.

Content providers. Autofill framework. Contacts provider. Data backup. Remember and authenticate users. User location. Using touch gestures. Handling keyboard input. Supporting game controllers. Input method editors. Performing network operations. Transmit network data using Volley. Perform network operations using Cronet. Transferring data without draining the battery. Reduce network battery drain. Transfer data using Sync Adapters.

Bluetooth Low Energy. Wi-Fi infrastructure. Discover and connect. Runtime API reference. Web-based content. Android App Bundles. Google Play. Play Asset Delivery. Play Feature Delivery. In-app reviews. In-app updates. Google Play Instant.

Get started with instant apps. Get started with instant games. Integrate with Firebase. Play Install Referrer. Play Install Referrer Library.

Application Licensing. Android GPU Inspector. System profiling. Analyze a system profile. Frame profiling. Analyze a frame profile. Frame Profiler UI. Customize or port game engines. Process input events. Tablets, large screens, and foldables.

Build responsive UIs. Build for foldables. Getting started. Handling data. User input. Watch Face Studio. Health services. Creating watch faces. Android TV. Build TV Apps. Build TV playback apps. Help users find content on TV.

Recommend TV content. Watch Next. Build TV games. Build TV input services. TV Accessibility. Android for Cars. Build media apps for cars. Build navigation, parking, and charging apps for cars. Android Things. Supported hardware. Advanced setup. Build apps. Create a Things app. Communicate with wireless devices. Configure devices. Interact with peripherals. Build user-space drivers. Manage devices. Create a build. Push an update.

Chrome OS devices. App architecture. Guide to app architecture. UI layer. Architecture Components. UI layer libraries. View binding. Data binding library. Lifecycle-aware components. Paging Library. Paging 2. Data layer libraries.

How-To Guides. Advanced Concepts. Threading in WorkManager. There are buttons to switch mode in the top right. In the design view, you can actually drag and drop different widgets onto the screen. The code view shows you a load of XML script. When you add new widgets via the Design view, this script will update.

This is a bit of a headache, but it actually simplifies the process in the long run. Or read this guide for more about the different views and what they each do. But some things that are useful to know about:. That includes the orientation of the app, the activities that you want to be included in it, the version, etc. See also: Xml: everything you need to know. Drawable: This folder is found in res.

This is where you will put things like images that you want to reference later. Values: This resource folder is a useful place to store values that will be used globally across your app. For example, this can include color codes making it easy for you to change the look of your entire app or strings words.

Gradle: Gradle is the tool that takes all your files and bundles them into a workable APK for testing. It is also useful for generating previews etc. Dependencies are external libraries that let you access additional functionality from within your own code. Of course, we also have a detailed introduction to Gradle for new Android developers. On the left of this is a drop-down menu, with a phone name in it.

When you installed Android Studio, this should also have installed an Android system image along with the Virtual Device Manager. In other words, you should already have an Android emulator set up and ready to go! Notice that this will also let you use the emulated phone as though it were a real device. You can change the settings for your virtual device — such as screen size, Android version, space etc. You can also download new system images here.

After the test coroutine completes, runBlockingTest returns. We want to add a short timeout to the network request. Let's write the test first then implement the timeout. Create a new test:. This test uses the provided fake MainNetworkCompletableFake , which is a network fake that's designed to suspend callers until the test continues them.

When refreshTitle tries to make a network request, it'll hang forever because we want to test timeouts. Then, it launches a separate coroutine to call refreshTitle. This is a key part of testing timeouts, the timeout should happen in a different coroutine than the one runBlockingTest creates. One of the features of runBlockingTest is that it won't let you leak coroutines after the test completes.

If there are any unfinished coroutines, like our launch coroutine, at the end of the test, it will fail the test. Open up TitleRepository and add a five second timeout to the network fetch. You can do this by using the withTimeout function:. In this exercise you'll refactor refreshTitle in MainViewModel to use a general data loading function.

This will teach you how to build higher order functions that use coroutines. The current implementation of refreshTitle works, but we can create a general data loading coroutine that always shows the spinner. This might be helpful in a codebase that loads data in response to several events, and wants to ensure the loading spinner is consistently displayed. Reviewing the current implementation every line except repository.

Now refactor refreshTitle to use this higher order function. By abstracting the logic around showing a loading spinner and showing errors, we've simplified our actual code needed to load data. Showing a spinner or displaying an error is something that's easy to generalize to any data loading, while the actual data source and destination needs to be specified every time.

To build this abstraction, launchDataLoad takes an argument block that is a suspend lambda. A suspend lambda allows you to call suspend functions. That's how Kotlin implements the coroutine builders launch and runBlocking we've been using in this codelab. To make a suspend lambda, start with the suspend keyword.

The function arrow and return type Unit complete the declaration. You don't often have to declare your own suspend lambdas, but they can be helpful to create abstractions like this that encapsulate repeated logic!

There are many options on Android for deferrable background work. This exercise shows you how to integrate WorkManager with coroutines. WorkManager is a compatible, flexible and simple library for deferrable background work. WorkManager is the recommended solution for these use cases on Android.

WorkManager is part of Android Jetpack , and an Architecture Component for background work that needs a combination of opportunistic and guaranteed execution.

Opportunistic execution means that WorkManager will do your background work as soon as it can. Guaranteed execution means that WorkManager will take care of the logic to start your work under a variety of situations, even if you navigate away from your app.

WorkManager provides different implementations of its base ListenableWorker class for different use cases. The simplest Worker class allows us to have some synchronous operation executed by WorkManager. However, having worked so far to convert our codebase to use coroutines and suspend functions, the best way to use WorkManager is through the CoroutineWorker class that allows to define our doWork function as a suspend function. To get started, open up RefreshMainDataWork. It already extends CoroutineWorker , and you need to implement doWork.

Inside the suspend doWork function, call refreshTitle from the repository and return the appropriate result! Note that CoroutineWorker. You can switch to other dispatchers by using withContext. WorkManager makes available a couple of different ways to test your Worker classes, to learn more about the original testing infrastructure, you can read the documentation.

WorkManager v2. Before we get to the test, we tell WorkManager about the factory so we can inject the fake network. The test itself uses the TestListenableWorkerBuilder to create our worker that we can then run calling the startWork method. In this codelab we have covered the basics you'll need to start using coroutines in your app! For testing coroutine based code, we covered both by testing behavior as well as directly calling suspend functions from tests. To learn more about cancellation and exceptions in coroutines, check out this article series: Part 1: Coroutines , Part 2: Cancellation in coroutines , and Part 3: Exceptions in coroutines.

Kotlin coroutines have many features that weren't covered by this codelab. If you're interested in learning more about Kotlin coroutines, read the coroutines guides published by JetBrains. Also check out " Improve app performance with Kotlin coroutines " for more usage patterns of coroutines on Android. Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.

For details, see the Google Developers Site Policies. Before you begin In this codelab you'll learn how to use Kotlin Coroutines in an Android app—the recommended way of managing background threads that can simplify code by reducing the need for callbacks.

Experience with Kotlin syntax, including extension functions and lambdas. A basic understanding of using threads on Android, including the main thread, background threads, and callbacks. What you'll do Call code written with coroutines and obtain results. Use suspend functions to make async code sequential. Use launch and runBlocking to control how code executes. Learn techniques to convert existing APIs to coroutines using suspendCoroutine.

Use coroutines with Architecture Components. Learn best practices for testing coroutines. What you'll need Android Studio 4. Getting set up Download the code Click the following link to download all the code for this codelab: Download Zip How do I set up a device for development? Run the starting sample app First, let's see what the starting sample app looks like. If you downloaded the kotlin-coroutines zip file, unzip the file.

Open the coroutines-codelab project in Android Studio. Select the start application module. Click the Run button, and either choose an emulator or connect your Android device, which must be capable of running Android Lollipop the minimum SDK supported is The Kotlin Coroutines screen should appear: This starter app uses threads to increment the count a short delay after you press the screen.

MainActivity displays the UI, registers click listeners, and can display a Snackbar. TitleRepository fetches results from the network and saves them to the database. Adding coroutines to a project To use coroutines in Kotlin, you must include the coroutines-core library in the build.

Coroutines on Android are available as a core library, and Android specific extensions: kotlinx-coroutines-core — Main interface for using coroutines in Kotlin kotlinx-coroutines-android — Support for the Android Main thread in coroutines The starter app already includes the dependencies in build. Coroutines in Kotlin On Android, it's essential to avoid blocking the main thread.

The callback pattern One pattern for performing long-running tasks without blocking the main thread is callbacks. Take a look at an example of the callback pattern.

Using coroutines to remove callbacks Callbacks are a great pattern, however they have a few drawbacks. Controlling the UI with coroutines In this exercise you will write a coroutine to display a message after a delay. Switch from threads to coroutines In MainViewModel.

However, there are some important differences: viewModelScope. If the user left the Activity before delay returned, this coroutine will automatically be cancelled when onCleared is called upon destruction of the ViewModel. Since viewModelScope has a default dispatcher of Dispatchers. Main , this coroutine will be launched in the main thread.

We'll see later how to use different threads. The function delay is a suspend function. This is shown in Android Studio by the icon in the left gutter. Even though this coroutine runs on the main thread, delay won't block the thread for one second.

Instead, the dispatcher will schedule the coroutine to resume in one second at the next statement.