Timeline.attachments: insert

Adds a new attachment to a timeline item. See an example.

This method supports an /upload URI and accepts uploaded media with the following characteristics:

Maximum file size: 10MB
Accepted Media MIME types: image/* , audio/* , video/*

Request

HTTP request

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

Parameters

Parameter name	Value	Description
Path parameters
`itemId`	`string`	The ID of the timeline item the attachment belongs to.
Required query parameters
`uploadType`	`string`	The type of upload request to the /upload URI. Acceptable values are: `media` - Simple upload. Upload the media data. `resumable` - Resumable upload. Upload the file in a resumable fashion, using a series of at least two requests.

Authorization

This request requires authorization with the following scope (read more about authentication and authorization).

Scope
`https://www.googleapis.com/auth/glass.timeline`

Request body

Do not supply a request body with this method.

Response

If successful, this method returns a Timeline.attachments resource in the response body.

Examples

Note: The code examples available for this method do not represent all supported programming languages (see the client libraries page for a list of supported languages).

Java

Uses the Java client library.

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

Uses the .NET client library.

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

Uses the PHP client library.

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

Uses the Python client library.

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

Uses the Ruby client library.

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

Raw HTTP

Does not use a client library.

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

Timeline.attachments: insert Stay organized with collections Save and categorize content based on your preferences.