appsonair-react-native-apppush 0.0.1-alpha

package/android/build.gradle

@@ -0,0 +1,177 @@
+buildscript {
+  // Buildscript is evaluated before everything else, so getExtOrDefault is not available yet.
+  def kotlin_version = rootProject.ext.has("kotlinVersion")
+    ? rootProject.ext.get("kotlinVersion")
+    : project.properties["AppsonairReactNativeApppush_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+    maven { url 'https://jitpack.io' }
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+// The React Gradle plugin runs Codegen and puts the generated NativeAppsonairApppushSpec
+// on the compile classpath. It is only applied on the New Architecture -- on the Old
+// Architecture the spec is never generated, which is why the module class that extends
+// it lives in the newarch source set rather than in main.
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name)
+    ? rootProject.ext.get(name)
+    : project.properties["AppsonairReactNativeApppush_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name)
+    ? rootProject.ext.get(name)
+    : (project.properties["AppsonairReactNativeApppush_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in AGP 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.appsonairreactnativeapppush"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    // Read back by AppsonairReactNativeApppushPackage to tag the module as a
+    // TurboModule or a legacy module. It has to be a build constant rather than a
+    // runtime check, because ReactModuleInfo is built before any React instance exists.
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+
+  buildFeatures {
+    // Required from AGP 8 onwards, where BuildConfig generation is off by default.
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+
+    // WORKAROUND -- remove once the native SDK is republished.
+    //
+    // appsonair-android-push-notification:0.0.2-alpha is compiled with Kotlin
+    // 2.2.10 and sets no languageVersion/apiVersion floor, so its classes carry
+    // metadata 2.2.0. React Native pins the Kotlin compiler per release -- 1.9.24
+    // on RN 0.76, 2.0.21 on 0.77-0.78, 2.1.x on 0.79-0.81 -- and none of those can
+    // read metadata 2.2.0, so compiling this module against the AAR fails with:
+    //
+    //   Class 'kotlin.Unit' was compiled with an incompatible version of Kotlin.
+    //   The actual metadata version is 2.2.0, but the compiler version 1.9.0 can
+    //   read versions up to 2.0.0.
+    //
+    // Raising the host's Kotlin version is not an option: KGP 2.2 breaks React
+    // Native's own Gradle plugin ("Found interface KotlinTopLevelExtension, but
+    // class was expected"). The real fix is upstream -- the SDK needs
+    // `languageVersion = "1.9"` and `apiVersion = "1.9"` in its kotlinOptions --
+    // at which point this flag and the stdlib pin below both go away.
+    freeCompilerArgs += ["-Xskip-metadata-version-check"]
+  }
+
+  // The architecture-specific module class. Both source sets declare the same
+  // class name in the same package and differ only in what they extend, so
+  // exactly one of them must ever be on the compile path.
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += ["src/newarch/java"]
+      } else {
+        java.srcDirs += ["src/oldarch/java"]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+  maven { url 'https://jitpack.io' }
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  // For < 0.71 this resolves from the local maven repo; for > 0.71 the React
+  // Gradle plugin rewrites it to com.facebook.react:react-android:$version.
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  // `strictly`, not a plain version -- the second half of the Kotlin 2.2.10
+  // workaround documented in kotlinOptions above.
+  //
+  // The SDK's POM requires kotlin-stdlib:2.2.10, and conflict resolution carries
+  // that onto the *host app's* compileClasspath (1.9.24 -> 2.2.10), so the app's
+  // own Kotlin then fails to compile even though nothing in the app touches the
+  // SDK. `-Xskip-metadata-version-check` cannot help there: it applies to this
+  // module, not to the consumer's. Pinning the stdlib back to whatever Kotlin the
+  // host is actually compiling with keeps the app buildable.
+  //
+  // The cost: the SDK was compiled against the 2.2.10 stdlib and now runs against
+  // an older one, so any stdlib API it uses that postdates the host's Kotlin
+  // throws NoSuchMethodError at runtime. That risk is the reason this is a
+  // stopgap and not a design -- it disappears with the upstream fix.
+  implementation("org.jetbrains.kotlin:kotlin-stdlib") {
+    version { strictly kotlin_version }
+  }
+
+  // The native AppsOnAir Push SDK, from JitPack -- the host app must have
+  // maven { url 'https://jitpack.io' } in its repositories. The coordinate stays
+  // overridable for teams pointing at a local build or a private repo -- set
+  // AppsonairReactNativeApppush_pushSdkCoordinate in the app's gradle.properties, or
+  // substitute a local project in settings.gradle:
+  //
+  //   includeBuild('../appsonair-push-notification-android')
+  //
+  implementation getExtOrDefault("pushSdkCoordinate")
+}

package/android/gradle.properties

@@ -0,0 +1,15 @@
+AppsonairReactNativeApppush_kotlinVersion=1.9.24
+AppsonairReactNativeApppush_minSdkVersion=24
+AppsonairReactNativeApppush_targetSdkVersion=34
+AppsonairReactNativeApppush_compileSdkVersion=35
+
+# minSdk 24 is inherited, not chosen: the native Push SDK requires AppsOnAir Core,
+# which is minSdk 24. Lowering this here will fail the manifest merge.
+
+# The native Push SDK coordinate, served by JitPack. The repo's git tag is
+# `v0.0.2-alpha`; JitPack publishes it under both `0.0.2-alpha` and `v0.0.2-alpha`
+# and reports the un-prefixed form as `latest`, which is also what the SDK's own
+# README documents -- so that is the one pinned here. Overridable from the host
+# app's gradle.properties so a team can point at a local build or a private repo
+# without patching this file.
+AppsonairReactNativeApppush_pushSdkCoordinate=com.github.apps-on-air:appsonair-android-push-notification:0.0.2-alpha

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.appsonairreactnativeapppush">
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>