Timeline: insert

Requiere autorización.

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

Si se proporciona, el contenido multimedia subido se inserta como un archivo adjunto al elemento de la línea de tiempo.

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

Parámetros

Nombre del parámetro Valor Descripción
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.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

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>
  /// 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

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

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

Rita

Utiliza 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

Go

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 utiliza 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--