Timeline: insert

Requiere autorización.

Inserta un elemento nuevo en el 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: image/* , audio/* , video/*

Si se proporciona, el medio subido se inserta como un archivo adjunto al elemento del cronograma.

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: 
    POST https://www.googleapis.com/upload/mirror/v1/timeline
  • URI de metadatos, para solicitudes de solo metadatos: 
    POST https://www.googleapis.com/mirror/v1/timeline

Parámetros

Nombre del parámetro Valor Descripción
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.client.http.InputStreamContent;
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;
import java.io.InputStream;

public class MyClass {
  // ...

  /**
   * Insert a new timeline item in the user's glass with an optional
   * notification and attachment.
   * 
   * @param service Authorized Mirror service.
   * @param text timeline item's text.
   * @param contentType Optional attachment's content type (supported content
   *        types are "image/*", "video/*" and "audio/*").
   * @param attachment Optional attachment stream.
   * @param notificationLevel Optional notification level, supported values are
   *        {@code null} and "AUDIO_ONLY".
   * @return Inserted timeline item on success, {@code null} otherwise.
   */
  public static TimelineItem insertTimelineItem(Mirror service, String text, String contentType,
      InputStream attachment, String notificationLevel) {
    TimelineItem timelineItem = new TimelineItem();
    timelineItem.setText(text);
    if (notificationLevel != null && notificationLevel.length() > 0) {
      timelineItem.setNotification(new NotificationConfig().setLevel(notificationLevel));
    }
    try {
      if (contentType != null && contentType.length() > 0 && attachment != null) {
        // Insert both metadata and attachment.
        InputStreamContent mediaContent = new InputStreamContent(contentType, attachment);
        return service.timeline().insert(timelineItem, mediaContent).execute();
      } else {
        // Insert metadata only.
        return service.timeline().insert(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>
  /// Insert a new timeline item in the user's glass with an optional
  /// notification and attachment.
  /// </summary>
  /// <param name='service'>Authorized Mirror service.</param>
  /// <param name='text'>Timeline Item's text.</param>
  /// <param name='contentType'>
  /// Optional attachment's content type (supported content types are
  /// "image/*", "video/*" and "audio/*").
  /// </param>
  /// <param name='attachment'>Optional attachment stream</param>
  /// <param name='notificationLevel'>
  /// Optional notification level, supported values are null and
  /// "AUDIO_ONLY".
  /// </param>
  /// <returns>
  /// Inserted timeline item on success, null otherwise.
  /// </returns>
  public static TimelineItem InsertTimelineItem(MirrorService service,
      String text, String contentType, Stream attachment,
      String notificationLevel) {
    TimelineItem timelineItem = new TimelineItem();
    timelineItem.Text = text;
    if (!String.IsNullOrEmpty(notificationLevel)) {
      timelineItem.Notification = new NotificationConfig() {
        Level = notificationLevel
      };
    }
    try {
      if (!String.IsNullOrEmpty(contentType) && attachment != null) {
        // Insert both metadata and media.
        TimelineResource.InsertMediaUpload request = service.Timeline.Insert(
            timelineItem, attachment, contentType);
        request.Upload();
        return request.ResponseBody;
      } else {
        // Insert metadata only.
        return service.Timeline.Insert(timelineItem).Fetch();
      }
    } catch (Exception e) {
      Console.WriteLine("An error occurred: " + e.Message);
      return null;
    }
  }

  // ...
}

PHP

Usa la biblioteca cliente PHP.

/**
 * Insert a new timeline item in the user's glass with an optional
 * notification and attachment.
 *
 * @param Google_MirrorService $service Authorized Mirror service.
 * @param string $text timeline item's text.
 * @param string $contentType Optional attachment's content type (supported
 *                            content types are "image/*", "video/*"
 *                            and "audio/*").
 * @param string $attachment Optional attachment content.
 * @param string $notificationLevel Optional notification level,
 *                                  supported values are {@code null}
 *                                  and "AUDIO_ONLY".
 * @return Google_TimelineItem Inserted timeline item on success, otherwise.
 */
function insertTimelineItem($service, $text, $contentType, $attachment,
                            $notificationLevel) {
  try {
    $timelineItem = new Google_TimelineItem();
    $timelineItem->setText($text);
    if ($notificationlevel != null) {
      $notification = new Google_NotificationConfig();
      $notification->setLevel($notificationLevel);
      $timelineItem->setNotification($notification);
    }
    $optParams = array();
    if ($contentType != null && $attachment != null) {
      $optParams['data'] = $attachment;
      $optParams['mimeType'] = $contentType;
    }
    return $service->timeline->insert($timelineItem, $optParams);
  } 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 insert_timeline_item(service, text, content_type=None, attachment=None,
                         notification_level=None):
  """Insert a new timeline item in the user's glass.

  Args:
    service: Authorized Mirror service.
    text: timeline item's text.
    content_type: Optional attachment's content type (supported content types
                  are 'image/*', 'video/*' and 'audio/*').
    attachment: Optional attachment as data string.
    notification_level: Optional notification level, supported values are None
                        and 'AUDIO_ONLY'.

  Returns:
    Inserted timeline item on success, None otherwise.
  """
  timeline_item = {'text': text}
  media_body = None
  if notification_level:
    timeline_item['notification'] = {'level': notification_level}
  if content_type and attachment:
    media_body = MediaIoBaseUpload(
        io.BytesIO(attachment), mimetype=content_type, resumable=True)
  try:
    return service.timeline().insert(
        body=timeline_item, media_body=media_body).execute()
  except errors.HttpError, error:
    print 'An error occurred: %s' % error

Ruby

Usa la biblioteca cliente de Ruby.

##
# Insert a new Timeline Item in the user's glass.
#
# @param [Google::APIClient] client
#   Authorized client instance.
# @param [String] text
#   Timeline item's text.
# @param [String] content_type
#   Optional attachment's content type (supported content types are 'image/*',
#   'video/*' and 'audio/*').
# @param [String] filename
#   Optional attachment's filename.
# @param [String] notification_level
#   Optional notification level, supported values are nil and 'AUDIO_ONLY'.
# @return [Google::APIClient::Schema::Mirror::V1::TimelineItem]
#   Timeline item instance if successful, nil otherwise.
def insert_timeline_item(client, text, content_type, filename,
                         notification_level)
  mirror = client.discovered_api('mirror', 'v1')
  timeline_item = mirror.timeline.insert.request_schema.new({ 'text' => text })
  if notification_level
    timeline_item.notification = { 'level' => notification_level }
  end
  result = nil
  if filename
    media = Google::APIClient::UploadIO.new(filename, content_type)
    result = client.execute(
      :api_method => mirror.timeline.insert,
      :body_object => timeline_item,
      :media => media,
      :parameters => {
        'uploadType' => 'multipart',
        'alt' => 'json'})
  else
    result = client.execute(
      :api_method => mirror.timeline.insert,
      :body_object => timeline_item)
  end
  if result.success?
    return result.data
  else
    puts "An error occurred: #{result.data['error']['message']}"
  end
end

Comienza a usarlo

Usa la biblioteca cliente de Go.

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

// InsertTimelineItem inserts a new timeline item in the user's glass with an
// optional notification and attachment.
func InsertTimelineItem(g *mirror.Service, text string, attachment io.Reader,
	notificationLevel string) (*mirror.TimelineItem, error) {
	t := &mirror.TimelineItem{Text: text}
	if notificationLevel != "" {
		t.Notification = &mirror.NotificationConfig{Level: notificationLevel}
	}
	req := g.Timeline.Insert(t)
	if attachment != nil {
		// Add attachment to the timeline item.
		req.Media(attachment)
	}
	r, err := req.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.

## A very simple timeline item

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

{ "text": "Hello world" }

## A more complete timeline item with an attachment

POST /mirror/v1/timeline HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer auth token
Content-Type: multipart/related; boundary="mymultipartboundary"
Content-Length: length

--mymultipartboundary
Content-Type: application/json; charset=UTF-8

{
 "text": "Hello world",
 "menuItems": [
   { "action": "REPLY" },
   {
     "action": "CUSTOM",
     "id": "complete"
     "values": [{
       "displayName": "Complete",
       "iconUrl": "http://example.com/icons/complete.png"
     }]
   }
}
--mymultipartboundary
Content-Type: image/jpeg
Content-Transfer-Encoding: binary

binary image data
--mymultipartboundary--