snapshot of https://github.com/jitsi/jitsi-meet.git @ fd1749dd28f4138aa80234fc7f311b19aaffa0e7 (2026-09-15)

react/features/google-api/googleApi.web.js

@@ -0,0 +1,461 @@
+import {
+    API_URL_BROADCAST_STREAMS,
+    API_URL_LIVE_BROADCASTS,
+    DISCOVERY_DOCS,
+    GOOGLE_SCOPE_CALENDAR,
+    GOOGLE_SCOPE_USERINFO,
+    GOOGLE_SCOPE_YOUTUBE
+} from './constants';
+import logger from './logger';
+
+const GOOGLE_API_CLIENT_LIBRARY_URL = 'https://apis.google.com/js/api.js';
+const GOOGLE_GIS_LIBRARY_URL = 'https://accounts.google.com/gsi/client';
+
+/**
+ * A promise for dynamically loading the Google API Client Library.
+ *
+ * @private
+ * @type {Promise}
+ */
+let googleClientLoadPromise;
+
+/**
+ * A singleton for loading and interacting with the Google API.
+ */
+const googleApi = {
+    /**
+     * Obtains Google API Client Library, loading the library dynamically if
+     * needed.
+     *
+     * @returns {Promise}
+     */
+    get() {
+        const globalGoogleApi = this._getGoogleApiClient();
+
+        if (!globalGoogleApi) {
+            return this.load();
+        }
+
+        return Promise.resolve(globalGoogleApi);
+    },
+
+    /**
+     * Gets the profile for the user signed in to the Google API Client Library.
+     *
+     * @returns {Promise}
+     */
+    getCurrentUserProfile() {
+        return this.get()
+            .then(() => this.isSignedIn())
+            .then(isSignedIn => {
+                if (!isSignedIn) {
+                    return null;
+                }
+
+                return this._getGoogleApiClient()
+                    .client.oauth2
+                    .userinfo.get().getPromise()
+                    .then(r => r.result);
+            });
+    },
+
+    /**
+     * Sets the Google Web Client ID used for authenticating with Google and
+     * making Google API requests.
+     *
+     * @param {string} clientId - The client ID to be used with the API library.
+     * @param {boolean} enableYoutube - Whether youtube scope is enabled.
+     * @param {boolean} enableCalendar - Whether calendar scope is enabled.
+     * @returns {Promise}
+     */
+    initializeClient(clientId, enableYoutube, enableCalendar) {
+        return this.get()
+            .then(api => new Promise((resolve, reject) => {
+                // setTimeout is used as a workaround for api.client.init not
+                // resolving consistently when the Google API Client Library is
+                // loaded asynchronously. See:
+                // github.com/google/google-api-javascript-client/issues/399
+                setTimeout(() => {
+                    api.client.init({})
+                    .then(() => {
+                        if (enableCalendar) {
+                            api.client.load(DISCOVERY_DOCS);
+                        }
+                    })
+                    .then(() => {
+                        api.client.load('https://www.googleapis.com/discovery/v1/apis/oauth2/v1/rest');
+                    })
+                    .then(resolve)
+                    .catch(reject);
+                }, 500);
+            }))
+            .then(() => new Promise((resolve, reject) => {
+                try {
+                    const scope
+                        = `${enableYoutube ? GOOGLE_SCOPE_YOUTUBE : ''} ${enableCalendar ? GOOGLE_SCOPE_CALENDAR : ''}`
+                        .trim();
+
+                    this.tokenClient = this._getGoogleGISApiClient().accounts.oauth2.initTokenClient({
+                        // eslint-disable-next-line camelcase
+                        client_id: clientId,
+                        scope: `${scope} ${GOOGLE_SCOPE_USERINFO}`,
+                        callback: '' // defined at request time in await/promise scope.
+                    });
+                    resolve();
+                } catch (err) {
+                    reject(err);
+                }
+            }));
+    },
+
+    /**
+     * Checks whether a user is currently authenticated with Google through an
+     * initialized Google API Client Library.
+     *
+     * @returns {Promise}
+     */
+    isSignedIn() {
+        return new Promise((resolve, _) => {
+            const te = parseInt(this.tokenExpires, 10);
+            const isExpired = isNaN(this.tokenExpires) ? true : new Date().getTime() > te;
+
+            resolve(Boolean(!isExpired));
+        });
+    },
+
+    /**
+     * Generates a script tag.
+     *
+     * @param {string} src - The source for the script tag.
+     * @returns {Promise<unknown>}
+     * @private
+     */
+    _loadScriptTag(src) {
+        return new Promise((resolve, reject) => {
+            const scriptTag = document.createElement('script');
+
+            scriptTag.async = true;
+            scriptTag.addEventListener('error', () => {
+                scriptTag.remove();
+
+                reject();
+            });
+            scriptTag.addEventListener('load', resolve);
+            scriptTag.type = 'text/javascript';
+
+            scriptTag.src = src;
+
+            document.head.appendChild(scriptTag);
+        });
+    },
+
+    /**
+     * Generates a script tag and downloads the Google API Client Library.
+     *
+     * @returns {Promise}
+     */
+    load() {
+        if (googleClientLoadPromise) {
+            return googleClientLoadPromise;
+        }
+
+        googleClientLoadPromise = this._loadScriptTag(GOOGLE_API_CLIENT_LIBRARY_URL)
+            .catch(() => {
+                googleClientLoadPromise = null;
+            })
+            .then(() => new Promise((resolve, reject) =>
+                this._getGoogleApiClient().load('client', {
+                    callback: resolve,
+                    onerror: reject
+                })))
+            .then(this._loadScriptTag(GOOGLE_GIS_LIBRARY_URL))
+            .catch(() => {
+                googleClientLoadPromise = null;
+            })
+            .then(() => this._getGoogleApiClient());
+
+        return googleClientLoadPromise;
+    },
+
+    /**
+     * Executes a request for a list of all YouTube broadcasts associated with
+     * user currently signed in to the Google API Client Library.
+     *
+     * @returns {Promise}
+     */
+    requestAvailableYouTubeBroadcasts() {
+        return this.get()
+            .then(api => api.client.request(API_URL_LIVE_BROADCASTS));
+    },
+
+    /**
+     * Executes a request to get all live streams associated with a broadcast
+     * in YouTube.
+     *
+     * @param {string} boundStreamID - The bound stream ID associated with a
+     * broadcast in YouTube.
+     * @returns {Promise}
+     */
+    requestLiveStreamsForYouTubeBroadcast(boundStreamID) {
+        return this.get()
+            .then(api => api.client.request(
+                `${API_URL_BROADCAST_STREAMS}${boundStreamID}`));
+    },
+
+    /**
+     * Prompts the participant to sign in to the Google API Client Library, even
+     * if already signed in.
+     *
+     * @param {boolean} consent - Whether to show account selection dialog.
+     * @returns {Promise}
+     */
+    showAccountSelection(consent) {
+        return this.get()
+            .then(api => new Promise((resolve, reject) => {
+                try {
+                    // Settle this promise in the response callback for requestAccessToken()
+                    this.tokenClient.callback = resp => {
+                        if (resp.error !== undefined) {
+                            reject(resp);
+                        }
+
+                        // Get the number of seconds the token is valid for, subtract 5 minutes
+                        // to account for differences in clock settings and convert to ms.
+                        const expiresIn = (parseInt(api.client.getToken().expires_in, 10) - 300) * 1000;
+                        const now = new Date();
+                        const expireDate = new Date(now.getTime() + expiresIn);
+
+                        this.tokenExpires = expireDate.getTime().toString();
+
+                        resolve(resp);
+                    };
+
+                    this.tokenClient.requestAccessToken({ prompt: consent ? 'consent' : '' });
+                } catch (err) {
+                    logger.error('Error requesting token', err);
+                }
+            }));
+    },
+
+    /**
+     * Prompts the participant to sign in to the Google API Client Library, if
+     * not already signed in.
+     *
+     * @param {boolean} consent - Whether to show account selection dialog.
+     * @returns {Promise}
+     */
+    signInIfNotSignedIn(consent) {
+        return this.get()
+            .then(() => this.isSignedIn())
+            .then(isSignedIn => {
+                if (!isSignedIn) {
+                    return this.showAccountSelection(consent);
+                }
+            });
+    },
+
+    /**
+     * Sign out from the Google API Client Library.
+     *
+     * @returns {Promise}
+     */
+    signOut() {
+        return this.get()
+            .then(() => {
+                this.tokenClient = undefined;
+                this.tokenExpires = undefined;
+            });
+    },
+
+    /**
+     * Parses the google calendar entries to a known format.
+     *
+     * @param {Object} entry - The google calendar entry.
+     * @returns {{
+     *  calendarId: string,
+     *  description: string,
+     *  endDate: string,
+     *  id: string,
+     *  location: string,
+     *  startDate: string,
+     *  title: string}}
+     * @private
+     */
+    _convertCalendarEntry(entry) {
+        return {
+            calendarId: entry.calendarId,
+            description: entry.description,
+            endDate: entry.end.dateTime,
+            id: entry.id,
+            location: entry.location,
+            startDate: entry.start.dateTime,
+            title: entry.summary,
+            url: this._getConferenceDataVideoUri(entry.conferenceData)
+        };
+    },
+
+    /**
+     * Checks conference data for jitsi conference solution and returns
+     * its video url.
+     *
+     * @param {Object} conferenceData - The conference data of the event.
+     * @returns {string|undefined} Returns the found video uri or undefined.
+     */
+    _getConferenceDataVideoUri(conferenceData = {}) {
+        try {
+            // check conference data coming from calendar addons
+            if (conferenceData.parameters.addOnParameters.parameters
+                    .conferenceSolutionType === 'jitsi') {
+                const videoEntry = conferenceData.entryPoints.find(
+                    e => e.entryPointType === 'video');
+
+                if (videoEntry) {
+                    return videoEntry.uri;
+                }
+            }
+        } catch (error) {
+            // we don't care about undefined fields
+        }
+    },
+
+    /**
+     * Retrieves calendar entries from all available calendars.
+     *
+     * @param {number} fetchStartDays - The number of days to go back
+     * when fetching.
+     * @param {number} fetchEndDays - The number of days to fetch.
+     * @returns {Promise<CalendarEntry>}
+     * @private
+     */
+    _getCalendarEntries(fetchStartDays, fetchEndDays) {
+        return this.get()
+            .then(() => this.isSignedIn())
+            .then(isSignedIn => {
+                if (!isSignedIn) {
+                    return null;
+                }
+
+                // user can edit the events, so we want only those that
+                // can be edited
+                return this._getGoogleApiClient()
+                    .client.calendar.calendarList.list();
+            })
+            .then(calendarList => {
+
+                // no result, maybe not signed in
+                if (!calendarList) {
+                    return Promise.resolve();
+                }
+
+                const calendarIds
+                    = calendarList.result.items.map(en => {
+                        return {
+                            id: en.id,
+                            accessRole: en.accessRole
+                        };
+                    });
+                const promises = calendarIds.map(({ id, accessRole }) => {
+                    const startDate = new Date();
+                    const endDate = new Date();
+
+                    startDate.setDate(startDate.getDate() + fetchStartDays);
+                    endDate.setDate(endDate.getDate() + fetchEndDays);
+
+                    // retrieve the events and adds to the result the calendarId
+                    return this._getGoogleApiClient()
+                        .client.calendar.events.list({
+                            'calendarId': id,
+                            'timeMin': startDate.toISOString(),
+                            'timeMax': endDate.toISOString(),
+                            'showDeleted': false,
+                            'singleEvents': true,
+                            'orderBy': 'startTime'
+                        })
+                        .then(result => result.result.items
+                            .map(item => {
+                                const resultItem = { ...item };
+
+                                // add the calendarId only for the events
+                                // we can edit
+                                if (accessRole === 'writer'
+                                    || accessRole === 'owner') {
+                                    resultItem.calendarId = id;
+                                }
+
+                                return resultItem;
+                            }));
+                });
+
+                return Promise.all(promises)
+                    .then(results => [].concat(...results))
+                    .then(entries =>
+                        entries.map(e => this._convertCalendarEntry(e)));
+            });
+    },
+
+    /**
+     * Updates the calendar event and adds a location and text.
+     *
+     * @param {string} id - The event id to update.
+     * @param {string} calendarId - The calendar id to use.
+     * @param {string} location - The location to add to the event.
+     * @param {string} text - The description text to set/append.
+     * @returns {Promise<T | never>}
+     * @private
+     */
+    _updateCalendarEntry(id, calendarId, location, text) {
+        return this.get()
+            .then(() => this.isSignedIn())
+            .then(isSignedIn => {
+                if (!isSignedIn) {
+                    return null;
+                }
+
+                return this._getGoogleApiClient()
+                    .client.calendar.events.get({
+                        'calendarId': calendarId,
+                        'eventId': id
+                    }).then(event => {
+                        let newDescription = text;
+
+                        if (event.result.description) {
+                            newDescription = `${event.result.description}\n\n${
+                                text}`;
+                        }
+
+                        return this._getGoogleApiClient()
+                            .client.calendar.events.patch({
+                                'calendarId': calendarId,
+                                'eventId': id,
+                                'description': newDescription,
+                                'location': location
+                            });
+                    });
+
+            });
+    },
+
+    /**
+     * Returns the global Google API Client Library object. Direct use of this
+     * method is discouraged; instead use the {@link get} method.
+     *
+     * @private
+     * @returns {Object|undefined}
+     */
+    _getGoogleApiClient() {
+        return window.gapi;
+    },
+
+
+    /**
+     * Returns the global Google Identity Services Library object.
+     *
+     * @private
+     * @returns {Object|undefined}
+     */
+    _getGoogleGISApiClient() {
+        return window.google;
+    }
+};
+
+export default googleApi;