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