Greifen Sie über die iOS-App auf Google Kalender zu

Dieses Mal möchte ich über die iOS-App über die Google Calenear-API auf Google Kalender zugreifen.

Umgebung: Xcode 12.0, Swift 5

Vorbereitung

Gehen Sie zunächst zu Google Cloud Platform und aktivieren Sie die Google Kalender-API. Rufen Sie als Nächstes die OAuth-Client-ID für die OAuth-Authentifizierung ab. Befolgen Sie die im folgenden Artikel unter "Registrieren einer Client-ID" beschriebenen Verfahren, um eine Client-ID zu beantragen.

Ich habe mit Swift4 die Google Kalender-API aufgerufen

Externe Bibliothek zu verwenden

Die Google-API selbst ist eine REST-API, aber es ist schwierig, sie direkt aufzurufen. Daher verwende ich eine externe Bibliothek. Dieses Mal werden wir die folgenden Bibliotheken verwenden.

・ Google-Authentifizierung AppAuth GTMAppAuth

・ Zugriff auf Google Kalender GoogleAPIClientForREST/Calendar

Alle oben genannten Bibliotheken können unter CocoaPods installiert werden. Schreiben Sie die Pod-Datei wie unten gezeigt und führen Sie die Pod-Installation aus, um sie zu installieren.

platform :ios, '14.0'

target 'GoogleCalendarSample' do
  use_frameworks!

  pod 'AppAuth'
  pod 'GTMAppAuth'
  pod 'GoogleAPIClientForREST/Calendar'

end

Authentifizierung

Jetzt implementieren wir den Prozess der Durchführung der Google-Authentifizierung mit AppAuth und GTMAppAuth.

Fügen Sie zunächst AppDelegate die Klasse OIDExternalUserAgentSession hinzu.

AppDelegate.swift


import UIKit
import AppAuth
import GTMAppAuth

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    var currentAuthorizationFlow: OIDExternalUserAgentSession?

---------------- (Folgendes wird weggelassen) ----------------

Beschreiben Sie anschließend die folgende Verarbeitung auf dem Bildschirm für die Google-Authentifizierung.

import UIKit
import AppAuth
import GTMAppAuth
import GoogleAPIClientForREST

---------------- (Unterlassung) ----------------

private var authorization: GTMAppAuthFetcherAuthorization?
private let clientID = "xxxxxxxxxxxxxxxxxxxx"
private let reverseClientID = "xxxxxxxxxxxxxxxxxxxx"
typealias showAuthorizationDialogCallBack = ((Error?) -> Void)

private func showAuthorizationDialog(callBack: @escaping showAuthorizationDialogCallBack) {
    let scopes = ["https://www.googleapis.com/auth/calendar","https://www.googleapis.com/auth/calendar.readonly","https://www.googleapis.com/auth/calendar.events","https://www.googleapis.com/auth/calendar.events.readonly"]
        
    let configuration = GTMAppAuthFetcherAuthorization.configurationForGoogle()
    let redirectURL = URL.init(string: reverseClientID + ":/oauthredirect")
        
    let request = OIDAuthorizationRequest.init(configuration: configuration,
                                                   clientId: clientID,
                                                   scopes: scopes,
                                                   redirectURL: redirectURL!,
                                                   responseType: OIDResponseTypeCode,
                                                   additionalParameters: nil)
        
    let appDelegate: AppDelegate = UIApplication.shared.delegate as! AppDelegate
    appDelegate.currentAuthorizationFlow = OIDAuthState.authState(
        byPresenting: request,
        presenting: self,
        callback: { (authState, error) in
            if let error = error {
                NSLog("\(error)")
            } else {
                if let authState = authState {
                    self.authorization = GTMAppAuthFetcherAuthorization.init(authState: authState)
                    GTMAppAuthFetcherAuthorization.save(self.authorization!, toKeychainForName: "authorization")
                }
            }
            callBack(error)
    })
}

Die folgenden Variablen beschreiben die ID, die erhalten wurde, als die OAuth-Client-ID erhalten wurde. Geben Sie die OAuth 2.0-Client-ID in clientID und die Reverse-Client-ID in reverseClientID ein.

private let clientID = "xxxxxxxxxxxxxxxxxxxx"
private let reverseClientID = "xxxxxxxxxxxxxxxxxxxx"

