SDK de iOS - Integración básica


Antes de empezar: Requisitos previos del SDK

¿Problemas durante la integración? Consulte las preguntas frecuentes más abajo.

Siga los pasos indicados en Integración de un SDK Singular:Planificación y requisitos previos.

Estos pasos son requisitos previos para cualquier integración de Singular SDK.


Instale el SDK

Puede instalar Singular SDK utilizando CocoaPods, el gestor de paquetes Swift o una biblioteca estática.

Instalación del SDK mediante CocoaPods
  1. Descargue e instale la última versión de CocoaPods.
  2. Para crear un archivo podfile, vaya a la carpeta raíz del proyecto en el Terminal y escriba:

    pod init
  3. Para añadir la dependencia de Singular SDK, añada lo siguiente al Podfile de su proyecto:

    pod 'Singular-SDK'

    Por ejemplo

    pod_for_swiftcocoapods.png

  4. En su Terminal, navegue hasta la carpeta raíz del proyecto y ejecute:

    pod install
  5. A partir de este momento, abra el archivo de espacio de trabajo de Xcode .xcworkspace para abrir el proyecto, en lugar del archivo .xcodeproj.
  6. Cree una cabecera puente Swift siguiendo las instrucciones que se indican a continuación.
Instalación del SDK mediante el gestor de paquetes Swift
  1. En Xcode, ve a Archivo > Añadir paquetes y entra en el repositorio de GitHub de Singular SDK:

    https://github.com/singular-labs/Singular-iOS-SDK

    update_sdk_version_1.png

  2. Actualiza la versión de Singular SDK:

    update_sdk_version_2.png

  3. Haz clic en el botón Añadir Paquete.
  4. Ve a Build Phases > Link Binary with Libraries y añade la librería AdServices.framework. Asegúrate de marcarla como Opcional ya que solo está disponible para dispositivos con iOS 14.3 y superior.

    link_binary_adservices.png

  5. Vaya a Build Settings > Linking > Other Linker Flags y actualice Other Linker Flags con los siguientes elementos:

    $(inherited) -ObjC -l "sqlite3.0" -l "z" -framework "AdSupport" -framework "Security" -framework "Singular" -framework "StoreKit" -framework "SystemConfiguration" -framework "WebKit" -framework "iAd"

    frameworks.png

    other_linker_flags.png

  6. Cree una cabecera puente Swift siguiendo las instrucciones que se indican a continuación.
Instalación del marco Singular SDK (Biblioteca estática)

La descarga e instalación de Singular Framework sólo es necesaria si NO está utilizando los métodos CocoaPods o SPM anteriores.

¿Está actualizando desde Singular SDK 12.3.2 o inferior?

Siga los pasos que se indican a continuación para eliminar la antigua biblioteca estática

  1. Vaya a los archivos del proyecto y elimine la biblioteca estática de Singular. Normalmente, debería tener una carpeta llamada algo así como Singular-iOS-sdk-v12.3.2. Haga clic con el botón derecho en la carpeta y elimínela del proyecto.
  2. Proceda a la siguiente sección para instalar el nuevo Framework

Añadir Singular Framework por primera vez

  1. Descargue y descomprima el SDK Framework.

    Seleccione el Framework correcto para su implementación:

  2. Añada la carpeta descomprimida a una carpeta de su proyecto Xcode:

    En Xcode, haga clic con el botón derecho en Nombre de su aplicación > Añadir archivos a [Nombre de su proyecto]. En el cuadro de diálogo que se abre, seleccione Opciones > Crear grupos y añada la carpeta donde descomprimió el SDK.





    El framework Singular debería estar ahora en su proyecto.

  3. Para añadir las bibliotecas necesarias

    • En Xcode, selecciona Build Phases > Link Binary With Libraries.
    • Haz clic en + y añade las siguientes bibliotecas:

      Libsqlite3.0.tbd
      SystemConfiguration.framework
      Security.framework
      Libz.tbd
      AdSupport.framework
      WebKit.framework
      StoreKit.framework
      AdServices.framework (mark as Optional since it's only
          available for devices with iOS 14.3 and higher).
  4. Embed & Sign the Singular Framework
    • Navega a General > Frameworks, Libraries, and Embedded Content
    • Ajusta el Singular Framework para que sea "Embed & Sign".

Añadir el encabezado de puente Swift

