Timeline: insert

Wymaga autoryzacji

Wstawia nowy element na osi czasu. Zobacz przykład

Ta metoda obsługuje identyfikator URI /upload i akceptuje przesyłane multimedia o następujących cechach:

  • Maksymalny rozmiar pliku: 10 MB
  • Akceptowane typy MIME multimediów: image/*, audio/*, video/*

Przesłane multimedia zostaną wstawione jako załącznik do elementu na osi czasu.

Żądanie

Żądanie HTTP

Ta metoda umożliwia przesyłanie multimediów za pomocą 2 oddzielnych identyfikatorów URI. Więcej informacji znajdziesz w artykule na temat przesyłania multimediów.

  • Identyfikator URI przesyłanych żądań multimediów: 
    POST https://www.googleapis.com/upload/mirror/v1/timeline
  • Identyfikator URI metadanych dotyczących żądań z samymi metadanymi: 
    POST https://www.googleapis.com/mirror/v1/timeline

Parametry

Nazwa parametru Wartość Opis
Wymagane parametry zapytania
uploadType string Typ żądania przesyłania do identyfikatora URI /upload. Akceptowane wartości to:

Upoważnienie

To żądanie wymaga autoryzacji z co najmniej jednym z poniższych zakresów (więcej informacji o uwierzytelnianiu i autoryzacji).

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

Treść żądania

W treści żądania jako zasób podaj oś czasu z tymi właściwościami. Więcej informacji znajdziesz w dokumencie dotyczącym przesyłania multimediów.

Nazwa usługi Wartość Opis Uwagi
Właściwości opcjonalne
bundleId string Identyfikator pakietu elementu. Usługi mogą określać identyfikator pakietu, aby grupować wiele elementów. Wyświetlają się pod jednym elementem najwyższego poziomu na urządzeniu. zapisywalny
canonicalUrl string Kanoniczny URL wskazuje kanoniczną/wysoką wersję danych reprezentowanych przez element osi czasu. zapisywalny
creator nested object Użytkownik lub grupa, która utworzyła ten element. zapisywalny
displayTime datetime Czas wyświetlania tego elementu na osi czasu, zgodny z RFC 3339. Oś czasu tego użytkownika jest posortowana chronologicznie według czasu wyświetlania, więc określa też miejsce wyświetlania elementu na osi czasu. Jeśli nie ustawisz tej funkcji, jej czas wyświetlania jest domyślnie ustawiony na updated. zapisywalny
html string Treść HTML tego elementu. Jeśli podany jest zarówno element text, jak i html, element html zostanie wyrenderowany na osi czasu.

Dozwolone elementy HTML – możesz ich używać na kartach osi czasu.

  • Nagłówki: h1, h2, h3, h4, h5, h6
  • Obrazy: img
  • Listy: li, ol, ul
  • Semantyka HTML5: article, aside, details, figure, figcaption, footer, header, nav, section, summary, time
  • Struktura: blockquote, br, div, hr, p, span
  • Styl: b, big, center, em, i, u, s, small, strike, strong, style, sub, sup
  • Stoły: table, tbody, td, tfoot, th, thead, tr

Zablokowane elementy HTML: te elementy i ich zawartość są usuwane z ładunków HTML.

  • Nagłówki dokumentów: head, title
  • Umieszczone: audio, embed, object, source, video
  • Ramki: frame, frameset
  • Skrypt: applet, script

Inne elementy: wszystkie elementy, których nie ma na liście, są usuwane, ale ich zawartość zostaje zachowana.

 zapisywalny
isBundleCover boolean Określa, czy ten element jest zdjęciem pakietu.

Jeśli element jest oznaczony jako okładka pakietu, będzie punktem wejścia do pakietu elementów, które mają tę samą wartość bundleId co ten element. Będzie ona widoczna tylko na głównej osi czasu – nie w otwartym pakiecie.

Na głównej osi czasu wyświetlają się następujące elementy:
  • Elementy, w których isBundleCover ma wartość true
  • Elementy, które nie mają: bundleId
Wyświetlane są na osi czasu grupy:
  • Elementy, których bundleId ma znaczenie ORAZ isBundleCover, są ustawione na false
zapisywalny
location nested object Lokalizacja geograficzna powiązana z tym elementem. zapisywalny
notification nested object Określa sposób wyświetlania powiadomień dotyczących danego elementu na urządzeniu. Jeśli go zabraknie, nie zostanie wygenerowane żadne powiadomienie. zapisywalny
notification.deliveryTime datetime Godzina doręczenia powiadomienia. zapisywalny
notification.level string Określa, jak ważne jest powiadomienie. Dozwolone wartości to:
  • DEFAULT – powiadomienia dotyczące domyślnego znaczenia. Zostanie odtworzony sygnał dźwiękowy.
 zapisywalny
recipients[] list Lista użytkowników lub grup, którym udostępniono ten element. zapisywalny
sourceItemId string Nieprzezroczysty ciąg znaków, którego możesz użyć do mapowania elementu osi czasu na dane w Twojej usłudze. zapisywalny
speakableText string Wersja głosu tego elementu. W połączeniu z pozycją w menu READ_ALOUD użyj tego pola, aby tekst był wyraźniejszy, gdy jest odczytywany na głos, albo podaj więcej informacji o tym, co jest wyświetlane w Google Glass.

Oprogramowanie Glassware powinno też zawierać poleSpeakableType, które będzie wypowiadane przed tym tekstem, w sytuacjach, gdy dodatkowy kontekst będzie przydatny, na przykład gdy użytkownik poprosi, że element zostanie odczytany na głos po powiadomieniu.
 zapisywalny
speakableType string Wyraźny opis typu tego elementu. O tym poinformujemy użytkownika przed przeczytaniem treści elementu, w sytuacji, gdy dodatkowy kontekst jest przydatny, na przykład gdy użytkownik zażąda, aby element został odczytany na głos po powiadomieniu.

To powinno być krótkie, proste wyrażenie rzeczowe, np. „E-mail”, „SMS” lub „Codzienne aktualności dotyczące planet”.

Zachęcamy do wypełniania tego pola w przypadku każdego elementu na osi czasu, nawet jeśli ten element nie zawiera tekstu lub tekstu możliwego do odczytania, aby użytkownik mógł poznać typ elementu bez patrzenia na ekran.		 zapisywalny
text string Treść tego elementu. zapisywalny
title string Tytuł tego elementu. zapisywalny

Odpowiedź

Jeśli operacja się uda, ta metoda zwróci zasób osi czasu w treści odpowiedzi.

Przykłady

Uwaga: dostępne dla tej metody przykłady kodu nie odzwierciedlają wszystkich obsługiwanych języków programowania. Listę obsługiwanych języków znajdziesz na stronie z bibliotekami klienta.

Java

Używa biblioteki klienta w języku 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

Używa biblioteki klienta .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

Używa biblioteki klienta 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

Używa biblioteki klienta dla języka 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

Używa biblioteki klienta 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

Używa biblioteki klienta 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
}

Nieprzetworzony protokół HTTP

Nie korzysta z biblioteki klienta.

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