Android Developers Blog: August 2022

Announcing Cross device SDK Developer Preview for building rich multi-device experiences on Android

26 August 2022

Posted by Alex Rocha - Developer Relations Engineer Manager, Ryan Ausanka-Crues - Eng Manager, Multi-device development, Stella Loh - Product Manager, Multi-device development Today we’re launching our Developer Preview of the new Cross device SDK for Android. First announced during the Google I/O ‘22 Multi-device development session, our Cross device SDK allows developers to build rich multi-device experiences with a simple and intuitive set of APIs. This SDK abstracts away the intricacies involved with working with device discovery, authentication, and connection protocols, allowing you to focus on what matters most—building delightful user experiences and connecting these experiences across a variety of form factors and platforms.
What’s in Developer Preview This initial release contains a set of rich APIs centered around the core functionality of Device discovery, Secure connections, and Multi-device Sessions.

Device discovery: Easily find nearby devices, authorize peer-to-peer communication, and start the target application on receiving devices.

Secure connections: Enable encrypted, low-latency bi-directional data sharing between authorized devices.

Multi-device Sessions: Enable transferring or extending an application’s user experience across multiple devices.

In turn, this will allow you to build compelling cross-device experiences by enabling and simplifying the following use cases:

Discovering and authorizing communication with nearby devices.
Sharing an app’s current state with the same app on another device.
Starting the app on a secondary device without having to keep the app running in background.
Establishing secure connections for devices to communicate with each other.
Enabling task handoff where the user starts a task on one device, and can easily continue on another device.

Starting today with a Developer Preview for Android phones and tablets, the Cross device SDK will be available later for other Android surfaces and non-Android OSs. Under The Hood The Cross device SDK provides a software abstraction layer that handles all aspects of cross-device connectivity, leveraging wireless technologies such as Bluetooth, Wi-Fi, and Ultra-wide band; our SDK does all the heavy-lifting under the hood, offering you a modular,connectivity-agnostic API that supports bi-directional communication between devices and is backward compatible to Android 8. In addition, apps will not have to declare or request Runtime Permissions for any of the underlying connectivity protocols used (such as BLUETOOTH_CONNECT, BLUETOOTH_SCAN, ACCESS_FINE_LOCATION, etc.), and the user can allow apps to connect to only the device(s) they selected.

Getting started with Developer Preview Head over to our developer guide to get started and try out the Developer Preview of the Cross device SDK for Android. Make sure to check out our Rock Paper Scissor sample app (Kotlin and Java) on GitHub for a demonstration on how to work with the various APIs and our Google I/O ‘22 Multi-device development session for a general overview of the SDK.

Feedback We’d love to hear from you during this initial Developer Preview launch to help us shape the SDK and influence future roadmapping, so please share your feedback and let us know your experience with the SDK!

Wear OS Tiles Material Library: Build Tiles, Fast.

24 August 2022

Posted by Anna Bernbaum, Product Manager, Ataul Munim, Developer Relations Engineer

create tiles that embrace the latest Material designTiles Design KitTiles Design Guidelines

animation showing the tiles experience on Wear OS. User swipes left from the watch face to see the first tile, and continues swiping to see others, including a fitness tile with buttons to initiate a workout, a music tile with chips to navigate to playlists, an alarm tile showing an upcoming alarm, among others.

Tiles carousel on Wear OS

common tile components. a round icon with a pencil labelled "button". a full width rectangle with rounded corners and text labelled "chip". similar components, one larger and one smaller, labelled "title chip" and "compact chip" respectively. a circle path filled 75% clockwise labelled "circular progress indicator" and finally text labelled "text with recommended typography pre-set"

val clickable: Clickable = generateClickable()

val button: Button = Button.Builder(this, clickable)
.setIconContent("icon_exercise")

.setContentDescription("Start workout")

.build()

A calendar event tile with vertically stacked text details with an "open" action at the bottom, a weather tile showing a cloud icon, the current temperature and the day's high and low in a single row, a step counter tile with a progress indicator encircling the content and a timer tile with 5 buttons for different durations.

Tile with a PrimaryLayout, showing "Primary label text" at the top and "Action" as the primary chip at the bottom. The content slot is a MultiButtonLayout with 2 round icons , each with the plus sign.

val theme = Colors(

/*primary=*/ 0xFFD0BCFF.toInt(), /*onPrimary=*/ 0xFF381E72.toInt(),

/*surface=*/ 0xFF202124.toInt(), /*onSurface=*/ 0xFFFFFFFF.toInt()

)

val buttonColors = ButtonColors.secondaryButtonColors(theme)

val chipColors = ChipColors.primaryChipColors(theme)

val timeline = Timeline.fromLayoutElement(
PrimaryLayout.Builder(deviceParameters)

.setPrimaryLabelTextContent(

Text.Builder(this, "1 run this week")

.setTypography(Typography.TYPOGRAPHY_CAPTION1)

.setColor(argb(theme.primary))

.build()

)

.setContent(

MultiButtonLayout.Builder()

.addButtonContent(

Button. Builder(this, clickable)

.setIconContent("icon_run")

.setButtonColors(buttonColors)

.setContentDescription("Run")

.build()

)

.addButtonContent(

Button.Builder(this, clickable )

.setIconContent("icon_yoga")

.setButtonColors(buttonColors)

.setContentDescription("Yoga")

.build()

)
.addButtonContent(

Button.Builder(this, clickable)

. setIconContent("icon_cycle")

.setButtonColors(buttonColors)

.setContentDescription("Cycle")

.build()

)

.build()

)

.setPrimaryChipContent(

CompactChip.Builder(this, "More", clickable, deviceParameters)

.setChipColors(chipColors)

.build()

)

.build()

)