Legen Sie diesmal die erforderlichen Berechtigungen in den Array-Bereichen fest. Dieses Mal bitten wir die Behörde, den Google-Kalender zu durchsuchen und zu ändern.

let scopes = ["https://www.googleapis.com/auth/calendar","https://www.googleapis.com/auth/calendar.readonly","https://www.googleapis.com/auth/calendar.events","https://www.googleapis.com/auth/calendar.events.readonly"]

Wenn die authState-Methode der OIDAuthState-Klasse ausgeführt wird, wird das folgende Google-Authentifizierungsdialogfeld angezeigt. Google認証ダイアログ Wenn der Benutzer die Google Mail-Adresse und das Kennwort im Dialogfeld korrekt eingibt und die Authentifizierung abgeschlossen ist, generiert und speichert die Rückruffunktion der authState-Methode die GTMAppAuthFetcherAuthorization-Klasse. Es ist nicht erforderlich, den Authentifizierungsdialog erneut anzuzeigen, solange diese GTMAppAuthFetcherAuthorization-Klasse erhalten bleibt.

Suche nach Ereignissen

Als Nächstes möchte ich mit GoogleAPIClientForREST auf Google Kalender zugreifen. Zunächst beschreibe ich den Vorgang zum Abrufen eines vorhandenen Ereignisses aus Google Kalender. Wenn Sie das Startdatum und die Startzeit sowie das Enddatum und die Endzeit an die Methode get übergeben, durchsucht dieses Programm den Google-Kalender nach Ereignissen zwischen dem Startdatum und der Startzeit sowie dem Enddatum und der Endzeit.

import UIKit
import AppAuth
import GTMAppAuth
import GoogleAPIClientForREST

---------------- (Unterlassung) ----------------

private var authorization: GTMAppAuthFetcherAuthorization?
private let clientID = "xxxxxxxxxxxxxxxxxxxx"
private let reverseClientID = "xxxxxxxxxxxxxxxxxxxx"
typealias showAuthorizationDialogCallBack = ((Error?) -> Void)
struct GoogleCalendaraEvent {
    var id: String
    var name: String
    var startDate: Date?
    var endDate: Date?
}
private var googleCalendarEventList: [GoogleCalendaraEvent] = []

private func showAuthorizationDialog(callBack: @escaping showAuthorizationDialogCallBack) {
---------------- (Unterlassung) ----------------
}

private func get(startDateTime: Date, endDateTime: Date) {
    if GTMAppAuthFetcherAuthorization(fromKeychainForName: "authorization") != nil {
        self.authorization = GTMAppAuthFetcherAuthorization(fromKeychainForName: "authorization")!
    }
        
    if self.authorization == nil {
        showAuthorizationDialog(callBack: {(error) -> Void in
            if error == nil {
                self.getCalendarEvents(startDateTime: startDateTime, endDateTime: endDateTime)
            }
        })
    } else {
        self.getCalendarEvents(startDateTime: startDateTime, endDateTime: endDateTime)
    }
}
    
private func getCalendarEvents(startDateTime: Date, endDateTime: Date) {
    let calendarService = GTLRCalendarService()
    calendarService.authorizer = self.authorization
    calendarService.shouldFetchNextPages = true
        
    let query = GTLRCalendarQuery_EventsList.query(withCalendarId: "primary")
    query.timeMin = GTLRDateTime(date: startDateTime)
    query.timeMax = GTLRDateTime(date: endDateTime)
        
    calendarService.executeQuery(query, completionHandler: { (ticket, event, error) -> Void in
        if let error = error {
            NSLog("\(error)")
        } else {
            if let event = event as? GTLRCalendar_Events, let items = event.items {
                self.googleCalendarEventList.removeAll()
                for item in items {
                    let id: String = item.identifier ?? ""
                    let name: String = item.summary ?? ""
                    let startDate: Date? = item.start?.dateTime?.date
                    let endDate: Date? = item.end?.dateTime?.date
                    self.googleCalendarEventList.append(GoogleCalendaraEvent(id: id, name: name, startDate: startDate, endDate: endDate))
                }
            }
        }
    })
}

Überprüfen Sie zunächst, ob die Google-Authentifizierung abgeschlossen ist. Überprüfen Sie, ob die GTMAppAuthFetcherAuthorization-Klasse gespeichert ist. Wenn sie nicht gespeichert ist, rufen Sie die zuvor erstellte Funktion showAuthorizationDialog auf, um den Google-Authentifizierungsdialog anzuzeigen und die GTMAppAuthFetcherAuthorization-Klasse abzurufen. Wenn die GTMAppAuthFetcherAuthorization-Klasse gespeichert wurde, verwenden Sie sie unverändert.

