Richiede l'autorizzazione
Viene aggiornato un elemento della 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:
audio/*
,image/*
,video/*
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:
PUT https://www.googleapis.com/upload/mirror/v1/timeline/id
- URI metadati, per richieste solo metadati:
PUT https://www.googleapis.com/mirror/v1/timeline/id
Parametri
Nome del parametro | Valore | Descrizione |
---|---|---|
Parametri percorso | ||
id |
string |
L'ID della voce della sequenza temporale. |
Parametri di ricerca obbligatori | ||
uploadType |
string |
Il tipo di richiesta di caricamento per l'URI /upload.
I valori accettabili sono:
|
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.
Elementi HTML bloccati: questi elementi e i relativi contenuti vengono rimossi dai payload HTML.
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:
|
scrivibile |
location |
nested object |
La posizione geografica associata a questo elemento. | scrivibile |
menuItems[] |
list |
Un elenco di voci del menu che verranno presentate all'utente quando viene selezionato nella sequenza temporale. | scrivibile |
menuItems[].action |
string |
Consente di controllare il comportamento quando l'utente seleziona l'opzione di menu. I valori consentiti sono:
|
scrivibile |
menuItems[].id |
string |
L'ID di questa voce di menu. Viene generato dall'applicazione e considerato come un token opaco. | scrivibile |
menuItems[].payload |
string |
Un payload generico il cui significato cambia a seconda dell'azione di questo elemento del menu.
|
scrivibile |
menuItems[].removeWhenSelected |
boolean |
Se viene impostato su true in una voce di menu di CUSTOM , quest'ultima viene rimossa dal menu dopo essere selezionata. |
scrivibile |
menuItems[].values[] |
list |
Per le voci CUSTOM , un elenco di valori che controllano l'aspetto della voce di menu in ciascuno dei relativi stati. È necessario fornire un valore per lo stato DEFAULT . Gli stati PENDING o CONFIRMED mancanti non verranno mostrati. |
scrivibile |
menuItems[].values[].displayName |
string |
Il nome da visualizzare per la voce di menu. Se specifichi questa proprietà per una voce di menu integrata, il comando vocale contestuale predefinito per tale voce di menu non viene visualizzato. | scrivibile |
menuItems[].values[].iconUrl |
string |
URL di un'icona da visualizzare con la voce di menu. | scrivibile |
menuItems[].values[].state |
string |
Lo stato a cui si applica questo valore. I valori consentiti sono:
|
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:
|
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.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 di.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 di 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 di 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 di 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
Go
Utilizza la libreria client di 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" }