Google Fit — vad är det, plattformsarkitektur och API

Vad är Google Fit?

Google Fit är en hälsohanteringsplattform som lanserades av Google 2014 vid I/O-konferensen. Plattformen tillhandahåller ett enhetligt API för att läsa och skriva data om fysisk aktivitet, vilket gör att appar kan utbyta information via ett centralt lager i Googles moln.

Till skillnad från proprietära lösningar fungerar Google Fit på Android-operativsystemet och iOS via REST API. Användaren kan ansluta fitnessarmband, smartklockor och aktivitetsspårningsappar, och Google Fit sammanställer all data i en enhetlig hälsoprofil i Google Cloud.

Enligt Google I/O 2024 används plattformen i över 5000 appar världen över och antalet aktiva användare överstiger 100 miljoner. Plattformen är integrerad med Wear OS och stöder alla populära fitnessspårare via tredjepartsappar.

Google Fit-arkitektur

Google Fit-arkitekturen är uppbyggd på tre nivåer: klient-SDK, molnlagring Google Fitness Store och REST API för serverintegration. Klient-SDK finns tillgängligt för Android (Kotlin, Java) och iOS (Swift, Objective-C), samt en webbklient via JavaScript.

Data är organiserad i form av källor (DataSource) och datapunkter (DataPoint). Varje källa representerar en enhet eller app, och varje datapunkt representerar en mätning med en tidsstämpel. Grupper av datapunkter slås samman till sessioner — sammanhängande aktivitetsperioder med typ och varaktighet.

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

Hur Google Fit fungerar

Google Fit använder en synkroniseringsmodell via Google Cloud med stöd för både online- och offlineläge. Appen skriver data lokalt och Google Fit SDK synkroniserar dem automatiskt med molnlagringen när det finns en internetanslutning. Konflikter löses enligt principen om senaste skrivning.

Varje datatyp har ett standardiserat format: steg — TYPE_STEP_COUNT_DELTA, kalorier — TYPE_CALORIES_EXPENDED, puls — TYPE_HEART_RATE_BPM, distans — TYPE_DISTANCE_DELTA. För anpassade typer kan egna DataType skapas via Google APIs-konsolen med ett unikt namnrymd.

Plattformen stöder två skrivlägen: aktivt — appen anropar explicit HistoryClient.insertData(), och passivt — via RecordingClient, som prenumererar på datainsamling i bakgrunden. Det passiva läget är bekvämt för fitnessappar: användaren startar appen en gång och Google Fit samlar automatiskt in steg, kalorier och distans när appen är minimerad utan kontinuerlig processoranvändning.

Enligt Google bearbetar plattformen över 2 miljarder datapunkter dagligen. Genomsnittlig synkroniseringsfördröjning är 5–10 sekunder vid aktiv anslutning och i bakgrundsläge sker synkronisering var 30:e minut för att spara batteri.

Användarsamtycke och säkerhet

Google Fit använder OAuth 2.0 för auktorisering med åtkomstområdena fitness.activity.read, fitness.activity.write, fitness.body.read och fitness.body.write. Appen begär endast nödvändiga områden och användaren bekräftar åtkomsten via standarddialogrutan Google Sign-In med kontoval.

Användaren kan när som helst återkalla åtkomst via Google Account Permissions eller Google Fit-appen. Google förbjuder strängt överföring av hälsodata till tredje part utan uttryckligt samtycke, liksom användning av data för reklamändamål i enlighet med Restricted Scopes-policyn.

Google Fit API

Google Fit tillhandahåller tre huvudsakliga API:er: Fitness API för att läsa och skriva historiska data, Sensors API för strömmande realtidsdata från sensorer och Sessions API för hantering av aktivitetspass. Varje API är tillgängligt både via Android SDK och via REST-förfrågningar.

Fitness API — det huvudsakliga API:et för att arbeta med data. Det stöder batchoperationer: skrivning av upp till 1000 datapunkter i ett anrop, läsning med filtrering efter tidsintervall, datatyp och källa. För aggregering används DataSet med gruppering efter valda mätvärden.

Sensors API gör det möjligt att prenumerera på sensordata i realtid — steg, puls, acceleration. Data levereras via SensorEventListener med en frekvens som bestäms av sensortypen och appens inställningar.

Förutom de tre huvudsakliga API:erna erbjuder Google Fit Recording API för automatisk datainsamling utan att behöva hålla appen aktiv. Detta API är särskilt värdefullt för Wear OS: smartklockor kan samla in data om puls och aktivitet, och appen på telefonen synkroniseras med dem vid anslutning. Recording API använder Google Fit Background Services som är optimerade för minimal energiförbrukning — upp till 2% batteri per dag vid passiv steginsamling.

REST API för Google Fit är tillgängligt via slutpunkten fitness.googleapis.com. REST API gör det möjligt för serverappar att läsa och skriva data på uppdrag av användaren efter OAuth-auktorisering. Detta är användbart för webbanalyspaneler, företagsfitnessprogram och medicinska system där centraliserad lagring av hälso data för anställda eller patienter krävs.

val recordingClient = Fitness
    .getRecordingClient(activity, googleSignInAccount)

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

// Hämta historikdata
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("Steg idag: $total")
    }

Integrera Google Fit i en app

Integrationen av Google Fit börjar med att lägga till beroenden för Google Fit SDK via build.gradle: com.google.android.gms:play-services-fitness. Därefter måste Google APIs-konsolen konfigureras — skapa ett projekt, aktivera Fitness API och lägga till OAuth 2.0-autentiseringsuppgifter med korrekta SHA-1-fingeravtryck.

Integrationsprocessen omfattar: initiering av GoogleSignIn med nödvändiga områden, skapande av FitnessClient via Fitness.getClient(), begäran om auktorisering från användaren och utförande av läs- eller skrivoperationer för data. För bakgrundsskrivning används RecordingClient, som automatiskt samlar in data även när appen är minimerad. Google Fit hanterar automatiskt frekvensen för datainsamling beroende på batterinivå och användaraktivitet.

Enligt Google visar appar med Google Fit-integration 35% högre användarretention. De viktigaste appkategorierna — fitnessspårare, löpappar, cykling, yoga och viktkontrollappar.

Det är viktigt att beakta integritetskraven: Google Fit använder Restricted Scopes — särskilda åtkomstområden som kräver separat verifiering av appen via OAuth Verification. Utvecklaren måste beskriva vilka data som samlas in, hur de används och hur länge de lagras. Google kräver också en integritetspolicy och efterlevnad av programmet API Services Terms of Service.

Praktiskt exempel på skrivning

För att skriva data skapas en DataSource med angivelse av typ, enhet och app. Sedan bildas en DataPoint med tidsstämpel och värden. Flera DataPoints slås samman i en DataSet som skickas till HistoryClient.write().

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("Data sparad")
    }