This sample shows how to use scene transitions from one Activity to another in Lollipop. Uses a combination of changeImageTransform and changeBounds to transition a grid of images to an Activity with a large image and detail text.

This sample demonstrates how to request and display an AdMob rewarded ad in an Android application. It creates an app with a single activity displaying a countdown timer. When the timer reaches zero, a video ad plays. The user can watch in full to receive their reward, or stop the video and forfeit it.

Immersive Mode, added in Android 4.4, improves the "hide full screen" and "hide nav bar" modes by letting users swipe the bars in and out. This sample lets the user experiment with immersive mode by seeing how it interacts with some of the other UI flags related to full-screen apps.

A basic sample showing how to support ambient mode for native Wear apps.

This sample demonstrates how to set restrictions to other apps as a profile owner. Use the AppRestrictionSchema sample to set restrictions.

A basic app showing how to allow a device administrator to restrict user activities using the Android Device Administration API. The app exports a custom policy that enables or disables a UI control. Device Administration applications are able to enforce a specific value for this policy, as directed by enterprise administrators.

A sample that demonstrates the use of the App Restriction feature on devices with multiuser support

A basic app showing how to use App usage statistics API to let users collect statistics related to usage of the applications.

This sample showcases the following Architecture Components:

This sample showcases the following Architecture Components:

The sample demos how to use OpenSL ES to create a player and recorder in Android Fast Audio Path, and connect them to loopback audio. On most android devices, there is a optimized audio path that is tuned up for low latency purpose. The sample creates player/recorder to work in this highly optimized audio path(sometimes called native audio path, low latency path, or fast audio path). The application is validated against the following configurations: * Android L AndroidOne * Android M Nexus 5, Nexus 9 This sample uses the new Android Studio with CMake support, and shows how to use shared stl lib with android studio version 2.2.0, see CMakeLists.txt for details

If you are new to unit testing on Android, try this sample first. This project uses the Gradle build system and the Android gradle plugin support for unit testing. You can either benefit from IDEs integration such as Android studio or run the tests on the command line. Unit tests run on a local JVM on your development machine. The Android Gradle plugin will compile your app's source code and execute it using gradle test task. Tests are executed against a modified version of android.jar where all final modifiers have been stripped off. This lets you use popular mocking libraries, like Mockito. For more information see http://tools.android.com/tech-docs/unit-testing-support

If you are new to unit testing on Android, try this sample first. This project uses the Gradle build system and the Android gradle plugin support for unit testing. You can either benefit from IDEs integration such as Android studio or run the tests on the command line. Unit tests run on a local JVM on your development machine. The Android Gradle plugin will compile your app's source code and execute it using gradle test task. Tests are executed against a modified version of android.jar where all final modifiers have been stripped off. This lets you use popular mocking libraries, like Mockito. For more information see http://tools.android.com/tech-docs/unit-testing-support

This sample detects gestures on a view and logs them. In order to try this sample out, try dragging or tapping the text.

Sample demonstrating the use of immersive mode to hide the system and navigation bars for full screen applications.

This sample demonstrates basic functionalities of Managed Profile API introduced in Android 5.0 Lollipop. You can set up this app as a profile owner, and use this app to enable/disable apps in the newly created managed profile. You can also set restrictions to some apps, enable/disable Intent forwarding between profiles, and wipe out all the data associated with the profile.

This sample shows how to use the MediaCoder to decode a video, use a TimeAnimator to sync the rendering commands with the system display frame rendering and finally render it to a TextureView.

This sample demonstrates the use of the MediaRouter API to display content on a secondary display. Use the "Media Route Action Item" in the ActionBar to select an output device. If your device supports Miracast wireless displays, you may need to enable "Wireless Display" functionality in the system settings. Secondary screen simulation can also be enabled from the "Developer Options". Once connected, use the "Change Color" button to change the background color of the secondary screen.

Sample demonstrates the use of MotionEvent properties to keep track of individual touches across multiple touch events.

This sample demonstrates using RenderScript to perform basic image manipulation. Specifically, it allows users to dynamically adjust the saturation for an image using a slider. A custom RenderScript kernel performs the saturation adjustment, running the computation on the device's GPU or other compute hardware as deemed appropriate by the system.

A basic app showing how to use the Transition framework introduced in KitKat. The app shows radioboxes to select between different Scenes, and uses various ways to transition between them.

