react-native-oauth-essentials 1.0.2

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Lucas Alves
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/OauthEssentials.podspec

@@ -0,0 +1,22 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "OauthEssentials"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/lucaswitch/react-native-oauth-essentials.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  s.dependency "GoogleSignIn"
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,30 @@
+# About
+
+**React Native OAuth Essentials** is an essential OAuth solution for React Native apps. It provides **up-to-date Google
+Sign-In, Apple Sign-In, and Password Sign-In**, delivering a **native sign-in experience** with a simple, promise-based
+API. It's a must-have for every React Native app.
+
+## How to use it
+
+[Installation](./installation.md)
+
+[Usage](./usage)
+
+## Short history
+
+I’ve always felt that React Native lacked a single library that handles OAuth end-to-end. Most React Native apps end up
+downloading multiple libraries just to implement OAuth features. Each library feels different—they follow different
+philosophies, have different implementations, and some are outdated.
+
+Coming from native development, I wanted a library that provides all the OAuth features an app actually needs. That’s
+why I created and launched it as “Essentials.” One big reason is that if you include Google OAuth in your app, Apple’s
+App Store policies require you to provide Apple OAuth as well, or your app won’t be approved.
+
+I was frustrated going through this process myself, and seeing how much time React Native developers spent trying to
+deliver a “good enough” sign-in experience. So I thought—why not create one library that actually behaves and doesn’t
+make me want to throw my laptop out the window?
+
+## Philosophy
+
+Free forever, up-to-date features, and focused only on the essentials your mobile app really needs.
+

package/android/build.gradle

