Se usó la API de Cloud Translation para traducir esta página.

Contacts: insert

Inserta un contacto nuevo. Ve un ejemplo.

Solicitud

Solicitud HTTP

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

Autorización

Esta solicitud requiere autorización con el siguiente alcance (obtén más información sobre la autenticación y autorización).

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

Cuerpo de la solicitud

En el cuerpo de la solicitud, suministra un recurso Contactos con las siguientes propiedades:

Nombre de la propiedad	Valor	Descripción	Notas
Propiedades obligatorias
`acceptCommands[].type`	`string`	El tipo de operación al que corresponde este comando. Los valores permitidos son: `TAKE_A_NOTE`: Comparte un elemento de cronograma con la transcripción de la voz del usuario a partir del comando del menú de voz "Crear una nota". `POST_AN_UPDATE`: Comparte un elemento de cronograma con la transcripción de la voz del usuario a partir del comando del menú de voz "Publicar una actualización".	admite escritura
`displayName`	`string`	El nombre que se mostrará para este contacto.	admite escritura
`id`	`string`	Es el ID de este contacto. La genera la aplicación y se trata como un token opaco.	admite escritura
`imageUrls[]`	`list`	Conjunto de URL de imagen para mostrar a un contacto. La mayoría de los contactos tienen una sola imagen, pero los contactos de "grupo" pueden incluir hasta 8 URL de imágenes y se les cambiará el tamaño y se recortarán para crear un mosaico en el cliente.	admite escritura
Propiedades opcionales
`acceptCommands[]`	`list`	Una lista de comandos del menú de voz que un contacto puede manejar. Glass muestra hasta tres contactos para cada comando del menú de voz. Si hay más que eso, se muestran los tres contactos con el `priority` más alto para ese comando en particular.	admite escritura
`acceptTypes[]`	`list`	Una lista de los tipos de MIME que admite un contacto. El contacto se mostrará al usuario si cualquiera de sus AcceptTypes coincide con cualquiera de los tipos de archivos adjuntos del elemento. Si no se acepta AcceptTypes, el contacto se mostrará para todos los elementos.	admite escritura
`phoneNumber`	`string`	Es el número de teléfono principal del contacto. Puede ser un número completo, con código de país y de área, o un número local.	admite escritura
`priority`	`unsigned integer`	Prioridad para que el contacto determine el orden en una lista de contactos. Los contactos con prioridades más altas se mostrarán antes que los contactos con prioridades más bajas.	admite escritura
`speakableName`	`string`	Nombre de este contacto, como debe pronunciarse. Si el nombre de este contacto debe pronunciarse como parte de un menú de desambiguación de voz, se usa como la pronunciación esperada. Esto es útil para los nombres de contactos que tienen caracteres impronunciables o cuya ortografía no se ve fonética.	admite escritura
`type`	`string`	Es el tipo de este contacto. Se usa para ordenar las IU. Los valores permitidos son: `INDIVIDUAL`: Representa a una sola persona. Esta es la opción predeterminada. `GROUP`: Representa a más de una sola persona.	admite escritura

Respuesta

Si se aplica correctamente, este método muestra un recurso Contactos en el cuerpo de la respuesta.

Ejemplos

Nota: Los ejemplos de código disponibles para este método no representan todos los lenguajes de programación admitidos (consulta la página de bibliotecas cliente para consultar una lista de lenguajes admitidos).

Java

Usa la biblioteca cliente de Java.

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

import java.io.IOException;
import java.util.Arrays;

public class MyClass {
  // ...

  /**
   * Insert a new contact for the current user.
   * 
   * @param service Authorized Mirror service.
   * @param contactId ID of the contact to insert.
   * @param displayName Display name for the contact to insert.
   * @param iconUrl URL of the contact's icon.
   * @return The inserted contact on success, {@code null} otherwise.
   */
  public static Contact insertContact(Mirror service, String contactId, String displayName,
      String iconUrl) {
    Contact contact = new Contact();
    contact.setId(contactId);
    contact.setDisplayName(displayName);
    contact.setImageUrls(Arrays.asList(iconUrl));

    try {
      return service.contacts().insert(contact).execute();
    } catch (IOException e) {
      System.err.println("An error occurred: " + e);
      return null;
    }
  }

  // ...
}

