react-native-config 1.6.1 → 1.6.2

package/README.md

@@ -26,6 +26,9 @@ Keep in mind this module doesn't obfuscate or encrypt secrets for packaging, so
 
 ## Setup
 
+> ⚠️ Note (Android): react-native-config v1.6.0+ requires React Native 0.74 or higher.  
+> If you use an older RN version, see Troubleshooting below.
+
 Install the package:
 
 ```
@@ -34,20 +37,34 @@ $ yarn add react-native-config
 
 Link the library:
 
-(Note: For React Native 0.60 or greater, [autolinking](https://reactnative.dev/blog/2019/07/03/version-60#native-modules-are-now-autolinked) is available)
+On React Native 0.60 and above there is no link step — the library is
+[autolinked](https://reactnative.dev/blog/2019/07/03/version-60#native-modules-are-now-autolinked).
+Rebuild the app so the native side is picked up. On iOS / macOS, install the pod first:
+
+```
+(cd ios; pod install)
+```
+
+> [!WARNING]
+> Do not link this library manually on React Native 0.60 or above, and do not disable its
+> autolinking in `react-native.config.js`. Autolinking is what registers the native module and,
+> on the New Architecture, generates its TurboModule bindings — adding
+> `include ':react-native-config'` to `android/settings.gradle` instead does neither, and the
+> module then resolves to `null` at runtime. See
+> [TypeError: Cannot read property 'getConfig' of null](#typeerror-cannot-read-property-getconfig-of-null).
 
 (Note: For Windows, this module supports autolinking when used with `react-native-windows@0.63`
 or later. For earlier versions you need to manually link the module.)
 
+<details>
+<summary><b>Manual linking</b> — only for React Native below 0.60, or react-native-windows below 0.63</summary>
+
 ```
 $ react-native link react-native-config
 ```
 
-if cocoapods are used in the project then pod has to be installed as well:
-
-```
-(cd ios; pod install)
-```
+(`react-native link` was removed from the React Native CLI; it is only available on the older
+versions these instructions apply to.)
 
  - Manual Link (iOS / macOS)
 
@@ -115,6 +132,8 @@ if cocoapods are used in the project then pod has to be installed as well:
 
 	Add `PackageProviders().Append(winrt::RNCConfig::ReactPackageProvider());` before `InitializeComponent();`.
 
+</details>
+
 ### Extra step for Android
 #### Using RN-Integrate
 Apply extra steps automatically:
@@ -132,16 +151,29 @@ apply from: project(':react-native-config').projectDir.getPath() + "/dotenv.grad
 
 #### Advanced Android Setup
 
-In `android/app/build.gradle`, if you use `applicationIdSuffix` or `applicationId` that is different from the package name indicated in `AndroidManifest.xml` in `<manifest package="...">` tag, for example, to support different build variants:
-Add this in `android/app/build.gradle`
+`BuildConfig` is generated in your module's `namespace`, which is not always the same as its
+`applicationId` — `applicationIdSuffix` and per-flavor `applicationId` change the latter and
+leave the former alone. The library resolves this for you: it looks for `BuildConfig` in the
+package declaring your `Application` class (that is, the `namespace`) before falling back to the
+`applicationId`, so the common variant setups need no extra configuration.
+
+If your `BuildConfig` lives somewhere neither of those points at, name the package explicitly in
+`android/app/build.gradle`:
 
 ```
 defaultConfig {
     ...
-    resValue "string", "build_config_package", "YOUR_PACKAGE_NAME_IN_ANDROIDMANIFEST_XML"
+    resValue "string", "build_config_package", "YOUR_NAMESPACE"
 }
 ```
 
+where `YOUR_NAMESPACE` matches the `namespace` in `android/app/build.gradle` (on React Native
+0.72 and older, the `package` attribute of `<manifest>` in `AndroidManifest.xml`). This value
+takes priority over the automatic resolution above.
+
+If the config arrives in JS as `{}`, check logcat for `ReactConfig: Could not find BuildConfig
+class` — the message lists every package that was tried.
+
 ## TypeScript declaration for your .env file
 
 If you want to get autocompletion and typesafety for your .env files. Create a file named `react-native-config.d.ts` in the same directory where you put your type declarations, and add the following contents:
@@ -395,12 +427,56 @@ If using Dexguard, the shrinking phase will remove resources it thinks are unuse
 
     -keepresources string/build_config_package
 
+### TypeError: Cannot read property 'getConfig' of null
+
+The JavaScript side loaded but the native module is not registered in the build, so
+`TurboModuleRegistry` returned `null`. In rough order of likelihood:
+
+1. **The app was not rebuilt** after the library was installed. Restarting Metro does not rebuild
+   native code — rebuild the app itself.
+2. **Autolinking is disabled for this library.** Look for an entry like this in
+   `react-native.config.js` and remove it:
+
+   ```js
+   dependencies: {
+     'react-native-config': {
+       platforms: { android: null }, // <- remove
+     },
+   },
+   ```
+
+3. **The library is linked manually.** On React Native 0.60+ autolinking replaces manual linking,
+   and on the New Architecture a manually linked module is never registered as a TurboModule.
+   Remove `include ':react-native-config'` (and the accompanying `project(...)` line) from
+   `android/settings.gradle`, and `implementation project(':react-native-config')` from
+   `android/app/build.gradle`.
+4. **iOS only:** `pod install` has not been run since the library was installed.
+
+After changing any of the above, rebuild from clean — on Android, delete `android/build` and
+`android/app/build` first, since a stale build can keep the old registration.
+
 ### TypeError: _reactNativeConfig.default.getConstants is not a function
 
 This error stems from `.env` file being malformed. Accepted formats are listed here https://regex101.com/r/cbm5Tp/1. Common causes are:
   - Missing the .env file entirely
   - Rogue space anywhere, example: in front of env variable: ` MY_ENV='foo'`
 
+### Android build error: cannot find symbol BaseReactPackage
+
+Starting from **react-native-config v1.6.0**, the Android implementation uses
+`BaseReactPackage` instead of `ReactPackage`.
+
+`BaseReactPackage` was introduced in **React Native 0.74**, so projects on React
+Native 0.73 or older will see build errors like:
+
+> cannot find symbol  
+> class BaseReactPackage
+
+To fix this:
+
+- Use `react-native-config` **below 1.6.0** (e.g. `1.5.10`), or
+- Upgrade React Native to **0.74 or higher**
+
 ## Testing
 
 Since `react-native-config` contains native code, it cannot be run in a node.js environment (Jest, Mocha). [react-native-config-node](https://github.com/CureApp/react-native-config-node) provides a way to mock `react-native-config` for use in test runners - exactly as it is used in the actual app.

package/android/src/main/java/com/lugg/RNCConfig/RNCConfigModuleImpl.java

@@ -7,12 +7,18 @@ import com.facebook.react.bridge.WritableMap;
 import java.lang.ClassNotFoundException;
 import java.lang.IllegalAccessException;
 import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.HashMap;
+import java.util.Set;
 
 public class RNCConfigModuleImpl {
   public static final String NAME = "RNCConfigModule";
 
+  private static final String TAG = "ReactNative";
+
   private ReactApplicationContext context;
 
   public RNCConfigModuleImpl(ReactApplicationContext context) {
@@ -32,31 +38,78 @@ public class RNCConfigModuleImpl {
     // because of type safety on the new arch
     final Map<String, Object> realConstants = new HashMap<>();
 
-    try {
-      int resId = this.context.getResources().getIdentifier("build_config_package", "string", context.getPackageName());
-      String className;
+    final List<String> candidates = buildConfigPackageCandidates();
+    Class<?> clazz = null;
+
+    for (String candidate : candidates) {
       try {
-        className = this.context.getString(resId);
-      } catch (Resources.NotFoundException e) {
-        className = this.context.getApplicationContext().getPackageName();
+        clazz = Class.forName(candidate + ".BuildConfig");
+        break;
+      }
+      catch (ClassNotFoundException e) {
+        // Not here - try the next candidate.
       }
-      Class clazz = Class.forName(className + ".BuildConfig");
+    }
+
+    if (clazz == null) {
+      Log.w(TAG, "ReactConfig: Could not find BuildConfig class. Tried: " + candidates + ". "
+          + "If BuildConfig is generated somewhere else, point the library at it with "
+          + "`resValue \"string\", \"build_config_package\", \"<your namespace>\"` in android/app/build.gradle.");
+    }
+    else {
       Field[] fields = clazz.getDeclaredFields();
       for(Field f: fields) {
         try {
           realConstants.put(f.getName(), f.get(null));
         }
         catch (IllegalAccessException e) {
-          Log.d("ReactNative", "ReactConfig: Could not access BuildConfig field " + f.getName());
+          Log.d(TAG, "ReactConfig: Could not access BuildConfig field " + f.getName());
         }
       }
     }
