Timeline: update

Nécessite une autorisation

Met à jour un élément de chronologie. 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:audio/* , image/* , video/*

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 : 
    PUT https://www.googleapis.com/upload/mirror/v1/timeline/id
  • URI des métadonnées, pour les requêtes ne contenant que des métadonnées : 
    PUT https://www.googleapis.com/mirror/v1/timeline/id

Paramètres

Nom du paramètre Valeur Description
Paramètres de chemin d'accès
id string ID de l'élément de la timeline.
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.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

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

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

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

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

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

N'utilise pas de bibliothèque cliente.

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