Forem: Andres Rojas

UserDefaults and Property Wrappers in Swift

Andres Rojas — Mon, 06 Apr 2020 23:40:28 +0000

The easiest way to save your objects into UserDefaults

According to Apple's documentation,

UserDefaults is an interface to the user’s defaults database, where you store key-value pairs persistently across launches of your app.

The UserDefaults class provides convenience methods for accessing common types such as floats, doubles, integers, Boolean values, and URLs. If you want to store any other type of object, you should typically archive it to create an instance of NSData.

Well, if we need NSData, how does it work?

First of all, we need to implement Codable, this is the easiest way to encode/decode our structs.

Let's define our Struct.

struct Task: Codable {
    var title: String
    var isDone: Bool
}

Before start using PropertyWrappers I'll show you use UserDefaults to save and get our objects.

func saveTask(_ task: Task, forKey key: String) throws {
    let userDefaults = UserDefaults.standard
    let encoder = JSONEncoder()
    do {
        let data = try encoder.encode(task)
        userDefaults.set(data, forKey: key)
        userDefaults.synchronize()
    } catch {
        throw(Errors.encodeError)
    }
}

func getTask(forKey key: String) throws -> Task? {
    let userDefaults = UserDefaults.standard
    let decoder = JSONDecoder()
    guard let data = userDefaults.object(forKey: key) as? Data else     {
        throw(Errors.noUserDefaults)
    }
    do {
        let task = try decoder.decode(Task.self, from: data)
        return task
    } catch {
        throw(Errors.decodeError)
    }
}

As you can see we have declared two different functions:

save Task, which encodes our Task model and use UserDefaults to save the whole data.
getTask, which uses UserDafaults to get the data and decodes it to get the Task model.

This is pretty simple to use, but the problem comes when we need to get and save our objects several times, so we need to be aware to call every function at a specific time.

What can we do to improve this process? Property Wrappers to the rescue!

A property wrapper is a swift feature that allows us to define a custom type that implements get and set methods, and we can reuse it everywhere in the app.

Before starting implementing our property wrapper, there are two important things to take into account:

Be sure you are using the @propertyWreapper annotation
You need to use a property called wrappedValue

This property will implement the get and set methods and here is where we're going to add our code to use the UserDefaults.

@propertyWrapper
struct UserDefaultsWrapper<Value: Codable> {
    let key: String
    let defaultValue: Value
    let userDefaults = UserDefaults.standard

    var wrappedValue: Value {
        get {
            let data = userDefaults.data(forKey: key)
            let value = data.flatMap { try? JSONDecoder().decode(Value.self, from: $0) }
            return value ?? defaultValue
        }

        set {
            let data = try? JSONEncoder().encode(newValue)
            userDefaults.set(data, forKey: key)
            userDefaults.synchronize()
        }
    }
}

This property wrapper expects two parameters: key and defaultValue, we use the default value when the UserDefaults can't retrieve the data, this will happen the first time when we try to access the property.

Finally, the implementation looks like this:

let defaultTasks: [Task] = [
    Task(title: "Learn SwiftUI", isDone: false),
    Task(title: "Share this article", isDone: true)
]
struct TaskProvider {
    @UserDefaultsWrapper(key: "Tasks", defaultValue: defaultTasks)
    var tasks: [Task]
}
print(TaskProvider().tasks)

And the result will be:

2 elements
  ▿ __lldb_expr_4.Task
    - title: "Learn SwiftUI"
    - isDone: false
  ▿ __lldb_expr_4.Task
    - title: "Share this article"
    - isDone: true

If you want to check the full implementation please visit this Gist

Introducción a los Atajos de Siri

Andres Rojas — Tue, 24 Mar 2020 01:29:17 +0000

Hace un tiempo tuve la oportunidad de compartir con la comunidad iOS de Medellín una charla introductoria a los Atajos de Siri, una herramienta que me parece muy interesante y que para mi modo de ver no es casi implementada.

Los Atajos de Siri salieron con iOS 12 y nos permite realizar tareas diarias de forma rápida y con las apps que más usamos. Estos atajos funcionan de varias formas:

Cuando son sugeridos por el propio Siri
Cuando nosotros los agregamos manualmente.
Cuando aparecen en ciertos lugares de la aplicación.

Atajos generados por Donaciones

Para que Siri pueda sugerir dichas acciones, nosotros como desarrolladores debemos comenzar a donarle actividades, estas actividades estarán relacionadas con el uso de la aplicación. Un ejemplo de esto podría ser una aplicación de domicilios el cual en un futuro pueda ser que Siri me sugiera comprar mi comida favorita.

Miremos cómo podemos hacer este tipo de donaciones en Swift, para esto, usaremos una aplicación básica de Todo List. La donación que realizaremos se hará cada vez que el usuario agregue una nueva tarea en nuestro Todo.

func  getNewTaskActivity() -> NSUserActivity {
    let activity = NSUserActivity(activityType: Constants.kNewTaskActivityType)
    activity.title = "Add a task"
    activity.isEligibleForSearch = true
    activity.isEligibleForPrediction = true
    activity.suggestedInvocationPhrase = "Let's create a task"

    let attributes = CSSearchableItemAttributeSet(itemContentType: kUTTypeItem as String)
    attributes.contentDescription = "Let's add more tasks to do"
    activity.contentAttributeSet = attributes

    return activity
}

Al crear el NSUserActivity nos pedirá el tipo de actividad, esta será una constante con la que identificaremos la actividad que inició nuestra aplicación.

