Timeline: insert

Autorisation requise

Insère un nouvel élément dans la timeline. Voir un exemple.

Cette méthode accepte un URI /upload et les fichiers multimédias importés présentant les caractéristiques suivantes:

  • Taille maximale du fichier:10 Mo
  • Types MIME de médias acceptés: image/* , audio/* , video/*

S'il est fourni, le contenu multimédia importé est inséré en tant que pièce jointe dans l'élément de la timeline.

Requête

Requête HTTP

Cette méthode fournit une fonctionnalité d'importation de fichiers multimédias via deux URI distincts. Pour en savoir plus, consultez le document sur l'importation de fichiers multimédias.

  • URI d'importation pour les requêtes d'importation de médias: 
    POST https://www.googleapis.com/upload/mirror/v1/timeline
  • URI de métadonnées, pour les requêtes ne contenant que des métadonnées: 
    POST https://www.googleapis.com/mirror/v1/timeline

Paramètres

Nom du paramètre Valeur Description
Paramètres de requête requis
uploadType string Type de requête d'importation pour l'URI /upload. Les valeurs acceptables sont les suivantes: <ph type="x-smartling-placeholder">
    </ph>
  • media : importation simple. Importez uniquement le contenu multimédia, sans métadonnées.
  • multipart : importation en plusieurs parties. Importez à la fois le contenu multimédia et ses métadonnées en une seule requête.
  • resumable : importation avec reprise. Importez le fichier en utilisant une méthode avec reprise, à l'aide d'une série d'au moins deux requêtes, la première incluant les métadonnées.

Autorisation

Une autorisation est requise pour cette requête. Celle-ci doit inclure au moins l'un des champs d'application suivants. En savoir plus sur le processus d'authentification et d'autorisation

Champ d'application
https://www.googleapis.com/auth/glass.timeline
https://www.googleapis.com/auth/glass.location

Corps de la requête

Dans le corps de la requête, indiquez une ressource Timeline avec les propriétés suivantes comme métadonnées. Pour en savoir plus, consultez le document sur l'importation de fichiers multimédias.

Nom de propriété Valeur Description Remarques
Propriétés facultatives
bundleId string ID du bundle de cet article. Les services peuvent spécifier un bundleId pour regrouper plusieurs éléments. Elles apparaissent sous un seul élément de premier niveau sur l'appareil. accessible en écriture
canonicalUrl string URL canonique pointant vers la version canonique/de haute qualité des données représentées par l'élément de la timeline. accessible en écriture
creator nested object Utilisateur ou groupe qui a créé cet élément. accessible en écriture
displayTime datetime Heure à afficher lors de l'affichage de cet élément dans la chronologie, au format conforme à la norme RFC 3339. La chronologie de cet utilisateur est triée chronologiquement en fonction de l'heure d'affichage. Cela détermine donc l'endroit où l'élément est affiché dans la chronologie. Si elle n'est pas définie par le service, elle est définie par défaut sur updated. accessible en écriture
html string Contenu HTML pour cet élément. Si text et html sont fournis pour un élément, html est affiché dans la timeline.

Éléments HTML autorisés : vous pouvez utiliser ces éléments dans vos fiches chronologiques.

  • En-têtes: h1, h2, h3, h4, h5, h6
  • Images: img
  • Listes: li, ol, ul
  • Sémantique HTML5: article, aside, details, figure, figcaption, footer, header, nav, section, summary, time
  • Structure: blockquote, br, div, hr, p, span
  • Style: b, big, center, em, i, u, s, small, strike, strong, style, sub, sup
  • Tables: table, tbody, td, tfoot, th, thead, tr

Éléments HTML bloqués: ces éléments et leur contenu sont supprimés des charges utiles HTML.

  • En-têtes du document: head, title
  • Contenu intégré: audio, embed, object, source, video
  • Images: frame, frameset
  • Script: applet, script

Autres éléments: tous les éléments non listés sont supprimés, mais leur contenu est conservé.

 accessible en écriture
isBundleCover boolean Indique s'il s'agit d'une couverture d'offre groupée.

Si un article est marqué comme couverture pour un lot, il s'agit du point d'entrée du lot qui possède le même bundleId que cet article. Il ne s'affichera que dans la timeline principale, et non dans le bundle ouvert.

Dans la chronologie principale, les éléments affichés sont les suivants:
  • Éléments pour lesquels isBundleCover est défini sur true
  • Éléments qui n'ont pas de bundleId
Dans un sous-calendrier de groupe, les éléments affichés sont les suivants:
  • Éléments pour lesquels bundleId est concerné ET isBundleCover défini sur false
accessible en écriture
location nested object Zone géographique associée à cet élément. accessible en écriture
notification nested object Contrôle la façon dont les notifications pour cet élément sont présentées sur l'appareil. Si ce champ n'est pas renseigné, aucune notification ne sera générée. accessible en écriture
notification.deliveryTime datetime Heure à laquelle la notification doit être envoyée. accessible en écriture
notification.level string Décrit l'importance de la notification. Valeurs autorisées:
  • DEFAULT : notifications d'importance par défaut. Un signal sonore est émis pour alerter les utilisateurs.
 accessible en écriture
recipients[] list Liste des utilisateurs ou des groupes avec lesquels cet élément a été partagé. accessible en écriture
sourceItemId string Chaîne opaque que vous pouvez utiliser pour mapper un élément de la chronologie avec les données de votre propre service. accessible en écriture
speakableText string Version prononçable du contenu de cet élément. En plus de l'élément de menu READ_ALOUD, utilisez ce champ pour fournir un texte plus clair à lire à voix haute ou pour fournir des informations détaillées sur ce qui s'affiche visuellement sur les lunettes Glass.

Glassware doit également spécifier le champ "SpeakableType", qui sera prononcé avant ce texte si le contexte supplémentaire est utile, par exemple lorsque l'utilisateur demande que l'élément soit lu à voix haute après une notification.
 accessible en écriture
speakableType string Description prononçable du type de cet élément. Cette information est annoncée à l'utilisateur avant la lecture du contenu de l'élément si le contexte supplémentaire est utile, par exemple lorsqu'il demande à ce que l'élément soit lu à voix haute après une notification.

Il doit s'agir d'un nom court et simple tel que "Email", "Text message" ou "Daily Planet News Update".

Glassware est invité à renseigner ce champ pour chaque élément de la chronologie, même s'il ne contient pas de texte prononçable ni de texte, afin que l'utilisateur puisse apprendre le type de l'élément sans regarder l'écran.		 accessible en écriture
text string Contenu textuel de cet élément. accessible en écriture
title string Titre de cet élément. accessible en écriture

Réponse

Lorsque cette méthode fonctionne, elle renvoie une ressource Timeline dans le corps de réponse.

Exemples

Remarque : Les langages de programmation compatibles ne figurent pas tous dans les exemples de code présentés pour cette méthode (consultez la page Bibliothèques clientes pour obtenir la liste des langages compatibles).

Java

Elle utilise la bibliothèque cliente 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

Elle utilise la bibliothèque cliente.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

Elle utilise la bibliothèque cliente 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

Elle utilise la bibliothèque cliente 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

Elle utilise la bibliothèque cliente 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

Elle utilise la bibliothèque cliente 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 brut

N'utilise pas de bibliothèque cliente.

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