@bravemobile/react-native-code-push 12.0.2 → 12.1.1

package/README.md

@@ -8,7 +8,7 @@
 
 ### 🚀 New Architecture support
 
-Supports React Native 0.74 ~ 0.81.
+Supports React Native 0.74 ~ 0.82.
 
 (Tested on the React Native CLI template apps)
 

package/android/app/src/debug/AndroidManifest.xml

@@ -0,0 +1,9 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <application>
+        <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
+    </application>
+
+</manifest>

package/android/app/src/main/java/com/microsoft/codepush/react/CodePush.java

@@ -5,22 +5,17 @@ import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.content.res.Resources;
 
-import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.JavaScriptModule;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.devsupport.interfaces.DevSupportManager;
-import com.facebook.react.modules.debug.interfaces.DeveloperSettings;
 import com.facebook.react.uimanager.ViewManager;
 
 import org.json.JSONException;
 import org.json.JSONObject;
 
-import java.io.File;
 import java.util.ArrayList;
 import java.util.List;
-import java.lang.reflect.Method;
 
 public class CodePush implements ReactPackage {
 
@@ -31,7 +26,7 @@ public class CodePush implements ReactPackage {
 
     private boolean mDidUpdate = false;
 
-    private String mAssetsBundleFileName;
+    private String mAssetsBundleFileName = CodePushConstants.DEFAULT_JS_BUNDLE_NAME;
 
     // Helper classes.
     private CodePushUpdateManager mUpdateManager;
@@ -47,7 +42,6 @@ public class CodePush implements ReactPackage {
 
     private static String mPublicKey;
 
-    private static ReactInstanceHolder mReactInstanceHolder;
     private static CodePush mCurrentInstance;
 
     public static String getServiceUrl() {
@@ -87,7 +81,6 @@ public class CodePush implements ReactPackage {
         String serverUrlFromStrings = getCustomPropertyFromStringsIfExist("ServerUrl");
         if (serverUrlFromStrings != null) mServerUrl = serverUrlFromStrings;
 
-        clearDebugCacheIfNeeded(null);
         initializeUpdateAfterRestart();
     }
 
@@ -128,39 +121,6 @@ public class CodePush implements ReactPackage {
         return null;
     }
 
-    private boolean isLiveReloadEnabled(ReactInstanceManager instanceManager) {
-        // Use instanceManager for checking if we use LiveReload mode. In this case we should not remove ReactNativeDevBundle.js file
-        // because we get error with trying to get this after reloading. Issue: https://github.com/microsoft/react-native-code-push/issues/1272
-        if (instanceManager != null) {
-            DevSupportManager devSupportManager = instanceManager.getDevSupportManager();
-            if (devSupportManager != null) {
-                DeveloperSettings devSettings = devSupportManager.getDevSettings();
-                Method[] methods = devSettings.getClass().getMethods();
-                for (Method m : methods) {
-                    if (m.getName().equals("isReloadOnJSChangeEnabled")) {
-                        try {
-                            return (boolean) m.invoke(devSettings);
-                        } catch (Exception x) {
-                            return false;
-                        }
-                    }
-                }
-            }
-        }
-
-        return false;
-    }
-
-    public void clearDebugCacheIfNeeded(ReactInstanceManager instanceManager) {
-        if (mIsDebugMode && mSettingsManager.isPendingUpdate(null) && !isLiveReloadEnabled(instanceManager)) {
-            // This needs to be kept in sync with https://github.com/facebook/react-native/blob/master/ReactAndroid/src/main/java/com/facebook/react/devsupport/DevSupportManager.java#L78
-            File cachedDevBundle = new File(mContext.getFilesDir(), "ReactNativeDevBundle.js");
-            if (cachedDevBundle.exists()) {
-                cachedDevBundle.delete();
-            }
-        }
-    }
-
     public boolean didUpdate() {
         return mDidUpdate;
     }
@@ -368,17 +328,6 @@ public class CodePush implements ReactPackage {
         mSettingsManager.removeFailedUpdates();
     }
 
-    public static void setReactInstanceHolder(ReactInstanceHolder reactInstanceHolder) {
-        mReactInstanceHolder = reactInstanceHolder;
-    }
-
-    static ReactInstanceManager getReactInstanceManager() {
-        if (mReactInstanceHolder == null) {
-            return null;
-        }
-        return mReactInstanceHolder.getReactInstanceManager();
-    }
-
     @Override
     public List<NativeModule> createNativeModules(ReactApplicationContext reactApplicationContext) {
         CodePushNativeModule codePushModule = new CodePushNativeModule(reactApplicationContext, this, mUpdateManager, mTelemetryManager, mSettingsManager);

package/android/app/src/main/java/com/microsoft/codepush/react/CodePushNativeModule.java

@@ -10,7 +10,6 @@ import android.view.Choreographer;
 
 import androidx.annotation.OptIn;
 
-import com.facebook.react.ReactApplication;
 import com.facebook.react.ReactDelegate;
 import com.facebook.react.ReactHost;
 import com.facebook.react.ReactInstanceManager;
@@ -116,7 +115,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
 
     // Use reflection to find and set the appropriate fields on ReactInstanceManager. See #556 for a proposal for a less brittle way
     // to approach this.
-    private void setJSBundle(ReactInstanceManager instanceManager, String latestJSBundleFile) throws IllegalAccessException {
+    private void setJSBundle(String latestJSBundleFile) throws IllegalAccessException {
         try {
             JSBundleLoader latestJSBundleLoader;
             if (latestJSBundleFile.toLowerCase().startsWith("assets://")) {
@@ -128,7 +127,6 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
             ReactHost reactHost = resolveReactHost();
             if (reactHost == null) {
                 // Bridge, Old Architecture
-                setJSBundleLoaderBridge(instanceManager, latestJSBundleLoader);
                 return;
             }
 
@@ -140,12 +138,6 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
         }
     }
 
-    private void setJSBundleLoaderBridge(ReactInstanceManager instanceManager, JSBundleLoader latestJSBundleLoader) throws NoSuchFieldException, IllegalAccessException {
-        Field bundleLoaderField = instanceManager.getClass().getDeclaredField("mBundleLoader");
-        bundleLoaderField.setAccessible(true);
-        bundleLoaderField.set(instanceManager, latestJSBundleLoader);
-    }
-
     @OptIn(markerClass = UnstableReactNativeAPI.class)
     private void setJSBundleLoaderBridgeless(ReactHost reactHost, JSBundleLoader latestJSBundleLoader) throws NoSuchFieldException, IllegalAccessException {
         Field mReactHostDelegateField = reactHost.getClass().getDeclaredField("mReactHostDelegate");
@@ -159,27 +151,14 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
 
     private void loadBundle() {
         clearLifecycleEventListener();
-        try {
-            mCodePush.clearDebugCacheIfNeeded(resolveInstanceManager());
-        } catch(Exception e) {
-            // If we got error in out reflection we should clear debug cache anyway.
-            mCodePush.clearDebugCacheIfNeeded(null);
-        }
 
         try {
-            // #1) Get the ReactInstanceManager instance, which is what includes the
-            //     logic to reload the current React context.
-            final ReactInstanceManager instanceManager = resolveInstanceManager();
-            if (instanceManager == null) {
-                return;
-            }
-
             String latestJSBundleFile = mCodePush.getJSBundleFileInternal(mCodePush.getAssetsBundleFileName());
 
-            // #2) Update the locally stored JS bundle file path
-            setJSBundle(instanceManager, latestJSBundleFile);
+            // #1) Update the locally stored JS bundle file path
+            setJSBundle(latestJSBundleFile);
 
-            // #3) Get the context creation method and fire it on the UI thread (which RN enforces)
+            // #2) Get the context creation method and fire it on the UI thread (which RN enforces)
             new Handler(Looper.getMainLooper()).post(new Runnable() {
                 @Override
                 public void run() {
@@ -249,24 +228,6 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
         }
     }
 
-    // Use reflection to find the ReactInstanceManager. See #556 for a proposal for a less brittle way to approach this.
-    private ReactInstanceManager resolveInstanceManager() throws NoSuchFieldException, IllegalAccessException {
-        ReactInstanceManager instanceManager = CodePush.getReactInstanceManager();
-        if (instanceManager != null) {
-            return instanceManager;
-        }
-
-        final Activity currentActivity = getReactApplicationContext().getCurrentActivity();
-        if (currentActivity == null) {
-            return null;
-        }
-
-        ReactApplication reactApplication = (ReactApplication) currentActivity.getApplication();
-        instanceManager = reactApplication.getReactNativeHost().getReactInstanceManager();
-
-        return instanceManager;
-    }
-
     private void restartAppInternal(boolean onlyIfUpdateIsPending) {
         if (this._restartInProgress) {
             CodePushUtils.log("Restart request queued until the current restart is completed");

package/bin/code-push.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+import('../cli/dist/index.js').catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/cli/commands/bundleCommand/{bundleCodePush.js → bundleCodePush.ts}

@@ -1,29 +1,23 @@
-const fs = require('fs');
-const { prepareToBundleJS } = require('../../functions/prepareToBundleJS');
-const { runReactNativeBundleCommand } = require('../../functions/runReactNativeBundleCommand');
-const { runExpoBundleCommand } = require('../../functions/runExpoBundleCommand');
-const { getReactTempDir } = require('../../functions/getReactTempDir');
-const { runHermesEmitBinaryCommand } = require('../../functions/runHermesEmitBinaryCommand');
-const { makeCodePushBundle } = require('../../functions/makeCodePushBundle');
-const { ROOT_OUTPUT_DIR, ENTRY_FILE } = require('../../constant');
+import fs from "fs";
+import { prepareToBundleJS } from "../../functions/prepareToBundleJS.js";
+import { runReactNativeBundleCommand } from "../../functions/runReactNativeBundleCommand.js";
+import { runExpoBundleCommand } from "../../functions/runExpoBundleCommand.js";
+import { getReactTempDir } from "../../functions/getReactTempDir.js";
+import { runHermesEmitBinaryCommand } from "../../functions/runHermesEmitBinaryCommand.js";
+import { makeCodePushBundle } from "../../functions/makeCodePushBundle.js";
+import { ROOT_OUTPUT_DIR, ENTRY_FILE } from "../../constant.js";
 
 /**
- * @param framework {string|undefined} 'expo'
- * @param platform {string} 'ios' | 'android'
- * @param outputRootPath {string}
- * @param entryFile {string}
- * @param jsBundleName {string|undefined}
- * @param bundleDirectory {string}
  * @return {Promise<string>} CodePush bundle file name (equals to packageHash)
  */
-async function bundleCodePush(
-  framework,
-  platform = 'ios',
-  outputRootPath = ROOT_OUTPUT_DIR,
-  entryFile = ENTRY_FILE,
-  jsBundleName, // JS bundle file name (not CodePush bundle file)
-  bundleDirectory, // CodePush bundle output directory
-) {
+export async function bundleCodePush(
+  framework: 'expo' | undefined,
+  platform: 'ios' | 'android' = 'ios',
+  outputRootPath: string = ROOT_OUTPUT_DIR,
+  entryFile: string = ENTRY_FILE,
+  jsBundleName: string, // JS bundle file name (not CodePush bundle file)
+  bundleDirectory: string, // CodePush bundle output directory
+): Promise<string> {
     if (fs.existsSync(outputRootPath)) {
         fs.rmSync(outputRootPath, { recursive: true });
     }
@@ -67,5 +61,3 @@ async function bundleCodePush(
 
     return codePushBundleFileName;
 }
-
-module.exports = { bundleCodePush: bundleCodePush };

package/cli/commands/bundleCommand/{index.js → index.ts}

@@ -1,6 +1,15 @@
-const { program, Option } = require("commander");
-const { bundleCodePush } = require("./bundleCodePush");
-const { OUTPUT_BUNDLE_DIR, ROOT_OUTPUT_DIR, ENTRY_FILE } = require('../../constant');
+import { program, Option } from "commander";
+import { bundleCodePush } from "./bundleCodePush.js";
+import { OUTPUT_BUNDLE_DIR, ROOT_OUTPUT_DIR, ENTRY_FILE } from "../../constant.js";
+
+type Options = {
+    framework: 'expo' | undefined;
+    platform: 'ios' | 'android';
+    outputPath: string;
+    entryFile: string;
+    bundleName: string;
+    outputBundleDir: string;
+}
 
 program.command('bundle')
     .description('Creates a CodePush bundle file (assumes Hermes is enabled).')
@@ -10,17 +19,7 @@ program.command('bundle')
     .option('-e, --entry-file <string>', 'path to JS/TS entry file', ENTRY_FILE)
     .option('-b, --bundle-name <string>', 'bundle file name (default-ios: "main.jsbundle" / default-android: "index.android.bundle")')
     .option('--output-bundle-dir <string>', 'name of directory containing the bundle file created by the "bundle" command', OUTPUT_BUNDLE_DIR)
-    /**
-     * @param {Object} options
-     * @param {string} options.framework
-     * @param {string} options.platform
-     * @param {string} options.outputPath
-     * @param {string} options.entryFile
-     * @param {string} options.bundleName
-     * @param {string} options.outputBundleDir
-     * @return {void}
-     */
-    .action((options) => {
+    .action((options: Options) => {
         bundleCodePush(
             options.framework,
             options.platform,

package/cli/commands/createHistoryCommand/{createReleaseHistory.js → createReleaseHistory.ts}

@@ -1,36 +1,21 @@
-const fs = require('fs');
-const path = require('path');
+import fs from "fs";
+import path from "path";
+import type { CliConfigInterface, ReleaseHistoryInterface, ReleaseInfo } from "../../../typings/react-native-code-push.d.ts";
 
-/**
- *
- * @param targetVersion {string}
- * @param setReleaseHistory {
- *   function(
- *     targetBinaryVersion: string,
- *     jsonFilePath: string,
- *     releaseInfo: ReleaseHistoryInterface,
- *     platform: string,
- *     identifier: string
- *   ): Promise<void>}
- * @param platform {"ios" | "android"}
- * @param identifier {string}
- * @returns {Promise<void>}
- */
-async function createReleaseHistory(
-    targetVersion,
-    setReleaseHistory,
-    platform,
-    identifier,
-) {
-    const BINARY_RELEASE = {
+export async function createReleaseHistory(
+    targetVersion: string,
+    setReleaseHistory: CliConfigInterface['setReleaseHistory'],
+    platform: 'ios' | 'android',
+    identifier?: string,
+): Promise<void> {
+    const BINARY_RELEASE: ReleaseInfo = {
         enabled: true,
         mandatory: false,
         downloadUrl: "",
         packageHash: "",
     };
 
-    /** @type {ReleaseHistoryInterface} */
-    const INITIAL_HISTORY = {
+    const INITIAL_HISTORY: ReleaseHistoryInterface = {
         [targetVersion]: BINARY_RELEASE
     };
 
@@ -49,5 +34,3 @@ async function createReleaseHistory(
         process.exit(1)
     }
 }
-
-module.exports = { createReleaseHistory: createReleaseHistory }

package/cli/commands/createHistoryCommand/{index.js → index.ts}

@@ -1,7 +1,14 @@
-const { program, Option } = require("commander");
-const { findAndReadConfigFile } = require("../../utils/fsUtils");
-const { createReleaseHistory } = require("./createReleaseHistory");
-const { CONFIG_FILE_NAME } = require('../../constant');
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { createReleaseHistory } from "./createReleaseHistory.js";
+import { CONFIG_FILE_NAME } from "../../constant.js";
+
+type Options = {
+    binaryVersion: string;
+    platform: 'ios' | 'android';
+    identifier?: string;
+    config: string;
+}
 
 program.command('create-history')
     .description('Creates a new release history for the binary app.')
@@ -9,15 +16,7 @@ program.command('create-history')
     .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
     .option('-i, --identifier <string>', 'reserved characters to distinguish the release.')
     .option('-c, --config <path>', 'set config file name (JS/TS)', CONFIG_FILE_NAME)
-    /**
-     * @param {Object} options
-     * @param {string} options.binaryVersion
-     * @param {string} options.platform
-     * @param {string} options.identifier
-     * @param {string} options.config
-     * @return {void}
-     */
-    .action(async (options) => {
+    .action(async (options: Options) => {
         const config = findAndReadConfigFile(process.cwd(), options.config);
 
         await createReleaseHistory(

package/cli/commands/initCommand/{index.js → index.ts}

@@ -1,6 +1,6 @@
-const { initAndroid } = require('./initAndroid');
-const { initIos } = require('./initIos');
-const { program } = require('commander');
+import { initAndroid } from "./initAndroid.js";
+import { initIos } from "./initIos.js";
+import { program } from "commander";
 
 program
     .command('init')

package/cli/commands/initCommand/{initAndroid.js → initAndroid.ts}

@@ -1,8 +1,8 @@
-const path = require('path');
-const fs = require('fs');
-const { EOL } = require('os');
+import path from "path";
+import fs from "fs";
+import { EOL } from "os";
 
-function modifyMainApplicationKt(mainApplicationContent) {
+export function modifyMainApplicationKt(mainApplicationContent: string) {
     if (mainApplicationContent.includes('CodePush.getJSBundleFile()')) {
         console.log('log: MainApplication.kt already has CodePush initialized.');
         return mainApplicationContent;
@@ -12,7 +12,7 @@ function modifyMainApplicationKt(mainApplicationContent) {
         .replace('override fun getJSMainModuleName(): String = "index"', `override fun getJSMainModuleName(): String = "index"${EOL}        override fun getJSBundleFile(): String = CodePush.getJSBundleFile()`)
 }
 
-async function initAndroid() {
+export async function initAndroid() {
     console.log('log: Running Android setup...');
     await applyMainApplication();
 }
@@ -37,12 +37,7 @@ async function applyMainApplication() {
 
 async function findMainApplication() {
     const searchPath = path.join(process.cwd(), 'android', 'app', 'src', 'main', 'java');
-    const files = fs.readdirSync(searchPath, { recursive: true });
+    const files = fs.readdirSync(searchPath, { encoding: 'utf-8', recursive: true });
     const mainApplicationFile = files.find(file => file.endsWith('MainApplication.java') || file.endsWith('MainApplication.kt'));
     return mainApplicationFile ? path.join(searchPath, mainApplicationFile) : null;
 }
-
-module.exports = {
-    initAndroid: initAndroid,
-    modifyMainApplicationKt: modifyMainApplicationKt,
-};

package/cli/commands/initCommand/initIos.ts

@@ -0,0 +1,123 @@
+import path from "path";
+import fs from "fs";
+// @ts-expect-error -- types for "xcode" are not available
+import xcode from "xcode";
+
+export async function initIos() {
+    console.log('log: Running iOS setup...');
+    const projectDir = path.join(process.cwd(), 'ios');
+    const files = fs.readdirSync(projectDir);
+    const xcodeprojFile = files.find(file => file.endsWith('.xcodeproj'));
+    if (!xcodeprojFile) {
+        console.log('log: Could not find .xcodeproj file in ios directory');
+        return;
+    }
+    const projectName = xcodeprojFile.replace('.xcodeproj', '');
+    const appDelegatePath = findAppDelegate(path.join(projectDir, projectName));
+
+    if (!appDelegatePath) {
+        console.log('log: Could not find AppDelegate file');
+        return;
+    }
+
+    if (appDelegatePath.endsWith('.swift')) {
+        await setupSwift(appDelegatePath, projectDir, projectName);
+    } else {
+        await setupObjectiveC(appDelegatePath);
+    }
+
+    console.log('log: Please run `cd ios && pod install` to complete the setup.');
+}
+
+function findAppDelegate(searchPath: string) {
+    if (!fs.existsSync(searchPath)) return null;
+    const files = fs.readdirSync(searchPath);
+    const appDelegateFile = files.find(file => file.startsWith('AppDelegate') && (file.endsWith('.m') || file.endsWith('.mm') || file.endsWith('.swift')));
+    return appDelegateFile ? path.join(searchPath, appDelegateFile) : null;
+}
+
+export function modifyObjectiveCAppDelegate(appDelegateContent: string) {
+    const IMPORT_STATEMENT = '#import <CodePush/CodePush.h>';
+    if (appDelegateContent.includes(IMPORT_STATEMENT)) {
+        console.log('log: AppDelegate already has CodePush imported.');
+        return appDelegateContent;
+    }
+
+    return appDelegateContent
+        .replace('#import "AppDelegate.h"\n', `#import "AppDelegate.h"\n${IMPORT_STATEMENT}\n`)
+        .replace('[[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];', '[CodePush bundleURL];');
+}
+
+export function modifySwiftAppDelegate(appDelegateContent: string) {
+    const CODEPUSH_CALL_STATEMENT = 'CodePush.bundleURL()';
+    if (appDelegateContent.includes(CODEPUSH_CALL_STATEMENT)) {
+        console.log('log: AppDelegate.swift already configured for CodePush.');
+        return appDelegateContent;
+    }
+
+    return appDelegateContent
+        .replace('Bundle.main.url(forResource: "main", withExtension: "jsbundle")', CODEPUSH_CALL_STATEMENT);
+}
+
+async function setupObjectiveC(appDelegatePath: string) {
+    const appDelegateContent = fs.readFileSync(appDelegatePath, 'utf-8');
+    const newContent = modifyObjectiveCAppDelegate(appDelegateContent);
+    fs.writeFileSync(appDelegatePath, newContent);
+    console.log('log: Successfully updated AppDelegate.m/mm.');
+}
+
+async function setupSwift(appDelegatePath: string, projectDir: string, projectName: string) {
+    const bridgingHeaderPath = await ensureBridgingHeader(projectDir, projectName);
+    if (!bridgingHeaderPath) {
+        console.log('log: Failed to create or find bridging header.');
+        return;
+    }
+
+    const appDelegateContent = fs.readFileSync(appDelegatePath, 'utf-8');
+    const newContent = modifySwiftAppDelegate(appDelegateContent);
+    fs.writeFileSync(appDelegatePath, newContent);
+    console.log('log: Successfully updated AppDelegate.swift.');
+}
+
+async function ensureBridgingHeader(projectDir: string, projectName: string) {
+    const projectPath = path.join(projectDir, `${projectName}.xcodeproj`, 'project.pbxproj');
+    const myProj = xcode.project(projectPath);
+
+    return new Promise((resolve, reject) => {
+        myProj.parse(function (err: unknown) {
+            if (err) {
+                console.error(`Error parsing Xcode project: ${err}`);
+                return reject(err);
+            }
+
+            const bridgingHeaderRelativePath = `${projectName}/${projectName}-Bridging-Header.h`;
+            const bridgingHeaderAbsolutePath = path.join(projectDir, bridgingHeaderRelativePath);
+
+            const configurations = myProj.pbxXCBuildConfigurationSection();
+            for (const name in configurations) {
+                const config = configurations[name];
+                if (config.buildSettings) {
+                    config.buildSettings.SWIFT_OBJC_BRIDGING_HEADER = `"${bridgingHeaderRelativePath}"`;
+                }
+            }
+
+            if (!fs.existsSync(bridgingHeaderAbsolutePath)) {
+                fs.mkdirSync(path.dirname(bridgingHeaderAbsolutePath), { recursive: true });
+                fs.writeFileSync(bridgingHeaderAbsolutePath, '#import <CodePush/CodePush.h>\n');
+                console.log(`log: Created bridging header at ${bridgingHeaderAbsolutePath}`);
+                const groupKey = myProj.findPBXGroupKey({ name: projectName });
+                myProj.addHeaderFile(bridgingHeaderRelativePath, { public: true }, groupKey);
+            } else {
+                const headerContent = fs.readFileSync(bridgingHeaderAbsolutePath, 'utf-8');
+                if (!headerContent.includes('#import <CodePush/CodePush.h>')) {
+                    fs.appendFileSync(bridgingHeaderAbsolutePath, '\n#import <CodePush/CodePush.h>\n');
+                    console.log(`log: Updated bridging header at ${bridgingHeaderAbsolutePath}`);
+                }
+            }
+
+            fs.writeFileSync(projectPath, myProj.writeSync());
+            console.log('log: Updated Xcode project with bridging header path.');
+            resolve(bridgingHeaderAbsolutePath);
+        });
+    });
+}

package/cli/commands/initCommand/test/initAndroid.test.ts

@@ -0,0 +1,86 @@
+import fs from "fs";
+import path from "path";
+import { initAndroid, modifyMainApplicationKt } from "../initAndroid.js";
+import { jest, expect, describe, it } from "@jest/globals";
+
+const tempDir = path.join(__dirname, 'temp');
+
+// https://github.com/react-native-community/template/blob/0.80.2/template/android/app/src/main/java/com/helloworld/MainApplication.kt
+const ktTemplate = `
+package com.helloworld
+
+import android.app.Application
+import com.facebook.react.PackageList
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeApplicationEntryPoint.loadReactNative
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactPackage
+import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
+import com.facebook.react.defaults.DefaultReactNativeHost
+
+class MainApplication : Application(), ReactApplication {
+
+  override val reactNativeHost: ReactNativeHost =
+      object : DefaultReactNativeHost(this) {
+        override fun getPackages(): List<ReactPackage> =
+            PackageList(this).packages.apply {
+              // Packages that cannot be autolinked yet can be added manually here, for example:
+              // add(MyReactNativePackage())
+            }
+
+        override fun getJSMainModuleName(): String = "index"
+
+        override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
+
+        override val isNewArchEnabled: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+        override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED
+      }
+
+  override val reactHost: ReactHost
+    get() = getDefaultReactHost(applicationContext, reactNativeHost)
+
+  override fun onCreate() {
+    super.onCreate()
+    loadReactNative(this)
+  }
+}
+`;
+
+describe('Android init command', () => {
+    it('should correctly modify Kotlin MainApplication content', () => {
+        const modifiedContent = modifyMainApplicationKt(ktTemplate);
+        expect(modifiedContent).toContain('import com.microsoft.codepush.react.CodePush');
+        expect(modifiedContent).toContain('override fun getJSBundleFile(): String = CodePush.getJSBundleFile()');
+    });
+
+    it('should log a message and exit if MainApplication.java is found', async () => {
+        const originalCwd = process.cwd();
+
+        fs.mkdirSync(tempDir, { recursive: true });
+        process.chdir(tempDir);
+
+        // Arrange
+        const javaAppDir = path.join(tempDir, 'android', 'app', 'src', 'main', 'java', 'com', 'helloworld');
+        fs.mkdirSync(javaAppDir, { recursive: true });
+        const javaFilePath = path.join(javaAppDir, 'MainApplication.java');
+        const originalContent = '// Java file content';
+        fs.writeFileSync(javaFilePath, originalContent);
+
+        const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {
+        });
+
+        // Act
+        await initAndroid();
+
+        // Assert
+        expect(consoleSpy).toHaveBeenCalledWith('log: MainApplication.java is not supported. Please migrate to MainApplication.kt.');
+        const finalContent = fs.readFileSync(javaFilePath, 'utf-8');
+        expect(finalContent).toBe(originalContent); // Ensure file is not modified
+
+        consoleSpy.mockRestore();
+
+        process.chdir(originalCwd);
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+});