Android Development Patterns: Best Practices for Professional Developers (2016)

---

Notifications, actions, and data can be passed back and forth between a Wear device and an Android device. Much of this is handled by Google Play Services, and also requires the installation of the Android Wear application on the Android device. Let’s look at how information can be displayed and how data is transferred between devices.

Notifications

By default, notifications are automatically bridged to Wear devices. For many, this is a major reason to use a Wear device because it allows users to receive notifications quickly that they may otherwise miss or be interrupted by when using their phone. However, something that makes notifications different for Wear devices is that they are able to have custom actions attached.

A standard notification needs to be built using an instance of NotificationCompat.Builder. The following snippet shows a notification being built and sent with an Intent through the NotificationManager:

int notificationId = 007;
Intent viewIntent = new Intent(this, ViewEventActivity.class);
viewIntent.putExtra(EXTRA_EVENT_ID, eventId);
PendingIntent viewPendingIntent =
PendingIntent.getActivity(this, 0, viewIntent, 0);

// create notification using support library
NotificationCompat.Builder notificationBuilder =
new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.ic_event)
.setContentTitle(eventTitle)
.setContentText(eventLocation)
.setContentIntent(viewPendingIntent);

// set up instance of NotificationManager service
NotificationManagerCompat notificationManager =
NotificationManagerCompat.from(this);

// Use notify() to build the notification and send
notificationManager.notify(notificationId, notificationBuilder.build());

When this notification appears on the Wear device, the specified PendingIntent is triggered by the user swiping the notification to the left and then tapping the Open button. This will then open the PendingIntent used in the setContentIntent() that was added when the notification was built. However, this does not open the notification on the Wear device; instead, it opens it on the handheld device.

Just like with standard device notifications, you can specify another action by using the addAction() method to the NotificationBuilder. The addAction() method allows you to set an icon (drawable), a description (String), and an Intent to launch when tapped. By adding to the previous snippet, the notificationBuilder includes the following:

// use addAction() to add
NotificationCompat.Builder notificationBuilder =
new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.ic_event)
.setContentTitle(eventTitle)
.setContentText(eventLocation)
.setContentIntent(viewPendingIntent);
.addAction(R.drawable.ic_menu_share,
getString(R.string.share), sharePendingIntent);

If you have an action that you only want visible on a Wear device, you need to create an Intent and an action to use, and then use the extend() method and pass WearableExtender with the action attached to it via the addAction() method. The following snippet demonstrates this in action:

// create the intent used for the reply action
Intent actionIntent = new Intent(this, ActionActivity.class);
PendingIntent actionPendingIntent =
PendingIntent.getActivity(this, 0, actionIntent,
PendingIntent.FLAG_UPDATE_CURRENT);

// create the action that will trigger on tap
NotificationCompat.Action action =
new NotificationCompat.Action.Builder(R.drawable.ic_action,
getString(R.string.label), actionPendingIntent)
.build();

// create the notification, attach the action, and build
Notification notification =
new NotificationCompat.Builder(mContext)
.setSmallIcon(R.drawable.ic_message)
.setContentTitle(getString(R.string.title))
.setContentText(getString(R.string.content))
.extend(new WearableExtender().addAction(action))
.build();

// remember to send notifications via NotificationManagerCompat

This snippet of code completes the build of the notification object, so you do not have to do this when you call the notify() method to display the notification. With this snippet, you have created an action that only appears on a Wear device and not on the phone or other device to which it is connected.

Sending Data

To optimize the process of sending information between devices, the Wearable Data Layer API has several components that are used specifically for Wear devices. The following is a list of objects and services that are part of the API:

DataItem: Object that stores data to be synced between handheld and wearable devices.

Asset: Object that stores binary blob data; assets will be automatically cached to improve Bluetooth performance.

DataListener: Used for determining when data layer events are in the foreground; note that it will only work when your app is in the foreground.

WearableListenerService: When not working exclusively in the foreground, WearableListenerService should be extended, allowing the system to control the lifecycle and data binding.

ChannelApi: This API is useful for transferring files that are large, such as movies, music, and other media files. Use of the ChannelApi allows you to transfer files without creating a container file first and then synchronizing the data.

MessageApi: Small payload messages use the MessageApi. These are messages such as media player commands and one-way directives.

Like with other Google Play Services, you need to create a client to access the Wearable Data Layer. The following snippet demonstrates the minimum code needed to create and connect a client:

GoogleApiClient myGoogleApiClient = new GoogleApiClient.Builder(this)
.addConnectionCallbacks(new ConnectionCallbacks() {
@Override
public void onConnected(Bundle connectionHint) {
Log.d(TAG, "onConnected: " + connectionHint);
// Data Layer ready for use
}
@Override
public void onConnectionSuspended(int cause) {
// log the cause of connection pause
Log.d(TAG, "onConnectionSuspended: " + cause);
}
}).addOnConnectionFailedListener(new OnConnectionFailedListener() {
@Override
public void onConnectionFailed(ConnectionResult result) {
// log reason for connection failure
Log.d(TAG, "onConnectionFailed: " + result);
}
}).addApi(Wearable.API).build();

The process for building the client uses the builder pattern to create the client and includes the onConnected(), onConnectionSuspended(), and onConnectionFailed() methods. Depending on how you want your application to work and what messaging information you are planning to pass back and forth, you need to insert your code into the onConnected() method where the comment Data Layer ready for use is.

When sending messages with the MessageApi, you can choose a specific node or available connections between the Wear and connected device, or you can broadcast to all of them. Specifying the node and capabilities creates a more streamlined service, but will require extra implementation to handle the hand-off between different nodes (such as Bluetooth and Wi-Fi switching on and off).

The following snippet of code shows you how to find all available nodes and return them in a HashSet of Strings that can then be used for sending a message:

private Collection<String> getNodes() {
HashSet<String> results = new HashSet<String>();
NodeApi.GetConnectedNodesResult nodes =
Wearable.NodeApi.getConnectedNodes(myGoogleApiClient).await();
for (Node node : nodes.getNodes()) {
results.add(node.getId());
}
return results;
}

For a full example of sending, receiving, and working with Android Wear, see the official sample code available at https://github.com/googlesamples/android-FindMyPhone/.

Summary

In this chapter, you learned about Android Wear and when Wear devices were introduced. You were also introduced to the concepts Google has set forward to create apps that match with the purpose of using a Wear device. You learned that similarly to Android devices, Wear devices come in different shapes and sizes, including watch face shapes. You learned how to provide different layout files to match the different shapes, as well as how to leverage the BoxInsetLayout to make your layout scale to be displayed on both shapes of watch faces.

You also learned how to create an emulator for Android Wear by using the AVD Manager as well as how to connect to the emulator and enable debugging to work with data from your actual Android device. You were then shown how to enable Bluetooth debugging through the Developer Options on the Wear device.

You also learned about extending notifications to Wear devices and how to customize the messages to only appear on the Wear device. You then were given a brief overview of the APIs and objects that can be used to synchronize and send data between the connected and Wear devices.