@@ -0,0 +1,74 @@
+buildscript {
+  ext.OauthEssentials = [
+    kotlinVersion    : "2.0.21",
+    minSdkVersion    : 24,
+    compileSdkVersion: 36,
+    targetSdkVersion : 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return OauthEssentials[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.oauthessentials"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+
+  // Needed oauth libraries
+  implementation 'androidx.browser:browser:1.9.0'
+  implementation 'androidx.credentials:credentials:1.5.0'
+  implementation("androidx.credentials:credentials-play-services-auth:1.6.0-rc01")
+  implementation 'com.google.android.libraries.identity.googleid:googleid:1.2.0'
+  implementation 'com.google.android.gms:play-services-auth:21.5.0'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,22 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <application>
+    <activity
+      android:name=".CustomTabsActivity"
+      android:exported="true"
+      android:launchMode="singleTask"
+      android:theme="@android:style/Theme.Translucent.NoTitleBar">
+      <intent-filter>
+        <action android:name="android.intent.action.VIEW" />
+
+        <category android:name="android.intent.category.DEFAULT" />
+        <category android:name="android.intent.category.BROWSABLE" />
+
+        <data
+          android:host="oauth"
+          android:path="/callback"
+          android:scheme="${applicationId}" />
+      </intent-filter>
+    </activity>
+  </application>
+</manifest>

package/android/src/main/java/com/oauthessentials/CredentialError.kt

@@ -0,0 +1,7 @@
+package com.oauthessentials
+
+enum class CredentialError(val code: String) {
+  NO_ACTIVITY_ERROR("NO_ACTIVITY_ERROR"),
+  INVALID_RESULT_ERROR("INVALID_RESULT_ERROR"),
+  NOT_SUPPORTED_ERROR("NOT_SUPPORTED")
+}

package/android/src/main/java/com/oauthessentials/CredentialFactory.kt

@@ -0,0 +1,114 @@
+package com.oauthessentials
+
+import android.net.Uri
+import androidx.credentials.CreateCredentialResponse
+import androidx.credentials.CreatePublicKeyCredentialResponse
+import androidx.credentials.CustomCredential
+import androidx.credentials.GetCredentialResponse
+import androidx.credentials.PasswordCredential
+import androidx.credentials.PublicKeyCredential
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.google.android.libraries.identity.googleid.GoogleIdTokenCredential
+
+object CredentialFactory {
+
+  enum class CredentialsType(val code: String) {
+    GOOGLE_ID("GOOGLE_ID"),
+    PASSWORD("PASSWORD"),
+    APPLE_ID("APPLE_ID"),
+    WEB_APPLE_ID("WEB_APPLE_ID"),
+    CANCELLED("CANCELLED"),
+    PASSKEY("PASSKEY")
+  }
+
+
+  /**
+   * Creates from an uri.
+   */
+  fun fromUri(uri: Uri): WritableMap {
+    if (uri.query.isNullOrEmpty()) {
+      throw IllegalStateException("Cannot handle empty deep link query.")
+    }
+
+    val data = Arguments.createMap()
+    val queryParams = uri.queryParameterNames
+    for (key in queryParams) {
+      uri.getQueryParameter(key)?.let { value ->
+        data.putString(key, value)
+      }
+    }
+
+    val event = Arguments.createMap()
+    event.putString("type", CredentialsType.WEB_APPLE_ID.code)
+    event.putMap("data", data)
+    return event
+  }
+
+  /**
+   * Creates from a response.
+   */
+  fun fromCredentialResponse(result: GetCredentialResponse): WritableMap {
+    return Arguments.createMap().apply {
+      val data = Arguments.createMap()
+      when (val credential = result.credential) {
+        is PasswordCredential -> {
+          val username = credential.id
+          val password = credential.password
+
+          putString("type", CredentialsType.PASSWORD.code)
+          data.putString("username", username)
+          data.putString("password", password)
+        }
+
+        is CustomCredential -> when (credential.type) {
+          GoogleIdTokenCredential.TYPE_GOOGLE_ID_TOKEN_CREDENTIAL -> {
+            val googleCred = GoogleIdTokenCredential.createFrom(credential.data)
+
+            putString("type", CredentialsType.GOOGLE_ID.code)
+            data.putString("idToken", googleCred.idToken)
+            data.putString("id", googleCred.id)
+            data.putString("displayName", googleCred.displayName)
+            data.putString("givenName", googleCred.givenName)
+            data.putString("familyName", googleCred.familyName)
+            data.putString("profilePictureUri", googleCred.profilePictureUri?.toString())
+            data.putString("phoneNumber", googleCred.phoneNumber)
+            data.putBoolean("legacy", false)
+          }
+
+          else -> {
+            throw IllegalStateException("Invalid auth type.")
+          }
+        }
+
+        else -> {
+          throw IllegalStateException("Invalid auth type.")
+        }
+      }
+      putMap("data", data)
+    }
+  }
+
+  fun fromCancelled(): WritableMap {
+    return Arguments.createMap().apply {
+      putString("type", CredentialsType.CANCELLED.code)
+      putNull("data")
+    }
+  }
+
+  fun fromPublicKeyCredential(result: CreateCredentialResponse): WritableMap {
+    val response = result as CreatePublicKeyCredentialResponse
+    return Arguments.createMap().apply {
+      putString("type", CredentialsType.PASSKEY.code)
+      putString("data", response.registrationResponseJson)
+    }
+  }
+
+  fun fromPublicKeyCredential(result: GetCredentialResponse): WritableMap {
+    val credential = result.credential as PublicKeyCredential
+    return Arguments.createMap().apply {
+      putString("type", CredentialsType.PASSKEY.code)
+      putString("data", credential.authenticationResponseJson)
+    }
+  }
+}

package/android/src/main/java/com/oauthessentials/CustomTabsActivity.kt

@@ -0,0 +1,133 @@
+package com.oauthessentials
+
+import android.app.Activity
+import android.content.Intent
+import android.content.Intent.FLAG_ACTIVITY_NO_HISTORY
+import android.os.Bundle
+import android.util.Log
+import androidx.browser.customtabs.CustomTabsIntent
+import com.oauthessentials.OauthEssentialsModule.Companion.DISPLAY_CUSTOM_TABS_INTENT
+import com.oauthessentials.OauthEssentialsModule.Companion.LOG_TAG
+import com.oauthessentials.OauthEssentialsModule.Companion.WEB_APPLE_DEEP_LINK_RECEIVED_INTENT
+import com.oauthessentials.OauthEssentialsModule.Companion.WEB_APPLE_CANCELLED_INTENT
+
+class CustomTabsActivity : Activity() {
+  private var deepLinkReceived = false
+  private var customTabLaunched = false
+  private var hasBeenPaused = false
+  private var resultProcessed = false
+
+  /**
+   * When the activity is created.
+   */
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    if (intent is Intent) {
+      when (intent.action) {
+        DISPLAY_CUSTOM_TABS_INTENT -> {
+          handleOnDisplayCustomTabsIntent(intent)
+        }
+
+        else -> {
+          handleOnDeepLinkIntent(intent)
+        }
+      }
+    }
+  }
+
+  /**
+   * When the activity resumes from background.
+   * This is called when the user closes the Custom Tab without completing authentication.
+   */
+  override fun onResume() {
+    super.onResume()
+    Log.d(LOG_TAG, "CustomTabsActivity resumed")
+
+    // Only check for cancellation if we've been paused (meaning the Custom Tab was shown)
+    // If we launched a custom tab but haven't received a deep link,
+    // it means the user closed the browser without completing auth
+    if (hasBeenPaused && customTabLaunched && !deepLinkReceived && !resultProcessed) {
+      Log.d(LOG_TAG, "CustomTabsActivity resumed without deep link, sending cancellation broadcast")
+      resultProcessed = true
+      sendBroadcast(
+        Intent(WEB_APPLE_CANCELLED_INTENT).apply {
+          setPackage(applicationContext.packageName)
+        }
+      )
+      // Return control to the previous activity
+      finish()
+    }
+  }
+
+  /**
+   * When the activity goes to background.
+   * This happens when the Custom Tab is displayed.
+   */
+  override fun onPause() {
+    super.onPause()
+    Log.d(LOG_TAG, "CustomTabsActivity paused")
+    if (customTabLaunched) {
+      hasBeenPaused = true
+    }
+  }
+
+  /**
+   * When the activity is destroyed.
+   */
+  override fun onDestroy() {
+    super.onDestroy()
+    Log.d(LOG_TAG, "CustomTabsActivity destroyed")
+  }
+
+  /**
+   * Whenever a new intent is received
+   */
+  override fun onNewIntent(intent: Intent?) {
+    super.onNewIntent(intent)
+    setIntent(intent)
+    if (intent is Intent) {
+      when (intent.action) {
+        DISPLAY_CUSTOM_TABS_INTENT -> {
+          handleOnDisplayCustomTabsIntent(intent)
+        }
+
+        else -> {
+          handleOnDeepLinkIntent(intent)
+        }
+      }
+    }
+  }
+
+  /**
+   * Handles the display custom tabs opening.
+   */
+  private fun handleOnDisplayCustomTabsIntent(intent: Intent) {
+    intent.data?.let { uri ->
+      Log.d(LOG_TAG, "Launching Custom Tab with URL: $uri")
+      customTabLaunched = true
+      val tabIntent =
+        CustomTabsIntent.Builder().setShowTitle(true).setUrlBarHidingEnabled(true).build()
+      tabIntent.intent.addFlags(FLAG_ACTIVITY_NO_HISTORY)
+      tabIntent.launchUrl(this, uri)
+    }
+  }
+
+  /**
+   * Handles the deep link intent.
+   */
+  private fun handleOnDeepLinkIntent(intent: Intent) {
+    Log.d(LOG_TAG, "Received new incoming intent")
+    intent.data?.let { uri ->
+      deepLinkReceived = true
+      resultProcessed = true
+      sendBroadcast(
+        Intent(WEB_APPLE_DEEP_LINK_RECEIVED_INTENT).apply {
+          setPackage(applicationContext.packageName)
+          putExtra("url", uri.toString())
+        }
+      )
+      // Return control to the previous activity
+      finish()
+    }
+  }
+}