Google Play Services: What They Are, Components and Android Development

What Are Google Play Services?

Google Play Services is a proprietary layer of Google services running on top of the Android operating system. Unlike AOSP (Android Open Source Project), which includes only basic libraries, Play Services provide APIs for integration with the Google ecosystem: maps, geolocation, authentication, push notifications, advertising, and payments. Play Services are installed as a system application with elevated privileges and have access to APIs unavailable to regular applications.

The key difference between Google Play Services and standard Android libraries is the ability to update via Play Store. When Google releases a new version of Maps SDK or Auth API, the user receives the update through Play Services without waiting for an OTA firmware update from the manufacturer. This solves Android fragmentation — according to Statista (2025), about 40% of Android devices run OS versions older than 3 years, but Play Services are updated to the latest version on 85% of devices.

Google Play Services are not part of the Android Open Source Project and are not available on devices without a Google license (for example, Huawei after 2019). For applications running on devices without GMS, Google recommends using the Firebase SDK with cross-platform support or switching to alternative solutions (Huawei Mobile Services).

Architecture and Components of Play Services

The architecture of Google Play Services is built as a set of independent modules (APK packages), each responsible for its own functionality. The main APK (com.google.android.gms) contains the core services and about 50 additional modules that are loaded on demand. The user process is called Google Play Services process and runs in the background with elevated priority.

Each Google Play Services module has its own version and API. The developer only connects the necessary modules via build.gradle, which reduces the application size. For example, Google Sign-In requires com.google.android.gms:play-services-auth, Google Maps requires play-services-maps. Google Play Services automatically resolve dependencies between modules and load missing components.

Interaction via AIDL

Interaction between the application and Play Services occurs through AIDL (Android Interface Definition Language). The application calls SDK methods, the SDK sends IPC requests to the Google Play Services process, which performs the actual work (network requests to Google servers, GPS operations, cryptography). The Play Services process is isolated from the application — if it crashes, the application continues running.

Auto-Update Mechanism and Versioning

Google Play Services update automatically via Google Play Store — the user receives a new version in the background without requiring confirmation. Updates are rolled out in stages (staged rollout): first to 1% of devices, then to 10%, 50%, and 100%. If a critical error is found in the new version, Google can roll back the update to a stable version within 24 hours.

The Google Play Services version is encoded with two numbers: the APK version (e.g., 25.15.32) and the SDK version (e.g., 12.8.0). The developer should check the Play Services version on the device via GoogleApiAvailability — if the user has disabled auto-updates or uses a custom ROM, the version may be outdated. According to Google, the average Play Services version on active devices is no older than 6 months.

// Checking Google Play Services version on device
val availability = GoogleApiAvailability.getInstance()
val resultCode = availability.isGooglePlayServicesAvailable(context)

when (resultCode) {
    ConnectionResult.SUCCESS ->
        Log.d("GMS", "Google Play Services available")

    ConnectionResult.SERVICE_MISSING,
    ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED -> {
        // Show update dialog
        availability.showErrorDialogFragment(
            activity, resultCode, REQUEST_CODE
        )
    }
}

Version issues: if Google Play Services are disabled (the user manually disabled them in settings), all Google APIs stop working. The application must check Play Services availability before each Google API call and show a clear message to the user with a button to go to settings or download Play Services. Google provides an error dialog via showErrorDialogFragment, which automatically leads to Play Store.

Key Modules and Their Purpose

Google Play Services Auth is an authentication module providing Google Sign-In, Credential Manager, and Smart Lock for passwords. Since 2024, Google recommends Credential Manager as a unified API for all authentication types. Google Play Services Maps provides Google Maps rendering, geocoding, Places API, and routing. Location provides Fused Location Provider, combining GPS, Wi-Fi, and cellular data for precise location with minimal power consumption.

Play Integrity API: SafetyNet Replacement

The Google Play Services Wallet module supports Google Pay for in-app and web payments, as well as Google Passes (loyalty cards, boarding passes, tickets). SafetyNet (being replaced by Play Integrity API) — device integrity checks: root access, custom ROM, emulator. Play Integrity API (recommended since 2024) provides more accurate verification: device integrity, app integrity (signature), account integrity (Google account).

// Requesting location via FusedLocationProvider
val fusedClient = LocationServices.getFusedLocationProviderClient(context)

val locationRequest = LocationRequest.Builder()
    .setPriority(Priority.PRIORITY_HIGH_ACCURACY)
    .setInterval(10000)
    .setFastestInterval(5000)
    .build()

if (ActivityCompat.checkSelfPermission(
    context, Manifest.permission.ACCESS_FINE_LOCATION
) == PackageManager.PERMISSION_GRANTED) {
    fusedClient.requestLocationUpdates(
        locationRequest,
        locationCallback,
        Looper.getMainLooper()
    )
}

The Google Play Services Awareness module is a combined API that merges data about location, time, weather, user activity, and connected headphones. Awareness API allows the app to react to context: for example, enable silent mode when the user is at work, or show a rain notification before going out. The API is available since Play Services 16.0.0.

Integrating Google Play Services into an Android Project

Integrating Google Play Services into an Android project is done by adding dependencies to the app-level build.gradle. Google recommends using individual module dependencies rather than the generic play-services-all package to reduce APK size. The minimum Play Services SDK version is 21.0.0 (corresponding to Android 14), but most modules support API 19+.