Si ha instalado el SDK utilizando CocoaPods o el gestor de paquetes de Swift, debe crear un Bridging Header para que Swift utilice las bibliotecas Obj-C del SDK de Singular.

  1. En su proyecto, cree un nuevo archivo de tipo Header , y nómbrelo YourProjectName-Bridging-Header.

    new_header_file.png

  2. Abra el archivo y añada lo siguiente:

    #import <Singular/Singular.h>

    Por ejemplo

    swift_cocoapods_import_singular.png

  3. Vaya a Build Settings > Objective-C Bridging Header y añada la ruta relativa del archivo:

    objective_c_bridging_header.png


Integrar el SDK

Importante:

  • Para utilizar Swift, debe disponer de un Bridging Header (consulte la guía anterior).
  • Si ha añadido Singular SDK mediante el gestor de paquetes Swift, asegúrese de actualizar Build Settings > Other Linker Flags como se explica más arriba.

Importación de la librería Singular

En el SceneDelegate, AppDelegate, o cualquier archivo donde se utilizará Singular, importar la biblioteca de clases Singular para empezar a utilizar el SDK Singular.

// If installed with Cocoapods or Swift Package Manager


import Singular
          
// If installed manually in Objective-C (New Framework)


#import <Singular/Singular.h>

// If installed manually in Objective-C (Legacy)


#import "Singular.h"

Creación de un objeto de configuración

Antes de inicializar la funcionalidad de Singular en su código, debe crear un objeto de configuración de Singular y establecer todas las opciones de configuración. Este bloque de código debe añadirse en SceneDelegate (o si no utiliza SceneDelegate, añádalo a AppDelegate).

El siguiente ejemplo de código crea un objeto de configuración y establece algunas opciones de configuración comunes, como activar SKAdNetwork en modo gestionado y establecer un tiempo de espera para una respuesta ATT.

En las secciones siguientes se ofrecen más detalles sobre cada una de estas opciones y sobre cómo personalizarlas.

Ejemplo: Creación de un objeto de configuración con algunas opciones comunes

SwiftObjective-C
func getConfig() -> SingularConfig? {
     
     // Create the config object with the SDK Key and SDK Secret


     guard let config = SingularConfig(apiKey: 'APIKEY', andSecret: 'SECRET') else {
         return nil
         }
     
     // If you are using App Tracking Transparency:


     // Set a 300 sec delay before initialization to wait for 


     // the user's ATT response.


     // (Remove this if you are not displaying an ATT prompt!)


     config.waitForTrackingAuthorizationWithTimeoutInterval = 300
     
     // Support custom ESP domains


     config.espDomains = ["links.your-website-domain.com"]
     
     // Set a handler method for deep links


     config.singularLinksHandler = { params in
          self.handleDeeplink(params: params)
     }
     
     return config
      }

Nota: A partir de la versión 12.0.6 del SDK de Singular iOS, SKAdNetwork está activado por defecto.

Si todavía utiliza una versión anterior del SDK, deberá habilitar SKAdNetwork utilizando el siguiente código al crear el objeto de configuración:

SwiftObjective-C
// Enable SKAdNetwork in Managed Mode


config.skAdNetworkEnabled = true

Personalización de las opciones de SKAdNetwork

SKAdNetwork es el marco de trabajo de Apple para determinar la atribución de instalaciones móviles sin comprometer la privacidad del usuario final. SKAdNetwork le permite medir el rendimiento de sus campañas de marketing de aplicaciones sin compartir la información de identificación personal del usuario.

Por defecto, SKAdNetwork está habilitado en Modo Gestionado, donde el valor de conversión es gestionado directamente por Singular desde el lado del servidor. Si utiliza el modo gestionado, no necesita añadir ningún código a su aplicación para gestionar SKAdNetwork.

Esto permite la máxima flexibilidad, ya que puede establecer y cambiar sus valores de conversión a través de la plataforma Singular sin modificar su código del lado del cliente.

Este modo gestionado del lado del servidor también le ayuda a manejar los temporizadores de SKAdNetwork. SKAdNetwork le permite actualizar el valor de conversión en un plazo de 24 horas desde el momento del registro en SKAdNetwork. Cualquier llamada para actualizar el valor de conversión prolonga el temporizador 24 horas más. Por lo tanto, al elegir sus eventos de conversión, tendrá que asegurarse de que los eventos se produzcan dentro de esa ventana de actualización. En modo gestionado, puede cambiar la configuración de los eventos de conversión en cualquier momento sin necesidad de lanzar una nueva versión de su aplicación.

