Google Fit para Android API de sesiones

Google Fit es una plataforma que permite a los desarrolladores crear aplicaciones que se centran en los datos de aptitud del usuario. Una de las herramientas que Google ha proporcionado es Google Fit para Android, que está disponible como un paquete en los Servicios de Google Play..

Anteriormente en esta serie, hemos explorado cómo almacenar datos de acondicionamiento físico a través de los Servicios de Google Play utilizando la API de grabación y cómo acceder y actualizar datos a través de la API de historial. En este tutorial, ampliamos estas ideas con la API de sesiones, que le permite organizar los datos de actividad por intervalos de tiempo.

Este tutorial lo guía a través de un proyecto de ejemplo que muestra cómo trabajar con la API de sesiones. El proyecto terminado se puede descargar desde GitHub..

1. Configuración del proyecto

Paso 1: configurar la consola de desarrollador

Para usar Google Fit, debe crear un ID de cliente de OAuth 2.0 y registrar su aplicación a través de la Consola de desarrolladores de Google. Puede encontrar una explicación detallada de cómo configurar un proyecto en la Consola de desarrollador de Google en mi tutorial sobre la API de sensores de ajuste de Google.

Paso 2: configurar el proyecto de Android

Una vez que haya configurado su aplicación para la autenticación en la Consola de desarrollador de Google, use el nombre del paquete que registró para crear una nueva aplicación de Android con un espacio vacío. Actividad.

Con el proyecto Android creado, abierto. construir.gradle e incluye Google Play Services en el nodo de dependencias y sincroniza tu aplicación. En este ejemplo, también estoy usando la biblioteca Butter Knife para reducir el código de la placa de la caldera para los oyentes de clics y encontrar Ver artículos.

compile 'com.google.android.gms: play-services-fitness: 8.4.0' compile 'com.jakewharton: butterknife: 7.0.1'

Una vez que haya sincronizado sus dependencias, abra AndroidManifest.xml e incluir el ACCESS_FINE_LOCATION permiso. Este permiso es necesario para leer los datos de sesión de Google Fit. Si bien no entro en detalles en este tutorial, vale la pena señalar que, si está apuntando a la API 23 o superior, debe solicitar el permiso de ubicación al usuario..

A continuación, abrir activity_main.xml y actualizarlo para que incluya cinco Botón Elementos que se utilizarán para demostrar algunas de las funciones de la API de sesiones. El resultado final debe ser similar al siguiente:

Una vez creado el layout, abrir MainActivity.java y conéctate a los servicios de Google Play.

la clase pública MainActivity extiende AppCompatActivity implementa GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener private final String SESSION_NAME = "nombre de sesión"; privado GoogleApiClient mGoogleApiClient = null; sesión privada mSession; @Override protected void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); ButterKnife.bind (esto); mGoogleApiClient = nuevo GoogleApiClient.Builder (esta). .enableAutoManage (this, 0, this) .build ();  @ Anular anulación protegida onDestroy () super.onDestroy (); ButterKnife.unbind (este);  @Override public void onConnected (Bundle bundle)  @Override public void onConnectionSuspended (int i)  @Override public void onConnectionFailed (@NonNull ConnectionResult connectionResult) 

Es posible que haya notado que está incluyendo la API de historial junto con la API de sesiones. Esto es necesario porque la API de historial se usa para eliminar datos de sesión, que veremos más adelante en este tutorial. También necesitas usar tanto FITNESS_LOCATION_READ_WRITE y FITNESS_ACTIVITY_READ_WRITE propiedades de alcance para las características de la API de Sesiones que discutiremos.

Una vez que haya configurado su aplicación para conectarse a Google Play Services y Google Fit, es hora de comenzar a probar la API de sesiones.

2. Usando la API de Sesiones

El API de sesiones es otra herramienta de Google Fit para almacenar datos de estado físico para el usuario. Como tal, no pretende ser un reemplazo para las API de grabación o historial, sino que es una forma adicional de mejorar sus aplicaciones para una mejor experiencia de usuario..

