How can I set a System.env variable in Android Studio? - android

In my build.gradle file in Android Studio using NDK, I have the following code. The app builds if I run it from the terminal with "./gradlew --assembleDebug" since I have set the path for ANDROID_NDK_HOME to /Users/chenige/Desktop/android-ndk-r9, but it will not build from inside Android Studio. From inside Android Studio, System.env.ANDROID_NDK_HOME is "null". Does anybody know why/how I can fix this?
task buildNative(type: Exec) {
if (System.env.ANDROID_NDK_HOME != null) {
def ndkBuild = new File(System.env.ANDROID_NDK_HOME, 'ndk-build')
commandLine ndkBuild
} else {
doLast {
println '##################'
println 'Skipping NDK build'
println 'Reason: ANDROID_NDK_HOME not set.'
println '##################'
}
}
}
}

Android Studio doesn't read environment variables, so this approach won't work. Also, using the projectDir scheme in settings.gradle will probably cause problems. Android Studio has a limitation that all of its modules need to be located underneath the project root. If you have libraries that are used in multiple projects and they can't be placed under a single project root, the best advice is to have them publish JARs or AARs to a local Maven repository that individual projects can pick up.
read more Environment variable in settings.gradle not working with Android Studio

It works for me with the follwoing steps:
Set your variable in Windows
Reboot
reach it in gradle build: "$System.env.MYVARIABLE"

Related

How to change path for release APK artifact?

How can I configure a Gradle Android project so that a release APK built by the IDE is saved to a path of my choosing (eg the project root) rather than buried deep in the build folder?
I've added this to the defaultConfig section of the app build file to sensibly name the APK and it works well, but how can I specify where it goes, or move it post build completion?
archivesBaseName = "AppName-v$versionName" // AppName-v1.2.3-release.apk
UPDATE:
I created a task in the app-level Gradle build file that successfully copies the release APK, if I run the Gradle task manually:
task copyReleaseApk(type: Copy) {
from 'build/outputs/apk'
into '..' // project root, one-level above "app"
include '**/*release.apk'
}
But I have not yet found a way to make the task run automatically after the last build task. I tried this:
assembleRelease.finalizedBy(copySupportFiles)
But that results in "Could not get unknown property 'assembleRelease' for object of type com.android.build.gradle.AppExtension."
I also tried this:
assembleRelease.finalizedBy(copySupportFiles)
It appears not to do anything.
This worked (in the android tag of the app build.gradle file). The afterEvaluate seems to be required in order to refer to tasks like packageRelease that don't initially exist.
task copyReleaseApk(type: Copy) {
from 'build/outputs/apk'
into '..' // folder above the app folder
include '**/*release.apk'
}
afterEvaluate {
packageRelease.finalizedBy(copyReleaseApk)
}
It can be defined in the project's root build.gradle:
allprojects {
buildDir = "/path/to/build/${rootProject.name}/${project.name}"
}

How to have a white list of files to be compiled in Gradle NDK build

I need to transform an Android app's from Ant to Gradle. This app uses a cross platform C++ library. With Ant we are using make (.mk) files to decide which files are compiled to create the JNI library. I am trying to use the new experimental Gradle version (gradle-experimental:0.7.0-rc1) to do something equivalent to what Ant is doing and white list the files I compile.
The problem is that according to the documentation, this can't be done.
sources.main {
jni {
source {
include "someFile.cpp" // This is ignored.
}
}
}
Does anyone have a workaround for this?
A relatively easy way to do this is to continue using your existing .mk makefiles and call to ndk-build from Gradle like this:
// Call external ndk-build(.cmd) script to build the native code
task ndkBuild(type: Exec) {
def ndkBuildExt = Os.isFamily(Os.FAMILY_WINDOWS) ? ".cmd" : ""
commandLine "ndk-build${ndkBuildExt}", '-C', file('.').absolutePath,
'-j', Runtime.runtime.availableProcessors()
}
tasks.withType(JavaCompile) {
compileTask -> compileTask.dependsOn ndkBuild
}
This approach requires the path to your NDK installation to be set in Android Studio's "Project Structure" dialog (File->Project Structure) or by setting the ANDROID_NDK_HOME environment variable on the command line.

Gradle multi-project dependency doesn't include

