Timeline.attachments: insert

Richiede l'autorizzazione

Aggiunge un nuovo allegato a un elemento della 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/*

Risorse richieste:

Richiesta HTTP

POST https://www.googleapis.com/upload/mirror/v1/timeline/itemId/attachments

Parametri

Nome del parametro Valore Descrizione
Parametri percorso
itemId string L'ID dell'elemento della sequenza temporale a cui appartiene l'allegato.
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 il seguente ambito (scopri di più su autenticazione e autorizzazione).

Ambito
https://www.googleapis.com/auth/glass.timeline

Corpo della richiesta

Non fornire un corpo della richiesta con questo metodo.

Risposta

In caso di esito positivo, questo metodo restituisce una risorsa Timeline.attachments 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.Attachment;

import java.io.IOException;
import java.io.InputStream;

public class MyClass {
  // ...

  /**
   * Insert a new attachment for the specified timeline item.
   * 
   * @param service Authorized Mirror service.
   * @param itemId ID of the timeline item to insert attachment for.
   * @param contentType Attachment's content type (supported content types are
   *        "image/*", "video/*", "audio/*").
   * @param attachment Attachment to insert.
   * @return Attachment's metadata on success, {@code null} otherwise.
   */
  public static Attachment insertAttachment(Mirror service, String itemId, String contentType,
      InputStream attachment) {
    try {
      InputStreamContent mediaContent = new InputStreamContent(contentType, attachment);
      return service.timeline().attachments().insert(itemId, mediaContent).execute();
    } catch (IOException e) {
      // An error occurred.
      e.printStackTrace();
      return null;
    }
  }

  // ...
}

.NET

Utilizza la libreria client di.NET.

using System;
using Google.Apis.Mirror.v1;
using Google.Apis.Mirror.v1.Data;
using System.IO;

public class MyClass {
  // ...

  /// <summary>
  /// Insert a new attachment for the specified timeline item.
  /// </summary>
  /// <param name="service">Authorized Mirror service.</param>
  /// <param name="itemId">ID of the timeline item to insert attachment for.</param>
  /// <param name="contentType">
  /// Attachment's content type (supported content types are "image/*", "video/*", "audio/*").
  /// </param>
  /// <param name="stream">Attachment to insert.</param>
  /// <returns>Attachment's metadata on success, null otherwise.</returns>
  public static Attachment InsertAttachment(
      MirrorService service, String itemId, String contentType, Stream stream) {
    try {
      TimelineResource.AttachmentsResource.InsertMediaUpload request = 
          service.Timeline.Attachments.Insert(itemId, stream, contentType);
      request.Upload();
      return request.ResponseBody;
    } 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 insertAttachment($service, $itemId, $contentType, $attachment) {
  try {
    $params = array(
        'data' => $attachment,
        'mimeType' => $contentType,
        'uploadType' => 'media');
    return $service->timeline_attachments->insert($itemId, $params);
  } catch (Exception $e) {
    print 'An error ocurred: ' . $e->getMessage();
    return null;
  }
}

Python

Utilizza la libreria client di Python.

from apiclient import errors
# ...

def insert_attachment(service, item_id, content_type, attachment):
  """Insert an new attachment for the specified timeline item.

  Args:
    service: Authorized Mirror service.
    item_id: ID of the timeline item to insert attachment for.
    content_type: Attachment's content type (supported content types are
                  'image/*', 'video/*' and 'audio/*').
    attachment: Attachment to insert as data string.
  Returns:
    Attachment's metadata on success, None otherwise.
  """
  try:
    media_body = MediaIoBaseUpload(
        io.BytesIO(attachment), mimetype=content_type, resumable=True)
    return service.timeline().attachments().insert(
        itemId=item_id, media_body=media_body).execute()
  except errors.HttpError, error:
    print 'An error occurred: %s' % error
    return None

Ruby

Utilizza la libreria client di Ruby.

##
# Insert an new attachment for the specified timeline item.
#
# @param [Google::APIClient] client
#   Authorized client instance.
# @param [String] item_id
#   ID of the timeline item to insert attachment for.
# @param [String] content_type
#   Attachment's content type (supported content types are 'image/*', 'video/*'
#   and 'audio/*').
# @param [String] filename
#   Attachment's filename.
# @return [Google::APIClient::Schema::Mirror::V1::Attachment]
#   Attachment's metadata on success, nil otherwise.
def insert_attachment(client, item_id, content_type, filename)
  mirror = client.discovered_api('mirror', 'v1')
  media = Google::APIClient::UploadIO.new(filename, content_type)
  result = client.execute(
    :api_method => mirror.timeline.attachments.insert,
    :media => media,
    :parameters => {
      'itemId' => item_id,
      'uploadType' => 'resumable',
      'alt' => 'json'})
  if result.success?
    return result.data
  else
    puts "An error occurred: #{result.data['error']['message']}"
  end
end

HTTP non elaborato

Non utilizza una libreria client.

POST /upload/mirror/v1/timeline/timeline item id/attachments?uploadType=media HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer auth token
Content-Type: media content type
Content-Length: media content length

media bytes