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

---

The listing should be fairly well documented with inline comments; however, you should take special note of the Boolean myResolvingError that is used to keep track of the connection state. It should also be noted that Google Play Services have an ErrorDialogFragmentalready defined so that you do not need to define it again.

It can be easy to forget that a user may decide to “pocket” his device or rotate his screen in the middle of a connection being established. When this happens, the Activity is restarted and any connections may be left in a connecting state. By saving the value of the Boolean inside ofonSaveInstanceState(), you can overcome this particular issue.

The following shows how this can be saved in the onSaveInstanceState() method and restored during the onCreate() method:

private static final String STATE_RESOLVING_ERROR = "resolving_error";

@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putBoolean(STATE_RESOLVING_ERROR, myResolvingError);
}

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// the rest of your onCreate code should be here

myResolvingError = savedInstanceState != null
&& savedInstanceState.getBoolean(STATE_RESOLVING_ERROR, false);
}

Now that you know how to create a connection using the GoogleApiClient, it is time to see some examples of using Google Play Services.

Google Fit

Google Fit is part of Google Play Services. It allows you to use the sensors in a device mixed with the computational heavy powers of Google to track the activity of a user. What makes Google Fit great is that it can use information from all of the devices a person may have and that are deemed the most accurate. This makes the only fitness “wearable” that a user needs the one they usually always have with them.

Note that Google Fit is actually a collection of APIs used to make the magic happen. The following is a list of these APIs and what they are used for with Google Fit:

Sensors API: Gives access to raw sensor data from devices and companion devices

Recording API: Allows data to be stored and recorded with subscriptions

History API: Allows for batching fitness data by inserting, deleting, and reading it

Sessions API: Allows data to be grouped into sessions via metadata

Bluetooth Low Energy API: Allows compatibility with BLE devices, enabling data to be interpreted and read from various BLE devices

Config API: Allows the use of custom data types and configuration settings used with Google Fit

Enable API and Authentication