Uso de SKAdNetwork en modo manual (Avanzado)

Aprenda a utilizar SKAdNetwork en modo manual

Si desea actualizar el valor de conversión por su cuenta utilizando el código de la app, primero debe establecer el flag manualSkanConversionManagement en el Singular Config. Esto le permite utilizar varios métodos del SDK para recuperar y actualizar el valor de conversión manualmente.

Para activar el modo manual:

SwiftObjective-C
func getConfig() -> SingularConfig? {
     
     // Singular Config Options


     guard let config = SingularConfig(apiKey: Constants.APIKEY,
       andSecret: Constants.SECRET) else {
         return nil
         }
     
     //...
     config.manualSkanConversionManagement = true
     //...
     
     return config
}

Para actualizar el valor de conversión:

En Modo Manual, para actualizar el valor de conversión, debe utilizar el método skanUpdateConversionValue. Puedes utilizarlo siempre que sea necesario en el ciclo de vida de tu aplicación.

Nota: El método skanUpdateConversionValue no funcionará si no has habilitado manualSkanConversionManagement.

Método skanUpdateConversionValue
Descripción Actualiza manualmente el valor de conversión de SKAdNetwork.
Firma (BOOL)skanUpdateConversionValue:(NSInteger)conversionValue;
Ejemplo de uso
SwiftObjective-C
// Sending a Standard Event for Login


Singular.event(EVENT_SNG_LOGIN)
      
// Manually updating the conversion value to 7 after the Event


Singular.skanUpdateConversionValue(7)

Otros métodos de SKAdNetwork:

Para obtener el valor de conversión actual, utilice el método skanGetConversionValue o conversionValueUpdatedCallback. Ambos funcionan en modo gestionado y manual.

Método skanGetConversionValue
Descripción Obtiene el valor de conversión actual rastreado por Singular SDK.
Firma (NSNumber *)skanGetConversionValue;
Ejemplo de uso
SwiftObjective-C
let conversionValue = Singular.skanGetConversionValue()
conversionValueUpdatedCallback Devolución de llamada
Descripción Obtiene el valor de conversión actual rastreado por Singular SDK.
Firma void(^conversionValueUpdatedCallback)(NSInteger);
Ejemplo de uso
SwiftObjective-C
func getConfig() -> SingularConfig? {
     // Singular Config Options


     guard let config = SingularConfig(apiKey: Constants.APIKEY,
       andSecret: Constants.SECRET) else {         
         return nil
         }     
     //...
     config.conversionValueUpdatedCallback = { conversionValue in
     // Here you have access to the latest conversion value


     }
     //...
     return config
}

Gestión del consentimiento ATT (establecimiento de un retardo de inicialización)

Visualización de un aviso ATT (App Tracking Transparency)

A partir de iOS 14.5, las aplicaciones están obligadas a solicitar el consentimiento del usuario (utilizando el marco App Tracking Transparency) antes de que puedan acceder y compartir algunos datos del usuario que son útiles para fines de seguimiento, incluyendo el IDFA del dispositivo.

Singular se beneficia enormemente de disponer del IDFA para identificar dispositivos y realizar la atribución de instalaciones (aunque hay formas de realizar la atribución sin el IDFA). Le recomendamos encarecidamente que solicite el consentimiento del usuario para obtener el IDFA.

Retrasar la inicialización para esperar la respuesta de la ATT

Por defecto, Singular SDK envía una sesión de usuario cuando se inicializa. Cuando se envía una sesión desde un nuevo dispositivo, se activa inmediatamente el proceso de atribución de Singular, que se realiza basándose únicamente en los datos de que dispone Singular en ese momento. Por lo tanto, es esencial solicitar el consentimiento y recuperar el IDFA antes de que el SDK de Singular envíe la primera sesión.

Para retrasar el lanzamiento de una sesión de usuario, inicialice Singular SDK con la opción waitForTrackingAuthorizationWithTimeoutInterval en el objeto Config. Esta opción ya está incluida en el ejemplo de código de 2.2. Creación de un objeto de configuración . Creación de un objeto Config.

SwiftObjective-C
func getConfig() -> SingularConfig? {
     guard let config = SingularConfig(apiKey: Constants.APIKEY,
       andSecret: Constants.SECRET) else {
         return nil
         }
     //...
     config.waitForTrackingAuthorizationWithTimeoutInterval = 300
     //...
     return config
}

