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

Guía de inicio rápido de Java

Crea una aplicación de línea de comandos en Java que realice solicitudes a la API de Google Meet.

En las guías de inicio rápido, se explica cómo configurar y ejecutar una app que llama a una API de Google Workspace. En esta guía de inicio rápido, se usa un enfoque de autenticación simplificado que es adecuado para un entorno de pruebas. Para un entorno de producción, te recomendamos que obtengas información sobre la autenticación y la autorización antes de elegir las credenciales de acceso adecuadas para tu app.

En esta guía de inicio rápido, se usan las bibliotecas cliente de la API recomendadas de Google Workspace para controlar algunos detalles del flujo de autenticación y autorización.

Objetivos

Configura el entorno.
Configura la muestra.
Ejecuta la muestra.

Requisitos previos

Una cuenta de Google Workspace con Google Meet habilitado

Configura tu entorno

Para completar esta guía de inicio rápido, configura tu entorno.

Habilita la API

Antes de usar las APIs de Google, debes activarlas en un proyecto de Google Cloud. Puedes activar una o más APIs en un solo proyecto de Google Cloud.

En la consola de Google Cloud, habilita la API de Google Meet.

Habilitar la API

Cómo configurar la pantalla de consentimiento de OAuth

Si usas un proyecto de Google Cloud nuevo para completar esta guía de inicio rápido, configura la pantalla de consentimiento de OAuth. Si ya completaste este paso para tu proyecto de Cloud, ve a la siguiente sección.

En la consola de Google Cloud, ve a Menú > > Branding.
Ir a Desarrollo de la marca
Si ya configuraste , puedes configurar los siguientes parámetros de configuración de la pantalla de consentimiento de OAuth en Branding, Audience y Data Access. Si ves un mensaje que dice aún no se configuró, haz clic en Comenzar:

En Información de la app, en Nombre de la app, ingresa un nombre para la app.
En Correo electrónico de asistencia del usuario, elige una dirección de correo electrónico de asistencia a la que los usuarios puedan comunicarse contigo si tienen preguntas sobre su consentimiento.
Haz clic en Siguiente.
En Público, selecciona Interno.
Haz clic en Siguiente.
En Información de contacto, ingresa una dirección de correo electrónico en la que puedas recibir notificaciones sobre cualquier cambio en tu proyecto.
Haz clic en Siguiente.
En Finalizar, revisa la Política de Datos del Usuario de los Servicios de las APIs de Google y, si la aceptas, selecciona Acepto la Política de Datos del Usuario de los Servicios de las APIs de Google.
Haz clic en Continuar.
Haz clic en Create.

Por el momento, puedes omitir la adición de permisos. En el futuro, cuando crees una app para usarla fuera de tu organización de Google Workspace, deberás cambiar el Tipo de usuario a Externo. Luego, agrega los permisos de autorización que requiere tu app. Para obtener más información, consulta la guía completa Configura el consentimiento de OAuth.

Autoriza credenciales para una aplicación de escritorio

Para autenticar a los usuarios finales y acceder a los datos del usuario en tu app, debes crear uno o más IDs de cliente de OAuth 2.0. Un ID de cliente se usa con el fin de identificar una sola app para los servidores de OAuth de Google. Si tu app se ejecuta en varias plataformas, debes crear un ID de cliente independiente para cada una.

En la consola de Google Cloud, ve a Menú > > Clientes.
Ir a Clientes
Haz clic en Crear cliente.
Haz clic en Tipo de aplicación > App para computadoras.
En el campo Nombre, escribe un nombre para la credencial. Este nombre solo se muestra en la consola de Google Cloud.
Haz clic en Create.
La credencial recién creada aparecerá en "IDs de cliente de OAuth 2.0".
Guarda el archivo JSON descargado como credentials.json y muévelo a tu directorio de trabajo.

Prepara el espacio de trabajo

En tu directorio de trabajo, crea una nueva estructura de proyecto:

gradle init --type basic
mkdir -p src/main/java src/main/resources

En el directorio src/main/resources/, copia el archivo credentials.json que descargaste anteriormente.
Abre el archivo build.gradle predeterminado y reemplaza su contenido por el siguiente código:

meet/quickstart/build.gradle

Ver en GitHub
```
apply plugin: 'java'
apply plugin: 'application'

mainClassName = 'MeetQuickstart'
sourceCompatibility = 11
targetCompatibility = 11
version = '1.0'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.google.cloud:google-cloud-meet:0.3.0'
    implementation 'com.google.auth:google-auth-library-oauth2-http:1.19.0'
    implementation 'com.google.oauth-client:google-oauth-client-jetty:1.34.1'
}
```

Configura la muestra

En el directorio src/main/java/, crea un archivo Java nuevo con un nombre que coincida con el valor mainClassName de tu archivo build.gradle.

Incluye el siguiente código en tu nuevo archivo Java:

meet/quickstart/src/main/java/MeetQuickstart.java

Ver en GitHub

import java.awt.Desktop;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.List;

import com.google.api.client.extensions.jetty.auth.oauth2.LocalServerReceiver;
import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.apps.meet.v2.CreateSpaceRequest;
import com.google.apps.meet.v2.Space;
import com.google.apps.meet.v2.SpacesServiceClient;
import com.google.apps.meet.v2.SpacesServiceSettings;
import com.google.auth.Credentials;
import com.google.auth.oauth2.ClientId;
import com.google.auth.oauth2.DefaultPKCEProvider;
import com.google.auth.oauth2.TokenStore;
import com.google.auth.oauth2.UserAuthorizer;

