iOS - Uso de Swift en tus Módulos Nativos

Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

Swift es el lenguaje oficial y predeterminado para desarrollar aplicaciones nativas en iOS.

En esta guía, explorarás cómo puedes escribir tus Módulos Nativos usando Swift.

nota

El núcleo de React Native está escrito principalmente en C++, y la interoperabilidad entre Swift y C++ no es óptima, a pesar de la capa de interoperabilidad desarrollada por Apple.

Por lo tanto, el módulo que crearás en esta guía no será una implementación pura en Swift debido a las incompatibilidades entre los lenguajes. Tendrás que escribir algo de código de conexión en Objective-C++, pero el objetivo de esta guía es minimizar la cantidad de código Objective-C++ necesario. Si estás migrando un Módulo Nativo existente de la arquitectura heredada a la Nueva Arquitectura, este enfoque te permitirá reutilizar la mayor parte del código.

Esta guía parte de la implementación para iOS de la guía de Módulo Nativo. Asegúrate de estar familiarizado con esa guía antes de profundizar en esta, idealmente implementando el ejemplo que allí se presenta.

El patrón Adaptador

El objetivo es implementar toda nuestra lógica de negocio usando un módulo en Swift y tener una fina capa de conexión en Objective-C++ que pueda vincular la aplicación con la implementación en Swift.

Puedes lograr esto utilizando el patrón de diseño Adaptador para conectar el Módulo Swift con la capa de Objective-C++.

El objeto Objective-C++ es creado por React Native y mantiene una referencia al módulo Swift, gestionando su ciclo de vida. El objeto Objective-C++ redirige todas las invocaciones de métodos a Swift.

Creando el Módulo Swift

El primer paso es trasladar la implementación de la capa Objective-C++ a la capa Swift.

Para lograrlo, sigue estos pasos:

1. Crea un nuevo archivo vacío en el proyecto de Xcode y nómbralo NativeLocalStorage.swift

2. Agrega la implementación en tu módulo Swift como se muestra a continuación:

NativeLocalStorage.swift

import Foundation

@objcMembers public class NativeLocalStorage: NSObject {
  let userDefaults = UserDefaults(suiteName: "local-storage");

  public func getItem(for key: String) -> String? {
    return userDefaults?.string(forKey: key)
  }

  public func setItem(for key: String, value: String) {
    userDefaults?.set(value, forKey: key)
  }

  public func removeItem(for key: String) {
    userDefaults?.removeObject(forKey: key)
  }

  public func clear() {
    userDefaults?.dictionaryRepresentation().keys.forEach { removeItem(for: $0) }
  }
}

Ten en cuenta que debes declarar todos los métodos que necesites llamar desde Objective-C como public y con la anotación @objc. Recuerda también hacer que tu clase herede de NSObject, de lo contrario no será posible usarla desde Objective-C.

Actualizar el archivo RCTNativeLocalStorage

Luego, necesitas actualizar la implementación de RCTNativeLocalStorage para poder crear el módulo Swift y llamar a sus métodos.

1. Abre el archivo RCTNativeLocalStorage.mm

2. Actualízalo como se muestra a continuación:

RCTNativeLocalStorage.mm

//  RCTNativeLocalStorage.m
//  TurboModuleExample

#import "RCTNativeLocalStorage.h"
+#import "SampleApp-Swift.h"

- static NSString *const RCTNativeLocalStorageKey = @"local-storage";

-@interface RCTNativeLocalStorage()
-@property (strong, nonatomic) NSUserDefaults *localStorage;
-@end

-@implementation RCTNativeLocalStorage
+@implementation RCTNativeLocalStorage {
+    NativeLocalStorage *storage;
+}

-RCT_EXPORT_MODULE(NativeLocalStorage)

 - (id) init {
   if (self = [super init]) {
-    _localStorage = [[NSUserDefaults alloc] initWithSuiteName:RCTNativeLocalStorageKey];
+    storage = [NativeLocalStorage new];
   }
   return self;
 }

 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
   return std::make_shared<facebook::react::NativeLocalStorageSpecJSI>(params);
 }

 - (NSString * _Nullable)getItem:(NSString *)key {
-   return [self.localStorage stringForKey:key];
+   return [storage getItemFor:key];
 }

 - (void)setItem:(NSString *)value key:(NSString *)key {
-   [self.localStorage setObject:value forKey:key];
+   [storage setItemFor:key value:value];
 }

 - (void)removeItem:(NSString *)key {
-   [self.localStorage removeObjectForKey:key];
+   [storage removeItemFor:key];
 }

 - (void)clear {
-   NSDictionary *keys = [self.localStorage dictionaryRepresentation];
-   for (NSString *key in keys) {
-     [self removeItem:key];
-   }
+  [storage clear];
 }

++ (NSString *)moduleName
+{
+  return @"NativeLocalStorage";
+}

@end

El código no cambia realmente. En lugar de crear una referencia directa a NSUserDefaults, creas un nuevo NativeLocalStorage usando la implementación en Swift y, cada vez que se invoca una función del módulo nativo, la invocación se redirige al NativeLocalStorage implementado en Swift.

Recuerda importar el encabezado "SampleApp-Swift.h". Este es un encabezado generado automáticamente por Xcode que contiene la API pública de tus archivos Swift, en un formato consumible por Objective-C. La parte de SampleApp en el encabezado es en realidad el nombre de tu aplicación, así que si creaste la aplicación con un nombre diferente a SampleApp, deberás cambiarlo.

Ten en cuenta también que la macro RCT_EXPORT_MODULE ya no es necesaria, porque los módulos nativos se registran usando el package.json como se describe aquí.

Este enfoque introduce cierta duplicación de código en las interfaces, pero te permite reutilizar el código Swift que ya puedas tener en tu base de código, con muy poco esfuerzo adicional.

Implementando el Encabezado de Puente

nota

Si eres un autor de bibliotecas y desarrollas un módulo nativo que se distribuirá como una biblioteca independiente, este paso no es necesario.

El último paso requerido para conectar el código Swift con su contraparte Objective-C++ es un encabezado puente (bridging header).

Un encabezado puente es un archivo de cabecera donde puedes importar todos los archivos de cabecera Objective-C que necesiten ser visibles para tu código Swift.

Es posible que ya tengas un encabezado puente en tu código base, pero si no es así, puedes crear uno nuevo siguiendo estos pasos:

1. En Xcode, crea un nuevo archivo y nómbralo "SampleApp-Bridging-Header.h"

2. Actualiza el contenido de "SampleApp-Bridging-Header.h" de la siguiente manera:

SampleApp-Bridging-Header.h

//
//  Use this file to import your target's public headers that you would like to expose to Swift.
//

+ #import <React-RCTAppDelegate/RCTDefaultReactNativeFactoryDelegate.h>

3. Vincula el encabezado puente en tu proyecto:
   1. En el navegador de proyectos, selecciona el nombre de tu aplicación (SampleApp, a la izquierda)
   2. Haz clic en Build Settings
   3. Filtra por "Bridging Header"
   4. Agrega la ruta relativa al "Bridging Header", en este ejemplo es SampleApp-Bridging-Header.h

Compila y ejecuta tu aplicación

Ahora puedes seguir el último paso de la guía de módulos nativos y deberías ver tu aplicación ejecutándose con un módulo nativo escrito en Swift.