Gate/AI for Android

Option 1: Maven Central (Recommended)

// app/build.gradle.kts
dependencies {
    implementation("com.gateai.sdk:gateai:1.0.0")
}

Option 2: Local development

// settings.gradle.kts
includeBuild("../gate-android")

// app/build.gradle.kts
dependencies {
    implementation("com.gateai.sdk:gateai")
}

Get your SHA-256 fingerprint

# Debug keystore
keytool -list -v -keystore ~/.android/debug.keystore \\
  -alias androiddebugkey \\
  -storepass android -keypass android | grep SHA256

# Release keystore
keytool -list -v -keystore /path/to/release.keystore \\
  -alias your-key-alias

Initialize in your Application class

class MyApplication : Application() {
    lateinit var gateAIClient: GateAIClient
        private set

    override fun onCreate() {
        super.onCreate()

        val configuration = GateAIConfiguration(
            baseUrl = "https://your-team.us01.gate-ai.net",
            packageName = packageName,
            signingCertSha256 = "AA:BB:CC:DD:...", // Your SHA-256 fingerprint
            developmentToken = if (BuildConfig.DEBUG) BuildConfig.DEV_TOKEN else null,
            logLevel = if (BuildConfig.DEBUG) 
                GateAIConfiguration.LogLevel.DEBUG 
            else 
                GateAIConfiguration.LogLevel.INFO
        )

        gateAIClient = GateAIClient.create(this, configuration)
        gateAIClient.userStatus = "premium" // Optional analytics
    }
}

Configure BuildConfig fields

// app/build.gradle.kts
android {
    defaultConfig {
        buildConfigField("String", "DEV_TOKEN", "\\"\\"")
    }

    buildTypes {
        debug {
            // For emulator testing (optional)
            buildConfigField("String", "DEV_TOKEN", "\\"your-dev-token\\"")
        }
    }
}

class MyViewModel(application: Application) : AndroidViewModel(application) {
    private val gateAI = (application as MyApplication).gateAIClient

    fun callOpenAI() {
        viewModelScope.launch {
            try {
                val requestBody = """
                {
                    "model": "gpt-4o",
                    "messages": [
                        {"role": "user", "content": "Say hello from Gate/AI"}
                    ]
                }
                """.trimIndent()

                val response = gateAI.performProxyRequest(
                    path = "openai/chat/completions",
                    method = HttpMethod.POST,
                    body = requestBody.toByteArray(),
                    additionalHeaders = mapOf("Content-Type" to "application/json")
                )

                if (response.status == 200) {
                    val result = response.body
                    // Process response
                }
            } catch (e: GateApiException) {
                // Handle HTTP errors (400, 401, etc.)
                Log.e("GateAI", "Error: ${e.statusCode} - ${e.body}")
            } catch (e: Exception) {
                // Handle other errors
                Log.e("GateAI", "Error", e)
            }
        }
    }
}

// Get authorization headers
val headers = gateAI.authorizationHeaders(
    path = "anthropic/v1/messages",
    method = HttpMethod.POST
)

// Use with your HTTP client
val request = Request.Builder()
    .url("https://your-team.us01.gate-ai.net/anthropic/v1/messages")
    .post(requestBody)
    .apply {
        headers.forEach { (key, value) ->
            addHeader(key, value)
        }
        addHeader("Content-Type", "application/json")
    }
    .build()

val response = httpClient.newCall(request).execute()

// Handle DPoP nonce challenge (401)
if (response.code == 401) {
    val nonce = gateAI.extractDPoPNonce(response.headers.toMultimap())
    if (nonce != null) {
        // Retry with nonce
        val retryHeaders = gateAI.authorizationHeaders(
            path = "anthropic/v1/messages",
            method = HttpMethod.POST,
            nonce = nonce
        )
        // Make request again with retryHeaders
    }
}

Automatic headers

• X-Client-Locale User's language and region (e.g., "en-US", "es-MX")
• X-App-Version App version from AndroidManifest.xml
• X-OS-Version Android OS version (e.g., "14", "13")
• X-Device-Identifier Android ID (unique per-app, per-device)
• X-Device-Type Device manufacturer and model (e.g., "Google Pixel 8")
• X-User-Status Custom user segment (set via `client.userStatus`)

try {
    val response = gateAI.performProxyRequest(...)
} catch (e: GateApiException) {
    // HTTP errors (400, 401, 403, 429, 500, etc.)
    when (e.statusCode) {
        401 -> Log.e("Auth", "Unauthorized: ${e.body}")
        403 -> Log.e("Auth", "Forbidden: ${e.body}")
        429 -> Log.e("RateLimit", "Rate limited: ${e.body}")
        else -> Log.e("API", "Error ${e.statusCode}: ${e.body}")
    }
} catch (e: Exception) {
    // Network errors, timeouts, etc.
    Log.e("Network", "Request failed", e)
}