Timeline: update

Autorisation requise

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

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:
    PUT https://www.googleapis.com/upload/mirror/v1/timeline/id
  • URI de 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 chronologie.
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 avertir 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 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 pouvant être énoncé 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.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

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

Elle 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

Elle 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

Elle 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

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