WaitForIt

Waitforit

WaitForit macht die Implementierung einer gemeinsamen iOS -App -Szenarien zum Kinderspiel:

• "Zeigen Sie nur einen Tutorial -Bildschirm an, wenn der Benutzer zum ersten Mal eine App startet."
• "Fragen Sie den Benutzer nach einer Überprüfung, aber nur, wenn er die App mehr als vor zwei Wochen installiert und mindestens fünfmal gestartet hat."
• "Bitten Sie den registrierten Benutzer, alle 3 Tage ein Abonnement zu kaufen, aber insgesamt nicht mehr als 5 -mal."
• "Bitten Sie den Benutzer, Inhalte auf Facebook zu teilen, wenn er es seit 4 Tagen nicht mehr getan hat."

Der Umgang mit dieser Art von Logik beinhaltet normalerweise das manuelle Speichern von Daten in UserDefaults und muss für jedes Szenario von Grund auf neu redone werden.

Verwendung

WaitForit bietet eine einfache deklarative API, mit der Sie die meisten möglichen Szenarien behandeln können, ohne sich um die Unterlagen der Implementierung zu kümmern.

ScenarioProtocol verfügt über die folgenden Eigenschaften, die verwendet werden können, um zu definieren, wann ein Szenario ausgeführt werden soll:

 protocol ScenarioProtocol {
    // minimum number of scenario events needed to be trigerred before scenario can be executed
    static var minEventsRequired : Int ? { get set }

    // maximum number of scenario events which can be trigerred before scenario stops executing
    static var maxEventsPermitted : Int ? { get set }

    // maximum number of times that scenario can be executed
    static var maxExecutionsPermitted : Int ? { get set }

    // minimum time interval, after the first scenario event was trigerred, before the scenario can be executed
    static var minSecondsSinceFirstEvent : TimeInterval ? { get set }

    // minimum time interval, after the last scenario event was trigerred, before the scenario can be executed
    static var minSecondsSinceLastEvent : TimeInterval ? { get set }

    // minimum time interval before scenario can be executed again after previous execution
    static var minSecondsBetweenExecutions : TimeInterval ? { get set }

    // custom conditions closure
    static var customConditions : ( ( ) -> Bool ) ? { get set }
}

Das Szenario ist eine einfache Struktur, die eine einzelne config implementiert. Sie verwenden es, um Werte zu konfigurieren, die feststellen, wann ein bestimmtes Szenario ausgeführt wird.

Sie können mit statischen Methoden auf einer Szenariostruktur arbeiten:

    // increment scenario specific event counter
    static func triggerEvent ( )

    // try to execute a scenario (it counts as executed only if bool param passed into a block was `true`)
    static func tryToExecute ( completion : @escaping ( Bool ) -> Void )

    // reset scenario event and execution counters
    static func reset ( )

Grundlegendes Beispiel

Angenommen, Sie möchten nur einmal einen Tutorial -Bildschirm anzeigen:

import WaitForIt

struct ShowTutorial : ScenarioProtocol {
    static func config ( ) {
        maxExecutionsPermitted = 1
    }
}

// In ViewController.swift
func viewDidLoad ( ) {
    super . viewDidLoad ( )
    ShowTutorial . tryToExecute { didExecute in
        if didExecute {
            self . showTutorial ( )
        }
    }
}

Das war's! Sie müssen sich nicht mehr mit UserDefaults zu tun. Konfigurieren Sie einfach eine Struktur mit den richtigen Ausführungsbedingungen, und Lib kümmert sich um den Rest. Wenn alle Bedingungen für Ihr Szenario erfüllt sind, wird der BOOL -Wert in dem tryToExecute -Block true .

Weitere Bedingungen

Versuchen wir es ein bisschen komplexeres Szenario. Sie möchten den Benutzer bitten, ein Abonnement zu kaufen, wenn er vor mindestens 1 Woche eine App installiert und mindestens fünfmal eingeschaltet hat. Sie möchten ihn einmal alle 2 Tage fragen, aber nicht mehr als insgesamt viermal:

import WaitForIt

struct AskToSubscribe : ScenarioProtocol {
    static func config ( ) {
        minEventsRequired = 5
        minSecondsSinceFirstEvent = 604 800 // seconds in one week
        maxExecutionsPermitted = 4
        minSecondsBetweenExecutions = 172 800 // seconds in two days
    }
}

// In AppDelegate.swift
func application ( _ application : UIApplication ,
  didFinishLaunchingWithOptions launchOptions : [ UIApplicationLaunchOptionsKey : Any ] ? ) -> Bool {

    AskToSubscribe . triggerEvent ( )
    AskToSubscribe . tryToExecute { didExecute in
        if didExecute {
            self . askToSubscribe ( )
        }
    }

    return true
}

Benutzerdefinierte Bedingungen

Wenn für Ihr Szenario zeit- und event zählbasierte Bedingungen nicht ausreichen, können Sie auch einen benutzerdefinierten Zustand des Verschlusses definieren. Es wird jedes Mal bewertet, wenn Sie versuchen, ein Szenario auszuführen:

 struct ShowLowBrightnessAlertOnce : ScenarioProtocol {
    static func config ( ) {
        customConditions = {
            return UIScreen . main . brightness < 0.3
        }
        maxExecutionsPermitted = 1
    }
}

Noch komplexere Geschichten könnten implementiert werden, wenn Sie sich entschlossen haben, Bedingungen von mehr als einem Szenariostruktur zu mischen. Natürlich können Sie auch Ereignisauslöser und Szenario -Ausführungen in der gesamten App verstreuen, sie müssen nicht in derselben Datei enthalten sein.

Die Implementierung basiert auf Standard UserDefaults , sodass die Daten nicht bestehen bleiben, wenn die App neu installiert ist. UserDefaults -Schlüsselnamen werden mit Strukturnamen generiert. Die Umbenennung der Struktur setzt daher alle Daten zurück. Sie können auch persistierte Daten mithilfe reset() -Methode zurücksetzen.

Installation

Karthago

In Ihrer Cartfile :

 github "pawurb/WaitForIt" ~> 2.0.0

Cocoapods

In Ihrer Podfile :

 platform :ios , '10.0'
use_frameworks!

target 'TargetName' do
  pod 'WaitForIt'
end 

Status

Lib wird in der Produktion verwendet, ist aber immer noch in einem frühen Entwicklungsstadium. Vorschläge, wie es verbessert werden könnte, sind willkommen.