Sample demonstrating how to set up SensorEventListeners for step detectors and step counters.

Bitmap Plasma is an Android sample that uses JNI to render a plasma effect in an Android Bitmap from C code. This sample uses the new Android Studio CMake plugin with C++ support.

This sample demonstrates the use of Android Bluetooth APIs for audio from an Android Things app.

This application demonstrates accessing the BluetoothGattServer Android API from within an Android Things application. The sample application advertises the Time Profile.

This application demonstrates accessing the BluetoothGattServer Android API from within an Android Things application. The sample application advertises the Time Profile.

This sample shows how to implement two-way text chat over Bluetooth between two Android devices, using all the fundamental Bluetooth API capabilities.

This Android Things sample demonstrates how to use a button input UserDriver to listen to GPIO pin changes, generate and listen for key events and change the state of an LED accordingly. Follow the Peripheral I/O Codelab for step-by-step instructions on how to build a similar sample.

This Android Things sample demonstrates how to use a button input UserDriver to listen to GPIO pin changes, generate and listen for key events and change the state of an LED accordingly.

This sample demonstrates using the Camera2 API to capture a JPEG, DEPTH or RAW frame. Check the source code to see a simple example of how to display the camera preview and capture a still image using the default configuration with the selected pixel format.

This sample captures video record via the Camera2 API including displaying a camera preview and capturing a high-speed (slow motion) video using repeating capture requests.

This sample demonstrates how to use CardView introduced in the support library in Android 5.0.

A basic app showing how to clip on a View using ViewOutlineProvider interface, by which a View builds its outline, used for shadowing and clipping.

The Android Things Doorbell sample demonstrates how to create a “smart” doorbell. The sample captures a button press from a user, obtains an image via a camera peripheral, processes the image data using Google’s Cloud Vision API, and uploads the image, Cloud Vision annotations and metadata to a Firebase database where it can be viewed by a companion app.

This sample shows how to implement a sensor hub on Android Things that collects sensor data from connected sensors and publish as telemetry events to Google Cloud IoT Core.

This sample shows how to implement a custom Transition extending the standard Transition class.

This sample demonstrates how to work with a WearableListenerService, to produce and consume DataEvents and effectively work with the DataLayer.

This sample demonstrates how to use some device owner features. As a device owner, you can configure global settings such as automatic time and timezone. You can mandate a specific launcher by preferred intent handler.

Sample demonstrating how to load large bitmaps efficiently off the main UI thread, caching bitmaps (both in memory and on disk), managing bitmap memory and displaying bitmaps in UI elements such as ViewPager and ListView/GridView.

This sample demonstrates how to request and display an Ad Manager banner ad in an Android application. The app contains a single, "Hello World" activity with a banner at the bottom of its layout.

This sample demonstrates how to request and display an ad from Ad Manager Custom Rendering in an Android application. The app displays an ad at the top of its activity, and offers a few checkboxes and a button you can use to request different native ad formats.

This project illustrates how to integrate into your app full-screen video ads that users can watch in exchange for in-app rewards.

This sample demonstrates how to request and display an Ad Manager interstitial ad in an Android application. The code illustrates how to instantiate a PublisherInterstitialAd object, preload an interstitial, and then display it. The app's UI contains a single activity with a countdown timer. When the timer reaches zero, the user can tap a "retry" button to display an interstitial and begin the countdown over again.

Sample that shows applying tinting and color filters to Drawables both programmatically and as Drawable resources in XML. Tinting is set on a nine-patch drawable through the "tint" and "tintMode" parameters. A color state list is referenced as the tint color, which defines colors for different states of a View (for example disabled/enabled, focused, pressed or selected). Programmatically, tinting is applied to a Drawable through its "setColorFilter" method, with a reference to a color and a PorterDuff blend mode. The color and blend mode can be changed from the UI to see the effect of different options.

This sample demonstrates ways to move a view in the z-axis using setTranslationZ(). This method was introduced in API Level 21 ('Lollipop').

This sample demonstrates a drag and drop action on different shapes. Elevation and z-translation are used to render the shadows and the views are clipped using different Outlines.