Some of the Google Play Services provided require more setup than just creating a connection client. Using Google Fit requires that you log in to your Google Developer Console (https://console.developers.google.com) and either create a new project or choose one you have already added. After you have created or chosen a project, you then need to enable the Fitness API. This can be done by finding the APIs & Auth menu and then typing Fitness into the search box. This then shows you the Fitness API page, which gives a brief description of what it does. Clicking the Enable API button near the top of the page will turn the API on for your project.

Now that you have the API enabled, you need to manage the connection to it. This is done by generating an OAuth 2.0 client for your Android app. This is done by clicking the Credentials link that is under the APIs & Auth menu. This will then show you a page that allows you to add your OAuth credentials. Before you click the Add Credentials link, make sure your project is properly filled out for the OAuth Consent screen. Filling out this data can be done by using the tabs at the top of the page. The OAuth Consent screen is shown to users when they initially make a connection to your application with their data. This also gives you an opportunity to add branding, policies, terms of service, and a Google+ page for users to see that allows them to make sure they understand that the data really is going to the app they want and to know what you will be doing with the information.

After you fill out the information you want to provide, you can save your changes and then go back to the Credentials tab and click the Add Credentials button on the page. This activates a drop-down menu asking what type of credentials you would like to add. You should then choose the OAuth 2.0 Client ID option.

Next, you are asked to choose the application type. There are many options listed, but you should click the option for Android because you will be using the API in your Android app. When you click this option, the page shows options that pertain to creating a client for your app. You can give the client ID a name and then pass in a signing-certificate fingerprint. If you do not already have one, you will need to run the following command from your command line or terminal:

keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore
-list -v

Note that the entire sample should be on one line, but was broken into two lines here. You should also correct the path to where your keystore file is. If you need to use the debug.keystore file, it is at the following location:

OS X and Linux: ~/.android/debug.keystore

Windows: %USERPROFILE%\.android\debug.keystore

When the command is run, you are prompted for the password to your keystore (if you are using the debug.keystore file, the password is empty, so you may press the Enter key to continue when prompted for a password). You will then see the output of your certificate. This contains quite a bit of data about the certificate. The piece of information you require is in the Certificate Fingerprints section. You need to copy the values displayed in the SHA1 section.

After typing or pasting your fingerprint into the required field in the Developer Console, you need to add the package name for your application and then decide if you want to allow deep linking from Google+. Deep linking allows clicks and shares of your application to automatically launch or prompt for an install of your application based on the deep-link data.

When you have made your decision, you can then click the Create button to generate your OAuth 2.0 client. After a few moments, you should receive your OAuth 2.0 client ID.

App Configuration and Connection

Google Fit is part of Google Play Services. In the first section of the chapter you were shown that you need to add a dependency to your application’s build.gradle file. As a reminder, you need to add the following to the dependencies section of the app build.gradlefile:

dependencies {
// other dependencies may be listed here
compile 'com.google.android.gms:play-services:7.8.0'
}

You are now ready to create the GoogleApiClient and add the Fitness API as well as specify the scopes you need to access. A list maintained by Google can be found at https://developers.google.com/fit/android/authorization (note that the field names start with “FITNESS”). Thefollowing demonstrates an example of building a client and adding two scopes for access to user data:

myClient = new GoogleApiClient.Builder(this)
.addApi(Fitness.API)
.addScope(FitnessScopes.SCOPE_ACTIVITY_READ)
.addScope(FitnessScopes.SCOPE_BODY_READ_WRITE)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.build();

Once the client has been made, you can then start making the calls you need inside of the onConnected() method. This may include creating listeners so that you can display live data, display heart rate, and even allow the user to manage their weight.

Nearby Messages API

One of the newer services that is provided by Google Play Services is the Nearby API. The Nearby API allows devices on either the Android or iOS platform to exchange messages. This is done by creating a publish-subscribe service that allows for small amounts of binary data to go between the devices. Transmission is done through either Wi-Fi, Bluetooth, or even by an ultrasonic modem that uses the speaker and microphone to send and parse data.

This means that you can now control the range of messages sent. Messages are no longer limited by physical space and can reach as far as any device with an Internet connection, or as close as within 5 feet (1.5 meters) of each other.

Although offered as a Google service when using the messaging portion of the Nearby API, having a Google Account is not required for the users of your application. However, to provide unique-in-time pairing codes as well as maintain common tokens and API keys to authenticate the application token, as a developer you will need to add this API in the Google Developers Console and generate an SHA1 fingerprint of your certificate.

Enabling Nearby Messages

Open the Google Developer Console (https://console.developers.google.com) and either create a new application or choose the existing application you will be working with. Once the project has been created or selected, click the APIs & Auth menu and then the APIs link.

If you do not see the Nearby Messages API in the list of available APIs, use the search box and type nearby messages. A link to the API then appears. By clicking the API, you can use the Enable API button to allow your application access to the API.

Once the API has been enabled, you then need to get the SHA1 fingerprint of your keystore certificate. This can be done by using the keytool command in your command line or terminal. For precise instructions, refer to the section “Enable API and Authentication,” earlier in the chapter.

After obtaining your SHA1 fingerprint, click the Credentials link that is under the APIs & Auth menu in the Google Developer Console. You should then click the Add Credentials button and choose API Key from the drop-down menu.

Of the options displayed, you should choose Android key, name the key, and then click the Add Package Name and Fingerprint button. Enter in your application package name and pass in the SHA1 fingerprint and then click the Create button. This processes and generates your API key.

After generating the API key is complete, you need to make some modifications to your Android application. The first thing you need to do is add a Google Play Services dependency to the application module of your project. Open up the build.gradle file of your app and make sure you add the call to the dependencies section as follows:

dependencies {
// other files
compile 'com.google.android.gms:play-services:7.8.0'
}

Next, you need to add a meta-data element that contains your generated API key to your application manifest XML. This element can be added anywhere inside of the <application> element. It should contain both a name and value property and look similar to the following:

<meta-data
android:name="com.google.android.nearby.messages.API_KEY"
android:value="GENERATED_API_KEY_GOES_HERE" />

The next thing you need to configure is your GoogleApiClient. This only requires that you add the Nearby Messages API. The following shows a sample client built using the builder method:

myGoogleApiClient = new GoogleApiClient.Builder(this)
.addApi(Nearby.MESSAGES_API)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.build();

Sending and Receiving Messages

The Nearby Messages API allows small payloads of data to be passed through a publisher and subscriber model. When a device wants to connect to another device, it sends out a small payload of data as a message using either Bluetooth or ultrasonic transmissions to any devices near it that are listening. This makes the sender the publisher and the listeners the subscribers. When tokens are received, they are then sent to the server for validation. If the validation is successful, a connection is created and the subscription process is complete.