Consejo: Cuando se establece un retardo de inicialización, el flujo de la aplicación es el siguiente:

  1. Cuando se abre la aplicación, Singular SDK comienza a registrar una sesión y los eventos del usuario, pero aún no los envía al servidor de Singular.
  2. Cuando se concede/deniega el consentimiento de App Tracking Transparency, o transcurre el tiempo establecido, el SDK envía la sesión y cualquier evento en cola al servidor de Singular (con o sin el IDFA).
  3. Singular inicia entonces el proceso de atribución, aprovechando el IDFA si está disponible.
Conozca todos los escenarios posibles de ATT

La siguiente tabla resume los posibles escenarios utilizando esta integración:

Escenario Disponibilidad de IDFA
El usuario ve el diálogo de consentimiento y otorga su consentimiento antes de que transcurra el tiempo establecido. El IDFA está disponible
El usuario ve el diálogo de consentimiento y lo deniega antes de que transcurra el tiempo establecido. IDFA no está disponible
El tiempo establecido expira, entonces el usuario ve el diálogo de consentimiento y otorga su consentimiento. IDFA está disponible sólo para los eventos de usuario que se reportan después de que se otorga el consentimiento
El tiempo establecido expira, entonces al usuario se le muestra el diálogo de consentimiento y niega el consentimiento. IDFA no está disponible
Al usuario se le muestra el diálogo de consentimiento, sale de la aplicación sin realizar ninguna acción, y más tarde abre la aplicación y otorga el consentimiento después de que el tiempo establecido haya expirado. Los eventos en cola se envían al servidor Singular cuando se vuelve a abrir la aplicación. El IDFA no está disponible para estos eventos. Cualquier evento registrado después de que se haya concedido el consentimiento tiene IDFA asociado.
Al usuario se le muestra el diálogo de consentimiento, sale de la aplicación sin realizar ninguna acción, y más tarde abre la aplicación y deniega el consentimiento. Los eventos en cola se envían a los servidores de Singular cuando se vuelve a abrir la aplicación. El IDFA no está disponible para estos eventos ni para ninguno de los eventos rastreados posteriormente.

Inicialización del SDK de Singular

Sugerencia: Antes de continuar, asegúrese de haber completado los pasos que se indican a continuación.

  • Añada la librería Singular
  • Si utiliza swift: cree un encabezado de puente Swift
  • Añadido código para crear el objeto Singular Config
  • Añadido un gestor de enlaces profundos
  • Habilitado SKAdNetwork
  • Si se muestra el ATT: añadido waitForTrackingAuthorizationWithTimeoutInterval
  • La aplicación se ha compilado correctamente (la aplicación debería compilarse sin errores en esta fase).

Singular SDK debe inicializarse cada vez que se abre la aplicación. Este es un requisito previo para todas las funciones de atribución de Singular, y también envía una nueva sesión de usuario a Singular (las sesiones se utilizan para calcular la retención de usuarios). El SDK se inicializa utilizando el objeto config que creó en Creación de un objeto de configuración.

¿Dónde añadir el código de inicialización?

Tiene que inicializar el SDK de Singular en cada punto de entrada a la aplicación:

  • Para iOS 13+ utilizando la Interfaz SwiftUI sin SceneDelegate o AppDelegate, inicialice el Singular SDK en el siguiente ContentView().onOpenURL() y .onChange(of: scenePhase) (Vea el código de abajo como ejemplo).

  • Para iOS 13+, inicialice Singular SDK en las siguientes funciones de SceneDelegate: willConnectTo session, continue userActivity, openURLContexts URLContexts.

  • Para versiones anteriores de iOS que no admitan SceneDelegate, inicialice el SDK en las siguientes funciones de AppDelegate: didFinishLaunchingWithOptions, continueUserActivity, openURL.

Ejemplos de código de inicialización

Para iOS 13+ (Swift SceneDelegate)
// INITIALIZE THE SDK IN THE FOLLOWING SCENEDELEGATE FUNCTIONS]


     
// willConnectTo session


func scene(_ scene: UIScene, willConnectTo session: UISceneSession,
  options connectionOptions: UIScene.ConnectionOptions) {
    let userActivity = connectionOptions.userActivities.first
    // Print IDFV to Console for use in Singular SDK Console


    print(Date(), "-- Scene Delegate IDFV:", 
    UIDevice().identifierForVendor!.uuidString as Any)
    
    //Initialize the Singular SDK here:
    if let config = self.getConfig() {
      config.userActivity = userActivity
      Singular.start(config)
    }
}
      