.NET

Usa la biblioteca cliente.NET.

using System;
using System.Collections.Generic;

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

public class MyClass {
  // ...

  /// <summary>
  /// Insert a new contact for the current user.
  /// </summary>
  /// <param name='service'>Authorized Mirror service.</param>
  /// <param name='contactId'>ID of the contact to insert.</param>
  /// <param name='displayName'>
  /// Display name for the contact to insert.
  /// </param>
  /// <param name='iconUrl'>URL of the contact's icon.</param>
  /// <returns>
  /// The inserted contact on success, null otherwise.
  /// </returns>
  public static Contact InsertContact(MirrorService service,
      String contactId, String displayName, String iconUrl) {
    Contact contact = new Contact() {
      Id = contactId,
      DisplayName = displayName,
      ImageUrls = new List<String>() {iconUrl}
    };
    try {
      return service.Contacts.Insert(contact).Fetch();
    } catch (Exception e) {
      Console.WriteLine("An error occurred: " + e.Message);
      return null;
    }
  }

  // ...
}

PHP

Usa la biblioteca cliente PHP.

/**
 * Insert a new contact for the current user.
 *
 * @param Google_MirrorService $service Authorized Mirror service.
 * @param string $contactId ID of the contact to insert.
 * @param string $displayName Display name for the contact to insert.
 * @param string $iconUrl URL of the contact's icon.
 * @return Google_Contact The inserted contact on success, null otherwise.
 */
function insertContact($service, $contactId, $displayName, $iconUrl) {
  try {
    $contact = new Google_Contact();
    $contact->setId($contactId);
    $contact->setDisplayName($displayName);
    $contact->setImageUrls(array($iconUrl));
    return $service->contacts->insert($contact);
  } catch (Exception $e) {
    print 'An error occurred: ' . $e->getMessage();
    return null;
  }
}

Python

Usa la biblioteca cliente de Python.

from apiclient import errors
# ...

def insert_contact(service, contact_id, display_name, icon_url):
  """Insert a new contact for the current user.

  Args:
    service: Authorized Mirror service.
    contact_id: ID of the contact to insert.
    display_name: Display name for the contact to insert.
    icon_url: URL of the contact's icon.
  Returns:
    The inserted contact on success, None otherwise.
  """
  contact = {
      'id': contact_id,
      'displayName': display_name,
      'imageUrls': [icon_url]
  }
  try:
    service.contacts().insert(body=contact).execute()
  except errors.HttpError, error:
    print 'An error occurred: %s' % error
    return None

Ruby

Usa la biblioteca cliente de Ruby.

##
# Insert a new contact for the current user.
#
# @param [Google::APIClient] client
#   Authorized client instance.
# @param [String] contact_id
#   ID of the contact to insert.
# @param [String] display_name
#   Display name for the contact to insert.
# @param [String] image_url
#   URL of the contact's icon.
# @return [Google::APIClient::Schema::Mirror::V1::Contact]
#   The inserted contact on success, nil otherwise.
def insert_contact(client, contact_id, display_name, image_url)
  mirror = client.discovered_api('mirror', 'v1')
  contact = mirror.contacts.insert.request_schema.new({
    'id' => contact_id,
    'displayName' => display_name,
    'imageUrls' => [image_url]
  })
  result = client.execute(
    :api_method => mirror.contacts.insert,
    :body_object => contact)
  if result.success?
    return result.data
  else
    puts "An error occurred: #{result.data['error']['message']}"
  end
end

Comienza a usarlo

Usa la biblioteca cliente de Go.

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

// InsertContact inserts a new contact for the current user.
func InsertContact(g *mirror.Service, contactId string,
        displayName string, iconUrl string) (*mirror.Contact, error) {
        s := &mirror.Contact{
                Id:          contactId,
                DisplayName: displayName,
                ImageUrls:     []string{iconUrl},
        }
        r, err := g.Contacts.Insert(s).Do()
        if err != nil {
                fmt.Printf("An error occurred: %v\n", err)
                return nil, err
        }
        return r, nil
}

HTTP sin procesar

No usa una biblioteca cliente.

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

{
  "id": "harold"
  "displayName": "Harold Penguin",
  "imageUrls": ["https://developers.google.com/glass/images/harold.jpg"]
}