Cómo agregar datos personalizados durante la grabación en el NDK de Android

Las sesiones de grabación y La API de Playback te permite grabar una sesión y usarla en lugar del feed de la cámara en tiempo real. Sin embargo, estos registros solo contienen datos de video y de sensores. También puedes agregar datos personalizados a la grabación de una sesión y hacer que se te devuelvan los datos durante la reproducción, como si fueran parte de una imagen de cámara.

ARCore no incluye automáticamente ningún dato personalizado en las grabaciones. En cambio, te permite agregar datos personalizados a un fotograma de ARCore durante la grabación y recuperar esos mismos datos del fotograma durante la reproducción. Depende de ti programar la app de modo que el usuario recupere los datos que espera cuando reproduzca la sesión.

Casos de uso para datos personalizados

Agregar datos personalizados a las grabaciones amplía las posibilidades de tus apps de RA. Estos son algunos casos de uso específicos.

Usa RA sobre la marcha

Antes, los usuarios solo podían acceder a experiencias de RA en el lugar y el momento adecuados. Si querían colocar una lámpara de RA en la sala de estar, debían pararse físicamente en el lugar para ver cómo se vería la lámpara allí. Con pistas personalizadas, pueden grabar su sala de estar una vez y agregar muebles virtuales a la escena cuando quieran.

Crea en conjunto con experiencias de RA

Como no exigen sesiones en vivo, los usuarios tienen muchas más opciones de edición en RA, lo que les permite crear contenido único de RA y acceder a él en cualquier momento y lugar. Por ejemplo, pueden grabar un entorno determinado, agregar efectos de realidad aumentada y compartirlos con amigos.

Requisitos previos

Asegúrate de comprender los conceptos fundamentales de RA y cómo configurar una sesión de ARCore antes de continuar.

Cómo registrar con datos personalizados

Crear una grabación de sesión con datos personalizados

Inicializa una grabación con datos personalizados

Sigue estos pasos para inicializar una grabación con datos personalizados. Para iniciar, detener y verificar una sesión de grabación, consulta Cómo grabar y reproducir una sesión de RA.

  1. Obtén un ArRecordingConfig.
  2. Crea un ArTrack nuevo con un UUID personalizado. Todos los datos personalizados se guardarán aquí.
  3. Agrega el ArTrack al ArRecordingConfig que creaste durante la configuración de la sesión.
// Initialize a new track with a custom UUID.
// Make sure to save the UUID because it is the ID that you will use to get
// your data back during playback.
ArTrack* track = NULL;
ArTrack_create(ar_session, &track);
// String from UUID generator: de5ec7a4-09ec-4c48-b2c3-a98b66e71893
uint8_t uuid_byte_array[16] = {0xde, 0x5e, 0xc7, 0xa4, 0x09, 0xec,
                               0x4c, 0x48, 0xb2, 0xc3, 0xa9, 0x8b,
                               0x66, 0xe7, 0x18, 0x93};
ArTrack_setId(ar_session, track, uuid_byte_array);

// Add the ArTrack to the recording_config.
// recording_config must already be configured.
ArRecordingConfig_addTrack(ar_session, recording_config, track);
ArTrack_destroy(track);

Todas las pistas nuevas se tratan como grabaciones independientes y cada una de ellas ocupa su propio UUID.

Opcional: Configura el segmento con datos adicionales

En caso de que quieras identificarla más adelante, puedes configurar una pista con datos adicionales que describan la grabación de la sesión. Por ejemplo, puedes "etiquetar" una pista agregando una nota que describa la ubicación y la hora a la que grabaste la sesión: "Esta sesión se grabó en el centro comercial por la tarde".

// Set additional data on this track.
// For example, describe where you recorded the session.
uint8_t metadata_size = 4;
uint8_t metadata[5] = "HOME";
ArTrack_setMetadata(ar_session, track, metadata, metadata_size);

Opcional: Configura el segmento con un tipo de MIME

Si tu app necesita ser compatible con herramientas externas, puedes configurar un segmento con un tipo de MIME que describa el tipo de datos registrados en el segmento. Si no especificas un tipo, los datos se categorizarán como application/text. ARCore ignora el tipo de MIME cuando lee datos.

// Set a MIME type for compatibility with external tools.
ArTrack_setMimeType(ar_session, track, "text/csv");

Cómo grabar segmentos de datos personalizados

Todos los datos de los segmentos personalizados se registran en ArFrame. Las sesiones de RA usan ArSession_update() para obtener un fotograma. La hora en la que grabas datos en un fotograma es la misma hora en la que se mostrarán los datos durante la reproducción. Por ejemplo, si llamas a ArFrame_recordTrackData() con el valor “A” en 00:07:02, obtendrás “A” en la marca 00:07:02 cuando se reproduzca la pista.

Para grabar un segmento de datos personalizado, llama a ArFrame_recordTrackData().

// Place an AR lamp in a room.
if (place_lamp_button_was_pressed) {
  uint8_t lamp_data[1] = {lamp_id};
  ArFrame_recordTrackData(ar_session, frame, uuid_byte_array, lamp_data,
                          /*payload_size=*/1);
}

Cómo reproducir segmentos de datos personalizados

Extraer datos personalizados de un registro de sesión durante la reproducción

Cómo inicializar una reproducción

Iniciar una reproducción con datos personalizados es lo mismo que inicializar la reproducción de una sesión normal.

Muestra datos personalizados

Llama a ArFrame_getUpdatedTrackData() para recuperar los datos personalizados registrados en un ArFrame. Es posible recuperar varios datos de seguimiento del mismo fotograma. Por ejemplo, si llamaste a ArFrame_recordTrackData() dos veces en el mismo fotograma durante la grabación, obtendrás dos instancias de ArTrackData durante la reproducción.

// Create the container to hold the track data retrieved from the frame.
ArTrackDataList* fetched_track_data_list;
ArTrackDataList_create(ar_session, &fetched_track_data_list);

// Fetch the track data from the frame into the created container.
ArFrame_getUpdatedTrackData(ar_session, frame, uuid_byte_array,
                            fetched_track_data_list);

Una vez que ArTrackData esté en un objeto contenedor, extrae los bytes de los datos personalizados.

// Fetch the size of the track data list.
int32_t fetched_track_data_list_size;
ArTrackDataList_getSize(ar_session, fetched_track_data_list,
                        &fetched_track_data_list_size);

// Iterate through the list.
for (int i = 0; i < fetched_track_data_list_size; i++) {
  ArTrackData* fetched_track_data;
  ArTrackDataList_acquireItem(ar_session, fetched_track_data_list, i,
                              &fetched_track_data);
  // Process "fetched_track_data->sample" as desired
  ArTrackData_release(fetched_track_data);
}
ArTrackDataList_destroy(fetched_track_data_list);

¿Qué sigue?