Share
Google Fit er en plattform som gjør det mulig for utviklere å bygge applikasjoner som er fokusert på brukerens treningsdata. Et av verktøyene Google har oppgitt, er Google Fit for Android, som er tilgjengelig som en pakke i Google Play Services.
Tidligere i denne serien har vi undersøkt hvordan du lagrer treningsdata via Google Play Services ved hjelp av innspillings-API og hvordan du får tilgang til og oppdaterer data gjennom historikk-API. I denne veiledningen utvider vi på disse ideene med Sessions API, som lar deg organisere aktivitetsdata med tidsintervaller.
Denne opplæringen går deg gjennom et prøveprosjekt som demonstrerer hvordan du arbeider med Sessions-API. Det ferdige prosjektet kan lastes ned fra GitHub.
For å bruke Google Fit må du opprette en OAuth 2.0 klient-ID og registrere programmet ditt gjennom Google Developer Console. Du finner en detaljert forklaring på hvordan du setter opp et prosjekt i Google Developer Console i min veiledning om API for Google Fit Sensors.
Når du har konfigurert søknaden din for godkjenning i Google Developer Console, bruker du pakkenavnet du registrerte for å opprette et nytt Android-program med en tom Aktivitet.
Med Android-prosjektet opprettet, åpne build.gradle og inkludere Google Play-tjenester under avhengighetsnoden og synkroniser appen din. I denne prøven bruker jeg også Butter Knife-biblioteket til å kutte ned på kjeleplatenkoden for klikklyttere og finne Utsikt elementer.
kompilere 'com.google.android.gms: play-services-fitness: 8.4.0' compile 'com.jakewharton: butterknife: 7.0.1'
Når du har synkronisert dine avhengigheter, åpner du AndroidManifest.xml og inkludere ACCESS_FINE_LOCATION tillatelse. Denne tillatelsen er nødvendig for å lese øktdata fra Google Fit. Selv om jeg ikke går i detalj i denne opplæringen, er det verdt å merke seg at hvis du målretter mot API 23 eller høyere, må du be om stedsstillatelse fra brukeren.
Deretter åpne activity_main.xml og oppdater den slik at den inneholder fem Knapp elementer som vil bli brukt til å demonstrere noen av funksjonene i Sessions API. Sluttresultatet skal se ut som følgende:
Når oppsettet er opprettet, åpne MainActivity.java og koble deg til Google Play-tjenester.
offentlig klasse MainActivity utvider AppCompatActivity implementerer GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener Private Final String SESSION_NAME = "øktnavn"; privat GoogleApiClient mGoogleApiClient = null; Privat sesjon mSession; @Override protected void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); ButterKnife.bind (this); mGoogleApiClient = ny GoogleApiClient.Builder (dette) .addApi (Fitness.SESSIONS_API) .addApi (Fitness.HISTORY_API) .addScope (nytt område (Scopes.FITNESS_LOCATION_READ_WRITE)) .addScope (nytt område (Scopes.FITNESS_ACTIVITY_READ_WRITE)) .addConnectionCallbacks (dette) .enableAutoManage (dette, 0, dette) .build (); @Override protected void onDestroy () super.onDestroy (); ButterKnife.unbind (this); @Override public void onConnectionFailed (@NonNull ConnectionResult connectionResult) Overstyr offentlig tomgang påConnectionFailed (@NonNull ConnectionResult connectionResult)
Du har kanskje lagt merke til at du inkluderer History API sammen med Sessions API. Dette er nødvendig fordi History API brukes til å slette øktdata, som vi vil diskutere senere i denne opplæringen. Du må også bruke begge FITNESS_LOCATION_READ_WRITE og FITNESS_ACTIVITY_READ_WRITE omfangsegenskaper for Sessions API-funksjonene som vi skal diskutere.
Når du har satt appen din opp for å koble deg til Google Play Services og Google Fit, er det på tide å begynne å prøve ut Sessions-API.
Sessions-API er et annet verktøy fra Google Fit for lagring av treningsdata for brukeren. Som sådan er det ikke ment å være en erstatning for innspillings- eller historikk-APIer, men det er heller en ekstra måte å forbedre appene dine for å få bedre brukeropplevelse..
I denne delen lærer du hvordan du starter og stopper sanntids øktdatainnsamling, hvordan du setter inn en økt i Google Fit datalager, hvordan du leser tidligere lagrede øktdata, og hvordan du sletter unødvendige eller feilaktige økter. I likhet med API-historien må Sessions-API-anrop avhenger av hovedtråden. Mens opplæringen for History API pakket inn operasjoner i AsyncTask samtaler, denne opplæringen vil fokusere på å bruke PendingResult tilbakeringinger for å holde oversikt over oppgaver.
Det vanligste scenariet for økt-API-en registrerer informasjon etter at en bruker har startet en treningsaktivitet. Dette startes ofte samtidig med innspillings-API, slik at sensordata kan knyttes til økt tidsramme. For å starte opptak av en økt må du opprette et øktobjekt med et navn, en unik identifikator, en beskrivelse, en starttid og typen aktivitet som brukeren utfører.
Accentsconagua
mSession = ny Session.Builder () .setName (SESSION_NAME) .setIdentifier (getString (R.string.app_name) + "" + System.currentTimeMillis ()) .setDescription ("Yoga Session Description") .setStartTime (Calendar.getInstance ) .getTimeInMillis (), TimeUnit.MILLISECONDS) .setActivity (FitnessActivities.YOGA) .build ();En gang din Økt objekt er opprettet, du kan ringe startSession på Sessions-API for å begynne å registrere brukerens aktivitet.
PendingResultpendingResult = Fitness.SessionsApi.startSession (mGoogleApiClient, mSession); pendingResult.setResultCallback (new ResultCallback () @Overtrid offentlig tomgang onResult (Status status) if (status.isSuccess ()) Log.i ("Tuts +", "Vellykket startet økt"); else Log.i ("Tuts +", "Kunne ikke starte økten:" + status.getStatusMessage ()); );
Når brukeren har avsluttet sin aktivitet, kan du avslutte økten ved å ringe stopSession med den unike identifikatoren for Økt.
PendingResultpendingResult = Fitness.SessionsApi.stopSession (mGoogleApiClient, mSession.getIdentifier ()); pendingResult.setResultCallback (new ResultCallback () @Overtrid offentlig tomgang onResult (SessionStopResult sessionStopResult) if (sessionStopResult.getStatus () .SSuccess ()) Log.i ("Tuts +", "Suksessivt stoppet økt"); else Log.i ("Tuts +", "Mislyktes å stoppe økten:" + sessionStopResult.getStatus (). getStatusMessage ()); );
Noe verdt å merke seg her er at Økt objektet implementerer Parcelable grensesnitt, slik at det kan lagres i en Bunt i tilfelle du må lagre eller sende det til en annen komponent i søknaden din. Dette kan være nyttig hvis brukeren starter en aktivitet og lukker appen, da du kanskje trenger den øktinformasjonen senere for å slutte å registrere innspillingen.
Nå som du vet hvordan du spiller inn sanntids øktinformasjon, er neste trinn å kunne sette inn økter etter faktum. Mens du kan sette inn en tidsperiode som en økt, kan Sessions-API også tillate deg å knytte aktiviteter med segmenter av en økt. Dette er nyttig for situasjoner der brukeren ikke kontinuerlig kan gjøre den samme aktiviteten over hele treningsrutinen.
Et eksempel på dette kan være når appen din har oppdaget at brukeren løp, hvilte for en kort periode ved å gå, og kjørte igjen. I det følgende eksempelet legger du inn en Økt hvor brukeren løp i 15 minutter, gikk for fem, og kjørte deretter i ytterligere 15 minutter ved å holde øye på når brukeren startet og stoppet hver aktivitet. Du registrerer også deres gjennomsnittlige fart for hver av disse aktivitetene.
Kalenderkalender = Calendar.getInstance (); Dato nå = nytt Dato (); calendar.setTime (nå); lang endTime = calendar.getTimeInMillis (); calendar.add (Kalender.MINUTE, -15); lang walkEndTime = calendar.getTimeInMillis (); calendar.add (Calendar.MINUTE, -5); lang walkStartTime = calendar.getTimeInMillis (); calendar.add (Kalender.MINUTE, -15); lang startTime = calendar.getTimeInMillis (); float firstRunSpeed = 15; float walkSpeed = 5; flyte secondRunSpeed = 13;
Når du har nøkkel- og hastighetsverdiene, må du opprette to datasett grupper for lagring av informasjon om aktiviteter og fart. Disse kan opprettes fra et sett av Datakilde gjenstander med riktig Data-type egenskaper sett.
DataSource speedSegmentDataSource = ny DataSource.Builder () .setAppPackageName (this.getPackageName ()) .setDataType (DataType.TYPE_SPEED) .setName ("Tuts + speed datasett") .setType (DataSource.TYPE_RAW) .build (); DataSource activitySegmentDataSource = new DataSource.Builder () .setAppPackageName (this.getPackageName ()) .setDataType (DataType.TYPE_ACTIVITY_SEGMENT) .setName ("Tuts + aktivitetssegment datasett") .setType (DataSource.TYPE_RAW) .build (); DataSet speedDataSet = DataSet.create (speedSegmentDataSource); DataSet activityDataSet = DataSet.create (ActivitySegmentDataSource);Deretter må du opprette Datapunkt objekter som vil bli satt inn i Google Fit datalager. Hver Datapunkt har et tidsintervall og et sett med Felt egenskaper som lagrer relaterte data. En gang hver Datapunkt er konfigurert, må du sette den inn i riktig format datasett. For korthet viser jeg bare kodestykket for å lage Datapunkt objekter for første runde segmentet nedenfor, men de andre datapunktobjektene vises i kildekoden for denne opplæringen på GitHub.
// Opprett hastighet datapunkt for første runde segmentet DataPoint firstRunSpeedDataPoint = speedDataSet.createDataPoint () .setTimeInterval (startTime, walkStartTime, TimeUnit.MILLISECONDS); firstRunSpeedDataPoint.getValue (Field.FIELD_SPEED) .setFloat (firstRunSpeed); speedDataSet.add (firstRunSpeedDataPoint); // Opprett aktivitet datapunkt for andre løp segmentet DataPoint secondRunActivityDataPoint = activityDataSet.createDataPoint () .setTimeInterval (walkEndTime, endTime, TimeUnit.MILLISECONDS); secondRunActivityDataPoint.getValue (Field.FIELD_ACTIVITY) .setActivity (FitnessActivities.RUNNING); activityDataSet.add (secondRunActivityDataPoint);
Når du har fylt de to datasett grupper, det er på tide å lage Økt som du vil sette inn. Dette Økt må sette navn, unik identifikator, beskrivelse, start og sluttider og aktivitetsegenskaper. En viktig ting å være klar over er at navnet du bruker når du setter inn en Økt er navnet du må bruke når du prøver å lese denne sesjonen senere.
Session session = Ny Session.Builder () .setName (SESSION_NAME) .setIdentifier (getString (R.string.app_name) + "" + System.currentTimeMillis ()) .setDescription ("Kjører i segmenter") .setStartTime (startTime, TimeUnit .MILLISECONDS) .setEndTime (endTime, TimeUnit.MILLISECONDS) .setActivity (FitnessActivities.RUNNING) .build ();Nå som din Økt er opprettet, må du opprette en SessionInsertRequest, legg til din datasett objekter på det, og sett inn det Økt inn i Google Fit.
SessionInsertRequest insertRequest = ny SessionInsertRequest.Builder () .setSession (økt) .addDataSet (speedDataSet) .addDataSet (activityDataSet) .build (); PendingResultpendingResult = Fitness.SessionsApi.insertSession (mGoogleApiClient, insertRequest); pendingResult.setResultCallback (new ResultCallback () @Overtrid offentlig tomgang onResult (Status status) if (status.isSuccess ()) Log.i ("Tuts +", "vellykket satt løpende økt"); ellers Log.i ("Tuts +", "Kunne ikke sette inn løpende økt:" + status.getStatusMessage ()); );
Uansett hvor mye øktdata du lagrer med appen din, vil det ikke gjøre deg så bra med mindre du kan lese dataene og bruke den til å gjøre appen din bedre for brukerne. Heldigvis gjør Google Fit det utrolig enkelt å motta øktdata innenfor en angitt tidsramme.
Først må du velge start- og sluttid for dataene du vil motta. I dette eksemplet ber vi øktdata for den siste måneden.
Kalender cal = Calendar.getInstance (); Dato nå = nytt Dato (); cal.setTime (nå); lang endTime = cal.getTimeInMillis (); cal.add (Kalender.MONTH, -1); lang startTime = cal.getTimeInMillis ();
Når du har valgt ditt tidsvindu, må du opprette en SessionReadRequest. Denne forespørselen inkluderer tidsintervallet for de ønskede øktdataene, typen øktdata du leter etter (denne opplæringen vil bare se etter fartdata) og navnet på øktene du ber om, men tidsintervallet er det kun nødvendig eiendom.
SessionReadRequest readRequest = nytt SessionReadRequest.Builder () .setTimeInterval (startTime, endTime, TimeUnit.MILLISECONDS) .read (DataType.TYPE_SPEED) .setSessionName (SESSION_NAME) .build (); PendingResultsessionReadResult = Fitness.SessionsApi.readSession (mGoogleApiClient, readRequest);
Etter at du har ringt SessionsApi.readSession, du mottar en SessionReadResult objekt som inneholder lister over Økt og datasett objekter du kan bruke i appen din. For denne opplæringen logger vi bare på dataene.
sessionReadResult.setResultCallback (nytt resultatCallback() @Overtrid offentlig tomgang påResultat (SessionReadResult sessionReadResult) if (sessionReadResult.getStatus (). IsSuccess ()) Log.i ("Tuts +", "Vellykket lese øktdata"); for (økt økt: sessionReadResult.getSessions ()) Log.i ("Tuts +", "Session navn:" + session.getName ()); for (DataSet dataSet: sessionReadResult.getDataSet (økt)) for (DataPoint dataPoint: dataSet.getDataPoints ()) Log.i ("Tuts +", "Speed:" + dataPoint.getValue (Field.FIELD_SPEED)); else Log.i ("Tuts +", "Mislyktes å lese øktdata"); );
Hvis du kjører programmet nå og bruker innsatsen og leser operasjonen, bør du motta tre hastigheter Datapunkt objekter du opprettet i forrige seksjon.
I / Tuts +: Hastighet: 15,0 I / Tuts +: Hastighet: 5,0 I / Tuts +: Hastighet: 13.0
Det kan være tider hvor du må slette noen øktinformasjon som enten er feil eller unødvendig. Dette kan gjøres ved hjelp av History API for å slette økter som er lagret i Google Fit datalager.
Først må du bestemme et tidsintervall for slettingen. Du kan deretter legge til tilleggsinformasjon, for eksempel a Data-type eller andre Økt egenskaper som skal slettes, eller du kan bare slette alle øktdata innenfor tidsintervallet.
Kalenderkalender = Calendar.getInstance (); Dato nå = nytt Dato (); calendar.setTime (nå); lang endTime = calendar.getTimeInMillis (); calendar.add (Kalender.DAY_OF_YEAR, -1); lang startTime = calendar.getTimeInMillis (); DataDeleteRequest request = ny DataDeleteRequest.Builder () .setTimeInterval (startTime, endTime, TimeUnit.MILLISECONDS) .addDataType (DataType.TYPE_SPEED) .deleteAllSessions () .build (); PendingResultdeleteRequest = Fitness.HistoryApi.deleteData (mGoogleApiClient, forespørsel); deleteRequest.setResultCallback (new ResultCallback () @Overtrid offentlig tomgang onResult (@NonNull Status status) if (status.isSuccess ()) Log.i ("Tuts +", "Vellykket slettede økter"); ellers Log.i ("Tuts +", "Mislyktes å slette økter"); );
Som du har lært i denne opplæringen, er Sessions API et kraftig verktøy for å organisere samle data i blokker av tid. Det er et godt kompliment til de andre Google Fit-APIene. Når det brukes sammen med APIer for historikk og opptak, er det mye du kan gjøre for å forstå aktiviteten til appens brukere og gi dem en utmerket opplevelse med treningsprogrammene dine.