I'm trying to set up a Gradle build to build and include an NDK static library into an Android project, but can't get the inclusion to work. I'm running Gradle 2.8 on a Linux system directly from the command line (AndroidStudio, Android SDK, and Android NDK are installed, but I'm not using them directly in the sample below). I've boiled down my issue to the following purely Gradle-based sample, and was hoping someone more versed in Gradle could show me the way.
Let's say I have the following directory structure:
gradle_test
mySubLibs
common.gradle
mySubA
build.gradle
settings.gradle
myProjA
common.gradle
Projects
Android
build.gradle
settings.gradle
My library sub projects are under the mySubLibs directory. I'll have gradle_test be the root project directory to get around the fact that Gradle sucks with dealing with arbitrary paths (another gripe for another time).
First, I set up my library to build with "assembleRelease" and "clean" tasks. In reality it will call to command-line compilers to work, but for testing Gradle this simplification will do.
gradle_test/mySubLibs/common.gradle
buildscript {
}
task NDKBuildReleaseLib(type: Exec) {
println "Running NDKBuildReleaseLib for " + rootProject.name
commandLine 'touch', 'obj/local/myOutput.a'
}
task NDKBuildCleanLib(type: Exec) {
println "Running NDKBuildCleanLib for " + rootProject.name
commandLine 'rm', '../libs/myOutput.a', 'obj/local/myOutput.a'
}
task copyLibs(type:Copy) {
from 'obj/local'
into '../libs'
include '*.a'
outputs.upToDateWhen {false}
}
NDKBuildReleaseLib.finalizedBy copyLib
gradle_test/mySubLibs/mySubA/build.gradle
apply from: '../common.gradle'
configurations.create('default')
allprojects {
task assembleRelease(dependsOn: NDKBuildReleaseLib) << {}
task clean(dependsOn: NDKBuildCleanLib) << {}
}
gradle_test/mySubLibs/mySubA/settings.gradle
rootProject.name = "mySubA"
include ':'
This works fine. I can call "gradle assembleRelease" from the mySubA directory, and it builds my library file (the build being simulated by running "touch" to create a file). Now let's create a similar setup for the main project.
gradle_test/myProjA/common.gradle
buildscript {
}
task NDKBuildRelease(type: Exec) {
println "Running NDKBuildRelease for " + rootProject.name
commandLine 'touch', 'obj/local/myProjOutput.a'
}
task NDKBuildClean(type: Exec) {
println "Running NDKBuildClean for " + rootProject.name
commandLine 'rm', 'obj/local/myProjOutput.a'
}
gradle_test/myProjA/Projects/Android/build.gradle
apply from: '../../common.gradle'
configurations.create('default')
dependencies {
// default project(':mySubLibs:mySubA')
}
allprojects {
task assembleRelease(dependsOn: NDKBuildRelease) << {
println "Assemble Release for " + project.name
}
task clean(dependsOn: NDKBuildClean) << {
println "Clean for " + project.name
}
}
gradle_test/myProjA/Projects/Android/settings.gradle
rootProject.projectDir = new File(settingsDir, '../../..')
rootProject.name = "myTestBase"
include ':'
include 'mySubLibs:mySubA'
include 'myProjA:Projects:Android'
This mostly works, except that it is not causing the sub project to build. So my questions are:
How do I get the sub-project to build? If I uncomment the line above in the "dependencies" section, I get an undefined token error. Almost all samples dealing with dependencies use "compile" instead of "default" there, but since this example doesn't have a compile configuration created by the java plugin inclusion, I can't do that (nor did it work when I tried that). I know the sub project is being evaluated from "gradle --info", but it doesn't run.
How would I specify an arbitrary task to build the sub-project? In the above examples, I've set both up to build off a task named "assembleRelease". How could I call "assembleRelease" to build the project, but have a task called "buildMySubLib" called to build the library project?
The end goal is to have multiple library projects called to each build their own static library and copy it to a known common location, then for the main project to include all the static lib files from that common location in its own compile and link stage. It seems silly to have to set up a task for each library in the main project that uses an Exec task to recursively call the command line version of "gradle" for each library project.
Thanks for any insight. So far Gradle is proving to be more hindrance than helpful in trying to set up what should actually be a pretty common build scenario.

Using NDK in Android Studio with outside C++ sources

