Timeline: insert

Wymaga autoryzacji

Wstawia nowy element na osi czasu. Zobacz przykład

Ta metoda obsługuje identyfikator URI /upload i akceptuje przesłane multimedia o tych cechach:

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

Jeśli przesłane multimedia zostaną udostępnione, zostaną wstawione jako załącznik do elementu osi czasu.

Żądanie

Żądanie HTTP

Ta metoda udostępnia funkcję przesyłania multimediów za pomocą 2 osobnych identyfikatorów URI. Więcej informacji znajdziesz w dokumencie na temat przesyłania multimediów.

  • Identyfikator URI przesyłania dla żądań przesłania multimediów: 
    POST https://www.googleapis.com/upload/mirror/v1/timeline
  • Identyfikator URI metadanych w przypadku żądań samych metadanych: 
    POST https://www.googleapis.com/mirror/v1/timeline

Parametry

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

Autoryzacja

To żądanie wymaga autoryzacji przy użyciu co najmniej 1 z tych 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 podaj zasób osi czasu z metadanymi o następujących właściwościach. Więcej informacji znajdziesz w dokumencie na temat przesyłania multimediów.

Nazwa usługi Wartość Opis Uwagi
Właściwości opcjonalne
bundleId string Identyfikator pakietu danego produktu. Usługi mogą mieć określony identyfikator pakietu, aby zgrupować wiele elementów. Są one wyświetlane na urządzeniu pod jednym elementem najwyższego poziomu. z możliwością zapisu
canonicalUrl string Kanoniczny adres URL wskazujący kanoniczną lub wysoką jakość danych reprezentowanych przez element osi czasu. z możliwością zapisu
creator nested object Użytkownik lub grupa, która utworzyła ten element. z możliwością zapisu
displayTime datetime Godzina, która powinna być wyświetlana, gdy ten element jest wyświetlany na osi czasu, sformatowany zgodnie ze standardem RFC 3339. Oś czasu tego użytkownika jest posortowana chronologicznie według czasu wyświetlania, dlatego ma to również wpływ na miejsce wyświetlania produktu na osi czasu. Jeśli usługa nie ustawi tego czasu, domyślnym czasem wyświetlania będzie updated. z możliwością zapisu
html string Zawartość HTML tego elementu. Jeśli w przypadku danego elementu podasz zarówno text, jak i html, na osi czasu zostanie wyświetlona wartość html.

Dozwolone elementy HTML – możesz używać tych elementów 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
  • Tabele: 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ść pozostaje bez zmian.

 z możliwością zapisu
isBundleCover boolean Określa, czy ten produkt jest okładką pakietu.

Jeśli element jest oznaczony jako okładka pakietu, będzie to punkt wejścia do pakietu elementów mających ten sam atrybut bundleId co ten element. Będzie wyświetlany tylko na głównej osi czasu, a nie w otwartym pakiecie.

Na głównej osi czasu wyświetlane są:
  • Elementy, w których atrybut isBundleCover ma wartość true.
  • Produkty, które nie mają atrybutu bundleId
Na osi czasu pakietu wyświetlane są:
  • Elementy, w których parametr bundleId jest określony ORAZ isBundleCover jest ustawiony na false
z możliwością zapisu
location nested object Położenie geograficzne powiązane z tym elementem. z możliwością zapisu
notification nested object Określa sposób wyświetlania na urządzeniu powiadomień dotyczących tego elementu. W przypadku jego braku powiadomienie nie zostanie wygenerowane. z możliwością zapisu
notification.deliveryTime datetime Godzina dostarczenia powiadomienia. z możliwością zapisu
notification.level string Określa, jak ważne jest powiadomienie. Dozwolone wartości to:
  • DEFAULT – powiadomienia o domyślnej ważności. Usłyszysz sygnał dźwiękowy, który będzie ostrzegać użytkowników.
 z możliwością zapisu
recipients[] list Lista użytkowników lub grup, którym udostępniono ten element. z możliwością zapisu
sourceItemId string Nieprzezroczysty ciąg znaków, którego możesz używać do zmapowania elementu osi czasu na dane w swojej usłudze. z możliwością zapisu
speakableText string Wypowiadająca się na głos wersja zawartości tego elementu. W tym polu oprócz pozycji menu READ_ALOUD możesz podać tekst, który będzie wyraźniejszy podczas czytania na głos, lub podać rozszerzone informacje o tym, co jest wyświetlane na ekranie Google Glass.

Glassware powinien też zawierać pole speechableType, które będzie odczytywane przed tym tekstem w przypadkach, gdy dodatkowy kontekst jest przydatny, na przykład gdy użytkownik zażąda odczytania elementu na głos po powiadomieniu.
 z możliwością zapisu
speakableType string Mówiony opis typu elementu. Jest to sygnalizowane użytkownikowi przed przeczytaniem treści produktu w przypadkach, gdy przydatny jest dodatkowy kontekst, np. gdy użytkownik poprosi o przeczytanie elementu na głos po powiadomieniu.

To powinno być krótkie, proste wyrażenie, np. „E-mail”, „SMS” lub „Codzienne aktualności na temat planety”.

Zalecamy, aby w przypadku wszystkich elementów osi czasu wypełnić to pole dla oprogramowania Glassware, nawet jeśli nie zawiera on tekstu SayableText ani tekstu, dzięki czemu użytkownik może poznać typ elementu bez patrzenia na ekran.		 z możliwością zapisu
text string Zawartość tekstowa tego elementu. z możliwością zapisu
title string Tytuł tego produktu. z możliwością zapisu

Odpowiedź

Jeśli operacja się uda, metoda zwróci zasób na 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 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 w Pythonie.

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

Przeczytaj

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