Develop Reference

Cannot invoke method doFirst() on null object : react.gradle - android

Can somebody help me.
I tried to create android dependency using a react native compiled to android studio.
and I encountered some error that says : Cannot invoke method doFirst() on null object and its directing to my react.gradle file.
Here's environment specs:
Android studio build gradle version : 4.0.0
distributionUrl=https\://services.gradle.org/distributions/gradle-6.1.1-all.zip
Here's the detailed error
FAILURE: Build failed with an exception.
* Where:
Script 'C:\Users\Nhick\esports-gameclient-mobile-v1.0\node_modules\react-native\react.gradle' line: 312
* What went wrong:
A problem occurred configuring project ':app'.
> Failed to notify project evaluation listener.
> Cannot invoke method doFirst() on null object
> Could not get unknown property 'applicationVariants' for extension 'android' of type com.android.build.gradle.LibraryExtension.
Here's my react.gradle
// Copyright (c) Facebook, Inc. and its affiliates.
// This source code is licensed under the MIT license found in the
// LICENSE file in the root directory of this source tree.
import org.apache.tools.ant.taskdefs.condition.Os
def config = project.hasProperty("react") ? project.react : [];
def cliPath = config.cliPath ?: "node_modules/react-native/cli.js"
def composeSourceMapsPath = config.composeSourceMapsPath ?: "node_modules/react-native/scripts/compose-source-maps.js"
def bundleAssetName = config.bundleAssetName ?: "index.android.bundle"
def entryFile = config.entryFile ?: "index.android.js"
def bundleCommand = config.bundleCommand ?: "bundle"
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%/hermes"
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.");
}
// Make sure not to inspect the Hermes config unless we need it,
// to avoid breaking any JSC-only setups.
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 ->
// Create variant and target names
def targetName = variant.name.capitalize()
def targetPath = variant.dirName
// React js bundle directories
def jsBundleDir = file("$buildDir/generated/assets/react/${targetPath}")
def resourcesDir = file("$buildDir/generated/res/react/${targetPath}")
def jsBundleFile = file("$jsBundleDir/$bundleAssetName")
def jsSourceMapsDir = file("$buildDir/generated/sourcemaps/react/${targetPath}")
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")
// Additional node and packager commandline arguments
def nodeExecutableAndArgs = config.nodeExecutableAndArgs ?: ["node"]
def extraPackagerArgs = config.extraPackagerArgs ?: []
def enableHermes = enableHermesForVariant(variant)
def currentBundleTask = tasks.create(
name: "bundle${targetName}JsAndAssets",
type: Exec) {
group = "react"
description = "bundle JS and assets for ${targetName}."
// Create dirs if they are not there (e.g. the "clean" task just ran)
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)
// Set up the call to the react-native cli
workingDir(reactRoot)
// Set up dev mode
def devEnabled = !(config."devDisabledIn${targetName}"
|| targetName.toLowerCase().contains("release"))
def extraArgs = extraPackagerArgs;
if (bundleConfig) {
extraArgs = extraArgs.clone()
extraArgs.add("--config");
extraArgs.add(bundleConfig);
}
if (Os.isFamily(Os.FAMILY_WINDOWS)) {
commandLine("cmd", "/c", *nodeExecutableAndArgs, cliPath, bundleCommand, "--platform", "android", "--dev", "${devEnabled}",
"--reset-cache", "--entry-file", entryFile, "--bundle-output", jsBundleFile, "--assets-dest", resourcesDir,
"--sourcemap-output", enableHermes ? jsPackagerSourceMapFile : jsOutputSourceMapFile, *extraArgs)
} else {
commandLine(*nodeExecutableAndArgs, cliPath, bundleCommand, "--platform", "android", "--dev", "${devEnabled}",
"--reset-cache", "--entry-file", entryFile, "--bundle-output", jsBundleFile, "--assets-dest", resourcesDir,
"--sourcemap-output", enableHermes ? jsPackagerSourceMapFile : jsOutputSourceMapFile, *extraArgs)
}
if (enableHermes) {
doLast {
def hermesFlags;
def hbcTempFile = file("${jsBundleFile}.hbc")
exec {
if (targetName.toLowerCase().contains("release")) {
// Can't use ?: since that will also substitute valid empty lists
hermesFlags = config.hermesFlagsRelease
if (hermesFlags == null) hermesFlags = ["-O", "-output-source-map"]
} else {
hermesFlags = config.hermesFlagsDebug
if (hermesFlags == null) hermesFlags = []
}
if (Os.isFamily(Os.FAMILY_WINDOWS)) {
commandLine("cmd", "/c", getHermesCommand(), "-emit-binary", "-out", hbcTempFile, jsBundleFile, *hermesFlags)
} else {
commandLine(getHermesCommand(), "-emit-binary", "-out", hbcTempFile, jsBundleFile, *hermesFlags)
}
}
ant.move(
file: hbcTempFile,
toFile: jsBundleFile
);
if (hermesFlags.contains("-output-source-map")) {
ant.move(
// Hermes will generate a source map with this exact name
file: "${jsBundleFile}.hbc.map",
tofile: jsCompilerSourceMapFile
);
exec {
// TODO: set task dependencies for caching
// Set up the call to the compose-source-maps script
workingDir(reactRoot)
if (Os.isFamily(Os.FAMILY_WINDOWS)) {
commandLine("cmd", "/c", *nodeExecutableAndArgs, composeSourceMapsPath, jsPackagerSourceMapFile, jsCompilerSourceMapFile, "-o", jsOutputSourceMapFile)
} else {
commandLine(*nodeExecutableAndArgs, composeSourceMapsPath, jsPackagerSourceMapFile, jsCompilerSourceMapFile, "-o", jsOutputSourceMapFile)
}
}
}
}
}
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")
}
// Expose a minimal interface on the application variant and the task itself:
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")
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)
}
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 releated 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) {
def task = tasks.findByName("package${targetName}")
task.doFirst(vmSelectionAction)
}
}
}

