Timeline: update

Requiere autorización.

Actualiza un elemento del cronograma establecido. Ve un ejemplo.

Este método admite un URI /upload y acepta archivos multimedia subidos con las siguientes características:

  • Tamaño máximo del archivo: 10 MB
  • Tipos de MIME de los archivos multimedia aceptados: audio/* , image/* , video/*

Solicitud

Solicitud HTTP

Este método proporciona la funcionalidad de carga de contenido multimedia a través de dos URIs separados. Para obtener más información, consulta el documento sobre carga de contenido multimedia.

  • URI de carga para solicitudes de carga de contenido multimedia: 
    PUT https://www.googleapis.com/upload/mirror/v1/timeline/id
  • URI de metadatos, para solicitudes solo de metadatos: 
    PUT https://www.googleapis.com/mirror/v1/timeline/id

Parámetros

Nombre del parámetro Valor Descripción
Parámetros de ruta de acceso
id string El ID del elemento de la línea de tiempo.
Parámetros de consulta obligatorios
uploadType string Es el tipo de solicitud de carga para el URI /upload. Los valores aceptables son los siguientes:
  • media: Carga simple. Sube solo el contenido multimedia, sin metadatos.
  • multipart: Carga multiparte. Sube el contenido multimedia y sus metadatos en una sola solicitud.
  • resumable: Carga reanudable. Sube el archivo de forma reanudable, con una serie de al menos dos solicitudes en las que la primera solicitud incluya los metadatos.

Autorización

Esta solicitud requiere autorización con al menos uno de los siguientes alcances (obtén más información acerca de la autenticación y autorización).

Alcance
https://www.googleapis.com/auth/glass.timeline
https://www.googleapis.com/auth/glass.location

Cuerpo de la solicitud

En el cuerpo de la solicitud, proporciona un recurso de cronograma con las siguientes propiedades como metadatos. Para obtener más información, consulta el documento sobre carga de contenido multimedia.

Nombre de la propiedad Valor Descripción Notas
Propiedades opcionales
bundleId string Es el ID del paquete de este artículo. Los Services pueden especificar un bundleId para agrupar muchos elementos. Aparecen debajo de un solo elemento de nivel superior del dispositivo. admite escritura
canonicalUrl string Es una URL canónica que dirige a la versión canónica o de alta calidad de los datos representados por el elemento de cronograma. admite escritura
creator nested object El usuario o grupo que creó este elemento. admite escritura
displayTime datetime Es la hora en la que se debe mostrar este elemento en la línea de tiempo, con el formato que se indica en RFC 3339. El cronograma de este usuario está ordenado cronológicamente por tiempo de visualización, por lo que esto también determinará dónde se muestra el elemento en el cronograma. Si el servicio no la establece, la hora de visualización se establece de forma predeterminada en la hora updated. admite escritura
html string Contenido HTML de este elemento. Si se proporcionan text y html para un elemento, html se renderizará en el cronograma.

Elementos HTML permitidos: Puedes usar estos elementos en tus tarjetas de cronograma.

  • Encabezados: h1, h2, h3, h4, h5, h6
  • Imágenes: img
  • Listas: li, ol, ul
  • Semántica de HTML5: article, aside, details, figure, figcaption, footer, header, nav, section, summary, time
  • Estructural: blockquote, br, div, hr, p, span
  • Estilo: b, big, center, em, i, u, s, small, strike, strong, style, sub, sup
  • Tabla: table, tbody, td, tfoot, th, thead, tr

Elementos HTML bloqueados: Estos elementos y su contenido se quitan de las cargas útiles HTML.

  • Encabezados del documento: head, title
  • Incorporaciones: audio, embed, object, source, video
  • Marcos: frame, frameset
  • Secuencia de comandos: applet, script

Otros elementos: Los elementos que no aparezcan en la lista se quitan, pero se conserva su contenido.

 admite escritura
isBundleCover boolean Indica si este artículo es una portada de paquete.

Si un artículo está marcado como portada del paquete, será el punto de entrada al paquete de elementos que tenga la misma bundleId que ese artículo. Solo se mostrará en el cronograma principal, no en el paquete abierto.

En el cronograma principal, se muestran los siguientes elementos:
  • Elementos que tienen isBundleCover establecido como true
  • Elementos que no tienen un bundleId
En el cronograma secundario del paquete, se muestran los siguientes elementos:
  • Elementos que tienen el bundleId en cuestión Y isBundleCover establecidos en false
admite escritura
location nested object Es la ubicación geográfica asociada con este elemento. admite escritura
notification nested object Controla cómo se presentan en el dispositivo las notificaciones de este elemento. Si falta, no se generará ninguna notificación. admite escritura
notification.deliveryTime datetime La hora a la que se debe entregar la notificación. admite escritura
notification.level string Describe la importancia de la notificación. Los valores permitidos son los siguientes:
  • DEFAULT: Notificaciones de importancia predeterminada. Se reproducirá una campanilla para alertar a los usuarios.
 admite escritura
recipients[] list Una lista de usuarios o grupos con los que se compartió este elemento. admite escritura
sourceItemId string Es una cadena opaca que puedes usar para asignar un elemento de cronograma a los datos de tu propio servicio. admite escritura
speakableText string Es la versión hablada del contenido de este elemento. Junto con el elemento de menú READ_ALOUD, usa este campo para proporcionar un texto que sea más claro cuando se lea en voz alta o para brindar información más detallada sobre lo que se muestra visualmente en Glass.

Glassware también debe especificar el campo talkableType, que se dirá antes de este texto en los casos en los que el contexto adicional sea útil, por ejemplo, cuando el usuario solicita que el elemento se lea en voz alta después de una notificación.
 admite escritura
speakableType string Es una descripción hablada del tipo de este elemento. Esto se anunciará al usuario antes de leer el contenido del elemento en los casos en los que el contexto adicional sea útil, por ejemplo, cuando el usuario solicita que el elemento se lea en voz alta después de una notificación.

Debe ser una frase nominal corta y simple, como "Correo electrónico", "Mensaje de texto" o "Actualización de noticias de Daily Planet".

Se recomienda que los objetos de Glassware propaguen este campo para cada elemento de la línea de tiempo, incluso si el elemento no contiene SpeakeasyText, de modo que el usuario pueda aprender el tipo de elemento sin mirar la pantalla.		 admite escritura
text string Contenido de texto de este elemento. admite escritura
title string Es el título de este elemento. admite escritura

Respuesta

Si se aplica correctamente, este método muestra un recurso de línea de tiempo en el cuerpo de la respuesta.

Ejemplos

Nota: Los ejemplos de código disponibles para este método no representan todos los lenguajes de programación admitidos (consulta la página de bibliotecas cliente para consultar una lista de lenguajes admitidos).

Java

Usa la biblioteca cliente de Java.

import com.google.api.services.mirror.Mirror;
import com.google.api.services.mirror.model.NotificationConfig;
import com.google.api.services.mirror.model.TimelineItem;

import java.io.IOException;

public class MyClass {
  // ...

  /**
   * Update a timeline item in the user's Glass with an optional notification and attachment.
   * 
   * @param service Authorized Mirror service.
   * @param itemId ID of the timeline item to update.
   * @param newText timeline item's text.
   * @param newNotificationLevel Optional notification level, supported values
   *        are {@code null} and "AUDIO_ONLY".
   * @return Updated timeline item on success, {@code null} otherwise.
   */
  public static TimelineItem updateTimelineItem(Mirror service, String itemId, String newText,
      String newNotificationLevel) {
    try {
      // First retrieve the timeline item from the API.
      TimelineItem timelineItem = service.timeline().get(itemId).execute();
      // Update the timeline item's metadata.
      timelineItem.setText(newText);
      if (newNotificationLevel != null && newNotificationLevel.length() > 0) {
        timelineItem.setNotification(new NotificationConfig().setLevel(newNotificationLevel));
      } else {
        timelineItem.setNotification(null);
      }
      return service.timeline().update(itemId, timelineItem).execute();
    } catch (IOException e) {
      System.err.println("An error occurred: " + e);
      return null;
    }
  }

  // ...
}

.NET

Utiliza la biblioteca cliente.NET.

using System;
using System.IO;

using Google.Apis.Mirror.v1;
using Google.Apis.Mirror.v1.Data;

public class MyClass {
  // ...

  /// <summary>
  /// Update a timeline item in the user's Glass with an optional
  /// notification and attachment.
  /// </summary>
  /// <param name='service'>Authorized Mirror service.</param>
  /// <param name='itemId'>ID of the timeline item to update.</param>
  /// <param name='newText'>Timeline Item's text content.</param>
  /// <param name='newNotificationLevel'>
  /// Optional notification level, supported values are null and
  /// "AUDIO_ONLY".
  /// </param>
  /// <returns>
  /// Updated timeline item on success, null otherwise.
  /// </returns>
  public static TimelineItem UpdateTimelineItem(MirrorService service,
      String itemId, String newText, String newNotificationLevel) {
    try {
      // First retrieve the timeline item from the API.
      TimelineItem timelineItem = service.Timeline.Get(itemId).Fetch();
      // Update the timeline item's metadata.
      timelineItem.Text = newText;
      if (!String.IsNullOrEmpty(newNotificationLevel)) {
        timelineItem.Notification = new NotificationConfig() {
          Level = newNotificationLevel
        };
      } else {
        timelineItem.Notification = null;
      }
      return service.Timeline.Update(timelineItem, itemId).Fetch();
    } catch (Exception e) {
      Console.WriteLine("An error occurred: " + e.Message);
      return null;
    }
  }

