feat: add kotlin for android client

flipt-client-kotlin-android/.gitignore

@@ -0,0 +1,26 @@
+*.iml
+.gradle
+/local.properties
+/.idea/caches
+/.idea/libraries
+/.idea/modules.xml
+/.idea/workspace.xml
+/.idea/navEditor.xml
+/.idea/assetWizardSettings.xml
+/.idea
+.DS_Store
+/build
+/captures
+.externalNativeBuild
+.cxx
+/.cxx/
+local.properties
+*.so
+*.a
+*.old
+*.tar.gz
+*.rlib
+*.d
+*.x86_64
+*.aarch64
+/.idea/

flipt-client-kotlin-android/README.md

@@ -0,0 +1,132 @@
+# Flipt Client Kotlin Android
+
+[![Maven Central](https://img.shields.io/maven-central/v/io.flipt/flipt-client-java?label=flipt-client-java)](https://central.sonatype.com/artifact/io.flipt/flipt-client-java)
+
+The `flipt-client-kotlin-android` library contains the Kotlin for Android source code for the Flipt [client-side evaluation](https://www.flipt.io/docs/integration/client) client.
+
+## Installation
+
+### Gradle
+
+Add the dependency in your `build.gradle`:
+
+```groovy
+dependencies {
+    implementation 'io.flipt:flipt-client-kotlin-android:0.x.x'
+}
+```
+
+### Maven
+
+Add the dependency in your `pom.xml`:
+
+```xml
+<dependency>
+    <groupId>io.flipt</groupId>
+    <artifactId>flipt-client-kotlin-android</artifactId>
+    <version>0.x.x</version>
+</dependency>
+```
+
+## How Does It Work?
+
+The `flipt-client-kotlin-android` library is a wrapper around the [flipt-engine-ffi](https://github.com/flipt-io/flipt-client-sdks/tree/main/flipt-engine-ffi) library.
+
+All evaluation happens within the SDK, using the shared library built from the [flipt-engine-ffi](https://github.com/flipt-io/flipt-client-sdks/tree/main/flipt-engine-ffi) library.
+
+Because the evaluation happens within the SDK, the SDKs can be used in environments where the Flipt server is not available or reachable after the initial data is fetched.
+
+## Data Fetching
+
+Upon instantiation, the `flipt-client-kotlin-android` library will fetch the flag state from the Flipt server and store it in memory. This means that the first time you use the SDK, it will make a request to the Flipt server.
+
+### Polling (Default)
+
+By default, the SDK will poll the Flipt server for new flag state at a regular interval. This interval can be configured using the `fetchMode` option when constructing a client. The default interval is 120 seconds.
+
+### Streaming (Flipt Cloud Only)
+
+[Flipt Cloud](https://flipt.io/cloud) users can use the `streaming` fetch method to stream flag state changes from the Flipt server to the SDK.
+
+When in streaming mode, the SDK will connect to the Flipt server and open a persistent connection that will remain open until the client is closed. The SDK will then receive flag state changes in real-time.
+
+## Supported Architectures
+
+This SDK currently supports the following OSes/architectures:
+
+- Linux x86_64
+- Linux x86_64 (musl)
+- Linux arm64
+- Linux arm64 (musl)
+- MacOS x86_64
+- MacOS arm64
+- Windows x86_64
+
+### Glibc vs Musl
+
+Most Linux distributions use [Glibc](https://en.wikipedia.org/wiki/Glibc), but some distributions like Alpine Linux use [Musl](https://en.wikipedia.org/wiki/Musl). If you are using Alpine Linux, you will need to install the `musl` version of the client.
+
+## Usage
+
+In your Kotlin Android code you can import this client and use it as so:
+
+```java
+package org.example;
+
+import java.util.HashMap;
+import java.util.Map;
+import io.flipt.client.FliptEvaluationClient;
+import io.flipt.client.models.*;
+
+public class Main {
+    public static void main(String[] args) {
+        FliptEvaluationClient fliptClient = null;
+        try {
+            fliptClient = FliptEvaluationClient.builder()
+                    .url("http://localhost:8080")
+                    .authentication(new ClientTokenAuthentication("secret"))
+                    .build();
+
+            Map<String, String> context = new HashMap<>();
+            context.put("fizz", "buzz");
+
+            VariantEvaluationResponse response =
+                    fliptClient.evaluateVariant("flag1", "entity", context);
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            // Important: always close the client to release resources
+            if (fliptClient != null) {
+                fliptClient.close();
+            }
+        }
+    }
+}
+```
+
+### Builder Methods
+
+The `FliptEvaluationClient.builder()` method returns a `FliptEvaluationClient.Builder` object that allows you to configure the client with the following methods:
+
+- `namespace`: The namespace to fetch flag state from. If not provided, the client will default to the `default` namespace.
+- `url`: The URL of the upstream Flipt instance. If not provided, the client will default to `http://localhost:8080`.
+- `updateInterval`: The interval (Duration) in which to fetch new flag state. If not provided, the client will default to 120 seconds.
+- `authentication`: The authentication strategy to use when communicating with the upstream Flipt instance. If not provided, the client will default to no authentication. See the [Authentication](#authentication) section for more information.
+- `reference`: The [reference](https://docs.flipt.io/guides/user/using-references) to use when fetching flag state. If not provided, reference will not be used.
+- `fetchMode`: The fetch mode to use when fetching flag state. If not provided, the client will default to polling.
+
+### Authentication
+
+The `FliptEvaluationClient` supports the following authentication strategies:
+
+- No Authentication (default)
+- [Client Token Authentication](https://docs.flipt.io/authentication/using-tokens)
+- [JWT Authentication](https://docs.flipt.io/authentication/using-jwts)
+
+## Contributing
+
+Contributions are welcome! Please feel free to open an issue or submit a Pull Request.
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

flipt-client-kotlin-android/build.gradle

@@ -0,0 +1,56 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+plugins {
+    id 'com.android.library' // For library modules
+    id 'kotlin-android' // Correct plugin ID for Kotlin Android projects
+    id 'org.jetbrains.kotlin.plugin.serialization'
+}
+
+android {
+    namespace 'io.flipt.client'
+    ndkVersion '25.1.8937393'
+    compileSdk 33
+    defaultConfig {
+        minSdk 26
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles "consumer-rules.pro"
+        ndk {
+            abiFilters "x86_64", "arm64-v8a"
+        }
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+            buildConfigField("String", "FLIPT_URL", "\"${System.getenv("FLIPT_URL") ?: ""}\"")
+            buildConfigField("String", "FLIPT_AUTH_TOKEN", "\"${System.getenv("FLIPT_AUTH_TOKEN") ?: ""}\"")
+        }
+        debug {
+            buildConfigField("String", "FLIPT_URL", "\"${System.getenv("FLIPT_URL") ?: ""}\"")
+            buildConfigField("String", "FLIPT_AUTH_TOKEN", "\"${System.getenv("FLIPT_AUTH_TOKEN") ?: ""}\"")
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+        jvmTarget = '1.8'
+    }
+
+    externalNativeBuild {
+        cmake {
+            path "src/main/cpp/CMakeLists.txt"
+        }
+    }
+}
+
+dependencies {
+    implementation libs.kotlinx.serialization.json
+    testImplementation libs.junit
+    androidTestImplementation libs.androidx.junit
+    androidTestImplementation libs.androidx.espresso.core
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.7.20"
+}

flipt-client-kotlin-android/gradle.properties

@@ -0,0 +1,23 @@
+# Project-wide Gradle settings.
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. For more details, visit
+# https://developer.android.com/r/tools/gradle-multi-project-decoupled-projects
+# org.gradle.parallel=true
+# AndroidX package structure to make it clearer which packages are bundled with the
+# Android operating system, and which are packaged with your app's APK
+# https://developer.android.com/topic/libraries/support-library/androidx-rn
+android.useAndroidX=true
+# Kotlin code style for this project: "official" or "obsolete":
+kotlin.code.style=official
+# Enables namespacing of each library's R class so that its R class includes only the
+# resources declared in the library itself and none from the library's dependencies,
+# thereby reducing the size of the R class for that library
+android.nonTransitiveRClass=true

flipt-client-kotlin-android/gradle/libs.versions.toml

@@ -0,0 +1,23 @@
+[versions]
+agp = "7.3.1"
+kotlin = "1.6.0"
+coreKtx = "1.13.1"
+junit = "4.13.2"
+junitVersion = "1.1.3"
+espressoCore = "3.4.0"
+appcompat = "1.7.0"
+kotlinxSerializationJson = "1.7.3"
+material = "1.12.0"
+activity = "1.9.3"
+constraintlayout = "2.2.0"
+
+[libraries]
+junit = { group = "junit", name = "junit", version.ref = "junit" }
+androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
+androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
+kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version = "1.3.3" }
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "agp" }
+jetbrains-kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+android-library = { id = "com.android.library", version.ref = "agp" }

flipt-client-kotlin-android/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Thu Oct 31 14:43:30 WIB 2024
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists