Dostęp do interfejsów API Google

Jeśli chcesz wywołać jeden z interfejsów API w pakiecie SDK obsługującym Usługi Google Play, np. Logowanie przez Google lub ML Kit, musisz najpierw utworzyć instancję obiektu klienta interfejsu API. Obiekty te automatycznie zarządzają połączeniem z Usługami Google Play. Gdy połączenie jest dostępne, każdy obiekt klienta interfejsu API wykonuje żądania po kolei. W przeciwnym razie obiekt klienta umieszcza żądania w kolejce. Jeśli z dokumentacji nie wynika inaczej, obiekty klienta są tanie w konstruowaniu. Możesz tworzyć nowe klienty interfejsu API za każdym razem, gdy chcesz wywoływać metody interfejsu API.

Z tego przewodnika dowiesz się, jak wykonywać wywołania interfejsu API do dowolnych z pakietów SDK obsługiwanych przez Usługi Google Play, w tym jak uzyskiwać dostęp do usług, które nie wymagają autoryzacji, i tych, które wymagają autoryzacji.

Rozpocznij

Na początek dodaj do projektu aplikacji niezbędne narzędzia i zależności zgodnie z opisem w przewodniku konfigurowania usług Google Play.

Dostęp, gdy autoryzacja nie jest wymagana

Aby uzyskać dostęp do usługi, która nie wymaga autoryzacji interfejsu API, pobierz instancję obiektu klienckiego usługi, przekazując ją jako bieżący obiekt Context lub bieżący Activity. Przed wywołaniem interfejsu API użytkownicy są proszeni o aktualizację Usług Google Play, jeśli to konieczne.

Aby np. określić ostatnią znaną lokalizację urządzenia za pomocą dostawcy Fused Location Provider na urządzeniach z Androidem, dodaj operator logiczny widoczny w tym fragmencie kodu:

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.
            }
        });

Dostęp, gdy wymagana jest autoryzacja

Aby uzyskać dostęp do usługi, która wymaga autoryzacji użytkownika, wykonaj te czynności:

1. Zaloguj użytkownika.
2. Poproś o uprawnienia dostępu do zakresów, których wymaga usługa.
3. Pobierz instancję obiektu klienckiego usługi, przekazując go oprócz obiektu Context lub Activity do obiektu GoogleSignInAccount użytkownika.

Poniższy przykład pokazuje, jak za pomocą Google Fit API odczytywać codzienne kroki użytkownika. Aby zobaczyć podobną implementację w kontekście całego projektu, wyświetl główne działanie aplikacji BasicHistoryApiKotlin na GitHubie.

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;
}

Sprawdź dostępność interfejsu API

Zanim włączysz w aplikacji funkcję, która wymaga interfejsu API Usług Google Play, sprawdź, czy ten interfejs API jest dostępny na urządzeniu. Aby to zrobić, wywołaj checkApiAvailability().

Uwaga: to sprawdzenie jest konieczne tylko wtedy, gdy chcesz wyłączyć funkcję w aplikacji, gdy interfejs API jest niedostępny. Można również wywoływać metody interfejsu API bez wcześniejszego przeprowadzenia tego sprawdzenia, ponieważ wywołania interfejsu API kończą się niepowodzeniem, jeśli interfejs API jest niedostępny.

Ten fragment kodu pokazuje, jak sprawdzić dostępność dostawcy uśrednionej lokalizacji.

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."));
}