WaitForIt

Attendre

WaitForit fait de l'implémentation des scénarios d'application iOS courants une brise:

• "Afficher un écran de tutoriel uniquement lorsque l'utilisateur lance une application pour la première fois."
• "Demandez à l'utilisateur un examen, mais seulement s'il a installé l'application il y a plus de deux semaines et l'a lancé au moins 5 fois."
• "Demandez à l'utilisateur enregistré d'acheter un abonnement une fois tous les 3 jours, mais pas plus de 5 fois au total."
• "Demandez à l'utilisateur de partager du contenu sur Facebook, s'il ne l'a pas fait depuis 4 jours."

Traiter ce type de logique implique généralement de l'enregistrement manuellement des données à UserDefaults et doit être refait à partir de zéro pour chaque scénario.

Usage

WaitForit fournit une API déclarative simple vous permettant de gérer la plupart des scénarios possibles sans vous soucier de l'implémentation sous-traitée.

ScenarioProtocol ont les propriétés suivantes qui peuvent être utilisées pour définir lorsqu'un scénario doit être exécuté:

 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 }
}

Le scénario est une structure simple qui implémente une seule fonction config . Vous l'utilisez pour configurer des valeurs déterminant quand un scénario donné s'exécutera.

Vous pouvez fonctionner sur une structure de scénario à l'aide de méthodes statiques:

    // 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 ( )

Exemple de base

Disons que vous souhaitez afficher un écran de tutoriel une seule fois:

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 ( )
        }
    }
}

C'est ça! Vous n'avez plus besoin de traiter vous-même avec UserDefaults . Configurez simplement une structure avec des conditions d'exécution correctes et Lib s'occupe du reste. Lorsque toutes les conditions de votre scénario sont remplies, la valeur Bool transmise à l'intérieur du bloc tryToExecute sera true .

Plus de conditions

Essayons un scénario un peu plus complexe. Vous souhaitez demander à l'utilisateur d'acheter un abonnement, s'il a installé une application il y a au moins 1 semaine et l'a allumée au moins 5 fois. Vous voulez lui demander une fois tous les 2 jours mais pas plus de 4 fois au total:

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
}

Conditions personnalisées

Si les conditions basées sur le temps et le nombre d'événements ne sont pas suffisantes pour votre scénario, vous pouvez également définir une fermeture de conditions personnalisées. Il sera évalué chaque fois que vous essaiera d'exécuter un scénario:

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

Des histoires encore plus complexes pourraient être mises en œuvre si vous décidiez de mélanger les conditions à partir de plus d'un scénario. Bien sûr, vous pouvez également disperser les déclencheurs d'événements et les exécutions de scénarios à travers l'application, ils n'ont pas besoin d'être dans le même fichier.

La mise en œuvre est basée sur UserDefaults standard afin que les données ne persistent pas si l'application est réinstallée. UserDefaults Les noms de clés sont générés avec des noms de structure, donc le renommer de la structure réinitialise toutes ses données. Vous pouvez également réinitialiser les données persistantes à l'aide de la méthode reset() .

Installation

Carthage

Dans votre Cartfile :

 github "pawurb/WaitForIt" ~> 2.0.0

Cocoapodes

Dans votre Podfile :

 platform :ios , '10.0'
use_frameworks!

target 'TargetName' do
  pod 'WaitForIt'
end 

Statut

La LIB est utilisée dans la production mais elle est encore à un stade précoce du développement. Les suggestions sur la façon dont cela pourraient être améliorées sont les bienvenues.