Timeline: insert

Richiede l'autorizzazione

Inserisce un nuovo elemento nella sequenza temporale. Vedi un esempio.

Questo metodo supporta un URI /upload e accetta contenuti multimediali caricati con le seguenti caratteristiche:

  • Dimensione massima del file: 10 MB
  • Tipi MIME multimediali accettati: image/* , audio/* , video/*

Se specificato, i contenuti multimediali caricati vengono inseriti come allegati all'elemento della sequenza temporale.

Richiesta

Richiesta HTTP

Questo metodo fornisce la funzionalità di caricamento di contenuti multimediali tramite due URI separati. Per ulteriori dettagli, consulta il documento sul caricamento di contenuti multimediali.

  • URI di caricamento, per le richieste di caricamento di contenuti multimediali: 
    POST https://www.googleapis.com/upload/mirror/v1/timeline
  • URI metadati, per richieste solo di metadati: 
    POST https://www.googleapis.com/mirror/v1/timeline

Parametri

Nome del parametro Valore Descrizione
Parametri di query obbligatori
uploadType string Il tipo di richiesta di caricamento nell'URI /upload. I valori accettati sono:
  • media - Caricamento semplice. Carica solo i contenuti multimediali, senza metadati.
  • multipart - Caricamento multiparte. Caricare sia i contenuti multimediali sia i relativi metadati in un'unica richiesta.
  • resumable - Caricamento ripristinabile. Carica il file in modo ripristinabile, utilizzando una serie di almeno due richieste in cui la prima include i metadati.

Autorizzazione

Questa richiesta richiede l'autorizzazione con almeno uno dei seguenti ambiti (scopri di più su autenticazione e autorizzazione).

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

Corpo della richiesta

Nel corpo della richiesta, fornisci una risorsa Spostamenti con le seguenti proprietà come metadati. Per ulteriori informazioni, consulta il documento sul caricamento di contenuti multimediali.

Nome proprietà Valore Descrizione Note
Proprietà facoltative
bundleId string L'ID pacchetto di questo articolo. I servizi possono specificare un bundleId per raggruppare molti elementi. Vengono visualizzati in un singolo elemento di primo livello sul dispositivo. accessibile in scrittura
canonicalUrl string Un URL canonico che rimanda alla versione canonica/di alta qualità dei dati rappresentati dall'elemento della sequenza temporale. accessibile in scrittura
creator nested object L'utente o il gruppo che ha creato questo elemento. accessibile in scrittura
displayTime datetime L'ora che dovrebbe essere indicata quando l'elemento viene visualizzato nella sequenza temporale, formattato in base a RFC 3339. La sequenza temporale di questo utente è ordinata cronologicamente in base al tempo di visualizzazione, in questo modo verrà stabilito anche dove viene visualizzato l'elemento nella sequenza temporale. Se non è impostato dal servizio, per impostazione predefinita il tempo di visualizzazione è updated. accessibile in scrittura
html string Contenuti HTML per questo elemento. Se per un elemento vengono forniti sia text sia html, nella sequenza temporale verrà visualizzato html.

Elementi HTML consentiti: puoi utilizzare questi elementi nelle schede della sequenza temporale.

  • Intestazioni: h1, h2, h3, h4, h5, h6
  • Immagini: img
  • Elenchi: li, ol, ul
  • Semantica HTML5: article, aside, details, figure, figcaption, footer, header, nav, section, summary, time
  • Strutturale: blockquote, br, div, hr, p, span
  • Stile: b, big, center, em, i, u, s, small, strike, strong, style, sub, sup
  • Tabelle: table, tbody, td, tfoot, th, thead, tr

Elementi HTML bloccati: questi elementi e i relativi contenuti vengono rimossi dai payload HTML.

  • Intestazioni dei documenti: head, title
  • Incorporamenti: audio, embed, object, source, video
  • Cornici: frame, frameset
  • Esecuzione script: applet, script

Altri elementi: tutti gli elementi non elencati vengono rimossi, ma i relativi contenuti vengono conservati.

 accessibile in scrittura
isBundleCover boolean Se l'articolo è una copertina in bundle.

Se un elemento è contrassegnato come copertina in bundle, sarà il punto di accesso al gruppo di articoli che hanno gli stessi bundleId dell'articolo. Verrà mostrato solo sulla sequenza temporale principale, non all'interno del bundle aperto.

Nella sequenza temporale principale, gli elementi visualizzati sono:
  • Elementi con isBundleCover impostato su true
  • Elementi senza bundleId
In una sottosequenza temporale di un bundle, gli elementi visualizzati sono:
  • Elementi con bundleId in questione E isBundleCover impostati su false
accessibile in scrittura
location nested object La posizione geografica associata a questo elemento. accessibile in scrittura
notification nested object Consente di controllare la modalità di presentazione sul dispositivo delle notifiche per questo elemento. Se manca, non verrà generata alcuna notifica. accessibile in scrittura
notification.deliveryTime datetime L'ora in cui deve essere inviata la notifica. accessibile in scrittura
notification.level string Descrive l'importanza della notifica. I valori consentiti sono:
  • DEFAULT - Notifiche di importanza predefinita. Verrà riprodotto un suono per avvisare gli utenti.
 accessibile in scrittura
recipients[] list Un elenco di utenti o gruppi con cui è stato condiviso questo elemento. accessibile in scrittura
sourceItemId string Stringa opaca che puoi utilizzare per mappare un elemento della sequenza temporale ai dati del tuo servizio. accessibile in scrittura
speakableText string La versione pronunciabile dei contenuti di questo elemento. Insieme alla voce di menu READ_ALOUD, usa questo campo per fornire testo che sarebbe più chiaro se letto ad alta voce o per fornire informazioni estese su ciò che viene visualizzato visivamente su Glass.

Glassware deve anche specificare il campo speakableType, che verrà pronunciato prima di questo testo nei casi in cui il contesto aggiuntivo sia utile, ad esempio quando l'utente richiede che l'elemento venga letto ad alta voce dopo una notifica.
 accessibile in scrittura
speakableType string Una descrizione pronunciabile del tipo di questo elemento. Questo verrà annunciato all'utente prima di leggere il contenuto dell'elemento nei casi in cui il contesto aggiuntivo sia utile, ad esempio quando l'utente richiede che l'elemento venga letto ad alta voce dopo una notifica.

Deve essere una frase nome breve e semplice, come "Email", "SMS" o "Aggiornamento giornaliero sul pianeta".

Ti consigliamo di compilare questo campo per Glassware per ogni elemento della sequenza temporale, anche se l'elemento non contiene speakableText o testo, in modo che l'utente possa conoscere il tipo di elemento senza guardare lo schermo.		 accessibile in scrittura
text string Contenuti testuali di questo elemento. accessibile in scrittura
title string Il titolo di questo elemento. accessibile in scrittura

Risposta

In caso di esito positivo, questo metodo restituisce una risorsa Spostamenti nel corpo della risposta.

Esempi

Nota: gli esempi di codice disponibili per questo metodo non rappresentano tutti i linguaggi di programmazione supportati (consulta la pagina relativa alle librerie client per un elenco dei linguaggi supportati).

Java

Utilizza la libreria client 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

Utilizza la libreria client.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

Utilizza la libreria client 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

Utilizza la libreria client 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

Utilizza la libreria client 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

Vai

Utilizza la libreria client 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 non elaborato

Non utilizza una libreria client.

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