Timeline: insert

Requer autorização

Insere um novo item na linha do tempo. Veja um exemplo.

Esse método é compatível com um URI de /upload e aceita mídias enviadas com as seguintes características:

  • Tamanho máximo do arquivo: 10 MB
  • Tipos de mídia MIME aceitos: image/* , audio/* , video/*

Se fornecida, a mídia enviada é inserida como um anexo ao item da linha do tempo.

Solicitação

Solicitação HTTP

Esse método oferece a funcionalidade de upload de mídia por dois URIs separados. Para mais detalhes, consulte o documento sobre upload de mídia.

  • URI de upload, para solicitações de upload de mídia:
    POST https://www.googleapis.com/upload/mirror/v1/timeline
  • URI de metadados, para solicitações somente de metadados:
    POST https://www.googleapis.com/mirror/v1/timeline

Parâmetros

Nome do parâmetro Valor Descrição
Parâmetros de consulta obrigatórios
uploadType string O tipo de solicitação de upload para o URI de /upload. Os valores aceitáveis são os seguintes:
  • media: upload simples. Envie somente a mídia, sem metadados.
  • multipart: upload de várias partes. Fazer upload da mídia e dos metadados com uma única solicitação.
  • resumable: upload retomável. Fazer upload do arquivo de modo retomável usando uma série de pelo menos duas solicitações. A primeira inclui os metadados.

Autorização

Esta solicitação requer autorização com pelo menos um dos seguintes escopos (leia mais sobre autenticação e autorização).

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

Corpo da solicitação

No corpo da solicitação, forneça um recurso de linha do tempo com as seguintes propriedades como metadados. Para mais informações, consulte o documento sobre upload de mídia.

Nome da propriedade Valor Descrição Observações
Propriedades opcionais
bundleId string O ID do pacote deste item. Os serviços podem especificar um bundleId para agrupar vários itens. Eles aparecem em um único item de nível superior no dispositivo. gravável
canonicalUrl string Um URL canônico que aponta para a versão canônica/de alta qualidade dos dados representados pelo item da linha do tempo. gravável
creator nested object O usuário ou grupo que criou o item. gravável
displayTime datetime É o horário que deve ser exibido quando o item é visualizado na linha do tempo, formatado de acordo com o RFC 3339. A linha do tempo desse usuário é organizada de acordo com o tempo de exibição, o que também determina onde o item aparece. Se não for definido pelo serviço, o tempo de exibição será definido como updated por padrão. gravável
html string Conteúdo HTML deste item. Se text e html forem fornecidos para um item, o html será renderizado no cronograma.

Elementos HTML permitidos: você pode usar esses elementos nos cards da linha do tempo.

  • Cabeçalhos: h1, h2, h3, h4, h5, h6
  • Imagens: img
  • Listas: li, ol, ul
  • Semântica do HTML5: article, aside, details, figure, figcaption, footer, header, nav, section, summary, time
  • Estrutural: blockquote, br, div, hr, p, span
  • Estilo: b, big, center, em, i, u, s, small, strike, strong, style, sub, sup
  • Tabelas: table, tbody, td, tfoot, th, thead, tr

Elementos HTML bloqueados: esses elementos e o conteúdo deles são removidos dos payloads HTML.

  • Cabeçalhos do documento: head, title
  • Incorporações: audio, embed, object, source, video
  • Armações: frame, frameset
  • Script: applet, script

Outros elementos: todos os elementos não listados serão removidos, mas o conteúdo deles será preservado.

gravável
isBundleCover boolean Indica se este item é uma capa de pacote.

Se um item for marcado como uma capa de pacote, ele será o ponto de entrada para o pacote de itens que tenham o mesmo bundleId. Ele será exibido somente na linha do tempo principal, não no pacote aberto.

Na linha do tempo principal, os itens mostrados são:
  • Itens com isBundleCover definido como true
  • Itens que não têm bundleId
Em um sub-linha do tempo de pacote, os itens mostrados são:
  • Itens com bundleId em questão E isBundleCover definido como false
gravável
location nested object A localização geográfica associada a este item. gravável
notification nested object Controla como as notificações deste item são apresentadas no dispositivo. Se essa informação não for informada, nenhuma notificação será gerada. gravável
notification.deliveryTime datetime O horário em que a notificação deve ser entregue. gravável
notification.level string Descreve a importância da notificação. Os valores permitidos são:
  • DEFAULT: notificações de importância padrão. Uma campainha vai tocar para alertar os usuários.
gravável
recipients[] list Uma lista de usuários ou grupos com os quais este item foi compartilhado. gravável
sourceItemId string String opaca que você pode usar para mapear um item da linha do tempo para dados no seu próprio serviço. gravável
speakableText string A versão falada do conteúdo deste item. Além do item de menu READ_ALOUD, use esse campo para fornecer um texto mais claro quando lido em voz alta ou para fornecer mais informações sobre o que é exibido visualmente no Google Glass.

O Glassware também precisa especificar o campo SpeakableType, que será falado antes do texto quando o contexto adicional for útil, por exemplo, quando o usuário solicitar que o item seja lido em voz alta após uma notificação.
gravável
speakableType string Uma descrição falada do tipo deste item. Isso será anunciado ao usuário antes da leitura do conteúdo do item nos casos em que o contexto adicional for útil, por exemplo, quando o usuário solicitar que o item seja lido em voz alta após uma notificação.

Deve ser um sintagma nominal curto e simples, como "E-mail", "Mensagem de texto" ou "Atualização diária de novidades do planeta".

Os Glasswares são incentivados a preencher esse campo para cada item da linha do tempo, mesmo que o item não contenha speakableText ou texto, para que o usuário possa aprender o tipo do item sem olhar para a tela.
gravável
text string Conteúdo de texto deste item. gravável
title string Título deste item. gravável

Resposta

Se for bem-sucedido, esse método retornará um recurso de Linha do tempo no corpo da resposta.

Exemplos

Observação: os exemplos de código disponíveis para esse método não representam todas as linguagens de programação compatíveis. Consulte a página de bibliotecas cliente para ver uma lista de linguagens compatíveis.

Java

Usa a 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 a biblioteca de 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 a 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

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

Não usa uma biblioteca de 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--