Timeline: insert

Nécessite une autorisation

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

Cette méthode accepte un URI /upload et accepte les éléments 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 support importé est ajouté en tant que pièce jointe à l'élément de la timeline.

Demande

Requête HTTP :

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

  • URI d'importation, pour les requêtes d'importation de contenus multimédias : 
    POST https://www.googleapis.com/upload/mirror/v1/timeline
  • URI des 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 vers l'URI /upload. Valeurs autorisées :
  • media : importation simple. Importez uniquement le contenu multimédia, sans métadonnées.
  • multipart : importation en plusieurs parties. Importez les contenus multimédias et leurs métadonnées en une seule requête.
  • resumable : importation avec reprise. Importez le fichier de manière réactivable en utilisant une série d'au moins deux requêtes, dont la première comprend 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

Portée
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 de timeline avec les propriétés suivantes comme métadonnées. Pour en savoir plus, consultez le document sur l'importation de contenu multimédia.

Nom de propriété Valeur Description Remarques
Propriétés facultatives
bundleId string ID du bundle pour cet article. Les services peuvent spécifier un bundleId pour regrouper de nombreux éléments. Ils apparaissent sous un seul élément de premier niveau sur l'appareil. accessible en écriture
canonicalUrl string URL canonique renvoyant 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 ayant créé cet élément. accessible en écriture
displayTime datetime Heure à afficher lorsque l'élément est consulté dans la timeline, au format RFC 3339. La chronologie de cet utilisateur est triée de façon chronologique en fonction de sa durée d'affichage. Il détermine donc également où l'élément doit s'afficher dans la chronologie. Si elle n'est pas définie par le service, l'heure d'affichage est définie par défaut sur updated. accessible en écriture
html string Contenu HTML pour cet élément. Si les valeurs text et html sont fournies pour un élément, html s'affiche dans la timeline.

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

  • 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
  • Intégration : audio, embed, object, source, video
  • Cadres : frame, frameset
  • Script : applet, script

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

 accessible en écriture
isBundleCover boolean Indique si cet article est une couverture de lot.

Si un article est marqué comme couverture du lot, il constitue le point d'entrée vers le lot d'éléments ayant le même bundleId que cet élément. Elle s'affichera uniquement sur la timeline principale, pas dans le groupe ouvert.

Sur la chronologie principale, les éléments affichés sont les suivants:
  • Éléments pour lesquels isBundleCover est défini sur true
  • Éléments sans bundleId
Dans un élément de campagne temporelle secondaire, les éléments affichés sont les suivants:
  • Éléments pour lesquels l'élément bundleId en question ET isBundleCover est défini sur false
accessible en écriture
location nested object Emplacement géographique associé à cet élément. accessible en écriture
notification nested object Contrôle la présentation des notifications pour cet élément sur l'appareil. Si ce n'est pas le cas, 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 timeline avec les données de votre propre service. accessible en écriture
speakableText string Version énoncée du contenu de cet élément. À l'aide de l'élément de menu READ_ALOUD, utilisez ce champ pour fournir un texte plus clair pour la lecture à voix haute ou pour fournir des informations plus détaillées sur le contenu affiché sur Google Glass.

Glassware doit également spécifier le champ "talkableType", qui sera lu avant ce texte lorsque 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 Une description vocale du type d'élément Cette information sera annoncée à l'utilisateur avant la lecture du contenu de l'élément 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.

Il doit s'agir d'un nom court et simple tel que "E-mail", "SMS" ou "Actualité Planète quotidienne".

Nous vous invitons à renseigner ce champ pour chaque élément de la chronologie, même si l'élément ne contient ni texte prononcé ni texte, afin que l'utilisateur puisse apprendre à identifier le type d'é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 article. accessible en écriture

Réponse

Lorsque cette méthode fonctionne, elle renvoie une ressource "Timeline" dans le corps de la 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

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

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

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

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

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

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