Timeline: update

Richiede l'autorizzazione

Consente di aggiornare un elemento della sequenza temporale attivo. 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: audio/* , image/* , video/*

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: 
    PUT https://www.googleapis.com/upload/mirror/v1/timeline/id
  • URI metadati, per richieste solo di metadati: 
    PUT https://www.googleapis.com/mirror/v1/timeline/id

Parametri

Nome del parametro Valore Descrizione
Parametri percorso
id string L'ID dell'elemento della sequenza temporale.
Parametri di ricerca 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 delle notifiche per questo elemento sul dispositivo. 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.services.mirror.Mirror;
import com.google.api.services.mirror.model.NotificationConfig;
import com.google.api.services.mirror.model.TimelineItem;

import java.io.IOException;

public class MyClass {
  // ...

  /**
   * Update a timeline item in the user's Glass with an optional notification and attachment.
   * 
   * @param service Authorized Mirror service.
   * @param itemId ID of the timeline item to update.
   * @param newText timeline item's text.
   * @param newNotificationLevel Optional notification level, supported values
   *        are {@code null} and "AUDIO_ONLY".
   * @return Updated timeline item on success, {@code null} otherwise.
   */
  public static TimelineItem updateTimelineItem(Mirror service, String itemId, String newText,
      String newNotificationLevel) {
    try {
      // First retrieve the timeline item from the API.
      TimelineItem timelineItem = service.timeline().get(itemId).execute();
      // Update the timeline item's metadata.
      timelineItem.setText(newText);
      if (newNotificationLevel != null && newNotificationLevel.length() > 0) {
        timelineItem.setNotification(new NotificationConfig().setLevel(newNotificationLevel));
      } else {
        timelineItem.setNotification(null);
      }
      return service.timeline().update(itemId, 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>
  /// Update a timeline item in the user's Glass with an optional
  /// notification and attachment.
  /// </summary>
  /// <param name='service'>Authorized Mirror service.</param>
  /// <param name='itemId'>ID of the timeline item to update.</param>
  /// <param name='newText'>Timeline Item's text content.</param>
  /// <param name='newNotificationLevel'>
  /// Optional notification level, supported values are null and
  /// "AUDIO_ONLY".
  /// </param>
  /// <returns>
  /// Updated timeline item on success, null otherwise.
  /// </returns>
  public static TimelineItem UpdateTimelineItem(MirrorService service,
      String itemId, String newText, String newNotificationLevel) {
    try {
      // First retrieve the timeline item from the API.
      TimelineItem timelineItem = service.Timeline.Get(itemId).Fetch();
      // Update the timeline item's metadata.
      timelineItem.Text = newText;
      if (!String.IsNullOrEmpty(newNotificationLevel)) {
        timelineItem.Notification = new NotificationConfig() {
          Level = newNotificationLevel
        };
      } else {
        timelineItem.Notification = null;
      }
      return service.Timeline.Update(timelineItem, itemId).Fetch();
    } catch (Exception e) {
      Console.WriteLine("An error occurred: " + e.Message);
      return null;
    }
  }

  // ...
}

PHP

Utilizza la libreria client PHP.

/**
 * Update a timeline item in the user's Glass with an optional
 * notification and attachment.
 *
 * @param Google_MirrorSservice $service Authorized Mirror service.
 * @param string $itemId ID of the timeline item to update.
 * @param string $newText timeline item's text (can be HTML content).
 * @param string $newNotificationLevel Optional notification level,
 *               supported values are {@code null} and "AUDIO_ONLY".
 * @return Google_TimelineItem Updated timeline item on success,
 *         null otherwise.
 */
function updateTimelineItem($service, $itemId, $newText, $newNotificationLevel) {
  try {
    $timelineItem = $service->timeline->get($itemId);
    $timelineItem->setText($newText);
    if ($notificationlevel != null) {
      $notification = new Google_NotificationConfig();
      $notification->setLevel($newNotificationLevel);
      $timelineItem->setNotification($notification);
    } else {
      $timelineItem->setNotification(null);
    }
    return $service->timeline->update($itemId, $timelineItem);
  } 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 update_timeline_item(service, item_id, new_text, 
                         new_notification_level=None):
  """Update a timeline item in the user's Glass.

  Args:
    service: Authorized Mirror service.
    item_id: ID of the timeline item to update.
    new_text: Timeline item's text (can be HTML content).
    new_content_type: Optional attachment's content type (supported content
                      types are 'image/*', 'video/*' and 'audio/*').
    new_attachment: Optional attachment as data string.
    new_notification_level: Optional notification level, supported values are
                            None and 'AUDIO_ONLY'.
  Returns:
    Updated timeline item on success, None otherwise.
  """
  try:
    # First retrieve the timeline item from the API.
    timeline_item = service.timeline().get(id=item_id).execute()
    # Update the timeline item's metadata.
    timeline_item['text'] = new_text
    if new_notification_level:
      timeline_item['notification'] = {'level': new_notification_level}
    elif 'notification' in timeline_item:
      timeline_item.pop('notification')
    return service.timeline().update(id=item_id, body=timeline_item).execute()
  except errors.HttpError, error:
    print 'An error occurred: %s' % error
    return None

Ruby

Utilizza la libreria client Ruby.

##
# Update a timeline item in the user's glass.
#
# @param [Google::APIClient] client
#   Authorized client instance.
# @param [String] item_id
#   ID of the timeline item to update.
# @param [String] new_text
#   Timeline item's new text.
# @param [String] new_notification_level
#   Optional new notification level, supported values are nil and 'AUDIO_ONLY'.
# @return [Google::APIClient::Schema::Mirror::V1::TimelineItem]
#   Updated timeline item instance if successful, nil otherwise.
def update_timeline_item(client, item_id, new_text, new_notification_level)
  mirror = client.discovered_api('mirror', 'v1')
  result = client.execute(
    :api_method => mirror.timeline.get,
    :parameters => { 'id' => item_id })
  if result.success?
    timeline_item = result.data
    timeline_item.text = new_text
    if new_notification_level
      timeline_item.notification = { 'level' => new_notification_level }
    else
      timeline_item.notification = nil
    end
    result = client.execute(
      :api_method => mirror.timeline.update,
      :body_object => timeline_item,
      :parameters => { 'id' => item_id })
    if result.success?
      return result.data
    end
  end
  puts "An error occurred: #{result.data['error']['message']}"
end

Vai

Utilizza la libreria client Go.

import (
	"code.google.com/p/google-api-go-client/mirror/v1"
	"fmt"
)

// UpdateTimelineItem updates a timeline item in the user's timeline with an
// optional notification and attachment.
func UpdateTimelineItem(g *mirror.Service, itemId string, newNotificationLevel string) (
	*mirror.TimelineItem, error) {
	t, err := g.Timeline.Get(itemId).Do()
	if err != nil {
		fmt.Printf("An error occurred: %v\n", err)
		return nil, err
	}
	t.Text = newText
	if newNotificationLevel != "" {
		t.Notification = &mirror.NotificationConfig{Level: newNotificationLevel}
	} else {
		t.Notification = nil
	}
	r, err := g.Timeline.Update(itemId, t).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.

PUT /mirror/v1/timeline/timeline item id HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer auth token
Content-Type: application/json
Content-Length: 26

{ "text": "Hello world" }