Timeline: update

Requiere autorización.

Actualiza un elemento del cronograma. Ve un ejemplo.

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

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

Solicitud

Solicitud HTTP

Este método proporciona la funcionalidad de carga de contenido multimedia a través de dos URI independientes. 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 de solo 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 Es el ID del elemento de cronograma.
Parámetros de búsqueda obligatorios
uploadType string El tipo de solicitud de carga para el URI /upload. Los valores aceptables son los siguientes:
  • media: Carga simple. Subir 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 manera reanudable, mediante 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 servicios pueden especificar un bundleId para agrupar muchos elementos. Aparecen en un solo elemento de nivel superior en el dispositivo. admite escritura
canonicalUrl string Corresponde a una URL canónica que dirige a la versión canónica/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 La hora que debe aparecer cuando se visualiza este elemento en el cronograma, según el formato RFC 3339. La línea de tiempo de este usuario se ordena cronológicamente en el tiempo de visualización, por lo que también determinará dónde se mostrará el elemento en la línea de tiempo. Si el servicio no lo establece, la hora predeterminada será updated. admite escritura
html string Contenido HTML de este elemento Si se proporcionan text y html para un elemento, se renderizará html 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
  • Tablas: table, tbody, td, tfoot, th, thead, tr

Elementos HTML bloqueados: estos elementos y sus contenidos se quitan de las cargas útiles de HTML.

  • Encabezados del documento: head, title
  • Inserciones: audio, embed, object, source, video
  • Fotogramas: frame, frameset
  • Secuencias de comandos: applet, script

Otros elementos: Se quitan todos los elementos de la lista, pero se conserva el contenido.

 admite escritura
isBundleCover boolean Indica si este elemento es una portada de paquete.

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

En el cronograma principal, se muestran los siguientes elementos:
  • Los elementos que tienen isBundleCover establecido en true
  • Elementos que no tienen bundleId
En el cronograma de un paquete, los elementos que se muestran son los siguientes:
  • Los elementos que tienen el elemento bundleId en cuestión Y isBundleCover establecido en false
admite escritura
location nested object La ubicación geográfica asociada con este elemento. admite escritura
notification nested object Controla cómo se presentan las notificaciones de este elemento en el dispositivo. 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:
  • DEFAULT: Notificaciones de importancia predeterminada. Se reproducirá un timbre para alertar a los usuarios.
 admite escritura
recipients[] list Una lista de usuarios o grupos con quienes se compartió este elemento. admite escritura
sourceItemId string String opaca que puedes usar para asignar un elemento de cronograma a los datos en tu propio servicio. admite escritura
speakableText string 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 bien para proporcionar información ampliada a lo que se muestra visualmente en Glass.

Glassware también debe especificar el campoSpeakableType, que se anunciará antes de este texto en casos en los que el contexto adicional sea útil, por ejemplo, cuando el usuario solicite 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 casos en los que el contexto adicional sea útil, por ejemplo, cuando el usuario solicite que el elemento se lea en voz alta después de una notificación.

Debería ser una frase corta y nominal simple, como "Correo electrónico", "Mensaje de texto" o "Actualización diaria de noticias del planeta".

Se recomienda que completes este campo para cada elemento del cronograma, incluso si el elemento no contiene texto hablado o texto a fin de 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 El título de este elemento. admite escritura

Respuesta

Si se aplica correctamente, este método muestra un recurso Timeline 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

Usa 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

Usa la biblioteca cliente 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

Usa la biblioteca cliente de 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

Ruby

Usa 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

Comienza a usarlo

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 usa 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" }