Verwenden Sie dann GoogleAPIClientForREST, um das Ereignis aus dem Googl-Kalender abzurufen. Generieren Sie zunächst eine GTLRCalendarService-Klasse, um auf den Goole-Kalender zuzugreifen, und legen Sie die GTMAppAuthFetcherAuthorization-Klasse in der Authorizer-Eigenschaft fest.

let calendarService = GTLRCalendarService()
calendarService.authorizer = self.authorization
calendarService.shouldFetchNextPages = true

Generieren Sie als Nächstes die GTLRCalendarQuery_EventsList-Klasse für die Suche nach Ereignissen in Google Kalender und legen Sie Startdatum und -zeit sowie Enddatum und -zeit als Suchbedingungen fest.

let query = GTLRCalendarQuery_EventsList.query(withCalendarId: "primary")
query.timeMin = GTLRDateTime(date: startDateTime)
query.timeMax = GTLRDateTime(date: endDateTime)

Nehmen Sie dann diese GTLRCalendarQuery_EventsList-Klasse als Argument und führen Sie die executeQuery-Methode der GTLRCalendarService-Klasse aus, um das Ereignis aus Google Kalender abzurufen. Wenn das Ereignis erfasst werden kann, wird die GTLRCalendar_Events-Klasse von der Callback-Funktion der executeQuery-Methode zurückgegeben, sodass die Ereignisinformationen von hier erfasst werden.

if let event = event as? GTLRCalendar_Events, let items = event.items {
    self.googleCalendarEventList.removeAll()
    for item in items {
        let id: String = item.identifier ?? ""
        let name: String = item.summary ?? ""
        let startDate: Date? = item.start?.dateTime?.date
        let endDate: Date? = item.end?.dateTime?.date
        self.googleCalendarEventList.append(GoogleCalendaraEvent(id: id, name: name, startDate: startDate, endDate: endDate))
    }
}

Die Kennung (eindeutige ID des Ereignisses) ist besonders wichtig. Diese Kennung ist der Schlüssel beim Ändern oder Löschen von Ereignissen.

Ereignis hinzufügen

Als Nächstes möchte ich Google Kalender ein Ereignis hinzufügen. Es ist ein Programm, das ein Ereignis in Google Kalender erstellt, indem der Ereignisname, das Startdatum und die Startzeit sowie das Enddatum und die Endzeit an die Add-Methode übergeben werden.

import UIKit
import AppAuth
import GTMAppAuth
import GoogleAPIClientForREST

---------------- (Unterlassung) ----------------

private var authorization: GTMAppAuthFetcherAuthorization?
typealias showAuthorizationDialogCallBack = ((Error?) -> Void)

private func showAuthorizationDialog(callBack: @escaping showAuthorizationDialogCallBack) {
---------------- (Unterlassung) ----------------
}

private func add(eventName: String, startDateTime: Date, endDateTime: Date) {
        
    if GTMAppAuthFetcherAuthorization(fromKeychainForName: "authorization") != nil {
        self.authorization = GTMAppAuthFetcherAuthorization(fromKeychainForName: "authorization")!
    }
        
    if self.authorization == nil {
        showAuthorizationDialog(callBack: {(error) -> Void in
            if error == nil {
                self.addCalendarEvent(eventName: eventName, startDateTime: startDateTime, endDateTime: endDateTime)
            }
        })
    } else {
        self.addCalendarEvent(eventName: eventName, startDateTime: startDateTime, endDateTime: endDateTime)
    }
}
    
private func addCalendarEvent(eventName: String, startDateTime: Date, endDateTime: Date) {
        
    let calendarService = GTLRCalendarService()
    calendarService.authorizer = self.authorization
    calendarService.shouldFetchNextPages = true
    
    let event = GTLRCalendar_Event()
    event.summary = eventName
        
    let gtlrDateTimeStart: GTLRDateTime = GTLRDateTime(date: startDateTime)
    let startEventDateTime: GTLRCalendar_EventDateTime = GTLRCalendar_EventDateTime()
    startEventDateTime.dateTime = gtlrDateTimeStart
    event.start = startEventDateTime
        
    let gtlrDateTimeEnd: GTLRDateTime = GTLRDateTime(date: endDateTime)
    let endEventDateTime: GTLRCalendar_EventDateTime = GTLRCalendar_EventDateTime()
    endEventDateTime.dateTime = gtlrDateTimeEnd
    event.end = endEventDateTime

    let query = GTLRCalendarQuery_EventsInsert.query(withObject: event, calendarId: "primary")
    calendarService.executeQuery(query, completionHandler: { (ticket, event, error) -> Void in
        if let error = error {
            NSLog("\(error)")
        }
    })
}

