Timeline: insert

Richiede l'autorizzazione

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

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

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

Se fornito, il contenuto multimediale caricato viene inserito come allegato nell'elemento della sequenza temporale.

Risorse richieste:

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 metadati: 
    POST https://www.googleapis.com/mirror/v1/timeline

Parametri

Nome del parametro Valore Descrizione
Parametri di ricerca obbligatori
uploadType string Il tipo di richiesta di caricamento per l'URI /upload. I valori accettabili sono:
  • media - Caricamento semplice. Carica solo i contenuti multimediali, senza metadati.
  • multipart - Caricamento a più parti. Carica 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 richiesta 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 della sequenza temporale 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 bundle di questo articolo. I servizi possono specificare un bundleId per raggruppare molti elementi. Vengono visualizzati in corrispondenza di un singolo elemento di primo livello del dispositivo. scrivibile
canonicalUrl string Un URL canonico che rimanda alla versione canonica/di alta qualità dei dati rappresentati dall'elemento della sequenza temporale. scrivibile
creator nested object L'utente o il gruppo che ha creato questo elemento. scrivibile
displayTime datetime L'ora da visualizzare quando questo elemento viene visualizzato nella sequenza temporale, formattato in base alla specifica RFC 3339. La sequenza temporale di questo utente è ordinata in ordine cronologico sul momento della visualizzazione, quindi determinerà anche dove viene visualizzato l'elemento nella sequenza temporale. Se non viene impostato dal servizio, il valore predefinito è updated. scrivibile
html string Contenuti HTML per questo elemento. Se per un elemento vengono specificati sia text sia html, html viene visualizzato nella sequenza temporale.

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 del documento: head, title
  • Incorporamenti: audio, embed, object, source, video
  • Fotogrammi: frame, frameset
  • Script: applet, script

Altri elementi: tutti gli elementi non presenti nell'elenco vengono rimossi, ma i loro contenuti vengono conservati.

 scrivibile
isBundleCover boolean Se questo articolo fa parte di una copertina.

Se un articolo è contrassegnato come pacchetto, sarà il punto di accesso al pacchetto di elementi che hanno lo stesso bundleId di quell'articolo. Verrà mostrato solo nella sequenza temporale principale, non all'interno del pacchetto aperto.

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

Inoltre, è necessario specificare il campo speakableType, che verrà letto prima di questo testo nei casi in cui il contesto aggiuntivo è utile, ad esempio quando l'utente richiede che l'elemento venga letto ad alta voce in seguito a una notifica.
 scrivibile
speakableType string Una descrizione pronunciabile del tipo di questo elemento. Questa comunicazione verrà annunciata all'utente prima di leggere i contenuti 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 in seguito a una notifica.

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

Ti invitiamo a compilare questo campo 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.		 scrivibile
text string Contenuti testuali di questo elemento. scrivibile
title string Il titolo dell'articolo. scrivibile

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 di 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 di .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 di 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 di 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 di 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

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