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:
|
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.
Elementos HTML bloqueados: esses elementos e o conteúdo deles são removidos dos payloads HTML.
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:
|
gravável |
location |
nested object |
A localização geográfica associada a este item. | gravável |
menuItems[] |
list |
Uma lista de itens de menu que vão ser apresentados ao usuário quando esse item for selecionado na linha do tempo. | gravável |
menuItems[].action |
string |
Controla o comportamento quando o usuário escolhe a opção do menu. Os valores permitidos são:
|
gravável |
menuItems[].id |
string |
O ID desse item de menu. Ele é gerado pelo aplicativo e tratado como um token opaco. | gravável |
menuItems[].payload |
string |
Um payload genérico cujo significado muda dependendo da ação desse MenuItem.
|
gravável |
menuItems[].removeWhenSelected |
boolean |
Se definido como verdadeiro em um item de menu do CUSTOM , ele será removido do menu depois de ser selecionado. |
gravável |
menuItems[].values[] |
list |
Para itens CUSTOM , uma lista de valores que controlam a aparência do item de menu em cada um dos estados. É necessário fornecer um valor para o estado DEFAULT . Se os estados PENDING ou CONFIRMED estiverem ausentes, eles não serão exibidos. |
gravável |
menuItems[].values[].displayName |
string |
Nome a ser exibido para o item de menu. Se você especificar essa propriedade para um item de menu integrado, o comando de voz contextual padrão desse item de menu não será mostrado. | gravável |
menuItems[].values[].iconUrl |
string |
URL de um ícone a ser exibido com o item de menu. | gravável |
menuItems[].values[].state |
string |
O estado ao qual este valor se aplica. Os valores permitidos são:
|
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:
|
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--