add config for edge-to-edge

plugin/android/build.gradle

@@ -90,5 +90,6 @@ repositories {
 dependencies {
   implementation project(':expo-modules-core')
   implementation project(':react-native-karte_core')
+  implementation project(':react-native-karte_in-app-messaging')
   implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
 }

plugin/android/src/main/java/expo/modules/karte/KarteApplicationLifecycleListener.kt

@@ -1,12 +1,34 @@
 package expo.modules.karte
 
 import android.app.Application
+import android.content.pm.PackageManager
 import expo.modules.core.interfaces.ApplicationLifecycleListener
 import io.karte.android.KarteApp
+import io.karte.android.core.config.Config
+import io.karte.android.inappmessaging.InAppMessagingConfig
+
+private const val KARTE_EDGE_TO_EDGE_ENABLED_KEY = "KARTE_EDGE_TO_EDGE_ENABLED"
 
 class KarteApplicationLifecycleListener : ApplicationLifecycleListener {
   override fun onCreate(application: Application) {
-    super.onCreate(application)
-    KarteApp.setup(application)
+    KarteApp.setup(application, createKarteConfig(application))
+  }
+
+  private fun createKarteConfig(application: Application): Config? {
+    val meta = application.packageManager
+      .getApplicationInfo(application.packageName, PackageManager.GET_META_DATA)
+      .metaData
+      ?: return null
+
+    val enabled = meta.get(KARTE_EDGE_TO_EDGE_ENABLED_KEY) as? Boolean
+      ?: return null
+
+    val iamConfig = InAppMessagingConfig.Builder()
+      .isEdgeToEdgeEnabled(enabled)
+      .build()
+
+    return Config.Builder()
+      .libraryConfigs(iamConfig)
+      .build()
   }
 }

plugin/src/__tests__/withKarteAndroid-test.ts

@@ -1,4 +1,5 @@
 import fs from "fs";
+import { withAndroidManifest, AndroidConfig } from "@expo/config-plugins";
 
 import { withKarteAndroid } from "../withKarteAndroid";
 
@@ -19,23 +20,40 @@ jest.mock("path", () => {
 });
 
 jest.mock("@expo/config-plugins", () => {
+  const mainApp = {};
   return {
     ...(jest.requireActual("@expo/config-plugins") as object),
     withDangerousMod: jest.fn().mockImplementation((config, [_, callback]) =>
       callback({
         ...config,
         modRequest: {
           projectRoot: "projectRoot",
+          platformProjectRoot: "platformRoot",
         },
       })
     ),
+    withAndroidManifest: jest.fn().mockImplementation((config, callback) =>
+      callback({
+        ...config,
+        modResults: {},
+      })
+    ),
+    AndroidConfig: {
+      Manifest: {
+        getMainApplicationOrThrow: jest.fn(() => mainApp),
+        addMetaDataItemToMainApplication: jest.fn(),
+      },
+    },
     withGradleProperties: jest.fn(),
   };
 });
 
 const exp = { name: "foo", slug: "bar" };
 
 describe(withKarteAndroid, () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
   it("should not throw if xml path is set", () => {
     jest.spyOn(fs, "existsSync").mockImplementation((_: any) => {
       return true;
@@ -68,4 +86,55 @@ describe(withKarteAndroid, () => {
       })
     ).toThrow(/karte.xml doesn't exist/);
   });
+
+  it("should add metadata when isEdgeToEdgeEnabled is defined", () => {
+    jest.spyOn(fs, "existsSync").mockReturnValue(true);
+    withKarteAndroid(exp, {
+      karteInfoPlist: "",
+      karteXml: "karte.xml",
+      isEdgeToEdgeEnabled: true,
+    });
+
+    const { Manifest } = AndroidConfig;
+    expect(Manifest.getMainApplicationOrThrow).toHaveBeenCalled();
+    expect(Manifest.addMetaDataItemToMainApplication).toHaveBeenCalledWith(
+      expect.any(Object),
+      "KARTE_EDGE_TO_EDGE_ENABLED",
+      "true"
+    );
+    expect(withAndroidManifest).toHaveBeenCalled();
+  });
+
+  it("should add metadata when isEdgeToEdgeEnabled is false", () => {
+    jest.spyOn(fs, "existsSync").mockReturnValue(true);
+    withKarteAndroid(exp, {
+      karteInfoPlist: "",
+      karteXml: "karte.xml",
+      isEdgeToEdgeEnabled: false,
+    });
+
+    const { Manifest } = AndroidConfig;
+    expect(Manifest.getMainApplicationOrThrow).toHaveBeenCalled();
+    expect(Manifest.addMetaDataItemToMainApplication).toHaveBeenCalledWith(
+      expect.any(Object),
+      "KARTE_EDGE_TO_EDGE_ENABLED",
+      "false"
+    );
+    expect(withAndroidManifest).toHaveBeenCalled();
+  });
+
+  it("should not add metadata when isEdgeToEdgeEnabled is undefined", () => {
+    jest.spyOn(fs, "existsSync").mockReturnValue(true);
+    withKarteAndroid(exp, {
+      karteInfoPlist: "",
+      karteXml: "karte.xml",
+    });
+
+    const { Manifest } = AndroidConfig;
+    expect(Manifest.getMainApplicationOrThrow).not.toHaveBeenCalled();
+    expect(
+      Manifest.addMetaDataItemToMainApplication
+    ).not.toHaveBeenCalled();
+    expect(withAndroidManifest).not.toHaveBeenCalled();
+  });
 });

plugin/src/types.ts

@@ -1,4 +1,5 @@
 export type ConfigProps = {
   karteInfoPlist: string;
   karteXml: string;
+  isEdgeToEdgeEnabled?: boolean | null;
 };

plugin/src/withKarteAndroid.ts

@@ -1,13 +1,20 @@
 import {
   ConfigPlugin,
   withDangerousMod,
+  withAndroidManifest,
   ExportedConfigWithProps,
+  AndroidConfig,
 } from "expo/config-plugins";
 import fs from "fs";
 import path from "path";
 
 import { ConfigProps } from "./types";
 
+const {
+  getMainApplicationOrThrow,
+  addMetaDataItemToMainApplication,
+} = AndroidConfig.Manifest;
+
 export const withKarteAndroid: ConfigPlugin<ConfigProps> = (config, props) => {
   config = withDangerousMod(config, [
     "android",
@@ -16,6 +23,19 @@ export const withKarteAndroid: ConfigPlugin<ConfigProps> = (config, props) => {
       return config;
     },
   ]);
+
+  if (props.isEdgeToEdgeEnabled !== undefined) {
+    config = withAndroidManifest(config, (androidConfig) => {
+      const mainApp = getMainApplicationOrThrow(androidConfig.modResults);
+      addMetaDataItemToMainApplication(
+        mainApp,
+        "KARTE_EDGE_TO_EDGE_ENABLED",
+        props.isEdgeToEdgeEnabled!.toString()
+      );
+      return androidConfig;
+    });
+  }
+
   return config;
 };