Ta strona została przetłumaczona przez Cloud Translation API.

Krótkie wprowadzenie do Javy

Przewodniki szybkiego startu wyjaśniają, jak skonfigurować i uruchamiać aplikację, która wywołuje interfejs Google Workspace API.

Szybkie starty Google Workspace korzystają z bibliotek klienta interfejsu API do obsługi niektórych szczegółów procesu uwierzytelniania i autoryzacji. Zalecamy używanie bibliotek klienta w przypadku własnych aplikacji. W tym krótkim wprowadzeniu użyjemy uproszczonego podejścia do uwierzytelniania, które jest odpowiednie dla środowiska testowego. W przypadku środowiska produkcyjnego zalecamy zapoznanie się z informacjami na temat uwierzytelniania i autoryzacji, zanim wybierzesz odpowiednie dla swojej aplikacji poświadczenia dostępu.

Utwórz aplikację wiersza poleceń w języku Java, która wysyła żądania do interfejsu Google Meet API.

Cele

skonfigurować środowisko,
Skonfiguruj próbkę.
Uruchom przykład.

Wymagania wstępne

Java w wersji 1.8 lub nowszej.
Gradle w wersji 7.0 lub nowszej.
projekt Google Cloud,

Konto Google Workspace z włączoną usługą Google Meet.

Konfigurowanie środowiska

Aby rozpocząć krótkie wprowadzenie, skonfiguruj środowisko.

Włącz API

Zanim zaczniesz używać interfejsów API Google, musisz je włączyć w projekcie Google Cloud. W jednym projekcie Google Cloud możesz włączyć 1 lub więcej interfejsów API.

W konsoli Google Cloud włącz interfejs Google Meet API.

Włączanie interfejsu API

Konfigurowanie ekranu zgody OAuth

Jeśli do wykonania tego samouczka używasz nowego projektu Google Cloud, skonfiguruj ekran akceptacji OAuth i dodaj siebie jako użytkownika testowego. Jeśli ten krok został już wykonany w przypadku Twojego projektu Cloud, przejdź do następnej sekcji.

W konsoli Google Cloud kliknij Menu > Interfejsy API i usługi > Ekran zgody OAuth.
Otwórz ekran zgody OAuth
W polu Typ użytkownika wybierz Wewnętrzny, a następnie kliknij Utwórz.
Wypełnij formularz rejestracji aplikacji, a potem kliknij Zapisz i kontynuuj.
Możesz pominąć dodawanie zakresów i kliknąć Zapisz i kontynuuj. Gdy w przyszłości będziesz tworzyć aplikację do użytku poza organizacją Google Workspace, musisz zmienić Typ użytkownika na Zewnętrzny, a następnie dodać zakresy autoryzacji wymagane przez aplikację.
Sprawdź podsumowanie rejestracji aplikacji. Aby wprowadzić zmiany, kliknij Edytuj. Jeśli rejestracja aplikacji wygląda dobrze, kliknij Powrót do panelu.

Autoryzowanie danych logowania do aplikacji na komputer

Aby uwierzytelniać użytkowników i dostępować do ich danych w aplikacji, musisz utworzyć co najmniej 1 identyfikator klienta OAuth 2.0. Identyfikator klienta wskazuje konkretną aplikację na serwerach OAuth Google. Jeśli Twoja aplikacja działa na kilku platformach, musisz utworzyć osobny identyfikator klienta dla każdej z nich.

W konsoli Google Cloud kliknij Menu > Interfejsy API i usługi > Dane logowania.
Przejdź do danych logowania
Kliknij Utwórz dane logowania > Identyfikator klienta OAuth.
Kliknij Typ aplikacji > Aplikacja na komputer.
W polu Nazwa wpisz nazwę danych logowania. Ta nazwa jest wyświetlana tylko w konsoli Google Cloud.
Kliknij Utwórz. Pojawi się ekran utworzonego klienta OAuth z nowym identyfikatorem klienta i tajnym kluczem klienta.
Kliknij OK. Nowo utworzone dane logowania pojawią się w sekcji Identyfikatory klienta OAuth 2.0.
Zapisz pobrany plik JSON jako credentials.json i przenieś go do katalogu roboczego.

Przygotowanie obszaru roboczego

W katalogu roboczym utwórz nową strukturę projektu:

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

W katalogu src/main/resources/ skopiuj pobrany wcześniej plik credentials.json.
Otwórz domyślny plik build.gradle i zastąp jego zawartość tym kodem:

meet/quickstart/build.gradle

Wyświetl w GitHubie
```
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'
}
```

Konfigurowanie próbki

W katalogu src/main/java/ utwórz nowy plik Java o nazwie odpowiadającej wartości mainClassName w pliku build.gradle.

W nowym pliku Java umieść ten kod:

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

Wyświetl w GitHubie

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();
    }
  }
}

Uruchamianie przykładu

Uruchom przykład:
```
gradle run
```

Gdy uruchomisz próbkę po raz pierwszy, pojawi się prośba o autoryzację dostępu:
1. Jeśli nie zalogowano się na konto Google, zaloguj się, gdy pojawi się taka prośba. Jeśli logujesz się na kilka kont, wybierz jedno konto, którego chcesz użyć do autoryzacji.
2. Kliknij Accept (Zaakceptuj).
Aplikacja w Javie działa i wywołuje interfejs API Google Meet.

Informacje autoryzacyjne są przechowywane w systemie plików, więc następnym razem, gdy uruchomisz przykładowy kod, nie pojawi się prośba o autoryzację.

Dalsze kroki

Dokumentacja Javadoc interfejsu Google Meet API