Integration requires setting up the Google Services Gradle Plugin and the google-services.json file, which is downloaded from the Firebase Console. The JSON file contains project identifiers, API keys, and Client ID for OAuth. Without google-services.json, most Play Services modules cannot authenticate with Google servers. If the project does not use Firebase, adding an API key to AndroidManifest.xml is sufficient.

// build.gradle (project level)
buildscript {
    dependencies {
        classpath "com.google.gms:google-services:4.4.2"
    }
}

// build.gradle (app level)
apply plugin: 'com.google.gms.google-services'

dependencies {
    implementation "com.google.android.gms:play-services-auth:21.2.0"
    implementation "com.google.android.gms:play-services-maps:19.0.0"
    implementation "com.google.android.gms:play-services-location:21.3.0"
}

An important nuance: different Google Play Services modules may require different versions of each other. If one module requires play-services-basement version 18.0.0 and another requires 18.1.0, Gradle resolves the conflict in favor of the higher version. It is recommended to use a single version for all modules via a variable: ext.playServicesVersion = '21.2.0'. Google Play Services also depend on the compileSdk version — version 21.0.0 requires compileSdk 34+.

Android Devices Without Google Play Services

Devices without Google Play Services (Huawei, Honor, some Chinese brands) cannot use the APIs provided by GMS. For such devices, Google recommends the Firebase SDK, which includes cross-platform libraries that work without Play Services. Firebase Authentication uses the REST API directly, Firebase Realtime Database uses WebSocket connections, Firebase Cloud Messaging uses its own protocol.

An alternative approach is using Huawei Mobile Services (HMS), which provide similar APIs: Huawei Maps Kit, Location Kit, Push Kit. To support both types of devices, developers implement an abstract layer that detects GMS or HMS availability at startup and connects the appropriate SDK. According to Counterpoint Research (2025), devices without GMS account for about 5% of the global Android market.

// Checking GMS availability on device
fun isGmsAvailable(): Boolean {
    return try {
        GoogleApiAvailability.getInstance()
            .isGooglePlayServicesAvailable(context) ==
            ConnectionResult.SUCCESS
    } catch (e: Exception) {
        false
    }
}

// Abstract layer for GMS/HMS
interface PushService {
    fun getToken(): String
}

class GmsPushService : PushService {
    override fun getToken() =
        FirebaseMessaging.getInstance().token.await()
}

Abstract GMS and HMS Layer

For applications running on devices without GMS, it is critical to test all functions that use Google APIs. Play Services return SERVICE_MISSING error if the service is not found. Graceful degradation is recommended: if Google Sign-In is unavailable, offer email login; if Google Maps is unavailable, show a WebView with Yandex.Maps or OpenStreetMap. Huawei AppGallery publishes about 15% of all Android applications worldwide.

Code Example: Checking and Updating Play Services

A complete example of checking Google Play Services availability and handling all possible states: service available, update required, service disabled, service missing. The code uses GoogleApiAvailability for checking and showErrorDialogFragment to display Google's standard dialog that leads to Play Store.

class GmsCheckActivity : AppCompatActivity() {

    companion object {
        private const val REQ_UPDATE = 1001
    }

    fun checkGooglePlayServices() {
        val api = GoogleApiAvailability.getInstance()
        when (api.isGooglePlayServicesAvailable(this)) {
            ConnectionResult.SUCCESS ->
                initializeApp()
            ConnectionResult.SERVICE_DISABLED ->
                showSettingsDialog()
            ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED ->
                api.showErrorDialogFragment(
                    this, ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED,
                    REQ_UPDATE
                )
        }
    }

    override fun onActivityResult(request: Int,
            result: Int, data: Intent?) {
        super.onActivityResult(request, result, data)
        if (request == REQ_UPDATE && result == RESULT_OK)
            initializeApp()
    }
}

It is recommended to check Google Play Services availability on every app launch, not just the first time. The user may disable Play Services in settings after installing the application, which will break all Google APIs. For critical functions (e.g., Google Pay payments), the check must be mandatory — without Play Services, the application cannot process payments.

Migration to Play Core and Modular Delivery

Play Core is a Google Play Services library for managing application modules, runtime updates, and downloading additional resources. Play Core enables Dynamic Delivery — on-demand delivery of application modules: the user downloads the base application, and additional features (e.g., an admin module or Premium content) are downloaded only when the user opens the corresponding screen for the first time.

Modular delivery via Google Play Services Play Core reduces the initial application install size by 30-50%. This is especially important for markets with slow internet — according to Google Play Console, every 10 MB reduces install conversion by 1%. Play Core SDK requires Android 5.0 (API 21) and Google Play Services 21.0.0+. Important: once a module is downloaded, it cannot be deleted, only updated with a full app update.

// On-demand module loading via Play Core
val manager = SplitInstallManagerFactory.create(context)
val request = SplitInstallRequest
    .Builder()
    .addModule("premium")
    .build()

manager.startInstall(request)
    .addOnSuccessListener {
        Log.d("Split", "Premium module loaded")
    }

Migration to Play Core requires changing the application architecture: functionality is split into on-demand modules in Android Studio, and Gradle builds each module as a separate APK. Google Play Store then assembles an APK Set (Android App Bundle) and delivers only the base APK to the user. Play Core also supports in-app updates — the user can update the app from within without going to Play Store. By 2026, about 70% of applications on Google Play use Android App Bundle and Play Core.