-    catch (ClassNotFoundException e) {
-      Log.d("ReactNative", "ReactConfig: Could not find BuildConfig class");
-    }
 
     ret.put("config", realConstants);
 
     return MapConverter.convertMapToWritableMap(ret);
   }
+
+  /**
+   * Packages that may hold the app's generated BuildConfig, most-specific first.
+   *
+   * BuildConfig is generated in the module's `namespace`, which is not necessarily the
+   * applicationId: `applicationIdSuffix` and per-flavor `applicationId` change the latter and
+   * leave the former alone. Resolving only via getPackageName() therefore misses BuildConfig on
+   * any such variant, and the config silently arrives in JS as {}.
+   */
+  private List<String> buildConfigPackageCandidates() {
+    // LinkedHashSet keeps the priority order below while dropping duplicates, which is the
+    // common case: for most apps all three candidates are the same string.
+    final Set<String> candidates = new LinkedHashSet<>();
+
+    // 1. An explicit `resValue "string", "build_config_package", "..."`. Honoured first so that
+    //    existing setups relying on it keep working, and so it stays an escape hatch when the
+    //    derived candidates below are wrong.
+    int resId = this.context.getResources().getIdentifier(
+        "build_config_package", "string", this.context.getPackageName());
+    if (resId != 0) {
+      try {
+        candidates.add(this.context.getString(resId));
+      }
+      catch (Resources.NotFoundException e) {
+        // Declared but unreadable - fall through to the derived candidates.
+      }
+    }
+
+    // 2. The package declaring the Application class. That class is part of the app module, so
+    //    its package is the `namespace` - unaffected by applicationId/applicationIdSuffix.
+    Package applicationPackage = this.context.getApplicationContext().getClass().getPackage();
+    if (applicationPackage != null) {
+      candidates.add(applicationPackage.getName());
+    }
+
+    // 3. The applicationId. Correct whenever it matches the namespace, which is the default.
+    candidates.add(this.context.getApplicationContext().getPackageName());
+
+    return new ArrayList<>(candidates);
+  }
 }