Endless Tunnel is a sample game that shows how to: - use the Android Studio C++ support - implement a game using Android native glue - implement joystick support, including robust DPAD navigation for non-touch screens It is NOT the goal of this sample to show the best way to write the game logic, load resources, etc. The game itself was intentionally kept rudimentary in order to keep the focus on the Android Studio C++ integration. For example, this game contains textures and geometry hard-coded in code, which works for small demo games like this one, but doesn't scale well to real games. This sample uses the new Android Studio CMake plugin with C++ support.

A sample that demonstrates how to use registered fingerprints to authenticate a user in your app

This is a sample app that uses Android Architecture Components with Dagger 2. NOTE It is a relatively more complex and complete example so if you are not familiar with Architecture Components, you are highly recommended to check other examples in this repository first.

This sample shows how to call the Google Assistant Service from Android Things using gRPC. It records a spoken request from the connected microphones, sends it to the Google Assistant API and plays back the Assistant's spoken response on the connected speaker.

Hello GL2 is an Android C++ sample that draws a triangle using GLES 2.0 API. It uses JNI to do the rendering in C++ over a GLSurfaceView created from a regular Android Java Activity. This sample uses the new Android Studio CMake plugin with C++ support.

Hello JNI is an Android sample that uses JNI to call C code from a Android Java Activity. This sample uses the new Hello-CMake codelab

This sample is an Aadd-on to Hello JNI sample to demonstrate calling back to Java from C code - create a java class instance from C code - call java class static and non-static member functions This sample uses the new Android Studio CMake plugin with C++ support.

One of the features introduced in KitKat is "immersive mode". Immersive mode gives the user the ability to show/hide the status bar and navigation bar with a swipe.To try, click the "Toggle immersive mode" button, then try swiping the bar in and out!

This sample app demonstrates how to use the Cookie API. It contains storage and retrieval of values using both, the Android Framework API and the InstantApps Play Services API. Usage This API is available to both, the Instant App as well as the Installed App, and allows to migrate user-generated data from an instant app to an installed app. The flow for this API is as follows:

• Check whether the cookie fits the allowance.
• Store data within the instant app.
• Retrieve data from the installed app.

This API is available for API 26 or higher via PackageManagerCompat.

• framework -> Android 8.0 (API level 26) or higher
• playServices -> Any API level

• Run the instant configuration
• Store some data
• Run the installed configuration
• Retrieve the data stored earlier

This sample app demonstrates how to integrate Google Analytics for Firebase into an instant app.

This sample app demonstrates how to build an installed and an instant app with the same behaviors by using Kotlin. The functionality of the instant app is built in two features, which can be individually installed and launched on a device.