// continue userActivity


      
func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
  // Starts a new Singular session on continueUserActivity


  if let config = self.getConfig() {
    config.userActivity = userActivity
    Singular.start(config)
  }
}
      
//openURLContexts URLContexts
      
func scene(_ scene: UIScene, openURLContexts URLContexts: 
  Set<UIOpenURLContext>) {
    // Starts a new Singular session on cold start from deeplink scheme


    if let config = self.getConfig() {
      config.openUrl = openurlString
      Singular.start(config)
    }
    
    // Add custom code here to Redirect to non-Singular deep links


    //...
}
Para iOS 13+ (SwiftUI Interface)
// INITIALIZE THE SDK IN THE FOLLOWING WINDOWGROUP FUNCTIONS


var body: some Scene {
    WindowGroup {
        ContentView()
            .onOpenURL(perform: { url in
                openURL = url
                // Initialize Singular from an openURL


                if let config = self.getConfig() {
                    config.openUrl = url
                    Singular.start(config)
                }
            })
    }
    .onChange(of: scenePhase) { oldValue, phase in
        // The SwiftUI ScenePhases replaces the old SceneDelegate lifecycle events


        switch phase {
        case .background:
            print("App Scene: backgrounded")
        case .inactive:
            print("App Scene: inactive")
        case .active:
            print("App Scene: active")
            
            // Initialize Singular


            if let config = self.getConfig() {
                Singular.start(config)
            }
        @unknown default:
            print("App Scene: unknown")
        }
    }
}
Para iOS 13+ (Objective-C SceneDelegate)
// INITIALIZE THE SDK IN THE FOLLOWING SCENEDELEGATE FUNCTIONS


     
// willConnectToSession


- (void)scene:(UIScene *)scene willConnectToSession:(UISceneSession *)session 
  options:(UISceneConnectionOptions *)connectionOptions {
    NSUserActivity* userActivity = [[[connectionOptions userActivities] allObjects] 
      firstObject];
    // Print identifier for Vendor (IDFV) to Xcode Console for use in Singular SDK Console


    NSLog(@"-- Scene Delegate IDFV: %@", [[[UIDevice currentDevice] identifierForVendor] UUIDString]);
    
    // Start a new Singular session from a backgrounded app


    SingularConfig *config = [self getConfig];
    config.userActivity = userActivity;
    [Singular start:config];
}
    
// continueUserActivity


- (void)scene:(UIScene *)scene continueUserActivity:(NSUserActivity *)userActivity{
  // Starts a new Singular session from a backgrounded App


  SingularConfig *config = [self getConfig];
  config.userActivity = userActivity;
  [Singular start:config];
}
    
// openURLContexts


- (void)scene:(UIScene *)scene openURLContexts:(nonnull NSSet *)URLContexts {
  // Starts a new Singular session on cold start from deeplink scheme


  SingularConfig *config = [self getConfig];
  config.openUrl = url;
  [Singular start:config];
  
  // Add custom code here to Redirect to Non-Singular deep links


  //...
}
Para versiones anteriores de iOS (Objective-C AppDelegate)
// INITIALIZE THE SDK IN THE FOLLOWING APPDELEGATE FUNCTIONS


    
// didFinishLaunchingWithOptions


- (BOOL)application:(UIApplication *)application 
  didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // Starts  new session when  user opens the app if session timeout passed/opened using Singular Link


    SingularConfig *config = [self getConfig];
    config.launchOptions = launchOptions;
    [Singular start:config];
    return YES;
}
    
// continueUserActivity


- (BOOL)application:(UIApplication *)application 
  continueUserActivity:(NSUserActivity *)userActivity 
    restorationHandler:(void (^)(NSArray<id> *restorableObjects))restorationHandler {
      // Starts a new session when the user opens the app using a Singular Link while it was in the background


      SingularConfig *config = [self getConfig];
      config.userActivity = userActivity;
      [Singular start:config];
      return YES;
}
    
// openURL