  // ...
}

PHP

Utiliza la biblioteca cliente de PHP.

/**
 * Update a timeline item in the user's Glass with an optional
 * notification and attachment.
 *
 * @param Google_MirrorSservice $service Authorized Mirror service.
 * @param string $itemId ID of the timeline item to update.
 * @param string $newText timeline item's text (can be HTML content).
 * @param string $newNotificationLevel Optional notification level,
 *               supported values are {@code null} and "AUDIO_ONLY".
 * @return Google_TimelineItem Updated timeline item on success,
 *         null otherwise.
 */
function updateTimelineItem($service, $itemId, $newText, $newNotificationLevel) {
  try {
    $timelineItem = $service->timeline->get($itemId);
    $timelineItem->setText($newText);
    if ($notificationlevel != null) {
      $notification = new Google_NotificationConfig();
      $notification->setLevel($newNotificationLevel);
      $timelineItem->setNotification($notification);
    } else {
      $timelineItem->setNotification(null);
    }
    return $service->timeline->update($itemId, $timelineItem);
  } catch (Exception $e) {
    print 'An error occurred: ' . $e->getMessage();
    return null;
  }
}

Python

Utiliza la biblioteca cliente Python.

import io

from apiclient import errors
from apiclient.http import MediaIoBaseUpload
# ...

def update_timeline_item(service, item_id, new_text, 
                         new_notification_level=None):
  """Update a timeline item in the user's Glass.

  Args:
    service: Authorized Mirror service.
    item_id: ID of the timeline item to update.
    new_text: Timeline item's text (can be HTML content).
    new_content_type: Optional attachment's content type (supported content
                      types are 'image/*', 'video/*' and 'audio/*').
    new_attachment: Optional attachment as data string.
    new_notification_level: Optional notification level, supported values are
                            None and 'AUDIO_ONLY'.
  Returns:
    Updated timeline item on success, None otherwise.
  """
  try:
    # First retrieve the timeline item from the API.
    timeline_item = service.timeline().get(id=item_id).execute()
    # Update the timeline item's metadata.
    timeline_item['text'] = new_text
    if new_notification_level:
      timeline_item['notification'] = {'level': new_notification_level}
    elif 'notification' in timeline_item:
      timeline_item.pop('notification')
    return service.timeline().update(id=item_id, body=timeline_item).execute()
  except errors.HttpError, error:
    print 'An error occurred: %s' % error
    return None

Rita

Utiliza la biblioteca cliente de Ruby.

##
# Update a timeline item in the user's glass.
#
# @param [Google::APIClient] client
#   Authorized client instance.
# @param [String] item_id
#   ID of the timeline item to update.
# @param [String] new_text
#   Timeline item's new text.
# @param [String] new_notification_level
#   Optional new notification level, supported values are nil and 'AUDIO_ONLY'.
# @return [Google::APIClient::Schema::Mirror::V1::TimelineItem]
#   Updated timeline item instance if successful, nil otherwise.
def update_timeline_item(client, item_id, new_text, new_notification_level)
  mirror = client.discovered_api('mirror', 'v1')
  result = client.execute(
    :api_method => mirror.timeline.get,
    :parameters => { 'id' => item_id })
  if result.success?
    timeline_item = result.data
    timeline_item.text = new_text
    if new_notification_level
      timeline_item.notification = { 'level' => new_notification_level }
    else
      timeline_item.notification = nil
    end
    result = client.execute(
      :api_method => mirror.timeline.update,
      :body_object => timeline_item,
      :parameters => { 'id' => item_id })
    if result.success?
      return result.data
    end
  end
  puts "An error occurred: #{result.data['error']['message']}"
end

Go

Usa la biblioteca cliente de Go.

import (
	"code.google.com/p/google-api-go-client/mirror/v1"
	"fmt"
)

// UpdateTimelineItem updates a timeline item in the user's timeline with an
// optional notification and attachment.
func UpdateTimelineItem(g *mirror.Service, itemId string, newNotificationLevel string) (
	*mirror.TimelineItem, error) {
	t, err := g.Timeline.Get(itemId).Do()
	if err != nil {
		fmt.Printf("An error occurred: %v\n", err)
		return nil, err
	}
	t.Text = newText
	if newNotificationLevel != "" {
		t.Notification = &mirror.NotificationConfig{Level: newNotificationLevel}
	} else {
		t.Notification = nil
	}
	r, err := g.Timeline.Update(itemId, t).Do()
	if err != nil {
		fmt.Printf("An error occurred: %v\n", err)
		return nil, err
	}
	return r, nil
}

HTTP sin procesar

No utiliza una biblioteca cliente.

PUT /mirror/v1/timeline/timeline item id HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer auth token
Content-Type: application/json
Content-Length: 26

{ "text": "Hello world" }