What's in the library

This library contains components and layouts that are in-line with Material guidelines and easy to use. The included components are:

Button - clickable, circular-shaped object, with either icon, text or image with three predefined sizes.
Chip - clickable, stadium-shaped object that can contain an icon, primary and secondary labels, and has fixed height and customizable width.
CompactChip & TitleChip - two variations of the standard Chip that have smaller and larger heights, respectively, and can contain one line of text.
CircularProgressIndicator - colored arc around the edge of the screen with the given start and end angles, which can describe a full or partial circle with the full progress arc behind it.
Text - styled text which uses the recommended Wear Material typography styles.

All these components have their own colors object that can be built with the main Colors class to easily apply the same theme over all components. In addition to colors, there is a Typography class to easily get FontStyle objects using the typography name.

In addition to components, there are recommended tile layouts:

PrimaryLayout - a layout which can be customized by adding primary or secondary labels, content in the middle, and a primary chip at the bottom. The main content within this layout could be added as a MultiSlotLayout or MultiButtonLayout object.
EdgeContentLayout - a layout for hosting CircularProgressIndicator around the edge with main content inside and primary or secondary label around it.
MultiButtonLayout - a layout that can contain between 1 - 7 buttons, arranged in line with the Material guidelines depending on their number.
MultiSlotLayout - a row-like style layout with horizontally aligned and spaced slots (for icons or other small content).

All layouts have recommended padding and styles applied that are within Material guidelines.

Tools for tiles

Android Studio Dolphin includes the Direct Surface Launch feature. This lets developers install and launch a tile directly from Android Studio, instead of having to manually add it from the tile selector on the target device. Get started with Direct Surface Launch by creating a new Run Configuration and selecting Wear OS Tile, then choosing the module and TileService class.

Horologist Tiles is also recommended to save time during tile development. This library gives you the ability to preview a tile UI straight from Android Studio, making the write-test loop a lot shorter. Horologist Tiles also includes Kotlin friendly abstractions, like CoroutinesTileService so you can use what you're already familiar with.

Get started with Tiles Material

For a quick start, take a look at the new Tiles codelab, the code sample and the docs.

Please share your feedback on the issue tracker and let us know what you think of Tiles Material!

CameraX 1.2 is now in Beta

24 August 2022

Posted by Donovan McMurray, CameraX Developer Relations Engineer

Android JetpackCameraXversion 1.2 is officially in Beta

ML Kit Integration

Google’s ML Kit provides several on-device vision APIs for detecting faces, barcodes, text, objects, and more. We’re making it easier to integrate these APIs with CameraX. Version 1.2 introduces MlKitAnalyzer, an implementation of ImageAnalysis.Analyzer that handles much of the ML Kit setup for you.

You can use MlKitAnalyzer with both cameraController and cameraProvider workflows. If you use the cameraController.setImageAnalysisAnalyzer() method, then CameraX can also handle the coordinates transformation between the ML Kit output and your PreviewView.

Here’s a code snippet using setImageAnalysisAnalyzer() to set a BarcodeScanner on a cameraController to detect QR codes. CameraX automatically handles the coordinate transformations when you pass COORDINATE_SYSTEM_VIEW_REFERENCED into the MlKitAnalyzer. (Use COORDINATE_SYSTEM_ORIGINAL to prevent CameraX from applying any coordinate transformations.)

val options = BarcodeScannerOptions.Builder()

.setBarcodeFormats(Barcode.FORMAT_QR_CODE)

.build()

val barcodeScanner = BarcodeScanning.getClient(options)

cameraController.setImageAnalysisAnalyzer(

executor,

new MlKitAnalyzer(List.of(barcodeScanner),

COORDINATE_SYSTEM_VIEW_REFERENCED,

executor, result -> {

// The value of result.getResult(barcodeScanner)

// can be used directly for drawing UI overlay.

}

)

Zero-Shutter Lag(CAPTURE_MODE_MAXIMIZE_QUALITY)(CAPTURE_MODE_MINIMIZE_LATENCY)ImageCapture.Builder.setCaptureMode()(CAPTURE_MODE_ZERO_SHOT_LAG)CAPTURE_MODE_MINIMIZE_LATENCYCAPTURE_MODE_MINIMIZE_LATENCY

Just like any other app with a Preview use case, CameraX sends images from the camera to the UI for the user to see.

With Zero-Shutter Lag, CameraX also sends images to a circular buffer which holds multiple recent images.

When the user presses the shutter button, there is inevitably some lag in sending the current camera image to your app. For this reason, Zero-Shutter Lag goes to the circular buffer to fetch an image.

CameraX finds the photo in the circular buffer closest to the actual time when the user pressed the shutter button, and returns that photo to your app.

CAPTURE_MODE_ZERO_SHOT_LAG VideoCaptureextensionsNext stepsfull release notes for CameraX 1.2create a CameraX issueCameraX Discussion Group

Announcing Cross device SDK Developer Preview for building rich multi-device experiences on Android

Wear OS Tiles Material Library: Build Tiles, Fast.

CameraX 1.2 is now in Beta

Labels

Archive

Feed

Newsletter