package/index.js

@@ -1,5 +1,27 @@
 "use strict";
 
-export const Config =
-  require("./codegen/NativeConfigModule").default.getConfig().config;
+const NativeConfigModule = require("./codegen/NativeConfigModule").default;
+
+if (NativeConfigModule == null) {
+  // TurboModuleRegistry.get returns null when the native module is not registered in the app.
+  // Left alone, the next line fails with "Cannot read property 'getConfig' of null", which says
+  // nothing about the cause - so spell out the ones that actually produce this.
+  throw new Error(
+    "react-native-config: the native module RNCConfigModule was not found.\n\n" +
+      "JavaScript loaded, but the native side is not registered in this build. Common causes:\n\n" +
+      "  1. The app was not rebuilt after installing the library. Restarting Metro is not enough -\n" +
+      "     rebuild the native app.\n" +
+      "  2. Autolinking is disabled for this library. Check react-native.config.js for a\n" +
+      "     `dependencies` entry setting `platforms.android` or `platforms.ios` to null, and\n" +
+      "     remove it.\n" +
+      "  3. The library is linked manually. React Native 0.60+ autolinks it, and on the New\n" +
+      "     Architecture a manually linked module is not registered as a TurboModule. Remove\n" +
+      "     `include ':react-native-config'` from android/settings.gradle and the matching\n" +
+      "     `implementation project(':react-native-config')` from android/app/build.gradle.\n" +
+      "  4. iOS only: `pod install` has not run since the library was installed.\n\n" +
+      "See https://github.com/react-native-config/react-native-config#troubleshooting"
+  );
+}
+
+export const Config = NativeConfigModule.getConfig().config;
 export default Config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-config",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "Expose config variables to React Native apps",
   "keywords": [
     "env",
@@ -12,14 +12,14 @@
     "windows",
     "12factor"
   ],
-  "homepage": "https://github.com/luggit/react-native-config",
+  "homepage": "https://github.com/react-native-config/react-native-config",
   "contributors": [
     "Luan Curti <luancurti@gmail.com> (https://github.com/luancurti)",
     "Amer Lotfi Orimi <amerllica@gmail.com> (https://github.com/amerllica)"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/luggit/react-native-config"
+    "url": "git+https://github.com/react-native-config/react-native-config.git"
   },
   "private": false,
   "author": "Pedro Belo",
@@ -62,7 +62,7 @@
     },
     "ios": {
       "modules": {
-        "RNCConfig": {
+        "RNCConfigModule": {
           "className": "RNCConfigModule",
           "unstableRequiresMainQueueSetup": true
         }