Der Prozess bis zur Generierung der GTLRCalendarService-Klasse ist der gleiche wie bei der Suche, daher werden wir dies im folgenden Teil erläutern. Generieren Sie die GTLRCalendar_Event-Klasse, um die Informationen des hinzuzufügenden Ereignisses festzulegen. Dieses Mal werden der Name des Ereignisses, das Startdatum und die Startzeit sowie das Enddatum und die Endzeit festgelegt, sodass sie jeweils in der Eigenschaft summary, der Eigenschaft start und der Eigenschaft end der Klasse GTLRCalendar_Event festgelegt werden.

let event = GTLRCalendar_Event()
event.summary = eventName
        
let gtlrDateTimeStart: GTLRDateTime = GTLRDateTime(date: startDateTime)
let startEventDateTime: GTLRCalendar_EventDateTime = GTLRCalendar_EventDateTime()
startEventDateTime.dateTime = gtlrDateTimeStart
event.start = startEventDateTime
        
let gtlrDateTimeEnd: GTLRDateTime = GTLRDateTime(date: endDateTime)
let endEventDateTime: GTLRCalendar_EventDateTime = GTLRCalendar_EventDateTime()
endEventDateTime.dateTime = gtlrDateTimeEnd
event.end = endEventDateTime

Wenn Sie eine neue Kennung hinzufügen, wird die eindeutige ID des Ereignisses automatisch von Google Kalender zugewiesen, sodass Sie sie hier nicht festlegen müssen.

Anschließend wird eine GTLRCalendarQuery_EventsInsert-Klasse zum Hinzufügen eines neuen Ereignisses zum Google-Kalender mit der GTLRCalendar_Event-Klasse als Argument generiert und ein neues Ereignis zum Google-Kalender hinzugefügt, indem die executeQuery-Methode der GTLRCalendarService-Klasse ausgeführt wird.

Ereignis ändern

Als nächstes ändern wir die Informationen des vorhandenen Ereignisses. Es ist ein Programm, das die Ereignisinformationen der entsprechenden Kennung im Google Kalender ändert, wenn die Ereigniskennung, der Ereignisname, das Startdatum und die Startzeit, das Enddatum und die Endzeit an die Aktualisierungsmethode übergeben werden.

import UIKit
import AppAuth
import GTMAppAuth
import GoogleAPIClientForREST

---------------- (Unterlassung) ----------------

private var authorization: GTMAppAuthFetcherAuthorization?
typealias showAuthorizationDialogCallBack = ((Error?) -> Void)

private func showAuthorizationDialog(callBack: @escaping showAuthorizationDialogCallBack) {
---------------- (Unterlassung) ----------------
}

private func update(eventId: String, eventName: String, startDateTime: Date, endDateTime: Date) {
        
    if GTMAppAuthFetcherAuthorization(fromKeychainForName: "authorization") != nil {
        self.authorization = GTMAppAuthFetcherAuthorization(fromKeychainForName: "authorization")!
    }
        
    if self.authorization == nil {
        showAuthorizationDialog(callBack: {(error) -> Void in
            if error == nil {
                self.updateCalendarEvent(eventId: eventId, eventName: eventName, startDateTime: startDateTime, endDateTime: endDateTime)
            }
        })
    } else {
        self.updateCalendarEvent(eventId: eventId, eventName: eventName, startDateTime: startDateTime, endDateTime: endDateTime)
    }
}
    