En esta sección, aprenderá cómo iniciar y detener la recopilación de datos de sesión en tiempo real, cómo insertar una sesión en el almacén de datos de Google Fit, cómo leer los datos de sesión almacenados previamente y cómo eliminar sesiones innecesarias o incorrectas. Similar a la API de historial, las llamadas a la API de sesiones deben hacerse fuera del hilo principal. Mientras que el tutorial para la API de historial envolvió las operaciones en AsyncTask llamadas, este tutorial se centrará en usar PendingResult devoluciones de llamada para realizar un seguimiento de las tareas.

Iniciar y detener una sesión

El escenario más común para la API de sesiones es registrar información después de que un usuario haya iniciado una actividad de acondicionamiento físico. A menudo, esto se inicia al mismo tiempo que la API de grabación para que los datos del sensor puedan asociarse con el período de tiempo de la sesión. Para comenzar a grabar una sesión, necesita crear un objeto de sesión con un nombre, un identificador único, una descripción, una hora de inicio y el tipo de actividad que el usuario está realizando..

mSession = new Session.Builder () .setName (SESSION_NAME) .setIdentifier (getString (R.string.app_name) + "" + System.currentTimeMillis ()) .setDescription ("Descripción de la sesión de yoga") .setStartTime (Calendar.getInstance ( ) .getTimeInMillis (), TimeUnit.MILLISECONDS) .setActivity (FitnessActivities.YOGA) .build ();

Una vez que tu Sesión Se crea el objeto, puedes llamar inicioSesión en la API de sesiones para comenzar a registrar la actividad de su usuario.

PendingResult pendingResult = Fitness.SessionsApi.startSession (mGoogleApiClient, mSession); pendingResult.setResultCallback (nuevo ResultCallback() @Override public void onResult (estado) if (status.isSuccess ()) Log.i ("Tuts +", "Sesión iniciada con éxito");  else Log.i ("Tuts +", "Error al iniciar sesión:" + status.getStatusMessage ()); );

Cuando su usuario haya terminado su actividad, puede finalizar la sesión llamando al detener sesión con el identificador único para el Sesión.

PendingResult pendingResult = Fitness.SessionsApi.stopSession (mGoogleApiClient, mSession.getIdentifier ()); pendingResult.setResultCallback (nuevo ResultCallback() @Override public void onResult (SessionStopResult sessionStopResult) if (sessionStopResult.getStatus (). IsSuccess ()) Log.i ("Tuts +", "Session exitosamente detenida");  else Log.i ("Tuts +", "Error al detener la sesión:" + sessionStopResult.getStatus (). getStatusMessage ()); );

Algo que vale la pena notar aquí es que el Sesión objeto implementa el Parcelable interfaz, por lo que se puede almacenar en una Haz en caso de que necesite almacenar o pasarlo a otro componente dentro de su aplicación. Esto puede ser útil si el usuario inicia una actividad y luego cierra la aplicación, ya que es posible que necesite los datos de la sesión más adelante para detener la grabación..

Inserción en Google Fit

Ahora que sabe cómo grabar información de sesión en tiempo real, el siguiente paso es poder insertar sesiones después del hecho. Si bien puede insertar un bloque de tiempo como una sesión, la API de sesiones también le permite asociar actividades con segmentos de una sesión. Esto es útil para situaciones en las que el usuario no puede realizar continuamente la misma actividad durante toda su rutina de ejercicios..

Un ejemplo de esto puede ser cuando su aplicación detectó que el usuario corrió, descansó por un corto período de tiempo caminando y luego corrió nuevamente. En el siguiente ejemplo, inserta un Sesión donde el usuario corrió durante 15 minutos, caminó durante cinco, y luego corrió durante otros 15 minutos al hacer un seguimiento de cuándo el usuario comenzó y detuvo cada actividad. También registra su velocidad promedio para cada una de esas actividades..

Calendar calendar = Calendar.getInstance (); Fecha ahora = nueva fecha (); calendar.setTime (ahora); long endTime = calendar.getTimeInMillis (); calendar.add (Calendar.MINUTE, -15); long walkEndTime = calendar.getTimeInMillis (); calendar.add (Calendar.MINUTE, -5); long walkStartTime = calendar.getTimeInMillis (); calendar.add (Calendar.MINUTE, -15); long startTime = calendar.getTimeInMillis (); float firstRunSpeed ​​= 15; float walkSpeed ​​= 5; float secondRunSpeed ​​= 13;

