Questa pagina è stata tradotta dall'API Cloud Translation.

Subscriptions: insert

Crea una nuova sottoscrizione. Vedi un esempio.

Richiesta

Richiesta HTTP

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

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

Nel corpo della richiesta, fornisci una risorsa sottoscrizioni con le seguenti proprietà:

Nome proprietà	Valore	Descrizione	Note
Proprietà obbligatorie
`callbackUrl`	`string`	L'URL a cui devono essere inviate le notifiche (deve iniziare con `https://`).	accessibile in scrittura
`collection`	`string`	La raccolta a cui iscriverti. I valori consentiti sono: `timeline`: modifiche nella sequenza temporale, tra cui inserimento, eliminazione e aggiornamenti. `locations` - Aggiornamenti sulla posizione. `settings` - Aggiornamenti delle impostazioni.	accessibile in scrittura
Proprietà facoltative
`operation[]`	`list`	Un elenco di operazioni a cui è necessario sottoscrivere un abbonamento. Un elenco vuoto indica che tutte le operazioni sulla raccolta devono essere sottoscritte. I valori consentiti sono: `UPDATE`: l'elemento è stato aggiornato. `INSERT`. È stato inserito un nuovo elemento. `DELETE`: l'elemento è stato eliminato.	accessibile in scrittura
`userToken`	`string`	Un token opaco inviato all'abbonato nelle notifiche in modo da poter determinare l'ID dell'utente.	accessibile in scrittura
`verifyToken`	`string`	Un token segreto inviato all'abbonato nelle notifiche, in modo che possa verificare che la notifica sia stata generata da Google.	accessibile in scrittura

Risposta

In caso di esito positivo, questo metodo restituisce una risorsa Abbonamenti 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 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

Utilizza la libreria client.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

Utilizza la libreria client 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

Utilizza la libreria client 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

Utilizza la libreria client 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

Utilizza la libreria client 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 non elaborato

Non utilizza una libreria client.

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