Kade iOS Core SDK

Overview

GeoFenceClient.shared is the high-level native entry point. It owns configuration, encryption, pings, continuous checks, and fingerprint submission. GeoFenceCore.shared exposes lower-level permissions, location, device, and marker collection.

Availability

The iOS Core SDK is not currently distributed as a standalone public CocoaPods artifact. There is no public pod installation command to use.

The source configuration sets an iOS 13.0 minimum, Swift 5.7, and links Foundation, CoreLocation, CoreMotion, SystemConfiguration, Network, Security, and DeviceCheck.

Integration

After Kade supplies the native package, add it to the application target using the delivery-specific instructions. Do not add the React Native bridge to a native-only target.

Application requirements

• Set the deployment target to iOS 13.0 or later.
• Link the system frameworks included by the supplied package.
• Add the location usage description shown below.
• Use the module name supplied by Kade when importing Core.

Build your application target to verify the delivered package:

xcodebuild \
  -workspace YourApp.xcworkspace \
  -scheme YourApp \
  -sdk iphonesimulator \
  build

Quick start

Start the shared client asynchronously, then issue a ping only after configuration succeeds.

import GeoFenceSdk

let client = GeoFenceClient.shared
let config = GeoFenceConfig(
    apiToken: "your-api-token",
    regionId: 123
)

client.start(config: config) { result in
    switch result {
    case .success:
        let options = PingOptions(
            userId: "player-123",
            source: "login",
            email: "player@example.com"
        )

        client.ping(options: options) { pingResult in
            switch pingResult {
            case .success(let response):
                if response.blocked == true {
                    print("Blocked:", response.code ?? "unknown")
                } else {
                    print("Inside:", response.inside)
                    print("Area:", response.area?.name ?? "none")
                }
            case .failure(let error):
                print("Kade ping failed:", error)
            }
        }
    case .failure(let error):
        print("Kade startup failed:", error)
    }
}

Location permissions

Add a user-facing location purpose string to the host application's Info.plist, then use GeoFenceCore to inspect and request authorization.

<key>NSLocationWhenInUseUsageDescription</key>
<string>Your location is used to verify availability in your region.</string>

let core = GeoFenceCore.shared

switch core.getLocationPermissionStatus() {
case .granted:
    beginVerification()
case .notDetermined:
    core.requestLocationPermission { status in
        DispatchQueue.main.async {
            if status == .granted {
                beginVerification()
            } else {
                showLocationUnavailable()
            }
        }
    }
case .denied, .restricted:
    showLocationUnavailable()
}

The native permission states are granted, denied, restricted, and notDetermined. If your policy permits a server-side check without device location, set skipLocation: true on PingOptions; confirm that policy with Kade.

Core API

These are native Swift signatures from the Core layer, not React Native bridge methods.

GeoFenceClient

Selected GeoFenceCore methods

let core = GeoFenceCore.shared

let status = core.getLocationPermissionStatus()
let device = core.getDeviceInfo()
let jailbreak = core.getJailbreak()
let developerMode = core.getDeveloperMode()
let mockLocation = core.getMockLocation()
let locationSource = core.getLocationSource()
let vpn = core.getVpn()
let battery = core.getBattery()

core.getCurrentLocation(
    accuracy: .high,
    timeoutMs: 10_000,
    maxAgeMs: 120_000
) { result in
    // Result<GeoLocation, Error>
}

Core also exposes sensor collection, integrity attestation, aggregate mobile markers, persisted fingerprint ID accessors, and explicit location watcher controls. Most integrations should prefer GeoFenceClient for policy checks.

Configuration

GeoFenceConfig

PingOptions

let options = PingOptions(
    userId: "player-123",
    silent: false,
    skipLocation: false,
    source: "deposit",
    regionId: 123,
    email: "player@example.com",
    firstName: "Player",
    lastName: "One"
)

Every option has a default. source is a free-form flow tag, regionId overrides configuration for that ping, and identity fields are associated with the server-side client record.

Lifecycle and continuous checks

Register handlers before starting continuous checks, retain no second client instance, and stop checks when the protected flow ends.

let client = GeoFenceClient.shared

client.onPingResponse = { response in
    DispatchQueue.main.async {
        updateAccessState(using: response)
    }
}

client.onPingError = { error in
    DispatchQueue.main.async {
        showVerificationError(error)
    }
}

client.startContinuousPing(
    options: PingOptions(userId: "player-123", source: "session")
)

// When the verified flow ends:
client.stopContinuousPing()

// When disposing the entire integration:
client.destroy()

• startContinuousPing does nothing before successful startup.
• Starting again while a controller exists does nothing.
• stop() and stopContinuousPing() stop continuous checks; destroy() also clears Core and configuration state.
• Callbacks are not documented as main-thread callbacks. Dispatch UI work to the main queue.

Response handling

Branch on blocked first, tolerate optional fields, and keep transport failures separate from server verdicts.

func handle(_ response: PingResponse) {
    if response.blocked == true {
        denyAccess(
            code: response.code,
            message: response.message
        )
        return
    }

    if response.inside {
        allowAccess(areaName: response.area?.name)
    } else {
        showOutsideRegion(distance: response.distanceToBorder)
    }

    if response.requestLocation == true {
        // Revisit the permission/location flow before the next check.
    }
}