Una vez que tenga los valores clave de tiempo y velocidad, debe crear dos Conjunto de datos Grupos para almacenar información sobre actividades y velocidad. Estos pueden ser creados a partir de un conjunto de Fuente de datos objetos con el apropiado Tipo de datos conjunto de propiedades.

DataSource speedSegmentDataSource = new DataSource.Builder () .setAppPackageName (this.getPackageName ()) .setDataType (DataType.TYPE_SPEED) .setName ("Tuts + speed dataset") .setType (DataSource.TYPE_RAW) .build () DataSource activitySegmentDataSource = new DataSource.Builder () .setAppPackageName (this.getPackageName ()) .setDataType (DataType.TYPE_ACTIVITY_SEGMENT) .setName ("Tuts + actividad de segmentos de datos") .setType (DataSource.TYPETY_RAW). DataSet speedDataSet = DataSet.create (speedSegmentDataSource); DataSet activityDataSet = DataSet.create (activitySegmentDataSource);

A continuación, necesita crear el Punto de datos Objetos que se insertarán en el almacén de datos de Google Fit. Cada Punto de datos tiene un intervalo de tiempo y un conjunto de Campo Propiedades que almacenan datos relacionados. Una vez cada Punto de datos está configurado, necesita insertarlo en el Conjunto de datos. Por brevedad, solo muestro el fragmento de código para crear Punto de datos Sin embargo, los objetos para el primer segmento de ejecución a continuación, los otros objetos de puntos de datos se muestran en el código fuente de este tutorial en GitHub..

// Crear punto de datos de velocidad para el primer segmento de ejecución DataPoint firstRunSpeedDataPoint = speedDataSet.createDataPoint () .setTimeInterval (startTime, walkStartTime, TimeUnit.MILLISECONDS); firstRunSpeedDataPoint.getValue (Field.FIELD_SPEED) .setFloat (firstRunSpeed); speedDataSet.add (firstRunSpeedDataPoint); // Crear un punto de datos de actividad para el segundo segmento de ejecución DataPoint secondRunActivityDataPoint = activityDataSet.createDataPoint () .setTimeInterval (walkEndTime, endTime, TimeUnit.MILLISECONDS); secondRunActivityDataPoint.getValue (Field.FIELD_ACTIVITY) .setActivity (FitnessActivities.RUNNING); activityDataSet.add (secondRunActivityDataPoint);

Una vez que hayas poblado los dos Conjunto de datos grupos, es hora de crear el Sesión que va a insertar. Esta Sesión deberá establecer el nombre, el identificador único, la descripción, las horas de inicio y finalización y las propiedades de la actividad. Una cosa importante a tener en cuenta es que el nombre que usa cuando inserta un Sesión es el nombre que debe usar al intentar leer esta sesión más tarde.

Session session = new Session.Builder () .setName (SESSION_NAME) .setIdentifier (getString (R.string.app_name) + "" + System.currentTimeMillis ()) .setDescription ("Running in Segments") .setStartTime (startTime, TimeUnit .MILLISECONDS) .setEndTime (endTime, TimeUnit.MILLISECONDS) .setActivity (FitnessActivities.RUNNING) .build ();

Ahora que tu Sesión es creado, necesitas crear un SessionInsertRequest, Agrega tu Conjunto de datos objetos a ella, y luego inserte ese Sesión en Google Fit.

SessionInsertRequest insertRequest = new SessionInsertRequest.Builder () .setSession (session) .addDataSet (speedDataSet) .addDataSet (activityDataSet) .build (); PendingResult pendingResult = Fitness.SessionsApi.insertSession (mGoogleApiClient, insertRequest); pendingResult.setResultCallback (nuevo ResultCallback() @Override public void onResult (Status Status) if (status.isSuccess ()) Log.i ("Tuts +", "insert session insertado correctamente");  else Log.i ("Tuts +", "No se pudo insertar la sesión en ejecución:" + status.getStatusMessage ()); );

Lectura de datos de la sesión

No importa la cantidad de datos de sesión que almacene con su aplicación, no le servirá de mucho a menos que pueda leerlos y usarlos para mejorar su aplicación para sus usuarios. Afortunadamente, Google Fit hace que sea increíblemente fácil recibir datos de sesión dentro de un período de tiempo establecido.

