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

Guía de inicio rápido de Java

En los guías de inicio rápido, se explica cómo configurar y ejecutar una app que llama a una API de Google Workspace.

Las guías de inicio rápido de Google Workspace usan las bibliotecas cliente de la API para controlar algunos detalles del flujo de autenticación y autorización. Te recomendamos que uses las bibliotecas cliente para tus propias apps. En esta guía de inicio rápido, se usa un enfoque de autenticación simplificado que es adecuado para un entorno de prueba. En el caso de un entorno de producción, te recomendamos que aprendas sobre la autenticación y autorización antes de elegir las credenciales de acceso adecuadas para tu app.

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

Objetivos

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

Requisitos previos

Una Cuenta de Google

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 Actividad de Google Drive.

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 y agrégate como usuario de prueba. 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ú > APIs y servicios > Pantalla de consentimiento de OAuth.
Ir a la pantalla de consentimiento de OAuth
En Tipo de usuario, selecciona Interno y, luego, haz clic en Crear.
Completa el formulario de registro de la aplicación y, luego, haz clic en Guardar y continuar.
Por ahora, puedes omitir agregar permisos y hacer clic en Guardar y continuar. En el futuro, cuando crees una app para usarla fuera de tu organización de Google Workspace, debes cambiar el Tipo de usuario a Externo y, luego, agregar los permisos de autorización que requiere tu app.
Revisa el resumen del registro de tu app. Para realizar cambios, haz clic en Editar. Si el registro de la app parece correcto, haz clic en Volver al panel.

Cómo autorizar credenciales para una aplicación de escritorio

Para autenticar a los usuarios finales y acceder a sus datos 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ú > APIs y servicios > Credenciales.
Ir a Credenciales
Haz clic en Crear credenciales > ID de cliente de OAuth.
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 Crear. Aparecerá la pantalla Se creó el cliente de OAuth, que muestra tu nuevo ID de cliente y secreto de cliente.
Haz clic en Aceptar. 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 al directorio de trabajo.

Prepara el lugar 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:

drive/activity-v2/quickstart/build.gradle

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

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

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.google.api-client:google-api-client:2.0.0'
    implementation 'com.google.oauth-client:google-oauth-client-jetty:1.34.1'
    implementation 'com.google.apis:google-api-services-driveactivity:v2-rev20220926-2.0.0'
}
```

Configura la muestra

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

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

drive/activity-v2/quickstart/src/main/java/DriveActivityQuickstart.java

Ver en GitHub

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.extensions.java6.auth.oauth2.AuthorizationCodeInstalledApp;
import com.google.api.client.extensions.jetty.auth.oauth2.LocalServerReceiver;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow;
import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.client.util.store.FileDataStoreFactory;
import com.google.api.services.driveactivity.v2.DriveActivityScopes;
import com.google.api.services.driveactivity.v2.model.*;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.AbstractMap;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;

public class DriveActivityQuickstart {
  /**
   * Application name.
   */
  private static final String APPLICATION_NAME = "Drive Activity API Java Quickstart";

  /**
   * Directory to store authorization tokens for this application.
   */
  private static final java.io.File DATA_STORE_DIR = new java.io.File("tokens");
  /**
   * Global instance of the JSON factory.
   */
  private static final JsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();
  /**
   * Global instance of the scopes required by this quickstart.
   *
   * <p>If modifying these scopes, delete your previously saved tokens/ folder.
   */
  private static final List<String> SCOPES =
      Arrays.asList(DriveActivityScopes.DRIVE_ACTIVITY_READONLY);
  private static final String CREDENTIALS_FILE_PATH = "/credentials.json";
  /**
   * Global instance of the {@link FileDataStoreFactory}.
   */
  private static FileDataStoreFactory DATA_STORE_FACTORY;
  /**
   * Global instance of the HTTP transport.
   */
  private static HttpTransport HTTP_TRANSPORT;

  static {
    try {
      HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport();
      DATA_STORE_FACTORY = new FileDataStoreFactory(DATA_STORE_DIR);
    } catch (Throwable t) {
      t.printStackTrace();
      System.exit(1);
    }
  }

  /**
   * Creates an authorized Credential object.
   *
   * @return an authorized Credential object.
   * @throws IOException
   */
  public static Credential authorize() throws IOException {
    // Load client secrets.
    InputStream in = DriveActivityQuickstart.class.getResourceAsStream(CREDENTIALS_FILE_PATH);
    if (in == null) {
      throw new FileNotFoundException("Resource not found: " + CREDENTIALS_FILE_PATH);
    }
    GoogleClientSecrets clientSecrets =
        GoogleClientSecrets.load(JSON_FACTORY, new InputStreamReader(in));

    // Build flow and trigger user authorization request.
    GoogleAuthorizationCodeFlow flow =
        new GoogleAuthorizationCodeFlow.Builder(
            HTTP_TRANSPORT, JSON_FACTORY, clientSecrets, SCOPES)
            .setDataStoreFactory(DATA_STORE_FACTORY)
            .setAccessType("offline")
            .build();
    Credential credential =
        new AuthorizationCodeInstalledApp(flow, new LocalServerReceiver())
            .authorize("user");
    System.out.println("Credentials saved to " + DATA_STORE_DIR.getAbsolutePath());
    return credential;
  }

  /**
   * Build and return an authorized Drive Activity client service.
   *
   * @return an authorized DriveActivity client service
   * @throws IOException
   */
  public static com.google.api.services.driveactivity.v2.DriveActivity getDriveActivityService()
      throws IOException {
    Credential credential = authorize();
    com.google.api.services.driveactivity.v2.DriveActivity service =
        new com.google.api.services.driveactivity.v2.DriveActivity.Builder(
            HTTP_TRANSPORT, JSON_FACTORY, credential)
            .setApplicationName(APPLICATION_NAME)
            .build();
    return service;
  }

  public static void main(String[] args) throws IOException {
    // Build a new authorized API client service.
    com.google.api.services.driveactivity.v2.DriveActivity service = getDriveActivityService();

    // Print the recent activity in your Google Drive.
    QueryDriveActivityResponse result =
        service.activity().query(new QueryDriveActivityRequest().setPageSize(10)).execute();
    List<DriveActivity> activities = result.getActivities();
    if (activities == null || activities.size() == 0) {
      System.out.println("No activity.");
    } else {
      System.out.println("Recent activity:");
      for (DriveActivity activity : activities) {
        String time = getTimeInfo(activity);
        String action = getActionInfo(activity.getPrimaryActionDetail());
        List<String> actors =
            activity.getActors().stream()
                .map(DriveActivityQuickstart::getActorInfo)
                .collect(Collectors.toList());
        List<String> targets =
            activity.getTargets().stream()
                .map(DriveActivityQuickstart::getTargetInfo)
                .collect(Collectors.toList());
        System.out.printf(
            "%s: %s, %s, %s\n", time, truncated(actors), action, truncated(targets));
      }
    }
  }

  /**
   * Returns a string representation of the first elements in a list.
   */
  private static String truncated(List<String> array) {
    return truncatedTo(array, 2);
  }

  /**
   * Returns a string representation of the first elements in a list.
   */
  private static String truncatedTo(List<String> array, int limit) {
    String contents = array.stream().limit(limit).collect(Collectors.joining(", "));
    String more = array.size() > limit ? ", ..." : "";
    return "[" + contents + more + "]";
  }

  /**
   * Returns the name of a set property in an object, or else "unknown".
   */
  private static <T> String getOneOf(AbstractMap<String, T> obj) {
    Iterator<String> iterator = obj.keySet().iterator();
    return iterator.hasNext() ? iterator.next() : "unknown";
  }

  /**
   * Returns a time associated with an activity.
   */
  private static String getTimeInfo(DriveActivity activity) {
    if (activity.getTimestamp() != null) {
      return activity.getTimestamp();
    }
    if (activity.getTimeRange() != null) {
      return activity.getTimeRange().getEndTime();
    }
    return "unknown";
  }

  /**
   * Returns the type of action.
   */
  private static String getActionInfo(ActionDetail actionDetail) {
    return getOneOf(actionDetail);
  }

  /**
   * Returns user information, or the type of user if not a known user.
   */
  private static String getUserInfo(User user) {
    if (user.getKnownUser() != null) {
      KnownUser knownUser = user.getKnownUser();
      Boolean isMe = knownUser.getIsCurrentUser();
      return (isMe != null && isMe) ? "people/me" : knownUser.getPersonName();
    }
    return getOneOf(user);
  }

  /**
   * Returns actor information, or the type of actor if not a user.
   */
  private static String getActorInfo(Actor actor) {
    if (actor.getUser() != null) {
      return getUserInfo(actor.getUser());
    }
    return getOneOf(actor);
  }

  /**
   * Returns the type of a target and an associated title.
   */
  private static String getTargetInfo(Target target) {
    if (target.getDriveItem() != null) {
      return "driveItem:\"" + target.getDriveItem().getTitle() + "\"";
    }
    if (target.getDrive() != null) {
      return "drive:\"" + target.getDrive().getTitle() + "\"";
    }
    if (target.getFileComment() != null) {
      DriveItem parent = target.getFileComment().getParent();
      if (parent != null) {
        return "fileComment:\"" + parent.getTitle() + "\"";
      }
      return "fileComment:unknown";
    }
    return getOneOf(target);
  }
}

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 accedeste 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 Actividad de Google Drive.

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.