This sample app demonstrates how to use the [Install API](https://developers.google.com/android/reference/com/google/android/gms/instantapps/InstantApps.html#showInstallPrompt(android.app.Activity,%20android.content.Intent,%20int,%20java.lang.String)). The API triggers Intent to install the app on device. The call also accepts Intent, which is triggered after the installation is complete. If an app wants to utilize this API, it needs an installable app on the Google Play Store. Also the applicationIds on both the instant as well as the application module have to match.

This sample app demonstrates building an installable and an instant app with the same behaviors. The functionality of the instant app is split in two features, which can be individually launched on a device.

This sample demonstrates how to create a started or a bound service within Android Instant Apps.

This sample demonstrates the use of animation interpolators and path animations for Material Design.

Demonstration of the JobScheduler API, which provides an interface for scheduling background tasks when certain tasks apply. To understand how this sample works, try these different scenarios:

This sample shows how to use the Media Effects APIs that were introduced in Android 4.0.

This sample uses the camera/camcorder as the A/V source for the MediaRecorder API. A TextureView is used as the camera preview which limits the code to API 14+. This can be easily replaced with a SurfaceView to run on older devices.

Demonstrates how to create a custom media route provider.

Sample demonstrating how to use the MIDI API to receive and process MIDI signals coming from an attached device.

Sample demonstrating how to use the MIDI API to receive and play MIDI messages coming from an attached input device (MIDI keyboard).

This sample demonstrates the use of the multi-window API available in Android N. It shows the use of new Intent flags and AndroidManifest properties to define the multi-window behavior. Switch the sample app into multi-window mode to see how it affects the lifecycle and behavior of the app.

Native Activity is an Android sample that initializes a GLES 2.0 context and reads accelerometer data from C code using Native Activity. This sample uses the new Android Studio CMake plugin with C++ support.

Native Audio is an Android sample that plays and records sounds with the C++ OpenSLES API using JNI. The recorder / players created are not in fast audio path. This sample uses the new Android Studio CMake plugin with C++ support.

This Android Things app runs basic code that exercises the Native PIO APIs from C++. Each sample is an Android module that can be run independently.

Native Plasma is an Android sample that renders a plasma effect in a Bitmap from C code using Native Activity. This sample uses the new Android Studio CMake plugin with C++ support.

This example illustrates a common usage of the DrawerLayout widget in the Android support library.

This sample demonstrates how to connect to the network and fetch raw HTML using HttpsURLConnection. AsyncTask is used to perform the fetch on a background thread.

This sample demonstrates how to use NFC to provision a new device with a device owner. Device owner is a specialized type of device administrator that can control device security and configuration. This sample itself is not a device owner, but it is a programming app that sends NFC message to an unprovisioned peer device and tells it to set up the specified device owner app.

This sample demonstrates how to display PDF document on screen using the PdfRenderer introduced in Android 5.0 Lollipop.

This sample demonstrates how to display PDF document on screen using the PdfRenderer introduced in Android 5.0 Lollipop.

Samples for Android Things peripheral drivers located in the contrib-drivers repository.

This sample demonstrates how to use the PermissionRequest API to securely provide access to restricted system features (such as a camera or microphone) from within a WebView. In this example, a dialog is created to allow users to explicitly approve or reject each request.

Sample demonstrating the use of RecyclerView to layout elements with a LinearLayoutManager and with a GridLayoutManager. It also demonstrates how to handle touch events on elements.

RenderScriptIntrinsic sample that demonstrates how to use RenderScript intrinsics. Creates several RenderScript intrinsics and shows a filtering result with various parameters. Also shows how to extends RedioButton with StateListDrawable.

Sample demonstrating circular reveal effect. It covers creating an ViewAnimationUtils as well as defining the parameters of the circular reveal including starting position and radius.

This is an API sample to showcase how to implement observable queries in Flowable objects.

This is an API sample to showcase how to use Flowable objects in Kotlin.

This sample demonstrates how to expose data stored in the Room persistence library with Android's Content Provider framework.

This sample shows runtime permissions available in Android M and above. It shows how to check and request permissions at runtime, handle backwards compatibility using the support library and how to declare optional permissions for M-devices only.

This basic sample shows runtime permissions available in the Android M and above. It shows how to use the new runtime permissions API to check and request permissions through the support library.

A sample that shows how you can handle remote data that requires permissions both on a wearable device and a mobile device.

This app is designed to show how to build live TV channel apps for Android TV using the TV Input Framework (TIF). The sample is a service that once installed, is recognized and run by the default TV app (e.g. Live Channels app).

San Angeles is an Android port of a demo that uses GLES C/API to render a procedural scene. See the original README for more details about the original GLES port. The sample demos: - ABI APK split

This sample demonstrates how to use Media Projection API to capture device screen in real time and show it on a SurfaceView.

Sensor graph is a C++ Android sample that read current accelerometer values and draw them using OpenGL. It demonstrate usage of the following Native C++ API: - Assets This sample uses the new Android Studio CMake plugin with C++ support.

This Android Things app runs basic code that exercises the Peripheral I/O APIs. Each sample is an Android module that can be run independently.

This Android Things app runs basic code that exercises the Peripheral I/O APIs. Each sample is an Android module that can be run independently.

This utility exposes the GPIO of an Android Things device as switch widgets in a graphical UI. You review the state of inputs, and click the switches to control the state of outputs.

This utility exposes the GPIO of an Android Things device as switch widgets in a graphical UI. You review the state of inputs, and click the switches to control the state of outputs.

Using the OPEN_DOCUMENT intent, a client app can access a list of Document Providers on the device, and choose a file from any of them.

This sample shows how to implement a simple documents provider using the storage access framework available in Android 4.4.

A gardening app illustrating Android development best practices with Android Jetpack. Android Sunflower is currently released as an alpha and is under heavy development. To view the latest changes, please visit the Releases page. Note that some changes (such as database schema modifications) are not backwards compatible during this alpha period and may cause the app to crash. In this case, please uninstall and re-install the app.

A basic sample which shows how to use SwipeRefreshLayout to add the 'swipe-to-refresh' gesture to a View, enabling the ability to trigger a refresh from swiping down on the view. In this sample the View which can be refreshed is a ListView.

A sample which shows how to use SwipeRefreshLayout to add the 'swipe-to-refresh' gesture to a layout with multiple children, enabling the ability to trigger a refresh from swiping down on the visible view. In this sample, SwipeRefreshLayout contains a scrollable GridView, along with a TextView empty view.

Teapots is an collection of Android C++ samples that uses a Teapot rendering to demostrate Android NDK platform features: - classic-teapot: Rendering classic teapot mesh using GLES 2.0 API and NativeActivity. - more-teapots: Rendering multiple instances of Classic Teapot with GLES 3.0 Instance Rendering - Choreographer-30fps: demonstrates multiple frame rate throttoling techniques based on API level using Chreographer API and EGL Android presentation time extension. This sample uses the new Android Studio CMake plugin with C++ support.

This sample demonstrates how to run TensorFlow Lite inference on Android Things. Push a button to capture an image with the camera, and TensorFlow Lite will tell you what it is! Follow the Image Classifier Codelab step-by-step instructions on how to build a similar sample.

A collection of Google's Android testing tools and frameworks, all integrated in a single application project.

This sample illustrates how links can be added to a TextView. This can be done either automatically by setting the "autoLink" property or explicitly.

This application demonstrates how to interact with the device update service on Android Things through the UpdateManager API. By default, the system checks for new OTA updates every few hours and applies them automatically. This example shows you how to configure the update policy to allow an app to take more control over the update process and monitor progress.

This sample shows how to use LoWPAN to connect multiple Android Things devices in the same network and wirelessly transfer data. There are three modules in this sample which demonstrate how to scan for networks, transmit data, and receive data. To learn more about LoWPAN networks, see the LoWPAN API guide.

A fun to play quiz that showcases Material Design on Android

Sample for Google Play Billing AIDL version 3

Sample for Google Play Billing AIDL version 3

This sample demonstrates basic data read and write operations over a UART. The application creates a loopback interface that immediately echoes any data read from the receive (RX) buffer to the transmit (TX) buffer.

This sample demonstrates basic data read and write operations over a UART. The application creates a loopback interface that immediately echoes any data read from the receive (RX) buffer to the transmit (TX) buffer.

This application demonstrates accessing the UsbManager Android API from within an Android Things application. The sample application iterates over all the USB devices discovered by the host and prints their interfaces and endpoints.

This application demonstrates accessing the UsbManager Android API from within an Android Things application. The sample application iterates over all the USB devices discovered by the host and prints their interfaces and endpoints.

The goal of this sample is to show how to implement an audio media app that works across multiple form factors and provide a consistent user experience on Android phones, tablets, Android Auto, Android Wear, Android TV, Google Cast devices, and with the Google Assistant.

Webp is an Android sample including a small app to demo usage of webp in Native Activity
view: - rotate decoding 3 webp images and load them into on-screen buffer. Decoding is in its own thread This sample uses the new Android Studio CMake plugin.

This sample demonstrates the use of the Autofill Framework. It includes implementations of client Activities with views that should be autofilled, and a Service that can provide autofill data to client Activities.

Complication Test Suite is a set of complication providers that provide placeholder data and it can be used to test how different types of complications render on a watch face.

A sample that shows how you can record voice using the microphone on a wearable and play the recorded voice or an mp3 file, if the wearable device has a built-in speaker. This sample doesn't have any companion phone app so you need to install this directly on your watch (using "adb").

Sample demonstrates best practices for checking if connected mobile device has your app installed from an Android Wear 2.+ standalone app and the other way around.

This sample integrates multiple Android Things peripheral drivers together to build a connected Weather Station.

gles3jni is an Android C++ sample that demonstrates how to use OpenGL ES 3.0 from JNI/native code. The OpenGL ES 3.0 rendering path uses a few new features compared to the OpenGL ES 2.0 path: - Instanced rendering and vertex attribute divisor to reduce the number of draw calls and uniform changes. - Vertex array objects to reduce the number of calls required to set up vertex attribute state on each frame. - Explicit assignment of attribute locations, eliminating the need to query assignments. This sample uses the new Android Studio CMake plugin with C++ support.

hello-libs is a sample that shows you how to manage 3rd party C/C++ libraries with Android Studio.