Primero, debe seleccionar la hora de inicio y finalización de los datos que desea recibir. En este ejemplo, solicitamos datos de sesión del último mes..

Calendar cal = Calendar.getInstance (); Fecha ahora = nueva fecha (); cal.setTime (ahora); long endTime = cal.getTimeInMillis (); cal.add (Calendar.MONTH, -1); long startTime = cal.getTimeInMillis ();

Una vez que haya seleccionado su ventana de tiempo, necesita crear un SessionReadRequest. Esta solicitud incluye el intervalo de tiempo para sus datos de sesión deseados, el tipo de datos de sesión que está buscando (este tutorial solo buscará datos de velocidad) y el nombre de las sesiones que está solicitando, sin embargo, el intervalo de tiempo es el solo se requiere propiedad.

SessionReadRequest readRequest = new SessionReadRequest.Builder () .setTimeInterval (startTime, endTime, TimeUnit.MILLISECONDS) .read (DataType.TYPE_SPEED) .setSessionName (SESSION_NAME) .build (); PendingResult sessionReadResult = Fitness.SessionsApi.readSession (mGoogleApiClient, readRequest);

Después de que hayas llamado SessionsApi.readSession, usted recibe un SessionReadResult objeto que contiene listas de Sesión y Conjunto de datos Objetos que puedes usar dentro de tu aplicación. Para este tutorial, simplemente registramos los datos.

sessionReadResult.setResultCallback (nuevo ResultCallback() @Override public void onResult (SessionReadResult sessionReadResult) if (sessionReadResult.getStatus (). IsSuccess ()) Log.i ("Tuts +", "Lectura exitosa de los datos de la sesión"); para (Session session: sessionReadResult.getSessions ()) Log.i ("Tuts +", "Nombre de sesión:" + session.getName ()); para (DataSet dataSet: sessionReadResult.getDataSet (session)) para (DataPoint dataPoint: dataSet.getDataPoints ()) Log.i ("Tuts +", "Speed:" + dataPoint.getValue (Field.FIELD_SPEED));  else else Log.i ("Tuts +", "Error al leer los datos de la sesión"); );

Si ejecuta su aplicación ahora y usa las operaciones de inserción y lectura, debería recibir las tres velocidades Punto de datos Objetos que creaste en la sección anterior..

I / Tuts +: Velocidad: 15.0 I / Tuts +: Velocidad: 5.0 I / Tuts +: Velocidad: 13.0

Eliminar datos de sesión

Puede haber ocasiones en las que necesite eliminar alguna información de sesión que sea incorrecta o innecesaria. Esto se puede hacer usando la API de historial para eliminar sesiones que se han guardado en el almacén de datos de Google Fit.

Primero, debe determinar un intervalo de tiempo para la operación de eliminación. A continuación, puede agregar información adicional, como un Tipo de datos u otro Sesión propiedades para eliminar, o simplemente puede eliminar todos los datos de la sesión dentro del intervalo de tiempo.

Calendar calendar = Calendar.getInstance (); Fecha ahora = nueva fecha (); calendar.setTime (ahora); long endTime = calendar.getTimeInMillis (); calendar.add (Calendar.DAY_OF_YEAR, -1); long startTime = calendar.getTimeInMillis (); DataDeleteRequest request = new DataDeleteRequest.Builder () .setTimeInterval (startTime, endTime, TimeUnit.MILLISECONDS) .addDataType (DataType.TYPE_SPEED) .deleteAllSessions () .build (); PendingResult deleteRequest = Fitness.HistoryApi.deleteData (mGoogleApiClient, solicitud); deleteRequest.setResultCallback (nuevo ResultCallback() @Override public void onResult (@NonNull Status status) if (status.isSuccess ()) Log.i ("Tuts +", "Sucesiones eliminadas con éxito");  else Log.i ("Tuts +", "Error al eliminar sesiones"); );

Conclusión

Como aprendió en este tutorial, la API de sesiones es una herramienta poderosa para organizar los datos recopilados en bloques de tiempo. Es un gran complemento para las otras API de Google Fit. Cuando se usa junto con el historial y las API de grabación, hay mucho que puede hacer para comprender la actividad de los usuarios de su aplicación y brindarles una excelente experiencia con sus aplicaciones de acondicionamiento físico..