Google Fit — Was es ist, Plattformarchitektur und APIs

Was ist Google Fit?

Google Fit ist eine Gesundheitsverwaltungsplattform, die Google 2014 auf der I/O-Konferenz vorgestellt hat. Die Plattform bietet eine einheitliche API zum Lesen und Schreiben von Aktivitätsdaten und ermöglicht Apps den Informationsaustausch über ein zentrales Repository in der Google Cloud.

Im Gegensatz zu proprietären Lösungen funktioniert Google Fit auf dem Android-Betriebssystem und iOS über die REST API. Nutzer können Fitnessbänder, Smartwatches und Aktivitäts-Tracking-Apps verbinden, und Google Fit fasst alle Daten in einem einzigen Gesundheitsprofil in Google Cloud zusammen.

Laut Google I/O 2024 wird die Plattform in über 5000 Apps weltweit genutzt, und die Zahl der aktiven Nutzer übersteigt 100 Millionen. Die Plattform ist in Wear OS integriert und unterstützt alle gängigen Fitness-Tracker über Drittanbieter-Apps.

Google Fit-Architektur

Die Google Fit-Architektur basiert auf drei Schichten: Client-SDK, Google Fitness Store-Cloud-Speicher und REST API für die Serverintegration. Das Client-SDK ist für Android (Kotlin, Java) und iOS (Swift, Objective-C) verfügbar, und es gibt auch einen Web-Client über JavaScript.

Die Daten sind als Quellen (DataSource) und Datenpunkte (DataPoint) organisiert. Jede Quelle repräsentiert ein Gerät oder eine App, und jeder Datenpunkt repräsentiert eine einzelne Messung mit einem Zeitstempel. Gruppen von Datenpunkten werden zu Sitzungen zusammengefasst — kontinuierliche Aktivitätszeiträume mit Typ und Dauer.

val fitnessClient = Fitness.getClient(activity, GoogleSignIn
    .getAccountForExtension(activity, fitnessOptions))

val stepType = DataType.TYPE_STEP_COUNT_DELTA

val request = DataReadRequest.Builder()
    .read(stepType)
    .setTimeRange(
        startTime, endTime, TimeUnit.MILLISECONDS
    )
    .build()

fitnessClient.readData(request)
    .addOnSuccessListener { response ->
        for (bucket in response.buckets) {
            println(bucket.dataSets)
        }
    }

Wie Google Fit funktioniert

Google Fit verwendet ein Synchronisationsmodell über Google Cloud mit Unterstützung für Online- und Offline-Modi. Die App zeichnet Daten lokal auf, und das Google Fit SDK synchronisiert sie automatisch mit dem Cloud-Speicher, wenn eine Internetverbindung besteht. Konflikte werden nach dem Prinzip der letzten Schreibung gelöst.

Jeder Datentyp hat ein standardisiertes Format: Schritte — TYPE_STEP_COUNT_DELTA, Kalorien — TYPE_CALORIES_EXPENDED, Herzfrequenz — TYPE_HEART_RATE_BPM, Distanz — TYPE_DISTANCE_DELTA. Für benutzerdefinierte Typen können Sie über die Google APIs Console benutzerdefinierte DataTypes mit einem eindeutigen Namespace erstellen.

Die Plattform unterstützt zwei Aufnahmemodi: aktiv — die App ruft explizit HistoryClient.insertData() auf, und passiv — über RecordingClient, der die Datenerfassung im Hintergrund abonniert. Der passive Modus ist praktisch für Fitness-Apps: Der Nutzer startet die App einmal, und Google Fit sammelt automatisch Schritte, Kalorien und Distanz, während die App minimiert ist, ohne ständige CPU-Nutzung.

Laut Google verarbeitet die Plattform täglich über 2 Milliarden Datenpunkte. Die durchschnittliche Synchronisationslatenz beträgt 5–10 Sekunden bei aktiver Verbindung, im Hintergrundmodus erfolgt die Synchronisation alle 30 Minuten, um Akku zu sparen.

Nutzereinwilligung und Sicherheit

Google Fit verwendet OAuth 2.0 zur Autorisierung mit den Zugriffsbereichen fitness.activity.read, fitness.activity.write, fitness.body.read und fitness.body.write. Die App fordert nur die notwendigen Bereiche an, und der Nutzer bestätigt den Zugriff über den Standard-Google-Sign-In-Dialog mit Kontoauswahl.

Der Nutzer kann den Zugriff jederzeit über Google Account Permissions oder die Google Fit App widerrufen. Google verbietet ausdrücklich die Weitergabe von Gesundheitsdaten an Dritte ohne ausdrückliche Zustimmung sowie die Nutzung von Daten zu Werbezwecken gemäß der Restricted Scopes-Richtlinie.

Google Fit APIs

Google Fit bietet drei Haupt-APIs: Fitness API zum Lesen und Schreiben historischer Daten, Sensors API zum Echtzeit-Streaming von Sensordaten und Sessions API zur Verwaltung von Aktivitätssitzungen. Jede API ist sowohl über das Android SDK als auch über REST-Anfragen verfügbar.

