When you want to make a call to one of the APIs in an SDK that's powered by Google Play services, such as Google Sign-in or ML Kit, you need to first create an instance of an API client object. These objects automatically manage the connection to Google Play services. When a connection is available, each API client object executes requests in order. Otherwise, the client object queues the requests. Unless documentation indicates otherwise, client objects are cheap to construct; it's fine to make new API clients every time you want to invoke API methods.
This guide shows how you can make API calls to any of the SDKs that are powered by Google Play services, including how to access the services that don't require authorization and those that require authorization.
Get started
To get started, add the necessary tools and dependencies in your app project, as described in the guide on how to set up Google Play services.
Access when authorization isn't required
To access a service that doesn't require API authorization, get an instance of
the service's client object, passing it either the current
Context or
the current
Activity.
Before any API calls are executed, users are prompted to upgrade Google Play
services if necessary.
For example, to get the device's last known location using the Fused Location Provider for Android, add the logic that's shown in the following code snippet:
Kotlin
// Code required for requesting location permissions omitted for brevity. val client = LocationServices.getFusedLocationProviderClient(this) // Get the last known location. In some rare situations, this can be null. client.lastLocation.addOnSuccessListener { location : Location? -> location?.let { // Logic to handle location object. } }
Java
// Code required for requesting location permissions omitted for brevity. FusedLocationProviderClient client = LocationServices.getFusedLocationProviderClient(this); // Get the last known location. In some rare situations, this can be null. client.getLastLocation() .addOnSuccessListener(this, location -> { if (location != null) { // Logic to handle location object. } });
Access when authorization is required
To access a service that requires user authorization, complete the following steps:
- Sign the user in.
- Request permission to access the scopes that the service requires.
- Get an instance of the service's client object, passing it the user's
GoogleSignInAccountobject in addition to aContextorActivityobject.
The following example implements reading a user's daily steps using the Google Fit API. To view a similar implementation in the context of a full project, view the main activity of the BasicHistoryApiKotlin app on GitHub.
Kotlin
class FitFragment : Fragment() {
private val fitnessOptions: FitnessOptions by lazy {
FitnessOptions.builder()
.addDataType(DataType.TYPE_STEP_COUNT_CUMULATIVE)
.addDataType(DataType.TYPE_STEP_COUNT_DELTA)
.build()
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
fitSignIn()
}
/*
* Checks whether the user is signed in. If so, executes the specified
* function. If the user is not signed in, initiates the sign-in flow,
* specifying the function to execute after the user signs in.
*/
private fun fitSignIn() {
if (oAuthPermissionsApproved()) {
readDailySteps()
} else {
GoogleSignIn.requestPermissions(
this,
SIGN_IN_REQUEST_CODE,
getGoogleAccount(),
fitnessOptions
)
}
}
private fun oAuthPermissionsApproved() =
GoogleSignIn.hasPermissions(getGoogleAccount(), fitnessOptions)
/*
* Gets a Google account for use in creating the fitness client. This is
* achieved by either using the last signed-in account, or if necessary,
* prompting the user to sign in. It's better to use the
* getAccountForExtension() method instead of the getLastSignedInAccount()
* method because the latter can return null if there has been no sign in
* before.
*/
private fun getGoogleAccount(): GoogleSignInAccount =
GoogleSignIn.getAccountForExtension(requireContext(), fitnessOptions)
/*
* Handles the callback from the OAuth sign in flow, executing the function
* after sign-in is complete.
*/
override fun onActivityResult(
requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
when (resultCode) {
RESULT_OK -> {
readDailySteps()
}
else -> {
// Handle error.
}
}
}
/*
* Reads the current daily step total.
*/
private fun readDailySteps() {
Fitness.getHistoryClient(requireContext(), getGoogleAccount())
.readDailyTotal(DataType.TYPE_STEP_COUNT_DELTA)
.addOnSuccessListener { dataSet ->
val total = when {
dataSet.isEmpty -> 0
else -> dataSet.dataPoints.first()
.getValue(Field.FIELD_STEPS).asInt()
}
Log.i(TAG, "Total steps: $total")
}
.addOnFailureListener { e ->
Log.w(TAG, "There was a problem getting the step count.", e)
}
}
companion object {
const val SIGN_IN_REQUEST_CODE = 1001
}
}
Java
public class FitFragment extends Fragment {
private final FitnessOptions fitnessOptions = FitnessOptions.builder()
.addDataType(DataType.TYPE_STEP_COUNT_CUMULATIVE)
.addDataType(DataType.TYPE_STEP_COUNT_DELTA)
.build();
@Override
public void onViewCreated(
@NotNull View view, @Nullable Bundle savedInstanceState) {
fitSignIn();
}
/*
* Checks whether the user is signed in. If so, executes the specified
* function. If the user is not signed in, initiates the sign-in flow,
* specifying the function to execute after the user signs in.
*/
private void fitSignIn() {
if (oAuthPermissionsApproved()) {
readDailySteps();
} else {
GoogleSignIn.requestPermissions(this, SIGN_IN_REQUEST_CODE,
getGoogleAccount(), fitnessOptions);
}
}
private boolean oAuthPermissionsApproved() {
return GoogleSignIn.hasPermissions(getGoogleAccount(), fitnessOptions);
}
/*
* Gets a Google account for use in creating the fitness client. This is
* achieved by either using the last signed-in account, or if necessary,
* prompting the user to sign in. It's better to use the
* getAccountForExtension() method instead of the getLastSignedInAccount()
* method because the latter can return null if there has been no sign in
* before.
*/
private GoogleSignInAccount getGoogleAccount() {
return GoogleSignIn.getAccountForExtension(
requireContext(), fitnessOptions);
}
/*
* Handles the callback from the OAuth sign in flow, executing the function
* after sign-in is complete.
*/
@Override
public void onActivityResult(
int requestCode, int resultCode, @Nullable Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (resultCode == RESULT_OK) {
readDailySteps();
} else {
// Handle error.
}
}
/*
* Reads the current daily step total.
*/
private void readDailySteps() {
AtomicInteger total = new AtomicInteger();
Fitness.getHistoryClient(requireContext(), getGoogleAccount())
.readDailyTotal(DataType.TYPE_STEP_COUNT_DELTA)
.addOnSuccessListener(dataSet -> {
if (!dataSet.isEmpty())
total.set(Integer.parseInt(dataSet.getDataPoints()
.get(0).getValue(FIELD_STEPS).toString()));
Log.i(TAG, "Total steps: $total");
})
.addOnFailureListener(e -> {
Log.w(TAG, "There was a problem getting the step count.", e);
});
}
private static final int SIGN_IN_REQUEST_CODE = 1001;
}
Check for API availability
Before you enable a feature in your app that depends on a Google Play services
API, include a check for the availability of the API on the device. To do so,
call checkApiAvailability().
The following code snippet demonstrates how to check for the availability of the fused location provider.
Kotlin
fun getLastLocationIfApiAvailable(context: Context?): Task<Location>? {
val client = getFusedLocationProviderClient(context)
return GoogleApiAvailability.getInstance()
.checkApiAvailability(client)
.onSuccessTask { _ -> client.lastLocation }
.addOnFailureListener { _ -> Log.d(TAG, "Location unavailable.")}
}
Java
public Task<Location> getLastLocationIfApiAvailable(Context context) {
FusedLocationProviderClient client =
getFusedLocationProviderClient(context);
return GoogleApiAvailability.getInstance()
.checkApiAvailability(client)
.onSuccessTask(unused -> client.getLastLocation())
.addOnFailureListener(e -> Log.d(TAG, "Location unavailable."));
}