增加Taro-RN代码

readme.md

+### 项目介绍
+
+Taro-rn 的 模板项目

template/.eslintignore

+build
+node_modules
+.git
\ No newline at end of file

template/.eslintrc.json

+{
+  "extends": ["taro/react", "prettier"],
+  "plugins": ["prettier"],
+  "rules": {
+    "prettier/prettier": "error",
+    "react/jsx-uses-react": "off",
+    "react/react-in-jsx-scope": "off"
+  }
+}

template/.gitignore

+dist/
+.temp/
+node_modules/
+
+# react native
+
+# OSX
+#
+.DS_Store
+
+# Xcode
+#
+build/
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+xcuserdata
+*.xccheckout
+*.moved-aside
+DerivedData
+*.hmap
+*.ipa
+*.xcuserstate
+
+# Android/IntelliJ
+#
+build/
+.idea
+.gradle
+local.properties
+*.iml
+
+# node.js
+#
+node_modules/
+npm-debug.log
+yarn-error.log
+
+# BUCK
+buck-out/
+\.buckd/
+*.keystore
+!debug.keystore
+
+# fastlane
+#
+# It is recommended to not store the screenshots in the git repo. Instead, use fastlane to re-generate the
+# screenshots whenever they are needed.
+# For more information about the recommended setup visit:
+# https://docs.fastlane.tools/best-practices/source-control/
+
+*/fastlane/report.xml
+*/fastlane/Preview.html
+*/fastlane/screenshots
+
+# Bundle artifact
+*.jsbundle
+
+# CocoaPods
+/ios/Pods/
+
+/android/app/src/main/java/com/tarodemo/generated
\ No newline at end of file

template/.prettierignore

+build
+node_modules
+.git
\ No newline at end of file

template/.prettierrc.json

+{
+  "printWidth": 80,
+  "tabWidth": 2,
+  "trailingComma": "es5",
+  "semi": true,
+  "arrowParens": "always"
+}

template/.vscode/settings.json

+{
+  "editor.formatOnSave": true,
+  "[javascript]": {
+    "editor.defaultFormatter": "dbaeumer.vscode-eslint"
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "dbaeumer.vscode-eslint"
+  },
+  "[javascriptreact]": {
+    "editor.defaultFormatter": "dbaeumer.vscode-eslint"
+  },
+  "[typescriptreact]": {
+    "editor.defaultFormatter": "dbaeumer.vscode-eslint"
+  },
+  "eslint.format.enable": true
+}

template/android/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>taroDemo</name>
+	<comment>Project android created by Buildship.</comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
+	</natures>
+	<filteredResources>
+		<filter>
+			<id>1636946938568</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
+</projectDescription>

template/android/.settings/org.eclipse.buildship.core.prefs

+arguments=
+auto.sync=false
+build.scans.enabled=false
+connection.gradle.distribution=GRADLE_DISTRIBUTION(WRAPPER)
+connection.project.dir=
+eclipse.preferences.version=1
+gradle.user.home=
+java.home=/Library/Java/JavaVirtualMachines/jdk-17.jdk/Contents/Home
+jvm.arguments=
+offline.mode=false
+override.workspace.settings=true
+show.console.view=true
+show.executions.view=true

template/android/app/.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11/"/>
+	<classpathentry kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer"/>
+	<classpathentry kind="output" path="bin/default"/>
+</classpath>

template/android/app/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>app</name>
+	<comment>Project app created by Buildship.</comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
+	</natures>
+	<filteredResources>
+		<filter>
+			<id>1636946938535</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
+</projectDescription>

template/android/app/.settings/org.eclipse.buildship.core.prefs

+connection.project.dir=..
+eclipse.preferences.version=1

template/android/app/BUCK

