WaitForIt

Waitforit

WaitForit torna a implementação de um aplicativo iOS comum uma brisa:

• "Exiba uma tela tutorial apenas quando o usuário iniciar um aplicativo pela primeira vez."
• "Peça uma revisão do usuário, mas apenas se ele instalou o aplicativo há mais de duas semanas e o lançou pelo menos 5 vezes".
• "Peça ao usuário registrado para comprar uma assinatura uma vez a cada 3 dias, mas não mais do que 5 vezes no total."
• "Peça ao usuário que compartilhe algum conteúdo no Facebook, se ele não o fez desde 4 dias".

Lidar com esse tipo de lógica geralmente envolve salvar manualmente os dados nos UserDefaults e deve ser refeito do zero para cada cenário.

Uso

O WaitForit fornece uma API declarativa simples, permitindo que você lide com a maioria dos cenários possíveis sem se preocupar em implementação subjacente.

ScenarioProtocol possui as seguintes propriedades que podem ser usadas para definir quando um cenário deve ser executado:

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

O cenário é uma estrutura simples que implementa uma única função config . Você o usa para configurar valores que determinam quando um determinado cenário será executado.

Você pode operar em uma estrutura de cenário usando 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 ( )

Exemplo básico

Digamos que você queira exibir uma tela tutorial apenas uma 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 ( )
        }
    }
}

É isso! Você não precisa mais lidar com UserDefaults . Basta configurar uma estrutura com condições de execução corretas e a LIB cuida do resto. Quando todas as condições para o seu cenário forem cumpridas, o valor do BOOL passado dentro do bloco tryToExecute será true .

Mais condições

Vamos tentar um cenário um pouco mais complexo. Você deseja pedir ao usuário que compre uma assinatura, se ele instalou um aplicativo há pelo menos 1 semana e ligou pelo menos 5 vezes. Você quer perguntar a ele uma vez a cada 2 dias, mas não mais do que 4 vezes no 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
}

Condições personalizadas

Se as condições baseadas no tempo e na contagem de eventos não forem suficientes para o seu cenário, você também poderá definir um fechamento de condições personalizadas. Ele será avaliado toda vez que você tentar executar um cenário:

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

Histórias ainda mais complexas poderiam ser implementadas se você decidisse misturar condições de mais de um cenário. É claro que você também pode dispersar gatilhos de eventos e execuções de cenário em todo o aplicativo, eles não precisam estar no mesmo arquivo.

A implementação é baseada em UserDefaults padrão, para que os dados não persistam se o aplicativo for reinstalado. Os nomes de chave UserDefaults são gerados com nomes de estruturas, portanto, renomear a estrutura redefinirá todos os seus dados. Você também pode redefinir os dados persistentes usando o método reset() .

Instalação

Cartago

No seu Cartfile :

 github "pawurb/WaitForIt" ~> 2.0.0

Cocoapods

No seu Podfile :

 platform :ios , '10.0'
use_frameworks!

target 'TargetName' do
  pod 'WaitForIt'
end 

Status

A LIB é usada na produção, mas ainda está em um estágio inicial de desenvolvimento. Sugestões sobre como isso pode ser melhorado são bem -vindas.