WaitForIt

Waitforit

Waitforit hace que la implementación de escenarios comunes de la aplicación iOS sea muy fácil:

• "Muestre una pantalla de tutorial solo cuando el usuario inicia una aplicación por primera vez".
• "Pida al usuario una revisión, pero solo si instaló la aplicación hace más de dos semanas y la lanzó al menos 5 veces".
• "Pídale al usuario registrado que compre una suscripción una vez cada 3 días, pero no más de 5 veces en total".
• "Pídale al usuario que comparta algo de contenido en Facebook, si no lo hizo desde 4 días".

Tratar con este tipo de lógica generalmente implica guardar los datos manualmente para UserDefaults y debe rehacerse desde cero para cada escenario.

Uso

Waitforit proporciona una API declarativa simple que le permite manejar la mayoría de los posibles escenarios sin preocuparse por la implementación de la implementación.

ScenarioProtocol tiene las siguientes propiedades que se pueden usar para definir cuándo se debe ejecutar un escenario:

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

El escenario es una estructura simple que implementa una sola función config . Lo usa para configurar los valores que determinan cuándo se ejecutará un escenario determinado.

Puede operar en una estructura de escenario utilizando métodos estáticos:

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

Ejemplo básico

Digamos que desea mostrar una pantalla de tutorial solo una vez:

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

¡Eso es todo! Ya no necesitas tratar con UserDefaults tú mismo. Simplemente configure una estructura con las condiciones de ejecución correctas, y LIB se encarga del resto. Cuando se cumplan todas las condiciones para su escenario, el valor de bool pasado dentro del bloque tryToExecute será true .

Más condiciones

Intentemos un escenario un poco más complejo. Desea pedirle al usuario que compre una suscripción, si instaló una aplicación al menos hace 1 semana y la encendió al menos 5 veces. Desea preguntarle una vez cada 2 días, pero no más de 4 veces en 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
}

Condiciones personalizadas

Si las condiciones basadas en el tiempo y el recuento de eventos no son suficientes para su escenario, también puede definir un cierre de condiciones personalizadas. Se evaluará cada vez que intente ejecutar un escenario:

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

Se podrían implementar historias aún más complejas si decidiera mezclar condiciones de más de una estructura de escenario. Por supuesto, también puede dispersar los desencadenantes de eventos y las ejecuciones de escenarios en toda la aplicación, no necesitan estar en el mismo archivo.

La implementación se basa en UserDefaults estándar para que los datos no persistan si la aplicación se reinstala. Los nombres clave UserDefaults se generan con nombres de estructura, por lo que renombrar la estructura restablecerá todos sus datos. También puede restablecer datos persistidos usando el método reset() .

Instalación

Cartago

En tu Cartfile :

 github "pawurb/WaitForIt" ~> 2.0.0

Cocoapods

En tu Podfile :

 platform :ios , '10.0'
use_frameworks!

target 'TargetName' do
  pod 'WaitForIt'
end 

Estado

Lib se usa en la producción, pero todavía se encuentra en una etapa temprana de desarrollo. Las sugerencias sobre cómo se podría mejorar son bienvenidas.