/* class to demonstrate use of Drive files list API */
public class MeetQuickstart {
  /**
   * Directory to store authorization tokens for this application.
   */
  private static final String TOKENS_DIRECTORY_PATH = "tokens";

  /**
   * Global instance of the scopes required by this quickstart.
   * If modifying these scopes, delete your previously saved tokens/ folder.
   */
  private static final List<String> SCOPES = Collections
      .singletonList("https://www.googleapis.com/auth/meetings.space.created");

  private static final String CREDENTIALS_FILE_PATH = "/credentials.json";

  private static final String USER = "default";

  // Simple file-based token storage for storing oauth tokens
  private static final TokenStore TOKEN_STORE = new TokenStore() {
    private Path pathFor(String id) {
      return Paths.get(".", TOKENS_DIRECTORY_PATH, id + ".json");
    }

    @Override
    public String load(String id) throws IOException {
      if (!Files.exists(pathFor(id))) {
        return null;
      }
      return Files.readString(pathFor(id));
    }

    @Override
    public void store(String id, String token) throws IOException {
      Files.createDirectories(Paths.get(".", TOKENS_DIRECTORY_PATH));
      Files.writeString(pathFor(id), token);
    }

    @Override
    public void delete(String id) throws IOException {
      if (!Files.exists(pathFor(id))) {
        return;
      }
      Files.delete(pathFor(id));
    }
  };

  /**
   * Initialize a UserAuthorizer for local authorization.
   * 
   * @param callbackUri
   * @return
   */
  private static UserAuthorizer getAuthorizer(URI callbackUri) throws IOException {
    // Load client secrets.
    try (InputStream in = MeetQuickstart.class.getResourceAsStream(CREDENTIALS_FILE_PATH)) {
      if (in == null) {
        throw new FileNotFoundException("Resource not found: " + CREDENTIALS_FILE_PATH);
      }

      ClientId clientId = ClientId.fromStream(in);

      UserAuthorizer authorizer = UserAuthorizer.newBuilder()
          .setClientId(clientId)
          .setCallbackUri(callbackUri)
          .setScopes(SCOPES)
          .setPKCEProvider(new DefaultPKCEProvider() {
            // Temporary fix for https://github.com/googleapis/google-auth-library-java/issues/1373
            @Override
            public String getCodeChallenge() {
              return super.getCodeChallenge().split("=")[0];
            }
          })
          .setTokenStore(TOKEN_STORE).build();
      return authorizer;
    }
  }

  /**
   * Run the OAuth2 flow for local/installed app.
   * 
   * @return An authorized Credential object.
   * @throws IOException If the credentials.json file cannot be found.
   */
  private static Credentials getCredentials()
      throws Exception {

    LocalServerReceiver receiver = new LocalServerReceiver.Builder().build();
    try {
      URI callbackUri = URI.create(receiver.getRedirectUri());
      UserAuthorizer authorizer = getAuthorizer(callbackUri);

      Credentials credentials = authorizer.getCredentials(USER);
      if (credentials != null) {
        return credentials;
      }

      URL authorizationUrl = authorizer.getAuthorizationUrl(USER, "", null);
      if (Desktop.isDesktopSupported() && 
          Desktop.getDesktop().isSupported(Desktop.Action.BROWSE)) {
        Desktop.getDesktop().browse(authorizationUrl.toURI());
      } else {
        System.out.printf("Open the following URL to authorize access: %s\n",
            authorizationUrl.toExternalForm());
      }

      String code = receiver.waitForCode();
      credentials = authorizer.getAndStoreCredentialsFromCode(USER, code, callbackUri);
      return credentials;
    } finally {
      receiver.stop();
    }
  }

  public static void main(String... args) throws Exception {
    // Override default service settings to supply user credentials.
    Credentials credentials = getCredentials();
    SpacesServiceSettings settings = SpacesServiceSettings.newBuilder()
        .setCredentialsProvider(FixedCredentialsProvider.create(credentials))
        .build();

    try (SpacesServiceClient spacesServiceClient = SpacesServiceClient.create(settings)) {
      CreateSpaceRequest request = CreateSpaceRequest.newBuilder()
          .setSpace(Space.newBuilder().build())
          .build();
      Space response = spacesServiceClient.createSpace(request);
      System.out.printf("Space created: %s\n", response.getMeetingUri());
    } catch (IOException e) {
      // TODO(developer): Handle errors
      e.printStackTrace();
    }
  }
}

Ejecuta la muestra

Ejecuta la muestra:
```
gradle run
```

La primera vez que ejecutes la muestra, se te solicitará que autorices el acceso:
1. Si aún no accediste a tu Cuenta de Google, hazlo cuando se te solicite. Si accediste a varias cuentas, selecciona una para usarla en la autorización.
2. Haz clic en Aceptar.
Tu aplicación de Java se ejecuta y llama a la API de Google Meet.

La información de autorización se almacena en el sistema de archivos, por lo que la próxima vez que ejecutes el código de muestra, no se te solicitará autorización.

Próximos pasos

Documentación de Javadoc de la API de Google Meet

Guía de inicio rápido de Java Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.