Halaman ini diterjemahkan oleh Cloud Translation API.

Subscriptions: insert

Memerlukan otorisasi

Membuat langganan baru. Lihat contoh.

Permintaan

Permintaan HTTP

POST https://www.googleapis.com/mirror/v1/subscriptions

Otorisasi

Permintaan ini memerlukan otorisasi dengan cakupan berikut (baca lebih lanjut tentang autentikasi dan otorisasi).

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

Isi permintaan

Dalam isi permintaan, berikan resource Subscription dengan properti berikut:

Nama properti	Nilai	Deskripsi	Catatan
Properti yang Diperlukan
`callbackUrl`	`string`	URL tempat notifikasi akan dikirim (harus diawali dengan `https://`).	dapat ditulis
`collection`	`string`	Koleksi yang akan dijadikan langganan. Nilai yang diizinkan adalah: `timeline` - Perubahan pada linimasa termasuk penyisipan, penghapusan, dan pembaruan. `locations` - Update lokasi. `settings` - Update setelan.	dapat ditulis
Properti Opsional
`operation[]`	`list`	Daftar operasi yang harus diikuti. Daftar kosong menunjukkan bahwa semua operasi pada koleksi harus menjadi langganan. Nilai yang diizinkan adalah: `UPDATE` - Item telah diperbarui. `INSERT` - Item baru telah disisipkan. `DELETE` - Item telah dihapus.	dapat ditulis
`userToken`	`string`	Token buram yang dikirimkan ke pelanggan dalam notifikasi agar dapat menentukan ID pengguna.	dapat ditulis
`verifyToken`	`string`	Token rahasia yang dikirim kepada pelanggan dalam notifikasi agar dapat memverifikasi bahwa notifikasi tersebut dibuat oleh Google.	dapat ditulis

Respons

Jika berhasil, metode ini akan menampilkan resource Subscription dalam isi respons.

Contoh

Catatan: Contoh kode yang tersedia untuk metode ini tidak merepresentasikan semua bahasa pemrograman yang didukung (lihat halaman library klien untuk mengetahui daftar bahasa yang didukung).

Java

Menggunakan library klien Java.

import com.google.api.services.mirror.Mirror;
import com.google.api.services.mirror.model.Subscription;

import java.io.IOException;
import java.util.List;

public class MyClass {
  // ...

  /**
   * Subscribe to notifications for the current user.
   * 
   * @param service Authorized Mirror service.
   * @param collection Collection to subscribe to (supported values are "timeline" and
            "locations").
   * @param userToken Opaque token used by the Glassware to identify the user
   *        the notification pings are sent for (recommended).
   * @param verifyToken Opaque token used by the Glassware to verify that the
   *        notification pings are sent by the API (optional).
   * @param callbackUrl URL receiving notification pings (must be HTTPS).
   * @param operation List of operations to subscribe to. Valid values are
   *        "UPDATE", "INSERT" and "DELETE" or {@code null} to subscribe to all.
   */
  public static void subscribeToNotifications(Mirror service, String collection, String userToken,
      String verifyToken, String callbackUrl, List<String> operation) {
    Subscription subscription = new Subscription();
    subscription.setCollection(collection).setUserToken(userToken).setVerifyToken(verifyToken)
        .setCallbackUrl(callbackUrl).setOperation(operation);
    try {
      service.subscriptions().insert(subscription).execute();
    } catch (IOException e) {
      System.err.println("An error occurred: " + e);
    }
  }

  // ...
}

.NET

Menggunakan library klien.NET.

using System;
using System.Collections.Generic;

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

public class MyClass {
  // ...

  /// <summary>
  /// Subscribe to notifications for the current user.
  /// </summary>
  /// <param name='service'>Authorized Mirror service.</param>
  /// <param name='collection'>
  /// Collection to subscribe to (supported values are "timeline" and
  /// "locations").
  /// </param>
  /// <param name='userToken'>
  /// Opaque token used by the Glassware to identify the user the
  /// notification pings are sent for (recommended).
  /// </param>
  /// <param name='verifyToken'>
  /// Opaque token used by the Glassware to verify that the notification
  /// pings are sent by the API (optional).
  /// </param>
  /// <param name='callbackUrl'>
  /// URL receiving notification pings (must be HTTPS).
  /// </param>
  /// <param name='operation'>
  /// List of operations to subscribe to. Valid values are "UPDATE", "INSERT"
  /// and "DELETE" or {@code null} to subscribe to all.
  /// </param>
  public static void SubscribeToNotifications(MirrorService service,
      String collection, String userToken, String verifyToken,
      String callbackUrl, List<String> operation) {
    Subscription subscription = new Subscription() {
      Collection = collection,
      UserToken = userToken,
      VerifyToken = verifyToken,
      CallbackUrl = callbackUrl,
      Operation = operation
    };
    try {
      service.Subscriptions.Insert(subscription).Fetch();
    } catch (Exception e) {
      Console.WriteLine("An error occurred: " + e.Message);
    }
  }