+# To learn about Buck see [Docs](https://buckbuild.com/).
+# To run your application with Buck:
+# - install Buck
+# - `npm start` - to start the packager
+# - `cd android`
+# - `keytool -genkey -v -keystore keystores/debug.keystore -storepass android -alias androiddebugkey -keypass android -dname "CN=Android Debug,O=Android,C=US"`
+# - `./gradlew :app:copyDownloadableDepsToLibs` - make all Gradle compile dependencies available to Buck
+# - `buck install -r android/app` - compile, install and run application
+#
+
+load(":build_defs.bzl", "create_aar_targets", "create_jar_targets")
+
+lib_deps = []
+
+create_aar_targets(glob(["libs/*.aar"]))
+
+create_jar_targets(glob(["libs/*.jar"]))
+
+android_library(
+    name = "all-libs",
+    exported_deps = lib_deps,
+)
+
+android_library(
+    name = "app-code",
+    srcs = glob([
+        "src/main/java/**/*.java",
+    ]),
+    deps = [
+        ":all-libs",
+        ":build_config",
+        ":res",
+    ],
+)
+
+android_build_config(
+    name = "build_config",
+    package = "com.tarodemo",
+)
+
+android_resource(
+    name = "res",
+    package = "com.tarodemo",
+    res = "src/main/res",
+)
+
+android_binary(
+    name = "app",
+    keystore = "//android/keystores:debug",
+    manifest = "src/main/AndroidManifest.xml",
+    package_type = "debug",
+    deps = [
+        ":app-code",
+    ],
+)

template/android/app/build.gradle

