Krótkie wprowadzenie do Javy

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

Przewodniki Szybki start wyjaśniają, jak skonfigurować i uruchomić aplikację, która wywołuje interfejs API Google Workspace. W tym krótkim wprowadzeniu użyjemy uproszczonego podejścia do uwierzytelniania, które jest odpowiednie w środowisku testowym. W przypadku środowiska produkcyjnego zalecamy zapoznanie się z informacjami o uwierzytelnianiu i autoryzacji przed wybraniem danych logowania odpowiednich dla Twojej aplikacji.

W tym przewodniku Szybki start używane są zalecane biblioteki klienta interfejsu API Google Workspace, które obsługują niektóre szczegóły procesu uwierzytelniania i autoryzacji.

Cele

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

Wymagania wstępne

• Java 11 lub nowsza.
• Gradle w wersji 7.0 lub nowszej.
• Projekt Google Cloud.

• konto Google Workspace z włączoną usługą Google Meet;

Konfigurowanie środowiska

Aby ukończyć ten przewodnik, skonfiguruj środowisko.

Włącz API

Zanim zaczniesz korzystać z interfejsów Google API, musisz je włączyć w projekcie Google Cloud. W jednym projekcie Google Cloud możesz włączyć co najmniej 1 interfejs API.

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

  Włączanie interfejsu API

Konfigurowanie ekranu zgody OAuth

Jeśli do wykonania zadań z tego krótkiego wprowadzenia posłużył Ci nowy projekt Google Cloud, skonfiguruj ekran akceptacji OAuth. Jeśli ten krok został już wykonany w przypadku Twojego projektu w Cloud, przejdź do następnej sekcji.

1. W konsoli Google Cloud otwórz Menu  > Google Auth platform > Branding.

   Otwórz Promowanie marki

2. Jeśli masz już skonfigurowany Google Auth platform, możesz skonfigurować te ustawienia ekranu zgody OAuth w sekcjach Branding, Odbiorcy i Dostęp do danych. Jeśli zobaczysz komunikat Google Auth platform Jeszcze nie skonfigurowano, kliknij Rozpocznij:
1. W sekcji Informacje o aplikacji w polu Nazwa aplikacji wpisz nazwę aplikacji.
2. W sekcji Adres e-mail pomocy dla użytkowników wybierz adres e-mail, na który użytkownicy mogą pisać, jeśli mają pytania dotyczące ich zgody.
3. Kliknij Dalej.
4. W sekcji Odbiorcy wybierz Wewnętrzny.
5. Kliknij Dalej.
6. W sekcji Dane kontaktowe wpisz adres e-mail, na który będziesz otrzymywać powiadomienia o wszelkich zmianach w projekcie.
7. Kliknij Dalej.
8. W sekcji Zakończ zapoznaj się z zasadami dotyczącymi danych użytkownika w usługach interfejsów API Google i jeśli się z nimi zgadzasz, kliknij Akceptuję zasady dotyczące danych użytkownika w usługach interfejsów API Google.
9. Kliknij Dalej.
10. Kliknij Utwórz.
3. Na razie możesz pominąć dodawanie zakresów. W przyszłości, gdy będziesz tworzyć aplikację do użytku poza organizacją Google Workspace, musisz zmienić Typ użytkownika na Zewnętrzny. Następnie dodaj zakresy autoryzacji wymagane przez aplikację. Więcej informacji znajdziesz w pełnym przewodniku Konfigurowanie zgody OAuth.

Autoryzowanie danych logowania w aplikacji na komputer

Aby uwierzytelniać użytkowników i uzyskiwać dostęp do danych użytkowników 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.

1. W konsoli Google Cloud otwórz Menu  > Google Auth platform > Klienci.

   Otwórz stronę Klienci

2. Kliknij Utwórz klienta.
3. Kliknij Typ aplikacji > Aplikacja na komputer.
4. W polu Nazwa wpisz nazwę danych logowania. Ta nazwa jest widoczna tylko w konsoli Google Cloud.
5. Kliknij Utwórz.

   Nowo utworzone dane logowania pojawią się w sekcji „Identyfikatory klientów OAuth 2.0”.

6. Zapisz pobrany plik JSON jako credentials.json i przenieś go do katalogu roboczego.

Przygotowywanie obszaru roboczego

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

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

2. W katalogu src/main/resources/ skopiuj pobrany wcześniej plik credentials.json.

3. 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

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

2. 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

1. Uruchom przykład:

   gradle run
   

2. Przy pierwszym uruchomieniu przykładu pojawi się prośba o autoryzację dostępu:
   1. Jeśli nie zalogowano się na konto Google, pojawi się prośba o zalogowanie. Jeśli logujesz się na wiele kont, wybierz jedno z nich, aby użyć go do autoryzacji.
   2. Kliknij Akceptuję.

   Aplikacja w Javie działa i wywołuje interfejs Google Meet API.

   Informacje o autoryzacji są przechowywane w systemie plików, więc przy następnym uruchomieniu przykładowego kodu nie pojawi się prośba o autoryzację.

Dalsze kroki

• Wypróbuj interfejsy Google Workspace API w narzędziu API Explorer
• Dokumentacja Javadoc interfejsu Google Meet API