So far into my foray with using NDK with Android Studio, I've written the Java Wrapper, generated the header file, and filled in some functions in the corresponding c++ file in JNI folder.
What I'm trying to do right now is to get a simple build going so that I can verify things work. My project relies on some c++ source files located outside of my entire android project. Do I build those source files somehow from within Android? How do I access them? Is there anything I need to do from Gradle?
I'm incredibly new to building projects with across multiple sources, so I have no idea what to do. Apologies if the questions don't make sense. Any help is greatly appreciated (:
http://ph0b.com/android-studio-gradle-and-ndk-integration/
user ph0b has many SO posts on NDK.
read this person's various posts on the subj ( AS + NDK )
IMO - You can follow strategy 'import NDK proj' from src dirs used for eclipse/NDK android project and AS 0.8.+ will get you almost all the way there with normal "File/Import project" dialog.
After the AS import is done, the NDK stuff will be at:
./root/module/src/main/jni
Java packages will be at
./root/module/src/main/java
Verify that the import to AS did NOT do auto-update on the "Android.mk" file that you input to the import process because you will need it and not any auto gen'd file from AS.
In AS gradle.build file ...
make sure
buildToolsVersion "19.1.0"
and add following as per the earlier links:
ndk {
moduleName "audioboo-ogg"
}
}
flavorDimensions "abi"
productFlavors {
x86 {
ndk {
abiFilter "x86"
}
}
armv7 {
ndk {
abiFilter "armeabi-v7a"
}
}
}
sourceSets {
main {
jni.srcDirs = [] /*disable automatic ndk-build call */
}
}
task ndkBuild(type: Exec) {
commandLine '$NDK_HOME/android-ndk-r9[a-z]/ndk-build', '-C', file('src/main/jni').absolutePath
}
tasks.withType(JavaCompile) {
compileTask -> compileTask.dependsOn ndkBuild
}
You then will have option of doing CLI NDK build in the jni folder, OR just using gradle integrated build that will use the "ndkBuild" task from gradle file.

How to export library to Jar in Android Studio?