Fitness API ist die Haupt-API für die Arbeit mit Daten. Sie unterstützt Batch-Operationen: Schreiben von bis zu 1000 Datenpunkten in einem einzigen Aufruf, Lesen mit Filterung nach Zeitbereich, Datentyp und Quelle. Zur Datenaggregation wird DataSet mit Gruppierung nach ausgewählten Metriken verwendet.

Sensors API ermöglicht das Abonnieren von Echtzeit-Sensordaten — Schritte, Herzfrequenz, Beschleunigung. Die Daten werden über SensorEventListener mit einer vom Sensortyp und den App-Einstellungen bestimmten Frequenz empfangen.

Zusätzlich zu den drei Haupt-APIs bietet Google Fit Recording API zur automatischen Datenerfassung, ohne die App aktiv halten zu müssen. Diese API ist besonders wertvoll für Wear OS: Smartwatches können Herzfrequenz- und Aktivitätsdaten erfassen, und die Telefon-App synchronisiert sich bei Verbindung mit ihnen. Die Recording API nutzt Google Fit Background Services, die für minimalen Stromverbrauch optimiert sind — bis zu 2% Akku pro Tag bei passiver Schritterfassung.

REST API von Google Fit ist am Endpunkt fitness.googleapis.com verfügbar. Die REST API ermöglicht Serveranwendungen, nach OAuth-Autorisierung im Namen des Nutzers Daten zu lesen und zu schreiben. Dies ist nützlich für Web-Analyse-Dashboards, betriebliche Fitnessprogramme und medizinische Systeme, die eine zentrale Speicherung von Gesundheitsdaten der Mitarbeiter oder Patienten benötigen.

val recordingClient = Fitness
    .getRecordingClient(activity, googleSignInAccount)

recordingClient.subscribe(DataType.TYPE_STEP_COUNT_DELTA)
    .addOnSuccessListener {
        println("Abonnement aktiv")
    }

// Abrufen von Verlaufsdaten
val historyClient = Fitness
    .getHistoryClient(activity, googleSignInAccount)

val endTime = Calendar.getInstance().timeInMillis
val startTime = endTime - TimeUnit
    .DAYS.toMillis(7)

historyClient.readDailyTotal(DataType.TYPE_STEP_COUNT_DELTA)
    .addOnSuccessListener { total ->
        println("Schritte heute: $total")
    }

Integration von Google Fit in eine App

Die Google Fit-Integration beginnt mit dem Hinzufügen von Abhängigkeiten für das Google Fit SDK über build.gradle: com.google.android.gms:play-services-fitness. Danach müssen Sie die Google APIs Console konfigurieren — ein Projekt erstellen, die Fitness API aktivieren und OAuth 2.0-Anmeldeinformationen mit den korrekten SHA-1-Fingerabdrücken hinzufügen.

Der Integrationsprozess umfasst: Initialisieren von GoogleSignIn mit den erforderlichen Bereichen, Erstellen eines FitnessClient über Fitness.getClient(), Anfordern der Nutzerautorisierung und Ausführen von Lese- oder Schreiboperationen. Für die Hintergrundaufzeichnung wird RecordingClient verwendet, der automatisch Daten sammelt, auch wenn die App minimiert ist. Google Fit verwaltet automatisch die Datenerfassungshäufigkeit basierend auf dem Akkustand und der Nutzeraktivität.

Laut Google zeigen Apps mit Google Fit-Integration eine um 35% höhere Nutzerbindung. Die wichtigsten App-Kategorien sind Fitness-Tracker, Lauf-, Radfahr-, Yoga- und Gewichtskontroll-Apps.

Es ist wichtig, die Datenschutzanforderungen zu beachten: Google Fit verwendet Restricted Scopes — spezielle Zugriffsbereiche, die eine separate App-Überprüfung durch OAuth Verification erfordern. Der Entwickler muss beschreiben, welche Daten erfasst werden, wie sie verwendet werden und wie lange sie gespeichert werden. Google verlangt außerdem eine Datenschutzerklärung und die Einhaltung der API Services Terms of Service.

Praktisches Aufzeichnungsbeispiel

Zum Aufzeichnen von Daten wird ein DataSource mit Angabe von Typ, Gerät und App erstellt. Dann wird ein DataPoint mit einem Zeitstempel und Werten erstellt. Mehrere DataPoints werden zu einem DataSet zusammengefasst, das an HistoryClient.write() übergeben wird.

val dataSource = DataSource.Builder()
    .setAppPackageName(activity)
    .setDataType(DataType.TYPE_STEP_COUNT_DELTA)
    .setType(DataSource.TYPE_RAW)
    .build()

val stepCount = DataPoint.builder(dataSource)
    .setTimestamp(now, TimeUnit.MILLISECONDS)
    .setField(Field.FIELD_STEPS, 500)
    .build()

val dataSet = DataSet.builder(dataSource)
    .add(stepCount)
    .build()

historyClient.insertData(dataSet)
    .addOnSuccessListener {
        println("Daten gespeichert")
    }