+apply plugin: "com.android.application"
+apply from: '../../node_modules/react-native-unimodules/gradle.groovy'
+
+import com.android.build.OutputFile
+/**
+ * The react.gradle file registers a task for each build variant (e.g. bundleDebugJsAndAssets
+ * and bundleReleaseJsAndAssets).
+ * These basically call `react-native bundle` with the correct arguments during the Android build
+ * cycle. By default, bundleDebugJsAndAssets is skipped, as in debug/dev mode we prefer to load the
+ * bundle directly from the development server. Below you can see all the possible configurations
+ * and their defaults. If you decide to add a configuration block, make sure to add it before the
+ * `apply from: "../../node_modules/react-native/react.gradle"` line.
+ *
+ * project.ext.react = [
+ *   // the name of the generated asset file containing your JS bundle
+ *   bundleAssetName: "index.android.bundle",
+ *
+ *   // the entry file for bundle generation. If none specified and
+ *   // "index.android.js" exists, it will be used. Otherwise "index.js" is
+ *   // default. Can be overridden with ENTRY_FILE environment variable.
+ *   entryFile: "index.android.js",
+ *
+ *   // https://reactnative.dev/docs/performance#enable-the-ram-format
+ *   bundleCommand: "ram-bundle",
+ *
+ *   // whether to bundle JS and assets in debug mode
+ *   bundleInDebug: false,
+ *
+ *   // whether to bundle JS and assets in release mode
+ *   bundleInRelease: true,
+ *
+ *   // whether to bundle JS and assets in another build variant (if configured).
+ *   // See http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Build-Variants
+ *   // The configuration property can be in the following formats
+ *   //         'bundleIn${productFlavor}${buildType}'
+ *   //         'bundleIn${buildType}'
+ *   // bundleInFreeDebug: true,
+ *   // bundleInPaidRelease: true,
+ *   // bundleInBeta: true,
+ *
+ *   // whether to disable dev mode in custom build variants (by default only disabled in release)
+ *   // for example: to disable dev mode in the staging build type (if configured)
+ *   devDisabledInStaging: true,
+ *   // The configuration property can be in the following formats
+ *   //         'devDisabledIn${productFlavor}${buildType}'
+ *   //         'devDisabledIn${buildType}'
+ *
+ *   // the root of your project, i.e. where "package.json" lives
+ *   root: "../../",
+ *
+ *   // where to put the JS bundle asset in debug mode
+ *   jsBundleDirDebug: "$buildDir/intermediates/assets/debug",
+ *
+ *   // where to put the JS bundle asset in release mode
+ *   jsBundleDirRelease: "$buildDir/intermediates/assets/release",
+ *
+ *   // where to put drawable resources / React Native assets, e.g. the ones you use via
+ *   // require('./image.png')), in debug mode
+ *   resourcesDirDebug: "$buildDir/intermediates/res/merged/debug",
+ *
+ *   // where to put drawable resources / React Native assets, e.g. the ones you use via
+ *   // require('./image.png')), in release mode
+ *   resourcesDirRelease: "$buildDir/intermediates/res/merged/release",
+ *
+ *   // by default the gradle tasks are skipped if none of the JS files or assets change; this means
+ *   // that we don't look at files in android/ or ios/ to determine whether the tasks are up to
+ *   // date; if you have any other folders that you want to ignore for performance reasons (gradle
+ *   // indexes the entire tree), add them here. Alternatively, if you have JS files in android/
+ *   // for example, you might want to remove it from here.
+ *   inputExcludes: ["android/**", "ios/**"],
+ *
+ *   // override which node gets called and with what additional arguments
+ *   nodeExecutableAndArgs: ["node"],
+ *
+ *   // supply additional arguments to the packager
+ *   extraPackagerArgs: []
+ * ]
+ */
+
+addUnimodulesDependencies()
+
+project.ext.react = [
+    enableHermes: false,  // clean and rebuild if changing
+]
+
+//apply from: "../../node_modules/react-native/react.gradle"
+
+apply from: "./react.gradle"
+apply from: "./codepush.gradle"
+
+/**
+ * Set this to true to create two separate APKs instead of one:
+ *   - An APK that only works on ARM devices
+ *   - An APK that only works on x86 devices
+ * The advantage is the size of the APK is reduced by about 4MB.
+ * Upload all the APKs to the Play Store and people will download
+ * the correct one based on the CPU architecture of their device.
+ */
+def enableSeparateBuildPerCPUArchitecture = false
+
+/**
+ * Run Proguard to shrink the Java bytecode in release builds.
+ */
+def enableProguardInReleaseBuilds = false
+
+/**
+ * The preferred build flavor of JavaScriptCore.
+ *
+ * For example, to use the international variant, you can use:
+ * `def jscFlavor = 'org.webkit:android-jsc-intl:+'`
+ *
+ * The international variant includes ICU i18n library and necessary data
+ * allowing to use e.g. `Date.toLocaleString` and `String.localeCompare` that
+ * give correct results when using with locales other than en-US.  Note that
+ * this variant is about 6MiB larger per architecture than default.
+ */
+def jscFlavor = 'org.webkit:android-jsc:+'
+
+/**
+ * Whether to enable the Hermes VM.
+ *
+ * This should be set on project.ext.react and mirrored here.  If it is not set
+ * on project.ext.react, JavaScript will not be compiled to Hermes Bytecode
+ * and the benefits of using Hermes will therefore be sharply reduced.
+ */
+def enableHermes = project.ext.react.get("enableHermes", false);
+
+ext {
+	extraPermissionsForDebug = []
+}
+
+android {
+    ndkVersion rootProject.ext.ndkVersion
+
+    compileSdkVersion rootProject.ext.compileSdkVersion
+
+    dexOptions {
+        javaMaxHeapSize "4g"
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    defaultConfig {
+        applicationId app_id
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        versionCode Integer.parseInt(version_code)
+        versionName version_name
+        // vectorDrawables.useSupportLibrary true
+        ndk {
+            abiFilters abi_filters.replaceAll("\\s*", "").split(",")
+        }
+    }
+    splits {
+        abi {
+            reset()
+            enable enableSeparateBuildPerCPUArchitecture
+            universalApk false  // If true, also generate a universal APK
+            include "armeabi-v7a", "x86", "arm64-v8a", "x86_64"
+        }
+    }
+    signingConfigs {
+        release {
+            if (project.hasProperty('MYAPP_RELEASE_STORE_FILE')) {
+                storeFile file(MYAPP_RELEASE_STORE_FILE)
+                storePassword MYAPP_RELEASE_STORE_PASSWORD
+                keyAlias MYAPP_RELEASE_KEY_ALIAS
+                keyPassword MYAPP_RELEASE_KEY_PASSWORD
+            }
+        }
+        debug {
+            storeFile file(keystore_file)
+            storePassword keystore_password
+            keyAlias keystore_key_alias
+            keyPassword keystore_key_password
+        }
+    }
+    buildTypes {
+        debug {
+            signingConfig signingConfigs.debug
+            manifestPlaceholders = [
+                    usesCleartextTraffic: "true",
+                    appIcon             : "@mipmap/${app_icon.isEmpty() ? 'ic_launcher' : app_icon}",
+                    appRoundIcon        : "@mipmap/${app_round_icon.isEmpty() ? 'ic_launcher_round' : app_round_icon}"
+            ]
+            extraPermissionsForDebug = ["SYSTEM_ALERT_WINDOW"]
+            resValue 'string', 'app_name', app_name
+        }
+        release {
+            // Caution! In production, you need to generate your own keystore file.
+            // see https://reactnative.dev/docs/signed-apk-android.
+            manifestPlaceholders = [
+                    usesCleartextTraffic: "false",
+                    appIcon             : "@mipmap/${app_icon.isEmpty() ? 'ic_launcher' : app_icon}",
+                    appRoundIcon        : "@mipmap/${app_round_icon.isEmpty() ? 'ic_launcher_round' : app_round_icon}"
+            ]
+            resValue 'string', 'app_name', app_name
+            signingConfig signingConfigs.release
+            minifyEnabled enableProguardInReleaseBuilds
+            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
+        }
+    }
+
+    // applicationVariants are e.g. debug, release
+    applicationVariants.all { variant ->
+        variant.outputs.each { output ->
+            // For each separate APK per architecture, set a unique version code as described here:
+            // https://developer.android.com/studio/build/configure-apk-splits.html
+            def versionCodes = ["armeabi-v7a": 1, "x86": 2, "arm64-v8a": 3, "x86_64": 4]
+            def abi = output.getFilter(OutputFile.ABI)
+            if (abi != null) {  // null for the universal-debug, universal-release variants
+                output.versionCodeOverride =
+                        defaultConfig.versionCode * 1000 + versionCodes.get(abi)
+            }
+
+            // 如果没有指定圆角icon，则将android:roundIcon从AndroidManifest.xml中移除
+            if (app_round_icon.isEmpty()) {
+                println "未指定圆角icon，准备将android:roundIcon从AndroidManifest.xml中移除"
+                def processManifest = output.getProcessManifestProvider().get()
+                processManifest.doLast { task ->
+                    def outputDir = task.getMultiApkManifestOutputDirectory().get().asFile
+                    File outputDirectory
+                    if (outputDir instanceof File) {
+                        outputDirectory = outputDir
+                    } else {
+                        outputDirectory = outputDir.get().asFile
+                    }
+                    File manifestOutFile = file("$outputDirectory/AndroidManifest.xml")
+
+                    if (manifestOutFile.exists() && manifestOutFile.canRead() && manifestOutFile.canWrite()) {
+                        def newManifest = manifestOutFile.getText().replace("android:roundIcon=\"@mipmap/ic_launcher_round\"", "")
+                        manifestOutFile.write(newManifest, 'UTF-8')
+                    }
+                    println "已将android:roundIcon从AndroidManifest.xml中移除"
+                }
+            }
+        }
+    }
+}
+
+dependencies {
+    implementation fileTree(dir: "libs", include: ["*.jar"])
+    //noinspection GradleDynamicVersion
+    implementation "com.facebook.react:react-native:+"  // From node_modules
+
+    implementation "androidx.swiperefreshlayout:swiperefreshlayout:1.0.0"
+
+    if (enableHermes) {
+        def hermesPath = "../../node_modules/hermes-engine/android/";
+        debugImplementation files(hermesPath + "hermes-debug.aar")
+        releaseImplementation files(hermesPath + "hermes-release.aar")
+    } else {
+        implementation jscFlavor
+    }
+}
+
+// Run this once to be able to run the application with BUCK
+// puts all compile dependencies into folder libs for BUCK to use
+task copyDownloadableDepsToLibs(type: Copy) {
+    from configurations.compile
+    into 'libs'
+}
+
+// 添加debug模式的权限
+android.applicationVariants.all {
+	variant ->
+		variant.outputs.each {
+			output ->
+				def processManifestTask = output.processManifestProvider.get()
+				if ((variant.name == 'release') || (extraPermissionsForDebug.size() == 0)) {
+					return
+				}
+				println(processManifestTask)
+				processManifestTask.doLast {
+					def processResources = output.getProcessResourcesProvider().get()
+					def manifestPath = processResources.manifestFile
+					 def manifestFile = file(manifestPath)
+					def parser = new XmlParser()
+					def rootNode = parser.parse(manifestFile)
+					extraPermissionsForDebug.each {
+						rootNode.appendNode("uses-permission", ["android:name": "android.permission.$it"])
+					}
+					def manifestContent = groovy.xml.XmlUtil.serialize(rootNode)
+					file(manifestPath).write(manifestContent)
+					println("**permission(s) ${extraPermissionsForDebug.join(',')} have been added for build variant ${variant.name}**")
+				}
+		}
+}
+
+apply from: file("../../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesAppBuildGradle(project)
\ No newline at end of file

template/android/app/build_defs.bzl

+"""Helper definitions to glob .aar and .jar targets"""
+
+def create_aar_targets(aarfiles):
+    for aarfile in aarfiles:
+        name = "aars__" + aarfile[aarfile.rindex("/") + 1:aarfile.rindex(".aar")]
+        lib_deps.append(":" + name)
+        android_prebuilt_aar(
+            name = name,
+            aar = aarfile,
+        )
+
+def create_jar_targets(jarfiles):
+    for jarfile in jarfiles:
+        name = "jars__" + jarfile[jarfile.rindex("/") + 1:jarfile.rindex(".jar")]
+        lib_deps.append(":" + name)
+        prebuilt_jar(
+            name = name,
+            binary_jar = jarfile,
+        )

template/android/app/codepush.gradle

+// Adapted from https://raw.githubusercontent.com/facebook/react-native/d16ff3bd8b92fa84a9007bf5ebedd8153e4c089d/react.gradle
+
+import java.nio.file.Paths;
+
+def config = project.hasProperty("react") ? project.react : [];
+def bundleAssetName = config.bundleAssetName ?: "index.android.bundle"
+
+// because elvis operator
+def elvisFile(thing) {
+    return thing ? file(thing) : null;
+}
+
+void runBefore(String dependentTaskName, Task task) {
+    Task dependentTask = tasks.findByPath(dependentTaskName);
+    if (dependentTask != null) {
+        dependentTask.dependsOn task
+    }
+}
+
+gradle.projectsEvaluated {
+    android.buildTypes.each {
+        // to prevent incorrect long value restoration from strings.xml we need to wrap it with double quotes
+        // https://github.com/microsoft/cordova-plugin-code-push/issues/264
+        it.resValue 'string', "CODE_PUSH_APK_BUILD_TIME", String.format("\"%d\"", System.currentTimeMillis())
+    }
+    
+    android.applicationVariants.all { variant ->
+        def nodeModulesPath;
+        if (config.root) {
+            nodeModulesPath = Paths.get(config.root, "/node_modules");
+        } else if (project.hasProperty('nodeModulesPath')) {
+            nodeModulesPath = project.nodeModulesPath
+        } else {
+            nodeModulesPath = "../../node_modules";
+        }
+
+        def targetName = variant.name.capitalize()
+        def targetPath = variant.dirName
+
+        def jsBundleDir;
+        def resourcesDir;
+        def jsBundleFile;
+
+        // Additional node commandline arguments
+        def nodeExecutableAndArgs = config.nodeExecutableAndArgs ?: ["node"]
+        def extraPackagerArgs = config.extraPackagerArgs ?: []
+
+        // Make this task run right after the bundle task
+        def generateBundledResourcesHash;
+
+        if (variant.hasProperty("bundleJsAndAssets")) {
+            def reactBundleTask = variant.bundleJsAndAssets
+            jsBundleDir = reactBundleTask.generatedAssetsFolders[0].absolutePath
+            resourcesDir = reactBundleTask.generatedResFolders[0].absolutePath
+            jsBundleFile = file("$jsBundleDir/$bundleAssetName")
+
+            generateBundledResourcesHash = tasks.create(
+                    name: "generateBundledResourcesHash${targetName}",
+                    type: Exec) {
+                commandLine (*nodeExecutableAndArgs, "${nodeModulesPath}/react-native-code-push/scripts/generateBundledResourcesHash.js", resourcesDir, jsBundleFile, jsBundleDir)
+
+                enabled config."bundleIn${targetName}" ||
+                config."bundleIn${variant.buildType.name.capitalize()}" ?:
+                targetName.toLowerCase().contains("release")
+            }   
+        } else {
+            def jsBundleDirConfigName = "jsBundleDir${targetName}"
+            jsBundleDir = elvisFile(config."$jsBundleDirConfigName") ?:
+                    file("$buildDir/intermediates/assets/${targetPath}")
+
+            def resourcesDirConfigName = "resourcesDir${targetName}"
+            resourcesDir = elvisFile(config."${resourcesDirConfigName}") ?:
+                    file("$buildDir/intermediates/res/merged/${targetPath}")
+
+            // In case version of 'Android Plugin for Gradle'' is lower than 1.3.0 
+            // '$buildDir' has slightly different structure - 'merged' folder
+            // does not exists so '${targetPath}' folder contains directly in 'res' folder.
+            if (!resourcesDir.exists() && file("$buildDir/intermediates/res/${targetPath}").exists()) {
+                resourcesDir = file("$buildDir/intermediates/res/${targetPath}")
+            }
+
+            jsBundleFile = file("$jsBundleDir/$bundleAssetName")
+
+            def resourcesMapTempFileName = "CodePushResourcesMap-" + java.util.UUID.randomUUID().toString().substring(0,8) + ".json"
+
+            generateBundledResourcesHash = tasks.create(
+                    name: "generateBundledResourcesHash${targetName}",
+                    type: Exec) {
+                commandLine (*nodeExecutableAndArgs, "${nodeModulesPath}/react-native-code-push/scripts/generateBundledResourcesHash.js", resourcesDir, jsBundleFile, jsBundleDir, resourcesMapTempFileName)
+            }
+
+            // Make this task run right before the bundle task
+            def recordFilesBeforeBundleCommand = tasks.create(
+                    name: "recordFilesBeforeBundleCommand${targetName}",
+                    type: Exec) {
+                commandLine (*nodeExecutableAndArgs, "${nodeModulesPath}/react-native-code-push/scripts/recordFilesBeforeBundleCommand.js", resourcesDir, resourcesMapTempFileName)
+            }
+
+            recordFilesBeforeBundleCommand.dependsOn("merge${targetName}Resources")
+            recordFilesBeforeBundleCommand.dependsOn("merge${targetName}Assets")
+            runBefore("bundle${targetName}JsAndAssets", recordFilesBeforeBundleCommand)
+
+            // We need to generate and record the resources map, but we use it to generate the bundle hash
+            generateBundledResourcesHash.dependsOn("recordFilesBeforeBundleCommand${targetName}")
+        }
+
+        generateBundledResourcesHash.dependsOn("bundle${targetName}JsAndAssets")
+        runBefore("processArmeabi-v7a${targetName}Resources", generateBundledResourcesHash)
+        runBefore("processX86${targetName}Resources", generateBundledResourcesHash)
+        runBefore("processUniversal${targetName}Resources", generateBundledResourcesHash)
+        runBefore("process${targetName}Resources", generateBundledResourcesHash)
+    }
+}

template/android/app/proguard-rules.pro

+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:

template/android/app/react.gradle

+import org.apache.tools.ant.taskdefs.condition.Os
+
+def config = project.hasProperty("react") ? project.react : [:];
+
+/**
+ * Detects CLI location in a similar fashion to the React Native CLI
+ */
+def detectCliPath(config) {
+  if (config.cliPath) {
+    return config.cliPath
+  }
+  if (new File("${projectDir}/../../node_modules/@tarojs/cli/index.js").exists()) {
+    return "${projectDir}/../../node_modules/@tarojs/cli/index.js"
+  }
+  throw new Exception("Couldn't determine CLI location. " +
+    "Please set `project.ext.react.cliPath` to the path of the @tarojs/cli cli.js");
+}
+
+def composeSourceMapsPath = config.composeSourceMapsPath ?: "node_modules/react-native/scripts/compose-source-maps.js"
+def bundleAssetName = config.bundleAssetName ?: "index.android.bundle"
+def bundleCommand = config.bundleCommand ?: "build"
+def reactRoot = file(config.root ?: "../../")
+def inputExcludes = config.inputExcludes ?: ["android/**", "ios/**"]
+def bundleConfig = config.bundleConfig ? "${reactRoot}/${config.bundleConfig}" : null ;
+def enableVmCleanup = config.enableVmCleanup == null ? true : config.enableVmCleanup
+def hermesCommand = config.hermesCommand ?: "../../node_modules/hermes-engine/%OS-BIN%/hermesc"
+
+def reactNativeDevServerPort() {
+  def value = project.getProperties().get("reactNativeDevServerPort")
+  return value != null ? value : "8081"
+}
+
+def reactNativeInspectorProxyPort() {
+  def value = project.getProperties().get("reactNativeInspectorProxyPort")
+  return value != null ? value : reactNativeDevServerPort()
+}
+
+def getHermesOSBin() {
+  if (Os.isFamily(Os.FAMILY_WINDOWS)) return "win64-bin";
+  if (Os.isFamily(Os.FAMILY_MAC)) return "osx-bin";
+  if (Os.isOs(null, "linux", "amd64", null)) return "linux64-bin";
+  throw new Exception("OS not recognized. Please set project.ext.react.hermesCommand " + "to the path of a working Hermes compiler.");
+}
+
+def getHermesCommand = {
+    // If the project specifies a Hermes command, don't second guess it.
+    if (!hermesCommand.contains("%OS-BIN%")) {
+        return hermesCommand
+    }
+    // Execution on Windows fails with / as separator
+    return hermesCommand
+            .replaceAll("%OS-BIN%", getHermesOSBin())
+            .replace('/' as char, File.separatorChar);
+}
+
+// Set enableHermesForVariant to a function to configure per variant,
+// or set `enableHermes` to True/False to set all of them
+def enableHermesForVariant = config.enableHermesForVariant ?: {
+    def variant -> config.enableHermes ?: false
+}
+
+android {
+    buildTypes.all {
+        resValue "integer", "react_native_dev_server_port", reactNativeDevServerPort()
+        resValue "integer", "react_native_inspector_proxy_port", reactNativeInspectorProxyPort()
+    }
+}
+
+afterEvaluate {
+    def isAndroidLibrary = plugins.hasPlugin("com.android.library")
+    def variants = isAndroidLibrary ? android.libraryVariants : android.applicationVariants
+    variants.all { def variant ->
+
+        def targetName = variant.name.capitalize()
+        def targetPath = variant.dirName
+
+        // React js bundle directories
+        def jsBundleDir = file("$buildDir/generated/assets/react/release")
+        def resourcesDir = file("$buildDir/generated/res/react/release")
+
+        def jsBundleFile = file("$jsBundleDir/$bundleAssetName")
+        def jsSourceMapsDir = file("$buildDir/generated/assets/react/release")
+        def jsIntermediateSourceMapsDir = file("$buildDir/intermediates/sourcemaps/react/${targetPath}")
+        def jsPackagerSourceMapFile = file("$jsIntermediateSourceMapsDir/${bundleAssetName}.packager.map")
+        def jsCompilerSourceMapFile = file("$jsIntermediateSourceMapsDir/${bundleAssetName}.compiler.map")
+        def jsOutputSourceMapFile = file("$jsSourceMapsDir/${bundleAssetName}.map")
+
+        def nodeExecutableAndArgs = config.nodeExecutableAndArgs ?: ["node"]
+        def cliPath = detectCliPath(config)
+
+        def execCommand = []
+
+        if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+            execCommand.addAll(["cmd", "/c", *nodeExecutableAndArgs, cliPath])
+        } else {
+            execCommand.addAll([*nodeExecutableAndArgs, cliPath])
+        }
+
+        def enableHermes = enableHermesForVariant(variant)
+
+        def currentBundleTask = tasks.create(
+            name: "bundle${targetName}JsAndAssets",
+            type: Exec) {
+            group = "react"
+            description = "bundle JS and assets for ${targetName}."
+
+            doFirst {
+                jsBundleDir.deleteDir()
+                jsBundleDir.mkdirs()
+                resourcesDir.deleteDir()
+                resourcesDir.mkdirs()
+                jsIntermediateSourceMapsDir.deleteDir()
+                jsIntermediateSourceMapsDir.mkdirs()
+                jsSourceMapsDir.deleteDir()
+                jsSourceMapsDir.mkdirs()
+            }
+
+            // Set up inputs and outputs so gradle can cache the result
+            inputs.files fileTree(dir: reactRoot, excludes: inputExcludes)
+            outputs.dir(jsBundleDir)
+            outputs.dir(resourcesDir)
+
+            workingDir(reactRoot)
+
+            def devEnabled = !(config."devDisabledIn${targetName}"
+                || targetName.toLowerCase().contains("release"))
+
+            commandLine("npx", "taro", "build", "--type", "rn", "--platform", "android", "--reset-cache")
+
+            enabled config."bundleIn${targetName}" != null
+                ? config."bundleIn${targetName}"
+                : config."bundleIn${variant.buildType.name.capitalize()}" != null
+                    ? config."bundleIn${variant.buildType.name.capitalize()}"
+                    : targetName.toLowerCase().contains("release")
+
+        }
+
+        variant.ext.bundleJsAndAssets = currentBundleTask
+        currentBundleTask.ext.generatedResFolders = files(resourcesDir).builtBy(currentBundleTask)
+        currentBundleTask.ext.generatedAssetsFolders = files(jsBundleDir).builtBy(currentBundleTask)
+
+        // registerGeneratedResFolders for Android plugin 3.x
+        if (variant.respondsTo("registerGeneratedResFolders")) {
+            variant.registerGeneratedResFolders(currentBundleTask.generatedResFolders)
+        } else {
+            variant.registerResGeneratingTask(currentBundleTask)
+        }
+        variant.mergeResourcesProvider.get().dependsOn(currentBundleTask)
+
+        // packageApplication for Android plugin 3.x
+        def packageTask = variant.hasProperty("packageApplication")
+            ? variant.packageApplicationProvider.get()
+            : tasks.findByName("package${targetName}")
+        if (variant.hasProperty("packageLibrary")) {
+            packageTask = variant.packageLibrary
+        }
+
+        // pre bundle build task for Android plugin 3.2+
+        def buildPreBundleTask = tasks.findByName("build${targetName}PreBundle")
+
+        def resourcesDirConfigValue = config."resourcesDir${targetName}"
+        if (resourcesDirConfigValue) {
+            def currentCopyResTask = tasks.create(
+                name: "copy${targetName}BundledResources",
+                type: Copy) {
+                group = "react"
+                description = "copy bundled resources into custom location for ${targetName}."
+
+                from(resourcesDir)
+                into(file(resourcesDirConfigValue))
+
+                dependsOn(currentBundleTask)
+
+                enabled(currentBundleTask.enabled)
+            }
+
+            packageTask.dependsOn(currentCopyResTask)
+            if (buildPreBundleTask != null) {
+                buildPreBundleTask.dependsOn(currentCopyResTask)
+            }
+        }
+
+        def currentAssetsCopyTask = tasks.create(
+            name: "copy${targetName}BundledJs",
+            type: Copy) {
+            group = "react"
+            description = "copy bundled JS into ${targetName}."
+
+            if (config."jsBundleDir${targetName}") {
+                from(jsBundleDir)
+                into(file(config."jsBundleDir${targetName}"))
+            } else {
+                into ("$buildDir/intermediates")
+                if (isAndroidLibrary) {
+                    into ("library_assets/${variant.name}/out") {
+                        from(jsBundleDir)
+                    }
+                } else {
+                    into ("assets/${targetPath}") {
+                        from(jsBundleDir)
+                    }
+
+                    // Workaround for Android Gradle Plugin 3.2+ new asset directory
+                    into ("merged_assets/${variant.name}/merge${targetName}Assets/out") {
+                        from(jsBundleDir)
+                    }
+
+                    // Workaround for Android Gradle Plugin 3.4+ new asset directory
+                    into ("merged_assets/${variant.name}/out") {
+                        from(jsBundleDir)
+                    }
+                }
+            }
+
+            // mergeAssets must run first, as it clears the intermediates directory
+            dependsOn(variant.mergeAssetsProvider.get())
+
+            enabled(currentBundleTask.enabled)
+            dependsOn(currentBundleTask)
+        }
+
+
+        // mergeResources task runs before the bundle file is copied to the intermediate asset directory from Android plugin 4.1+.
+        // This ensures to copy the bundle file before mergeResources task starts
+        def mergeResourcesTask = tasks.findByName("merge${targetName}Resources")
+        mergeResourcesTask.dependsOn(currentAssetsCopyTask)
+
+        packageTask.dependsOn(currentAssetsCopyTask)
+        if (buildPreBundleTask != null) {
+            buildPreBundleTask.dependsOn(currentAssetsCopyTask)
+        }
+
+        // Delete the VM related libraries that this build doesn't need.
+        // The application can manage this manually by setting 'enableVmCleanup: false'
+        //
+        // This should really be done by packaging all Hermes related libs into
+        // two separate HermesDebug and HermesRelease AARs, but until then we'll
+        // kludge it by deleting the .so files out of the /transforms/ directory.
+        def isRelease = targetName.toLowerCase().contains("release")
+        def libDir = "$buildDir/intermediates/transforms/"
+        def vmSelectionAction = {
+            fileTree(libDir).matching {
+                if (enableHermes) {
+                    // For Hermes, delete all the libjsc* files
+                    include "**/libjsc*.so"
+
+                    if (isRelease) {
+                        // Reduce size by deleting the debugger/inspector
+                        include '**/libhermes-inspector.so'
+                        include '**/libhermes-executor-debug.so'
+                    } else {
+                        // Release libs take precedence and must be removed
+                        // to allow debugging
+                        include '**/libhermes-executor-release.so'
+                    }
+                } else {
+                    // For JSC, delete all the libhermes* files
+                    include "**/libhermes*.so"
+                }
+            }.visit { details ->
+                def targetVariant = ".*/transforms/[^/]*/${targetPath}/.*"
+                def path = details.file.getAbsolutePath().replace(File.separatorChar, '/' as char)
+                if (path.matches(targetVariant) && details.file.isFile()) {
+                    details.file.delete()
+                }
+            }
+        }
+
+        if (enableVmCleanup) {
+            packageTask.doFirst(vmSelectionAction)
+        }
+    }
+}

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

+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
+
+    <application
+        android:usesCleartextTraffic="true"
+        tools:targetApi="28"
+        tools:ignore="GoogleAppIndexingWarning">
+        <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
+    </application>
+</manifest>
\ No newline at end of file