Aller au contenu principal

Intégration native iOS et Android

Vous pouvez intégrer directement les binaires du SDK dans une application Swift ou Kotlin. Consultez la présentation pour la livraison et les environnements, et la référence pour les résultats et les erreurs.

iOS — Swift​

Installer le framework​

Ajoutez CertificallTrust.xcframework à General > Frameworks, Libraries, and Embedded Content dans Xcode, en choisissant Embed & Sign.

Ajoutez les descriptions d'usage à Info.plist :

<key>NSCameraUsageDescription</key>
<string>Nécessaire pour la capture de photos certifiées.</string>
<key>NSLocationWhenInUseUsageDescription</key>
<string>Nécessaire pour certifier la localisation de la photo.</string>
<key>NSMotionUsageDescription</key>
<string>Nécessaire pour collecter les mouvements lors de la capture.</string>

Conservez une instance de CertificallTrustSDK dans votre contrôleur. Demandez les permissions avant de la configurer :

import CertificallTrust

// Propriété de votre UIViewController :
let sdk = CertificallTrustSDK()

func prepareCapture() {
    sdk.requestCameraPermission { [weak self] granted in
        guard let self = self, granted else { return }
        self.sdk.requestLocationPermission { [weak self] status in
            guard let self = self, status == "granted" else { return }
            self.sdk.requestMotionPermission()
            self.sdk.configure(
                apiKey: "<votre clé API SDK>",
                baseUrl: "https://dev.certificall.app/certificall/",
                appVersion: "1.0.0"
            )
        }
    }
}

Capturer et envoyer​

Appelez la capture depuis votre contrôleur visible, sans autre écran modal déjà présenté :

sdk.takePhoto(
    from: self,
    reportToken: "CHANTIER-2026-001",
    metadata: ["site": "Paris", "zone": "A1"]
) { [weak self] photo, error in
    guard let photo = photo else {
        print("Capture : \(CertificallSDKError.code(of: error))")
        return
    }

    // Conservez photo.toJSON() dans votre stockage avant un envoi différé.
    self?.sdk.sendPhoto(photo) { sent, error in
        guard let sent = sent else {
            print("Envoi : \(CertificallSDKError.code(of: error))")
            // Conservez la capture pour un réessai, selon l'erreur.
            return
        }
        DispatchQueue.main.async {
            print("Certificat PDF : \(sent["pdfUrl"] ?? "")")
        }
    }
}

La réponse d'envoi est un dictionnaire [String: Any]. Le callback d'envoi peut être exécuté hors du thread principal : utilisez DispatchQueue.main pour mettre à jour votre interface.

Pour conserver puis relire une capture :

let data = try JSONSerialization.data(withJSONObject: photo.toJSON())
// Enregistrez `data` dans votre stockage.

let json = try JSONSerialization.jsonObject(with: data) as! [String: Any]
let restored = try CapturedPhoto.fromJSON(json)
sdk.sendPhoto(restored) { sent, error in
    // Même parcours d'envoi que pour la capture initiale.
}

Pour une erreur typée, lisez CertificallSDKError.code(of: error) et, sur CertificallSDKError, les propriétés reasons, httpStatus et serverCode.

Android — Kotlin​

Installer le binaire​

Placez le binaire livré certificall-trust-sdk.aar dans le dossier app/libs/. Dans le build.gradle de votre application, ajoutez le binaire et ses dépendances : un AAR local ne les installe pas automatiquement.

dependencies {
    implementation(files("libs/certificall-trust-sdk.aar"))
    implementation("com.google.android.play:integrity:1.4.0")
    implementation("com.google.android.gms:play-services-location:21.0.1")
    implementation("androidx.exifinterface:exifinterface:1.3.7")
    implementation("androidx.core:core-ktx:1.12.0")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.6.2")
}

Déclarez les permissions dans AndroidManifest.xml :

<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.INTERNET" />

Le SDK fournit ses propres déclarations de caméra et de fournisseur de fichier. Aucune déclaration supplémentaire de FileProvider n'est nécessaire.

Configurer et recevoir le retour de la caméra​

Conservez l'instance du SDK dans votre Activity. Demandez les permissions caméra et localisation avec les API Android, puis configurez le SDK sur le thread principal une fois les permissions accordées :

import android.content.Intent
import app.certificall.sdk.CertificallTrustSDK

// Propriété de votre Activity :
private val sdk by lazy { CertificallTrustSDK(applicationContext) }

private fun configureSdk() {
    sdk.configure(
        apiKey = "<votre clé API SDK>",
        baseUrl = "https://dev.certificall.app/certificall/",
        appVersion = "1.0.0"
    )
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    sdk.handleActivityResult(this, requestCode, resultCode, data)
}

Le transfert de onActivityResult() au SDK est nécessaire pour terminer l'appel de capture.

Capturer et envoyer​

import app.certificall.sdk.CertificallError

sdk.takePhoto(
    this,
    "CHANTIER-2026-001",
    mapOf("site" to "Paris", "zone" to "A1")
) { photo, error ->
    if (photo == null) {
        println("Capture : ${CertificallError.codeOf(error)}")
        return@takePhoto
    }

    // Conservez photo.toJson().toString() dans votre stockage.
    sdk.sendPhoto(photo) { sent, sendError ->
        if (sent == null) {
            println("Envoi : ${CertificallError.codeOf(sendError)}")
            // Conservez la capture pour un réessai, selon l'erreur.
            return@sendPhoto
        }
        runOnUiThread {
            println("Certificat PDF : ${sent.optString("pdfUrl")}")
        }
    }
}

La réponse est un JSONObject. Le callback d'envoi s'exécute hors du thread principal : utilisez runOnUiThread pour mettre à jour l'interface.

Pour relire le JSON conservé :

import app.certificall.sdk.models.CapturedPhoto
import org.json.JSONObject

val restored = CapturedPhoto.fromJson(JSONObject(serializedPhoto))
sdk.sendPhoto(restored) { sent, error ->
    // Même parcours d'envoi que pour la capture initiale.
}

Lisez le code d'erreur avec CertificallError.codeOf(error). Les refus d'appareil sont des DeviceNotTrustedException (reasons) et les erreurs d'envoi des SendPhotoException (httpStatus, serverCode).

Libérer les suivis​

Les SDK natifs démarrent les suivis de réseau, de position et de mouvement à la configuration. Appelez sdk.stop() lorsque votre parcours n'en a plus besoin. Avant une nouvelle série de captures, reconfigurez le SDK pour redémarrer la collecte.