I have downloaded some library sources and would like to export it as a Jar file using
Android Studio. Is there a way to export to jar file using Android studio ?
edit:
The library I want to export as jar is an Android library.
It's called "StandOut" and can be downloaded from GitHub.
https://github.com/pingpongboss/StandOut
It is not possible to export an Android library as a jar file. It is possible, however, to export it as aar file. Aar files being the new binary format for Android libraries. There's info about them in Google I/O, the New Build System video.
First, build the library in Android Studio or from command line issuing gradle build from your library's root directory.
This will result in <yourlibroot>/libs/build/yourlib.aar file.
This aar file is a binary representation of your library and can be added to your project instead of the library as a dependency project.
To add aar file as a dependency you have to publish it to the maven central or to your local maven repository, and then refer the aar file in your project's gradle.build file.
However, this step is a bit convoluted. I've found a good explanation how to do so here:
http://www.flexlabs.org/2013/06/using-local-aar-android-library-packages-in-gradle-builds
I was able to build a library source code to compiled .jar file, using approach from this solution:
https://stackoverflow.com/a/19037807/1002054
Here is the breakdown of what I did:
1. Checkout library repository
In may case it was a Volley library
2. Import library in Android Studio.
I used Android Studio 0.3.7. I've encountered some issues during that step, namely I had to copy gradle folder from new android project before I was able to import Volley library source code, this may vary depending on source code you use.
3. Modify your build.gradle file
// If your module is a library project, this is needed
//to properly recognize 'android-library' plugin
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'com.android.tools.build:gradle:0.6.3'
}
}
apply plugin: 'android-library'
android {
compileSdkVersion 17
buildToolsVersion = 17
sourceSets {
main {
// Here is the path to your source code
java {
srcDir 'src'
}
}
}
}
// This is the actual solution, as in https://stackoverflow.com/a/19037807/1002054
task clearJar(type: Delete) {
delete 'build/libs/myCompiledLibrary.jar'
}
task makeJar(type: Copy) {
from('build/bundles/release/')
into('build/libs/')
include('classes.jar')
rename ('classes.jar', 'myCompiledLibrary.jar')
}
makeJar.dependsOn(clearJar, build)
4. Run gradlew makeJar command from your project root.
I my case I had to copy gradlew.bat and gradle files from new android project into my library project root.
You should find your compiled library file myCompiledLibrary.jar in build\libs directory.
I hope someone finds this useful.
Edit:
Caveat
Althought this works, you will encounter duplicate library exception while compiling a project with multiple modules, where more than one module (including application module) depends on the same jar file (eg. modules have own library directory, that is referenced in build.gradle of given module).
In case where you need to use single library in more then one module, I would recommend using this approach:
Android gradle build and the support library
Since Android Studio V1.0 the jar file is available inside the following project link:
debug ver: "your_app"\build\intermediates\bundles\debug\classes.jar
release ver: "your_app"\build\intermediates\bundles\release\classes.jar
The JAR file is created on the build procedure,
In Android Studio GUI it's from Build->Make Project and from CMD line it's "gradlew build".
Include the following into build.gradle:
android.libraryVariants.all { variant ->
task("generate${variant.name}Javadoc", type: Javadoc) {
description "Generates Javadoc for $variant.name."
source = variant.javaCompile.source
ext.androidJar = "${android.plugin.sdkDirectory}/platforms/${android.compileSdkVersion}/android.jar"
classpath = files(variant.javaCompile.classpath.files) + files(ext.androidJar)
}
task("javadoc${variant.name}", type: Jar) {
classifier = "javadoc"
description "Bundles Javadoc into a JAR file for $variant.name."
from tasks["generate${variant.name}Javadoc"]
}
task("jar${variant.name}", type: Jar) {
description "Bundles compiled .class files into a JAR file for $variant.name."
dependsOn variant.javaCompile
from variant.javaCompile.destinationDir
exclude '**/R.class', '**/R$*.class', '**/R.html', '**/R.*.html'
}
}
You can then execute gradle with: ./gradlew clean javadocRelease jarRelease which will build you your Jar and also a javadoc jar into the build/libs/ folder.
EDIT: With android gradle tools 1.10.+ getting the android SDK dir is different than before. You have to change the following (thanks Vishal!):
android.sdkDirectory
instead of
android.plugin.sdkDirectory
I was able to export a jar file in Android Studio using this tutorial:
https://www.youtube.com/watch?v=1i4I-Nph-Cw
"How To Export Jar From Android Studio "
I updated my answer to include all the steps for exporting a JAR in Android Studio:
1) Create Android application project, go to app->build.gradle
2) Change the following in this file:
modify apply plugin: 'com.android.application' to apply plugin: 'com.android.library'
remove the following: applicationId, versionCode and versionName
Add the following code:
// Task to delete old jar
task deleteOldJar(type: Delete){
delete 'release/AndroidPlugin2.jar'
}
// task to export contents as jar
task exportJar(type: Copy) {
from ('build/intermediates/bundles/release/')
into ('release/')
include ('classes.jar')
rename('classes.jar', 'AndroidPlugin2.jar')
}
exportJar.dependsOn(deleteOldJar, build)
3) Don't forget to click sync now in this file (top right or use sync button).
4) Click on Gradle tab (usually middle right) and scroll down to exportjar
5) Once you see the build successful message in the run window, using normal file explorer go to exported jar using the path: C:\Users\name\AndroidStudioProjects\ProjectName\app\release
you should see in this directory your jar file.
Good Luck :)
Here's yet another, slightly different answer with a few enhancements.
This code takes the .jar right out of the .aar. Personally, that gives me a bit more confidence that the bits being shipped via .jar are the same as the ones shipped via .aar. This also means that if you're using ProGuard, the output jar will be obfuscated as desired.
I also added a super "makeJar" task, that makes jars for all build variants.
task(makeJar) << {
// Empty. We'll add dependencies for this task below
}
// Generate jar creation tasks for all build variants
android.libraryVariants.all { variant ->
String taskName = "makeJar${variant.name.capitalize()}"
// Create a jar by extracting it from the assembled .aar
// This ensures that products distributed via .aar and .jar exactly the same bits
task (taskName, type: Copy) {
String archiveName = "${project.name}-${variant.name}"
String outputDir = "${buildDir.getPath()}/outputs"
dependsOn "assemble${variant.name.capitalize()}"
from(zipTree("${outputDir}/aar/${archiveName}.aar"))
into("${outputDir}/jar/")
include('classes.jar')
rename ('classes.jar', "${archiveName}-${variant.mergedFlavor.versionName}.jar")
}
makeJar.dependsOn tasks[taskName]
}
For the curious reader, I struggled to determine the correct variables and parameters that the com.android.library plugin uses to name .aar files. I finally found them in the Android Open Source Project here.
We can export a jar file for Android library project without resource files by Android studio. It is also requirement what I met recently.
1. Config your build.gradle file
// Task to delete old jar
task clearJar(type: Delete){
delete 'release/lunademo.jar'
}
// task to export contents as jar
task makeJar(type: Copy) {
from ('build/intermediates/bundles/release/')
into ('build/libs/')
include ('classes.jar')
rename('classes.jar', 'lunademo.jar')
}
makeJar.dependsOn(clearJar, build)
2. Run gradlew makeJar under your project root
You will see your libs under dir as build/libs/ if you are luckily.
============================================================
If you met issue as "Socket timeout exception" on command line as below,
You can follow this steps to open Gradle window in the right part and click "makeJar" on Android studio like this,
Then go to build/libs dir, you will see your jar file.
Hope that it is helpful for u.
Good Luck #.#
Luna

Categories

Resources