- (BOOL)application:(UIApplication *)app openURL:(NSURL *)url 
  options:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options{
    // Starts new session when user opens the app using a non-Singular link, like a traditional app scheme.


    SingularConfig *config = [self getConfig];
    config.openUrl = url;
    [Singular start:config];
    // Add custom code here to Redirect to non-Singular deep links


    //...
    return YES;
}
Para versiones anteriores de iOS (Swift AppDelegate)
Importante:
  • AppDelegate inicializará Singular sólo para iOS 12.4 o versiones anteriores.
  • Si su objetivo son versiones de iOS superiores a la 12.4, deberá empezar a utilizar las actividades de SceneDelegate.
// INITIALIZE THE SDK IN THE FOLLOWING APPDELEGATE FUNCTIONS


    
// didFinishLaunchingWithOptions


func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) - Bool {
     // Print IDFV to Console for use in Singular SDK Console 


     print(Date(), "-- Scene Delegate IDFV:", UIDevice().identifierForVendor!.uuidString as Any)
     
     //Initialize the Singular SDK here: 
     if let config = self.getConfig() { 
          config.launchOptions = launchOptions 
          Singular.start(config) 
     }
     
     return true
}
    
// continue userActivity


func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([any UIUserActivityRestoring]?) - Void) - Bool {
     
     //Initialize the Singular SDK here: 
     if let config = self.getConfig() {
          config.userActivity = userActivity
          Singular.start(config) 
     }
     
     return true
}
     
// open url


func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) - Bool {
     
     //Initialize the Singular SDK here: 
     if let config = self.getConfig() {
          config.openUrl = url
          Singular.start(config) 
     }
     
     return true
}

Notas:

  • Al crear el objeto config, tenga cuidado de pasar la opción correcta: userActivity o openUrl. Consulte el código de ejemplo a continuación y consulte las aplicaciones de ejemplo si es necesario.
  • Recuerde cumplir las distintas leyes de privacidad promulgadas en las regiones en las que realiza negocios, incluidas GDPR, CCPA y COPPA. Para obtener más información, consulte SDK Opt-In and Opt-Out Practices y revise las funciones de Singular SDK que le ayudan a cumplir con las leyes de privacidad de datos.
  • Para inicializar el SDK, necesita su Clave Singular SDK y su Secreto SDK. Puede obtenerlas en la plataforma Singular en"Herramientas para desarrolladores > Integración SDK > Claves SDK".

Preguntas frecuentes y problemas

Consulte esta sección si encuentra algún problema o error al crear su aplicación de prueba.

¿Por qué recibo un error "Sandbox: rsync.samba(15813) deny(1) file-read-data..."?

En Xcode 15, hay una nueva opción llamada "User Script Sandboxing" que juega un papel crucial en la compilación El propósito es evitar que los scripts realicen cambios no deseados en el sistema, mejorando así la estabilidad y la seguridad de la compilación. Cuando está activado, el sistema de compilación restringe los scripts de usuario para no permitir dependencias de entrada/salida no declaradas. Esto es problemático para Singular SDK, ya que necesita ejecutar scripts para vincular dinámicamente las dependencias.

Para resolver el problema

  1. Vaya a Configuración de compilación > Opciones de compilación.
  2. Ajuste "User Script Sandboxing " al valor "No".
¿Por qué aparece el error "No module named Singular"?
  1. Compruebe que se ha creado el Bridging Header.
  2. Compruebe que el archivo Bridging Header está vinculado en Build Settings > Objective-C Bridging Header.
¿Por qué recibo un error de compilación "Arm64"?

En algunos casos, el simulador de iOS requiere que arm64 se excluya en Build Settings > Excluded Architectures.

excluded_architectures_arm64.png

He implementado las propiedades globales. ¿Por qué no las veo en la consola de pruebas?

Las propiedades globales no se muestran actualmente en la consola de pruebas. Se añadirán en el futuro. Utilice Exportar registros para validar esta funcionalidad.

¿Por qué aparece un error de registro?

Los siguientes errores de registro comunes pueden ignorarse:

  • [logging] nombre de columna duplicado: singular_link en "ALTER TABLE sessions ADD COLUMN singular_link TEXT DEFAULT NULL"
  • [logging] nombre de columna duplicado: payload en "ALTER TABLE sessions ADD COLUMN payload TEXT DEFAULT NULL"
  • [logging] duplicate column name: sequence in "ALTER TABLE events ADD COLUMN sequence INTEGER DEFAULT -1"
  • [logging] duplicate column name: payload in "ALTER TABLE events ADD COLUMN payload TEXT DEFAULT NULL"