private func updateCalendarEvent(eventId: String, eventName: String, startDateTime: Date, endDateTime: Date) {
    let calendarService = GTLRCalendarService()
    calendarService.authorizer = self.authorization
    calendarService.shouldFetchNextPages = true
        
    let event = GTLRCalendar_Event()
    event.identifier = eventId
    event.summary = eventName
        
    let gtlrDateTimeStart: GTLRDateTime = GTLRDateTime(date: startDateTime)
    let startEventDateTime: GTLRCalendar_EventDateTime = GTLRCalendar_EventDateTime()
    startEventDateTime.dateTime = gtlrDateTimeStart
    event.start = startEventDateTime
        
    let gtlrDateTimeEnd: GTLRDateTime = GTLRDateTime(date: endDateTime)
    let endEventDateTime: GTLRCalendar_EventDateTime = GTLRCalendar_EventDateTime()
    endEventDateTime.dateTime = gtlrDateTimeEnd
    event.end = endEventDateTime

    let query = GTLRCalendarQuery_EventsUpdate.query(withObject: event, calendarId: "primary", eventId: eventId)
    calendarService.executeQuery(query, completionHandler: { (ticket, event, error) -> Void in
        if let error = error {
            NSLog("\(error)")
        }
    })
}

Legen Sie für Aktualisierungen die ID des Ereignisses in der Bezeichner-Eigenschaft der GTLRCalendar_Event-Klasse fest. Legen Sie dann den Wert, den Sie ändern möchten, in eine Eigenschaft der Klasse GTLRCalendar_Event fest. Generieren Sie anschließend eine GTLRCalendarQuery_EventsUpdate-Klasse zum Aktualisieren von Google Kalender-Ereignissen mit der GTLRCalendar_Event-Klasse als Argument und führen Sie die executeQuery-Methode der GTLRCalendarService-Klasse mit dieser als Argument aus.

Ereignis löschen

Löschen Sie schließlich das Ereignis in Google Kalender. Es ist ein Programm, das das entsprechende Ereignis aus dem Google-Kalender löscht, wenn die Kennung des Ereignisses an die Löschmethode übergeben wird.

import UIKit
import AppAuth
import GTMAppAuth
import GoogleAPIClientForREST

---------------- (Unterlassung) ----------------

private var authorization: GTMAppAuthFetcherAuthorization?
typealias showAuthorizationDialogCallBack = ((Error?) -> Void)

private func showAuthorizationDialog(callBack: @escaping showAuthorizationDialogCallBack) {
---------------- (Unterlassung) ----------------
}

private func delete(eventId: String) {
        
    if GTMAppAuthFetcherAuthorization(fromKeychainForName: "authorization") != nil {
        self.authorization = GTMAppAuthFetcherAuthorization(fromKeychainForName: "authorization")!
    }
        
    if self.authorization == nil {
        showAuthorizationDialog(callBack: {(error) -> Void in
            if error == nil {
                self.deleteCalendarEvent(eventId: eventId)
            }
        })
    } else {
        self.deleteCalendarEvent(eventId: eventId)
    }
}
    
private func deleteCalendarEvent(eventId: String) {
    let calendarService = GTLRCalendarService()
    calendarService.authorizer = self.authorization
    calendarService.shouldFetchNextPages = true
        
    let query = GTLRCalendarQuery_EventsDelete.query(withCalendarId: "primary", eventId: eventId)
    calendarService.executeQuery(query, completionHandler: { (ticket, event, error) -> Void in
        if let error = error {
            NSLog("\(error)")
        }
    })
}

Das Löschen kann erfolgen, indem die GTLRCalendarQuery_EventsDelete-Klasse mit der Ereignis-ID als Argument generiert und die executeQuery-Methode von GTLRCalendarService mit dieser als Argument ausgeführt wird.

Beispielprogramm

Das diesmal erstellte Beispielprogramm ist auf GitHub verfügbar. https://github.com/naosekig/GoogleCalendarSample

Verweise

CocoaDocs.org - GoogleAPIClientForRest Qiita: Ich habe mit Swift4 die Google Kalender-API aufgerufen

Recommended Posts

Greifen Sie über die iOS-App auf Google Kalender zu
Importieren Sie den von "Schedule-kun" erhaltenen Zeitplan in Google Kalender
Generieren Sie tägliche Berichte aus Google Kalender
So greifen Sie von außen auf den Datenspeicher zu
Holen Sie sich Urlaub mit der Google Kalender-API
Greifen Sie über REPL auf die im Skript definierten Variablen zu
Greifen Sie über die iOS-App auf Google Kalender zu
Lesen Sie die Zeitung Deep Self-Learning From Noisy Labels
Holen Sie sich den neuesten Termin aus Google Kalender und benachrichtigen Sie jeden Morgen online
Greifen Sie über Python auf Bitcoind zu