  // ...
}

PHP

Menggunakan library klien PHP.

/**
 * Subscribe to notifications for the current user.
 *
 * @param Google_MirrorService $service Authorized Mirror service.
 * @param string $collection Collection to subscribe to (supported
 *                           values are "timeline" and "locations").
 * @param string $userToken Opaque token used by the Service to
 *                          identify the  user the notification pings
 *                          are sent for (recommended).
 * @param string $verifyToken Opaque token used by the Service to verify
 *                            that the notification pings are sent by
 *                            the API (optional).
 * @param string $callbackUrl URL receiving notification pings (must be HTTPS).
 * @param Array $operation List of operations to subscribe to. Valid values
 *                         are "UPDATE", "INSERT" and "DELETE" or
 *                         null to subscribe to all.
 */
function subscribeToNotifications($service, $collection, $userToken,
     $verifyToken, $callbackUrl, $operation) {
  try {
    $subscription = new Google_Subscription();
    $subscription->setCollection($collection);
    $subscription->setUserToken($userToken);
    $subscription->setVerifyToken($verifyToken);
    $subscription->setCallbackUrl($callbackUrl);
    $subscription->setOperation($operation);
    $service->subscriptions->insert($subscription);
  } catch (Exception $e) {
    print 'An error occurred: ' . $e->getMessage();
  }
}

Python

Menggunakan library klien Python.

from apiclient import errors
# ...

def subscribe_to_notifications(service, collection, user_token, verify_token,
                               callback_url, operation):
  """Subscribe to notifications for the current user.

  Args:
    service: Authorized Mirror service.
    collection: Collection to subscribe to (supported values are "timeline"
                and "locations").
    user_token: Opaque token used by the Glassware to identify the user the
                notification pings are sent for (recommended).
    verify_token: Opaque token used by the Glassware to verify that the
                  notification pings are sent by the API (optional).
    callback_url: URL receiving notification pings (must be HTTPS).
    operation: List of operations to subscribe to. Valid values are "UPDATE",
               "INSERT" and "DELETE" or None to subscribe to all.
  """
  subscription = {
      'collection': collection,
      'userToken': user_token,
      'verifyToken': verify_token,
      'callbackUrl': callback_url,
      'operation': operation
   }
  try:
    service.subscriptions().insert(body=subscription).execute()
  except errors.HttpError, error:
    print 'An error occurred: %s' % e

Ruby

Menggunakan library klien Ruby.

##
# Subscribe to notifications for the current user.
#
# @param [Google::APIClient] client
#   Authorized client instance.
# @param [String] collection
#   Collection to subscribe to (supported values are "timeline" and "locations").
# @param [String] user_token
#   Opaque token used by the Glassware to identify the user the notification
#   pings are sent for (recommended).
# @param [String] verify_token
#   Opaque token used by the Glassware to verify that the notification pings are
#   sent by the API (optional).
# @param [String] callback_url
#   URL receiving notification pings (must be HTTPS).
# @param [Array] operation
#   List of operations to subscribe to. Valid values are "UPDATE", "INSERT" and
#   "DELETE" or nil to subscribe to all.
# @return nil
def subscribe_to_notification(client, collection, user_token, verify_token,
                              callback_url, operation)
  mirror = client.discovered_api('mirror', 'v1')
  subscription = mirror.subscriptions.insert.request_schema.new({
    'collection' => collection,
    'userToken' => user_token,
    'verifyToken' => verify_token,
    'callbackUrl' => callback_url,
    'operation' => operation})
  result = client.execute(
    :api_method => mirror.subscriptions.insert,
    :body_object => subscription)
  if result.error?
    puts "An error occurred: #{result.data['error']['message']}"
  end
end

Go

Menggunakan library klien Go.

import (
	"code.google.com/p/google-api-go-client/mirror/v1"
	"fmt"
)

// SubscribeToNotifications subscribes to notifications for the current user.
func SubscribeToNotifications(g *mirror.Service, collection string,
	userToken string, verifyToken string, callbackUrl string,
	operations []string) (*mirror.Subscription, error) {
	s := &mirror.Subscription{
		Collection:  collection,
		UserToken:   userToken,
		VerifyToken: verifyToken,
		CallbackUrl: callbackUrl,
	}
	r, err := g.Subscriptions.Insert(s).Do()
	if err != nil {
		fmt.Printf("An error occurred: %v\n", err)
		return nil, err
	}
	return r, nil
}

HTTP Mentah

Tidak menggunakan library klien.

POST /mirror/v1/subscriptions HTTP/1.1
Authorization: Bearer auth token
Content-Type: application/json
Content-Length: length

{
  "collection": "timeline"
  "userToken": "harold_penguin",
  "operation": ["UPDATE"],
  "callbackUrl": "https://example.com/notify/callback"
}