isEligibleForSearch permite que nuestro shortcut pueda aparecer como un resultado de búsqueda de Siri.

isEligibleForPrediction indica que Siri que puede sugerir esta actividad en el futuro.

Mediante suggestedInvocationPhrase podemos sugerirle al usuario una frase con la cual invocará la acción con Siri. En el proceso de creación del atajo, el usuario podrá modificar esta frase y usar la de su elección.

Los atributos hacen referencia a información adicional que ayudará al usuario a entender la finalidad de este atajo, esta información es opcional y para que podamos usarla debemos hacer uso de CoreSpotlight y MobileCoreServices.

Ahora, para realizar la donación utilizaremos el siguiente bloque de código:

// 1
let activity = ActivityHelper.getNewTaskActivity()
view.userActivity = activity
// 2
activity.becomeCurrent()

Crearemos la actividad y la agregaremos al view controller que está siendo presentado
Llamamos becomeCurrent() para registrar esta actividad en el sistema.

Para ver el resultado de nuestra donación es necesario que habilitemos unas opciones de desarrollador, para esto vamos a Configuración buscamos Desarrollador y luego iremos a la sección SHORTCUTS TESTING en donde encontraremos Display Recent Shortcuts el cual nos ayudará a ver las donaciones como resultados de búsqueda en Spotlight y Display Donations on Lock Screen el cual permitirá que las donaciones aparezcan cuando tengamos la pantalla bloqueada.

Luego de habilitar estas opciones podremos ver cómo comienzan a generarse nuestras nuevas sugerencias de Siri.

Por último, para hacer que nuestra aplicación reaccione a las acciones del atajo debemos implementar la siguiente función dentro del AppDelegate.swift

func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
    if userActivity.activityType == Constants.kNewTaskActivityType {
        guard let navController = window?.rootViewController as? UINavigationController, let viewController = navController.viewControllers.first as? ListTableViewController else {
        return false
    }
    viewController.addTask()
    }   
    return false
}

Dentro de esta función validamos que la actividad que inició la aplicación corresponde a la de nuestro atajo, y por último llamamos la función addTask() la cual nos llevará a la creación de las tareas.

Atajos relevantes

Los atajo relevantes son aquellos que aparecen en lugares estratégicos de la aplicación y no es necesario esperar a que el usuario interactúe con la aplicación para que estos funcionen. Estos atajos aparecerán como un botón y se verá de la siguiente forma:

Una vez el usuario interactúe con dicho botón, automáticamente saldrá un asistente que lo guiará en la configuración del atajo.

Para agregar este botón vamos a hacer uso de la librería IntentsUI. El siguiente código de ejemplo es utilizado para agregar el botón a la vista de forma programática.

lazy  var  shortcut: INUIAddVoiceShortcutButton = {
    // 1
    let activity = ActivityHelper.getNewTaskActivity()
    // 2
    let shortcut = INShortcut(userActivity: activity)
    // 3
    let button = INUIAddVoiceShortcutButton(style: .whiteOutline)
    button.shortcut = shortcut
    button.translatesAutoresizingMaskIntoConstraints = false
    // 4
    button.delegate = self

    return button
}()

Obtenemos la actividad que será utilizada dentro de este atajo, para este ejemplo utilizaremos la actividad generada anteriormente que es getNewTaskActivity().
Una vez tenemos esta actividad procedemos a generar un nuevo shortcut a través de la clase INShortcut, el cual recibe como parámetro nuestra actividad recientemente creada.
Por último creamos el botón que utilizaremos en nuestra vista a través de la clase INUIAddVoiceShortcutButton y le asignaremos el atajo que creamos en el paso anterior.
Es necesario implementar INUIAddVoiceShortcutButtonDelegate para responder a las posibles acciones del botón. Este delegate tienes dos métodos que son importantes para nosotros: addVoiceShortcutViewController y editVoiceShortcutViewController. Para nuestro ejercicio solo utilizaremos el primero.

addVoiceShortcutViewController es llamado cuando el usuario va a crear un nuevo atajo, y es necesario que implementemos INUIAddVoiceShortcutViewControllerDelegate para conocer el resultado del proceso de creación. Estos resultados podrán ser addVoiceShortcutViewController y addVoiceShortcutViewControllerDidCancel.

El siguiente bloque de código nos muestra la implementación de los dos delegates anteriores.

extension  TaskItemViewController: INUIAddVoiceShortcutButtonDelegate {
    func present(_ addVoiceShortcutViewController: INUIAddVoiceShortcutViewController, for addVoiceShortcutButton: INUIAddVoiceShortcutButton) {
        addVoiceShortcutViewController.delegate = self
        present(addVoiceShortcutViewController, animated: true)
    }

    func present(_ editVoiceShortcutViewController: INUIEditVoiceShortcutViewController, for addVoiceShortcutButton: INUIAddVoiceShortcutButton) {

    }
}

extension  TaskItemViewController: INUIAddVoiceShortcutViewControllerDelegate {
    func addVoiceShortcutViewController(_ controller: INUIAddVoiceShortcutViewController, didFinishWith voiceShortcut: INVoiceShortcut?, error: Error?) {
        controller.dismiss(animated: true)
    }

    func addVoiceShortcutViewControllerDidCancel(_ controller: INUIAddVoiceShortcutViewController) {
        controller.dismiss(animated: true)
    }
}

Una vez creado el atajo, podremos acceder a él a través de la aplicación Atajos del iPhone.

Si quieres probar esta implementación puedes acceder a este repositorio de Github y clonar el proyecto.