klaviyo swift sdk
4.0.0
Mit dem Klaviyo Swift SDK können Entwickler die Analytik von Klaviyo einbeziehen und die Benachrichtigungsfunktionalität in ihre iOS -Anwendungen übertragen. Der SDK hilft bei der Identifizierung von Benutzern und Verfolgung von Ereignissen über Klaviyo -Client -APIs. Um die Leistungsaufwand zu verringern, werden API -Anfragen in die Warteschlange gestellt und in Chargen gesendet. Die Warteschlange ist auf den lokalen Speicher festgehalten, sodass die Daten nicht verloren gehen, wenn das Gerät offline ist oder die App beendet wird.
Nach der Integration kann Ihr Marketing -Team die Anforderungen Ihrer App -Benutzer besser verstehen und sie über APNs zeitnahe Nachrichten senden.
Aktivieren Sie Push -Benachrichtigungsfunktionen in Ihrem Xcode -Projekt. Der Abschnitt "aktivieren Sie die Push -Benachrichtigungsfähigkeit" in diesem Apple Developer -Handbuch enthält detaillierte Anweisungen.
[Optional, aber empfohlen] Wenn Sie beabsichtigen, Rich Push -Benachrichtigungen zu verwenden, fügen Sie Ihrem Xcode -Projekt eine Benachrichtigungsdienstverlängerung hinzu. Eine Benachrichtigungsdienst -App -Erweiterung wird als separates Bundle in Ihrer iOS -App geliefert. Um diese Erweiterung Ihrer App hinzuzufügen:
Euen Das Bereitstellungsziel Ihrer Benachrichtigungserweiterung stand für die neueste iOS -Version. Wenn dies die von der App unterstützte iOS -Version Ihrer App überschreitet, werden Push -Benachrichtigungen möglicherweise nicht angehängte Medien auf älteren Geräten angezeigt. Stellen Sie sicher, dass das minimale Bereitstellungsziel der Erweiterung dem Ihrer App entspricht.Euen
Befolgen Sie die folgenden Anweisungen, um die Abhängigkeiten des Klaviyo zu installieren.
Klaviyoswift ist über Swift Paket Manager erhältlich. Befolgen Sie die folgenden Schritte, um zu installieren.
https://github.com/klaviyo/klaviyo-swift-sdk im Textfeld ein. Dies sollte das Paket auf dem Bildschirm aufbringen.KlaviyoSwift Ihrem App -Ziel und KlaviyoSwiftExtension dem Benachrichtigungsdienst -Erweiterungsziel (falls einer erstellt wurde) und klicken Sie auf Paket hinzufügen .Klaviyoswift ist über Cocoapods erhältlich.
YourAppTarget und YourAppNotificationServiceExtenionTarget durch die Namen Ihrer App- bzw. Benachrichtigungserweiterungsziele ersetzen. target 'YourAppTarget' do
pod 'KlaviyoSwift'
end
target 'YourAppNotificationServiceExtenionTarget' do
pod 'KlaviyoSwiftExtension'
endpod install aus, um die Integration abzuschließen. Die Bibliothek kann über pod update KlaviyoSwift und pod update KlaviyoSwiftExtension auf dem Laufenden gehalten werden. Schließlich fügen Sie in der Datei NotificationService.swift den Code für die beiden erforderlichen Delegierten aus dieser Datei hinzu. Dieses Beispiel deckt in Klaviyo auf, damit wir die Medien herunterladen und an die Push -Benachrichtigung anhängen können.
Der SDK muss mit dem kurzen alphanumerischen öffentlichen API -Schlüssel für Ihr Klaviyo -Konto, auch als Ihre Site -ID bezeichnet, initialisiert werden.
// AppDelegate
import KlaviyoSwift
class AppDelegate : UIResponder , UIApplicationDelegate {
func application ( _ application : UIApplication , didFinishLaunchingWithOptions launchOptions : [ UIApplication . LaunchOptionsKey : Any ] ? ) -> Bool {
KlaviyoSDK ( ) . initialize ( with : " YOUR_KLAVIYO_PUBLIC_API_KEY " )
return true
}
}Das SDK sollte initialisiert werden, bevor andere Klaviyo -SDK -Methoden aufgerufen werden.
Das SDK bietet Methoden zur Identifizierung Ihrer Benutzer als Klaviyo -Profile über die API des Client -Profils erstellen. Ein Profil kann durch eine beliebige Kombination der folgenden Identifizierung identifiziert werden:
Diese oben genannten Kennungen sind auf den lokalen Speicher festgehalten, damit der SDK den aktuellen Benutzer/das aktuelle Profil für Sie verfolgen kann, wenn Sie Ereignisanfragen erstellen oder ein Push -Token usw. festlegen möchten.
Profilkennungen können auf einmal oder einzeln festgelegt werden. In jedem Fall werden die SDK -API -Anrufe gruppieren und basieren, um die Leistung zu verbessern.
Der folgende Code zeigt, wie Sie Profilkennungen festlegen:
// organization, title, image, location and additional properties (dictionary) can also be set using the below constructor
let profile = Profile ( email : " [email protected] " , firstName : " Blob " , lastName : " Jr. " )
KlaviyoSDK ( ) . set ( profile : profile )
// or setting individual properties
KlaviyoSDK ( ) . set ( profileAttribute : . firstName , value : " Blob " )
KlaviyoSDK ( ) . set ( profileAttribute : . lastName , value : " Jr. " ) So starten Sie ein neues Profil insgesamt (z. B. wenn sich ein Benutzer anmeldet) entweder KlaviyoSDK().resetProfile() auf, um die aktuell verfolgten Profilkennungen zu löschen, oder verwenden Sie KlaviyoSDK().set(profile: profile) um es mit einem neuen Profil zu überschreiben, um es mit einem neuen Profil zu überschreiben Objekt.
// start a profile for Blob Jr.
let profile = Profile ( email : " [email protected] " , firstName : " Blob " , lastName : " Jr. " )
KlaviyoSDK ( ) . set ( profile : profile )
// stop tracking Blob Jr.
KlaviyoSDK ( ) . resetProfile ( )
// start a profile for Robin Hood
let profile = Profile ( email : " [email protected] " , firstName : " Robin " , lastName : " Hood " )
KlaviyoSDK ( ) . set ( profile : profile )Klaviyo verfolgt nicht identifizierte Benutzer mit einer autogenerierten ID, wenn ein Push -Token festgelegt oder ein Ereignis erstellt wird. Auf diese Weise können Sie Push -Token sammeln und Ereignisse verfolgen, bevor Sie Profilkennungen wie E -Mail oder Telefonnummer sammeln. Wenn eine Kennung bereitgestellt wird, fusioniert Klaviyo den anonymen Benutzer mit einem identifizierten Benutzer.
Das SDK bietet Tools zum Nachverfolgung von Ereignissen, die Benutzer über die API von Client -Event -Event -API in Ihrer App durchführen. Unten finden Sie ein Beispiel für die Verfolgung eines Ereignisses:
// using a predefined event name
let event = Event ( name : . StartedCheckoutMetric ,
properties : [
" name " : " cool t-shirt " ,
" color " : " blue " ,
" size " : " medium " ,
] ,
value : 166 )
KlaviyoSDK ( ) . create ( event : event )
// using a custom event name
let customEvent = Event ( name : . CustomEvent ( " Checkout Completed " ) ,
properties : [
" name " : " cool t-shirt " ,
" color " : " blue " ,
" size " : " medium " ,
] ,
value : 166 )
KlaviyoSDK ( ) . create ( event : customEvent ) Die Methode create nimmt ein Ereignisobjekt als Argument an. Das Ereignis kann mit den folgenden Argumenten konstruiert werden:
name : Der Name des Ereignisses, den Sie verfolgen möchten, als EventName Enum. Eine Liste der gemeinsamen Klaviyo -definierten Ereigniskennzahlen finden Sie im Event.EventName . Sie können auch benutzerdefinierte Ereignisse erstellen, indem Sie den Fall von CustomEvent verwenden Event.EventNameproperties : Ein Wörterbuch von Eigenschaften, die für das Ereignis spezifisch sind. Dieses Argument ist optional.value : Ein numerischer Wert ( Double ), der mit diesem Ereignis in Verbindung steht. Zum Beispiel der Dollarbetrag eines Kaufs. Um Ihren Benutzern Push -Benachrichtigungen zu senden, müssen Sie ihre Push -Token sammeln und sie bei Klaviyo registrieren. Dies geschieht über die KlaviyoSDK().set(pushToken:)
registerForRemoteNotifications() an, um ein Push -Token von APNs anzufordern. Dies erfolgt in der Regel in der application:didFinishLaunchingWithOptions: Methode Ihres App -Delegiertens.application:didRegisterForRemoteNotificationsWithDeviceToken in Ihrem Anwendungsdelegierten, um das Push -Token von APNs zu erhalten und sie bei Klaviyo zu registrieren.Im Folgenden finden Sie den Code, um beide oben genannten Schritte auszuführen:
import KlaviyoSwift
func application ( _ application : UIApplication , didFinishLaunchingWithOptions launchOptions : [ UIApplication . LaunchOptionsKey : Any ] ? ) -> Bool {
KlaviyoSDK ( ) . initialize ( with : " YOUR_KLAVIYO_PUBLIC_API_KEY " )
UIApplication . shared . registerForRemoteNotifications ( )
return true
}
func application ( _ application : UIApplication , didRegisterForRemoteNotificationsWithDeviceToken deviceToken : Data ) {
KlaviyoSDK ( ) . set ( pushToken : deviceToken )
} Sobald das Push -Token erhalten wurde, besteht der nächste Schritt darin, die Erlaubnis Ihrer Benutzer zu beantragen, ihnen Push -Benachrichtigungen zu senden. Sie können den Berechtigungsanforderungscode überall in Ihrer Anwendung hinzufügen, wo es sinnvoll ist, die Benutzer für diese Berechtigte aufzufordern. Apple gibt einige Richtlinien für die Best Practices, wann und wie Sie um diese Erlaubnis bitten. Das folgende Beispiel zeigt, wie Push -Berechtigungen innerhalb der application:didFinishLaunchingWithOptions: Methode in der Anwendungsdelegiertendatei. Es ist jedoch erwähnenswert, dass dies möglicherweise nicht der ideale Ort ist, da es das Start -up -Erlebnis der App unterbrechen könnte.
Nach dem Einstellen eines Push -Tokens verfolgt der Klaviyo SDK die Änderungen der Benachrichtigungsberechtigung des Benutzers automatisch, wenn die Anwendung aus dem Hintergrund geöffnet oder wieder aufgenommen wird.
Im Folgenden finden Sie Beispielcode zum Anfordern von Push -Benachrichtigungsgenehmigungen:
import UserNotifications
func application ( _ application : UIApplication , didFinishLaunchingWithOptions launchOptions : [ UIApplication . LaunchOptionsKey : Any ] ? ) -> Bool {
KlaviyoSDK ( ) . initialize ( with : " YOUR_KLAVIYO_PUBLIC_API_KEY " )
UIApplication . shared . registerForRemoteNotifications ( )
let center = UNUserNotificationCenter . current ( )
center . delegate = self as? UNUserNotificationCenterDelegate // the type casting can be removed once the delegate has been implemented
let options : UNAuthorizationOptions = [ . alert , . sound , . badge ]
// use the below options if you are interested in using provisional push notifications. Note that using this will not
// show the push notifications prompt to the user.
// let options: UNAuthorizationOptions = [.alert, .sound, .badge, .provisional]
center . requestAuthorization ( options : options ) { granted , error in
if let error = error {
// Handle the error here.
print ( " error = " , error )
}
// Irrespective of the authorization status call `registerForRemoteNotifications` here so that
// the `didRegisterForRemoteNotificationsWithDeviceToken` delegate is called. Doing this
// will make sure that Klaviyo always has the latest push authorization status.
DispatchQueue . main . async {
UIApplication . shared . registerForRemoteNotifications ( )
}
}
return true
} Wenn ein Benutzer auf eine Push -Benachrichtigung klopft, implementieren Sie userNotificationCenter:didReceive:withCompletionHandler und userNotificationCenter:willPresent:withCompletionHandler in Ihrem Anwendungsdelegierter, um Empfangs -Push -Benachrichtigungen zu verarbeiten, wenn sich die App im Hintergrund und im Vordergrund befindet.
Im Folgenden finden Sie ein Beispiel dafür, wie Sie Push -Benachrichtigungen in Ihrem App -Delegierten behandeln:
// be sure to set the UNUserNotificationCenterDelegate to self in the didFinishLaunchingWithOptions method (refer the requesting push notification permission section above for more details on this)
extension AppDelegate : UNUserNotificationCenterDelegate {
// below method will be called when the user interacts with the push notification
func userNotificationCenter (
_ center : UNUserNotificationCenter ,
didReceive response : UNNotificationResponse ,
withCompletionHandler completionHandler : @escaping ( ) -> Void ) {
// If this notification is Klaviyo's notification we'll handle it
// else pass it on to the next push notification service to which it may belong
let handled = KlaviyoSDK ( ) . handle ( notificationResponse : response , withCompletionHandler : completionHandler )
if !handled {
completionHandler ( )
}
}
// below method is called when the app receives push notifications when the app is the foreground
func userNotificationCenter (
_ center : UNUserNotificationCenter ,
willPresent notification : UNNotification ,
withCompletionHandler completionHandler : @escaping ( UNNotificationPresentationOptions ) -> Void ) {
if #available ( iOS 14 . 0 , * ) {
completionHandler ( [ . list , . banner ] )
} else {
completionHandler ( [ . alert ] )
}
}
} Bei der Verfolgung der geöffneten Push -Benachrichtigung können Sie auch die Abzeichenanzahl des App -Symbols verringern, indem Sie den folgenden Code zum userNotificationCenter:didReceive:withCompletionHandler -Methode:
func userNotificationCenter (
_ center : UNUserNotificationCenter ,
didReceive response : UNNotificationResponse ,
withCompletionHandler completionHandler : @escaping ( ) -> Void ) {
// decrement the badge count on the app icon
if #available ( iOS 16 . 0 , * ) {
UNUserNotificationCenter . current ( ) . setBadgeCount ( UIApplication . shared . applicationIconBadgeNumber - 1 )
} else {
UIApplication . shared . applicationIconBadgeNumber -= 1
}
// If this notification is Klaviyo's notification we'll handle it
// else pass it on to the next push notification service to which it may belong
let handled = KlaviyoSDK ( ) . handle ( notificationResponse : response , withCompletionHandler : completionHandler )
if !handled {
completionHandler ( )
}
} Wenn Sie beim Öffnen der App nur die Abzeichenanzahl auf Null zurücksetzen möchten (beachten Sie, dass dies vom Benutzer stammen kann, der gerade die App unabhängig von der Push -Nachricht öffnet), können Sie den folgenden Code zur applicationDidBecomeActive -Methode in der folgenden Code hinzufügen App -Delegierter:
func applicationDidBecomeActive ( _ application : UIApplication ) {
// reset the badge count on the app icon
if #available ( iOS 16 . 0 , * ) {
UNUserNotificationCenter . current ( ) . setBadgeCount ( 0 )
} else {
UIApplication . shared . applicationIconBadgeNumber = 0
}
}Sobald Ihre ersten Push -Benachrichtigungen gesendet und geöffnet sind, sollten Sie anfangen, geöffnete Push -Metriken in Ihrem Klaviyo -Dashboard zu sehen.
Ihre App muss mindestens Version 1.7.2 verwenden, damit die folgenden Schritte funktionieren.
Mit tiefen Links können Sie zu einer bestimmten Seite in Ihrer App navigieren, um auf den Benutzer zu reagieren, der eine Push -Benachrichtigung öffnet.
Sie müssen tiefe Links in Ihrer App konfigurieren, damit sie arbeiten können. Der Konfigurationsprozess für Klaviyo unterscheidet sich nicht von dem, was für die Behandlung von Deep -Verknüpfungen im Allgemeinen erforderlich ist, sodass Sie die Apple -Dokumentation für die Deep -Verknüpfung in Verbindung mit den hier beschriebenen Schritten befolgen können.
Sie haben zwei Optionen für die Implementierung von Deep -Links: URL -Schemata und universelle Links.
URL -Schemata sind die traditionelle und einfachere Art, aus einer Push -Benachrichtigung mit Ihrer App zu verbinden. Diese Links funktionieren jedoch nur, wenn Ihre mobile App auf einem Gerät installiert ist und von einem Webbrowser nicht verstanden wird, wenn Sie beispielsweise von einer E -Mail an Ihre App verlinken möchten.
Damit Apple einen tiefen Link zu Ihrer Anwendung weiterleitet, müssen Sie ein URL -Schema in der Info.plist -Datei Ihrer Anwendung registrieren. Dies kann mit dem Editor erfolgen, den Xcode auf der Registerkarte "Info" Ihrer Projekteinstellungen oder durch direkte Bearbeitung der info.plisten direkt zur Verfügung stellt.
Die erforderlichen Felder sind wie folgt:
Um die info.plist direkt zu bearbeiten, füllen Sie einfach Ihre App -spezifischen Details ein und fügen Sie diese in Ihren Plan ein.
< key >CFBundleURLTypes</ key >
< array >
< dict >
< key >CFBundleTypeRole</ key >
< string >Editor</ string >
< key >CFBundleURLName</ key >
< string >{your_unique_identifier}</ string >
< key >CFBundleURLSchemes</ key >
< array >
< string >{your_URL_scheme}</ string >
</ array >
</ dict >
</ array >Da iOS 9 Apple vorgeschrieben hat, dass die URL -Programme, die Ihre App geöffnet hat, auch in der Info.plist aufgeführt werden müssen. Dies ist zusätzlich zu Schritt 1 oben. Auch wenn Ihre App keine anderen Apps öffnet, müssen Sie das URL -Schema Ihrer App auflisten, damit Deep Linking mit der Arbeit mit der Arbeit verknüpft.
Dies muss in der info.plist direkt erfolgen:
< key >LSApplicationQueriesSchemes</ key >
< array >
< string >{your custom URL scheme}</ string >
</ array > Die Schritte 1 und 2 ermöglichen es Ihrer App, tiefe Links zu empfangen, aber Sie müssen diese Links in Ihrer App verarbeiten. Dies erfolgt durch die Implementierung der application:openURL:options: Methode in Ihrem App -Delegierten.
Beispiel:
func application (
_ app : UIApplication ,
open url : URL ,
options : [ UIApplication . OpenURLOptionsKey : Any ] = [ : ]
) -> Bool {
guard let components = NSURLComponents ( url : url , resolvingAgainstBaseURL : true )
else {
print ( " Invalid deep linking URL " )
return false
}
print ( " components: ( components . debugDescription ) " )
return true
} Wenn Sie Swiftui verwenden, können Sie onOpenURL(perform:) als Ansichtsmodifikator in der Ansicht, die Sie beabsichtigen, tiefe Links zu verarbeiten. Dies kann die Wurzel Ihrer Szene sein oder nicht.
Beispiel:
@ main
struct MyApplication : App {
var body : some Scene {
WindowGroup {
ContentView ( )
. onOpenURL { url in
// handle the URL that must be opened
}
}
}
} Schließlich haben wir eine Beispiel -App ( Examples/KlaviyoSwiftExamples ) im SDK -Repo, auf die Sie sich verweisen können, um ein Beispiel dafür zu erhalten, wie Deep -Links in Ihrer App implementiert werden.
Sobald die oben genannten Schritte abgeschlossen sind, können Sie Push -Benachrichtigungen vom Klaviyo -Push -Editor auf der Klaviyo -Website senden. Hier können Sie eine Push -Benachrichtigung über Klaviyo erstellen und senden, um sicherzustellen, dass die URL in dem in Schritt 3 implementierten Handler angezeigt wird.
Darüber hinaus können Sie lokal einen tiefen Link auslösen, um sicherzustellen, dass Ihr Code mit dem folgenden Befehl im Terminal funktioniert.
xcrun simctl openurl booted {your_URL_here}
Universelle Links sind eine modernere Art, tiefe Links zu bewältigen, und werden von Apple empfohlen. Sie sind sicherer und bieten eine bessere Benutzererfahrung. Im Gegensatz zu URL -Schemata benötigen sie jedoch ein bisschen mehr Setup, das in diesen Apple -Dokumenten hervorgehoben wird.
Sobald Sie das Setup aus den Apple -Dokumenten haben, müssen Sie die nachstehend beschriebene Push -Open -Tracking ändern:
extension AppDelegate : UNUserNotificationCenterDelegate {
func userNotificationCenter ( _ center : UNUserNotificationCenter , didReceive response : UNNotificationResponse , withCompletionHandler completionHandler : @escaping ( ) -> Void ) {
let handled = KlaviyoSDK ( ) . handle ( notificationResponse : response , withCompletionHandler : completionHandler ) { url in
print ( " deep link is " , url )
}
if !handled {
// not a klaviyo notification should be handled by other app code
}
}
}Beachten Sie, dass der Deep -Link -Handler auf dem Hauptfaden zurückgerufen wird. Wenn Sie zusätzlich zu universellen Links URL -Schemata verarbeiten möchten, implementieren Sie sie wie in Option 1: URL -Schema beschrieben.
Reiche Push -Benachrichtigungen werden in SDK Version 2.2.0 und höher unterstützt
Rich Push ist die Möglichkeit, Bilder hinzuzufügen, um Benachrichtigungsnachrichten zu pushen. Sobald die Schritte im Installationsabschnitt abgeschlossen sind, sollten Sie eine Benachrichtigungserweiterung in Ihrem Projekt -Setup mit dem Code aus der KlaviyoSwiftExtension haben. Im Folgenden finden Sie Anweisungen zum Testen reichhaltiger Push -Benachrichtigungen.
{
"aps" : {
"alert" : {
"title" : " Free apple vision pro " ,
"body" : " Free Apple vision pro when you buy a Klaviyo subscription. "
},
"mutable-content" : 1
},
"rich-media" : " https://www.apple.com/v/apple-vision-pro/a/images/overview/hero/portrait_base__bwsgtdddcl7m_large.jpg " ,
"rich-media-type" : " jpg "
}didRegisterForRemoteNotificationsWithDeviceToken mit der Konsole mit der Methode in AppDelegate ausgedruckt werden.Sobald Sie diese drei Dinge haben, können Sie den Push -Benachrichtigungs -Tester verwenden und eine lokale Push -Benachrichtigung senden, um sicherzustellen, dass alles richtig eingerichtet wurde.
Die Unterstützung von Sandbox ist in SDK Version 2.2.0 und höher erhältlich
Apple verfügt über zwei Umgebungen mit Push -Benachrichtigungsunterstützung - Produktion und Sandbox. Die Produktionsumgebung unterstützt das Versenden von Push -Benachrichtigungen an echte Benutzer, wenn eine App im App Store oder TestFlight veröffentlicht wird. Im Gegensatz dazu sind Sandbox -Anwendungen, die Push -Benachrichtigungen unterstützen, diejenigen, die mit iOS -Entwicklungszertifikaten anstelle von iOS -Verteilungszertifikaten unterschrieben sind. Sandbox fungiert als Staging -Umgebung und ermöglicht es Ihnen, Ihre Anwendungen in einer ähnlichen Umgebung zu testen, sich jedoch von der Produktion unterscheidet, ohne sich Sorgen um das Senden von Nachrichten an echte Benutzer zu machen.
Unser SDK unterstützt auch die Verwendung von Sandbox für Push. Das SDK von Klaviyo ermittelt und speichert die Umgebung, zu der Ihr Push -Token angehört und dies mit unserem Backend mitteilt, sodass Ihre Token an die richtigen Umgebungen weitergeleitet werden können. Es ist kein zusätzliches Setup erforderlich. Solange Sie Ihre Bewerbung mit unserem SDK zur Übertragung von Push-Token an unser Backend eingesetzt haben, sollte die Möglichkeit, Push in diesen Sandbox-Anwendungen zu senden und zu empfangen, out-of-the-Boxs senden.
Ab Version 1.7.0 wird der SDK eingehende Daten zwischenstrichen und in einem Intervall zur Klaviyo -API zurückkehren. Das Intervall basiert auf der derzeit von der App verwendeten Netzwerkverbindung. Die folgende Tabelle zeigt das für jede Art von Verbindung verwendete Flush -Intervall:
| Netzwerk | Intervall |
|---|---|
| Wwan/wifi | 10 Sekunden |
| Zellulär | 30 Sekunden |
Die Verbindungsbestimmung basiert auf Benachrichtigungen aus unserem Erreichbarkeitsdienst. Wenn kein Netzwerk verfügbar ist, kann der SDK Daten zwischengespeichert, bis das Netzwerk erneut verfügbar ist. Alle vom SDK gesendeten Daten sollten kurz nach der Spülung des SDK verfügbar sein.
Der SDK wird API -Anfragen wiederholen, die unter bestimmten Bedingungen fehlschlagen. Wenn beispielsweise ein Netzwerk -Timeout stattfindet, wird die Anfrage im nächsten Flush -Intervall wiedergegeben. Wenn der SDK einen Rate -Limiting -Fehler 429 von der Klaviyo -API erhält, verwendet er exponentielle Backoffs mit Jitter, um die nächste Anfrage wiederzuholen.
Weitere Informationen finden Sie im beitragenden Leitfaden, um zu erfahren, wie Sie zum Klaviyo Swift SDK beitragen. Wir begrüßen Ihr Feedback im Abschnitt "Ausgaben" unseres öffentlichen Github -Repositorys.
Klaviyoswift ist im Rahmen der MIT -Lizenz erhältlich. Weitere Informationen finden Sie in der Lizenzdatei.