I didn't see you declare a task like package$..., so that maybe a reason, gradle can't find tasks.findByName("package${targetName}") and it return null.

I've faced the same problem when changed the plugin from application to library.
To solve this I've just added a null-check:
...
if (enableVmCleanup) {
def task = tasks.findByName("package${targetName}")
if (task != null) task.doFirst(vmSelectionAction)
}

Related

I'm doing automated build number generation via build.gradle using property file.
Changes on the property file is not being pushed in the Git Repository after the assembleRelease has been executed on Azure Devops
private Integer generateBuildNum() {
File buildNumPropsFile = file('../app/src/main/assets/buildnum.properties')
if (buildNumPropsFile.canRead()) {
Properties buildNumProps = new Properties()
buildNumProps.load(new FileInputStream(buildNumPropsFile))
return buildNumProps['VERSION_BUILD'].toInteger()
}
else {
throw new GradleException("Could not read buildnum.properties!")
}
return null
}
private void increaseBuildNum() {
gradle.taskGraph.whenReady { taskGraph ->
println taskGraph.hasTask(assembleRelease)
if (taskGraph.hasTask(assembleRelease)) {
/* when run release task */
File buildNumPropsFile = file('../app/src/main/assets/buildnum.properties')
if (buildNumPropsFile.canRead()) {
Properties buildNumProps = new Properties()
buildNumProps.load(new FileInputStream(buildNumPropsFile))
def build = buildNumProps['VERSION_BUILD'].toInteger() + 1
if(build != null) {
println "*********increaseBuildNum build: "+build
}
buildNumProps['VERSION_BUILD'] = build.toString()
buildNumProps.store(buildNumPropsFile.newWriter(), null)
def buildUpdated = buildNumProps['VERSION_BUILD'].toInteger()
} else {
throw new GradleException("Could not read buildnum.properties!")
}
}
}
}
android {
compileSdkVersion 28
buildToolsVersion "28.0.0"
defaultConfig {
.....
increaseBuildNum()
}
The property file is working when the apk is built on local machine but not on Azure Pipeline. How can I update it on the Git Repo.

added flutter to my existing project as a module and getting this crash.
by following this link.
2019-06-24 11:08:24.366 30834-30834/com.alarmnet.tc2 E/flutter: [ERROR:flutter/runtime/dart_vm_data.cc(19)] VM snapshot invalid and could not be inferred from settings.
2019-06-24 11:08:24.366 30834-30834/com.alarmnet.tc2 E/flutter: [ERROR:flutter/runtime/dart_vm.cc(241)] Could not setup VM data to bootstrap the VM from.
2019-06-24 11:08:24.366 30834-30834/com.alarmnet.tc2 E/flutter: [ERROR:flutter/runtime/dart_vm_lifecycle.cc(89)] Could not create Dart VM instance.
2019-06-24 11:08:24.366 30834-30834/com.alarmnet.tc2 A/flutter: [FATAL:flutter/shell/common/shell.cc(218)] Check failed: vm. Must be able to initialize the VM.
2019-06-24 11:08:24.368 30834-30834/com.alarmnet.tc2 A/libc: Fatal signal 6 (SIGABRT), code -6 in tid 30834 (om.alarmnet.tc2)

Find a fix for it :
If you trying to add a flutter to your existing project as per this link
Open your Flutter SDK : FlutterSdk/flutter/packages/flutter_tools/gradle/flutter.gradle
open flutter.gradle in any of the editors and do the following changes
from :
// We know that the flutter app is a subproject in another Android app when these tasks exist.
Task packageAssets = project.tasks.findByPath(":flutter:package${variant.name.capitalize()}Assets")
Task cleanPackageAssets = project.tasks.findByPath(":flutter:cleanPackage${variant.name.capitalize()}Assets")
Task copyFlutterAssetsTask = project.tasks.create(name: "copyFlutterAssets${variant.name.capitalize()}", type: Copy) {
dependsOn flutterTasks
if (packageAssets && cleanPackageAssets) {
dependsOn packageAssets
dependsOn cleanPackageAssets
into packageAssets.outputDir
} else {
dependsOn variant.mergeAssets
dependsOn "clean${variant.mergeAssets.name.capitalize()}"
into variant.mergeAssets.outputDir
}
flutterTasks.each { flutterTask ->
with flutterTask.assets
// Include the snapshots in the assets directory.
if (flutterBuildMode != 'release' || targetPlatformValue != 'android-arm-all') {
with flutterTask.snapshots
}
}
}
if (packageAssets) {
String mainModuleName = "app"
try {
String tmpModuleName = project.rootProject.ext.mainModuleName
if (tmpModuleName != null && !tmpModuleName.empty) {
mainModuleName = tmpModuleName
}
} catch (Exception e) {
}
Only include configurations that exist in parent project.
Task mergeAssets = project.tasks.findByPath(":${mainModuleName}:merge${variant.name.capitalize()}Assets")
if (mergeAssets) {
mergeAssets.dependsOn(copyFlutterAssetsTask)
}
} else {
def processResources = variant.outputs.first().processResources
processResources.dependsOn(copyFlutterAssetsTask)
}
To :
// We know that the flutter app is a subproject in another Android app when these tasks exist.
Task packageAssets = project.tasks.findByPath(":flutter:package${variant.name.capitalize()}Assets")
Task cleanPackageAssets = project.tasks.findByPath(":flutter:cleanPackage${variant.name.capitalize()}Assets")
Task copyFlutterAssetsTask = project.tasks.create(name: "copyFlutterAssets${variant.name.capitalize()}", type: Copy) {
dependsOn flutterTasks
if (packageAssets && cleanPackageAssets) {
dependsOn packageAssets
dependsOn cleanPackageAssets
into packageAssets.outputDir
} else {
dependsOn variant.mergeAssets
dependsOn "clean${variant.mergeAssets.name.capitalize()}"
into variant.mergeAssets.outputDir
}
flutterTasks.each { flutterTask ->
with flutterTask.assets
// Include the snapshots in the assets directory.
if (flutterBuildMode != 'release' || targetPlatformValue != 'android-arm-all') {
with flutterTask.snapshots
}
}
}
// if (packageAssets) {
// String mainModuleName = "app"
// try {
// String tmpModuleName = project.rootProject.ext.mainModuleName
// if (tmpModuleName != null && !tmpModuleName.empty) {
// mainModuleName = tmpModuleName
// }
// } catch (Exception e) {
// }
// Only include configurations that exist in parent project.
// Task mergeAssets = project.tasks.findByPath(":${mainModuleName}:merge${variant.name.capitalize()}Assets")
// if (mergeAssets) {
// mergeAssets.dependsOn(copyFlutterAssetsTask)
// }
//} else {
// def processResources = variant.outputs.first().processResources
// processResources.dependsOn(copyFlutterAssetsTask)
// }
def processResources = variant.outputs.first().processResources
processResources.dependsOn(copyFlutterAssetsTask)
save and follow this link

if you are added flutter in the existing app go to flutter module --> .android --> build.gradle. classpath must be same as of Android
dependencies {
classpath 'com.android.tools.build:gradle:3.4.2'
}

Below is gradle console error statement, signingconfig.properties file, signingconfig.gradle code that reads the file. I believe it is a simple syntax error such as quotes. Could someone correct the syntax in the signingconfig.properties file?
Where:
Script '/Users/gregmarsh/AndroidStudioProjects/DanceApps1/WCSVidMet/signingconfig.gradle' line: 23
What went wrong:
A problem occurred evaluating script.
Neither path nor baseDir may be null or empty string. path='null' basedir='/Users/gregmarsh/AndroidStudioProjects/DanceApps1/WCSVidMet'
signingconfig.properties file below
debug.store=
release.store=/Users/gregmarsh/AndroidStudioProjects/android.jks
release.storePass=
release.alias=MyAndroidKey
release.pass=
signingconfig.gradle code that reads the file below
def readPasswordFromConsole(prompt) {
def c = System.console()
if(c != null) {
return new String(System.console().readPassword("\n\$ " + prompt + " "))
}
return ""
}
android {
signingConfigs {
def configPropsFile = file("signingconfig.properties")
if (configPropsFile.exists()) {
def props = new Properties()
props.load(new FileInputStream(configPropsFile))
debug {
if(props.debug_store?.trim()) {
storeFile file(props.debug_store)
}
}
release {
storeFile file(props.release_store)
storePassword(props.release_storePass?.trim() ? props.release_storePass : readPasswordFromConsole("keystore pass:"))
keyAlias props.release_alias
keyPassword(props.release_pass?.trim() ? props.release_pass : readPasswordFromConsole("key pass:"))
}
} else {
println "signingconfig.properties file is missing (required for release builds)!"
}
}
}

I have a json config file and I put it in res/raw folder. previously I have a gradle script that updates the file contents when it was necessary.
def fetchMeta(buildVariant) {
def flavor = buildVariant.productFlavors.get(0).name
def buildType = buildVariant.buildType.name
def middleMetaFolder = "${buildDir}/intermediates/meta/${flavor}"
def pathToMiddleMeta = "${middleMetaFolder}/latest.json"
def rawFolder = "${buildDir}/intermediates/res/merged/${buildVariant.dirName}/raw/"
def f = new File(pathToMiddleMeta)
boolean doDownload = (!f.exists()) || (f.lastModified() < (System.currentTimeMillis() - 86400000))
// Force on production release
if (doDownload || (flavor == "production" && buildType == "release")) {
new File(middleMetaFolder).mkdirs()
def serverAddress = "https://example.com"
String srcUrl = serverAddress + "/latest.json"
println "Downloading Meta from: " + srcUrl + " to " + pathToMiddleMeta
new URL(srcUrl).withInputStream { i -> f.withOutputStream { it << i } }
} else {
println "Skipping Meta as it exists here: " + pathToMiddleMeta
}
copy {
from pathToMiddleMeta
into rawFolder
}
}
android.applicationVariants.all { variant ->
variant.mergeResources.doLast {
fetchMeta(variant)
}
}
But as of android gradle plugin 3.0 merge strategy changed and files are with flat extension. How can I update the contents of my file after these changes?

had the same issue, which comes with the update from aapt to aapt2
issue is already assigned at google issue-tracker
https://issuetracker.google.com/issues/65220623
as a workaround right now you can set android.enableAapt2=false in your gradle.properties

all!
I'm trying to get Gradle generate different files (Android.mk and Application.mk) for the release and debug builds. Default way, gradle android plugin doing so doesn't suit me, because it doesn't allow to modify Application.mk, I want to. The main problem is that I can not identify current build type.
I tried the following:
android {
...
defaultConfig {
project['CONFIGURATION_FLAGS'] = ''
project['APP_ABI'] = ''
project['APP_PLATFORM'] = 'android-9'
project['APP_STL'] = 'gnustl_static'
project['NDK_TOOLCHAIN_VERSION'] = 'clang'
}
buildTypes {
release {
project['CONFIGURATION_FLAGS'] = '-fvisibility=hidden'
project['APP_ABI'] = 'armeabi x86'
}
debug {
project['CONFIGURATION_FLAGS'] = '-g -DDEBUG -DENABLE_LOG'
project['APP_ABI'] = 'armeabi'
}
}
}
task processTemplates {
def templatesDir = System.getProperty('user.dir') + '/app/templates'
def jniDir = System.getProperty('user.dir') + '/app/src/main/jni'
// Android.mk
def configFlags = project['CONFIGURATION_FLAGS']
def androidMk = file(templatesDir + '/Android.mk').text
androidMk = androidMk.replaceAll '<CONFIGURATION_FLAGS>', configFlags
def newAndroidMk = new File(jniDir + '/Android.mk')
newAndroidMk.text = androidMk
// Application.mk
def appAbi = project['APP_ABI']
def appPlatform = project['APP_PLATFORM']
def appStl = project['APP_STL']
def toolchain = project['NDK_TOOLCHAIN_VERSION']
def applicationMk = file(templatesDir + '/Application.mk').text
applicationMk = applicationMk.replaceAll '<APP_ABI>', appAbi
applicationMk = applicationMk.replaceAll '<APP_PLATFORM>', appPlatform
applicationMk = applicationMk.replaceAll '<APP_STL>', appStl
applicationMk = applicationMk.replaceAll '<NDK_TOOLCHAIN_VERSION>', toolchain
def newApplicationMk = new File(jniDir + '/Application.mk')
newApplicationMk.text = applicationMk
}
But found that the setting of parameters is performed 2 times, that is, for each type of build, regardless of the current build type. Which leads to the fact that for any type of build it set debug options. Can anyone advise me how to solve this problem?

Add a task which depends on each assembleXxx task and property setting up after it invoked
see my answer for similar problem.