Timeline: update

Requer autorização

Atualiza um item da 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: audio/* , image/* , video/*

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:
    PUT https://www.googleapis.com/upload/mirror/v1/timeline/id
  • URI de metadados, para solicitações somente de metadados:
    PUT https://www.googleapis.com/mirror/v1/timeline/id

Parâmetros

Nome do parâmetro Valor Descrição
Parâmetros de caminho
id string ID do item de linha do tempo.
Parâmetros de consulta obrigatórios
uploadType string O tipo de solicitação de upload para o URI /upload. Os valores aceitáveis são os seguintes:
  • media: upload simples. Faça upload somente da mídia, sem metadados.
  • multipart: upload de várias partes. Faz upload da mídia e dos metadados em uma única solicitação.
  • resumable: upload retomável. Faça upload do arquivo de modo retomável usando uma série de pelo menos duas solicitações em que a primeira solicitação inclua 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 os 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 muitos itens. Eles são exibidos 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 Usuário ou grupo que criou o item. gravável
displayTime datetime É o horário em que esse item é exibido na linha do tempo, formatado de acordo com o RFC 3339. A linha do tempo do usuário é classificada cronologicamente no tempo de exibição. Portanto, isso também determina onde o item é exibido na linha do tempo. Se não for definido pelo serviço, o tempo de exibição padrão será updated. gravável
html string Este é o conteúdo HTML para este item. Se text e html forem fornecidos para um item, o html será renderizado na linha do tempo.

Elementos HTML permitidos: use esses elementos nos cards da linha do tempo.

  • Cabeçalhos: h1, h2, h3, h4, h5, h6
  • Imagens: img
  • Listas: li, ol, ul
  • Semântica 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 em: audio, embed, object, source, video
  • Molduras: frame, frameset
  • Script: applet, script

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

gravável
isBundleCover boolean Indica se o item é uma capa do pacote.

Se um item for marcado como uma capa do pacote, ele será o ponto de entrada para o pacote de itens que têm o mesmo bundleId que esse item. Essa informação será exibida somente na linha do tempo principal, e 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 um bundleId
Em uma linha do tempo de pacote, os itens mostrados são:
  • Itens que têm 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. Nenhuma notificação é gerada se esse recurso estiver ausente. 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 da importância padrão. Uma campainha tocará para alertar os usuários.
gravável
recipients[] list Lista de usuários ou grupos com os quais esse 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 que fique mais claro quando lido em voz alta ou para fornecer mais informações sobre o que está sendo exibido visualmente no Google Glass.

O Glassware também precisa especificar o campo talkableType, que vai ser falado antes desse texto nos casos em que o contexto extra é útil, por exemplo, quando o usuário solicita 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 para o usuário antes da leitura do conteúdo do item nos casos em que o contexto adicional é útil, por exemplo, quando o usuário solicitar que o item seja lido em voz alta após uma notificação.

Essa frase precisa ser um substantivo simples, como "E-mail", "Mensagem de texto" ou "Atualização diária sobre notícias do planeta".

Recomendamos que o usuário preencha esse campo em todos os itens da linha do tempo, mesmo que o item não tenha textableText ou text. Assim o usuário aprende o tipo de item sem olhar para a tela.
gravável
text string Conteúdo de texto desse item. gravável
title string O título deste item. gravável

Resposta

Se for bem-sucedido, este método retornará um recurso Timeline 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.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 a biblioteca do 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 a 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

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

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