Synheart Core - Android/Kotlin SDK

dependencies {
    implementation("ai.synheart:synheart-core:0.0.4")
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- Required permissions -->
    <uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />

    <!-- Health Connect Permissions (if using Wear module) -->
    <uses-permission android:name="android.permission.health.READ_HEART_RATE"/>
    <uses-permission android:name="android.permission.health.READ_HEART_RATE_VARIABILITY"/>

    <application>
        <!-- Your application configuration -->
    </application>
</manifest>

import ai.synheart.core.Synheart
import ai.synheart.core.SynheartConfig

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        // Initialize Synheart Core
        Synheart.initialize(
            context = this,
            userId = "anon_user_123",
            config = SynheartConfig(
                allowUnsignedCapabilities = true  // Use capabilityToken in production
            )
        )
    }
}

import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.launch

lifecycleScope.launch {
    Synheart.onHSIUpdate.collect { hsiJson ->
        Log.d("HSI", "HSI JSON: $hsiJson")
    }
}

// Available features:
//   SynheartFeature.WEAR          — biosignals from wearables
//   SynheartFeature.BEHAVIOR      — interaction telemetry
//   SynheartFeature.PHONE_CONTEXT — motion / screen / app context
//   SynheartFeature.CLOUD         — HSI upload connector

Synheart.activate(SynheartFeature.WEAR)
Synheart.activate(SynheartFeature.CLOUD)

// Stop a feature without uninitializing the SDK.
Synheart.deactivate(SynheartFeature.CLOUD)

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.lifecycle.lifecycleScope
import ai.synheart.core.Synheart
import ai.synheart.core.SynheartConfig
import ai.synheart.core.config.SynheartFeature
import kotlinx.coroutines.launch

class HumanStateActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycleScope.launch {
            Synheart.initialize(
                context = applicationContext,
                userId = "user_123",
                config = SynheartConfig(allowUnsignedCapabilities = true),
            )
            Synheart.activate(SynheartFeature.WEAR)
            Synheart.activate(SynheartFeature.BEHAVIOR)
        }
        setContent { HumanStateMonitor() }
    }
}

@Composable
fun HumanStateMonitor() {
    var hsiJson by remember { mutableStateOf<String?>(null) }
    LaunchedEffect(Unit) {
        Synheart.onHSIUpdate.collect { hsiJson = it }
    }
    Scaffold(topBar = { TopAppBar(title = { Text("Human State") }) }) { p ->
        Column(Modifier.padding(p).padding(16.dp)) {
            Text("HSI: ${hsiJson?.take(100) ?: "Waiting…"}")
        }
    }
}

// Enable cloud sync (requires cloudConfig in SynheartConfig and a
// granted cloudUpload consent).
Synheart.activate(SynheartFeature.CLOUD)

// Pause uploads without tearing down the SDK.
Synheart.deactivate(SynheartFeature.CLOUD)

val config = SynheartConfig(
    allowUnsignedCapabilities = true,  // use capabilityToken in production

    // Cloud configuration (optional).
    cloudConfig = CloudConfig(
        appId = "your_app_id",
        subjectId = "user_123",
        instanceId = "device_abc",
        baseUrl = "https://api.synheart.ai",
    ),

    // Capability JWT (optional, for extended/research access).
    capabilityToken = null,
)

Synheart.initialize(
    context = context,
    userId = "user_123",
    config = config,
)

// Live counters / last-error strings.
val diag = Synheart.runtimeDiagnostics()
Log.d("Synheart", diag.toString())

// Synchronous getters — safe to read from UI code.
val depth = Synheart.uploadQueueLength
val lastMs = Synheart.lastIngestSuccessAtMs

// Manually flush queued snapshots when eligible.
val result = Synheart.ingestion.flushIfEligible()

try {
    Synheart.initialize(
        context = context,
        userId = userId,
        config = config
    )
} catch (e: PermissionDeniedException) {
    Log.e("Synheart", "Permission denied: ${e.message}")
} catch (e: InitializationException) {
    Log.e("Synheart", "Initialization failed: ${e.message}")
} catch (e: SynheartException) {
    Log.e("Synheart", "SDK error: ${e.message}")
}

// Coarse status — granted | pending | expired | denied
val status = Synheart.consentStatus()

// Per-type check (wire strings: biosignals, phoneContext, behavior,
// cloudUpload, vendorSync, research)
val canUpload = Synheart.hasConsent("cloudUpload")
val canRead   = Synheart.hasConsent("biosignals")

// Request consent — opens the cloud consent flow when configured.
val token = Synheart.requestConsent()

if (Synheart.hasConsent("cloudUpload")) {
    Synheart.activate(SynheartFeature.CLOUD)
}

// Revoke a single type or everything
Synheart.revokeConsentType("cloudUpload")
Synheart.revokeConsent()