I'm running into a strange issue with gradle.
My app/build.gradle file has a section which looks like this:
buildTypes {
debug {
...
}
release {
signingConfig signingConfigs.release
...
}
beta {
initWith release
...
}
}
When I run ./gradlew assembleBeta, the output is app-beta.apk, which I can install on my device.
However, I want to change the order of my build types, purely for aesthetics. So it now looks like:
buildTypes {
debug {
...
}
beta {
initWith release
...
}
release {
signingConfig signingConfigs.release
...
}
}
This syncs fine, but when I run ./gradlew assembleBeta, the output is now app-beta-unsigned.apk! And I cannot install this apk on a device - it tells me installation failed.
How is it possible that simply by changing the order in which my build types are declared, my apk can become broken?
The reason the apk is broken after changing the order of build types is because, in this situation, gradle requires that the release build type is defined before the beta build type.
Why is this? It's because beta refers to release in the line: initWith release
If release is defined after beta, then the initWith release command will silently fail. This is because, at the point initWith release is run, release does not exist. Although it may seem like Gradle should be able to look-ahead to the definition of release later in the file, it cannot.
Then, when running ./gradlew assembleBeta, the beta apk is built successfully - but the apk is unsigned - as alluded to by the name of the output file, app-beta-unsigned.apk. In the previous setup, beta was getting its signingConfig from release. When initWith release fails, the beta build simply has no signingConfig set - so the output apk is of course unsigned.
I need to disable Crashlytics build_id automatic generation every time I assemble a new build because of CI requirements.
According to fabric docs, it's as simple as adding the next flag inside my build type:
android {
buildTypes {
debug {
ext.alwaysUpdateBuildId = false
...
}
release {
ext.alwaysUpdateBuildId = false
...
}
But for some reasons it's only working for debug builds and not on the release ones.
What am I doing wrong?
It's working fine in the latest version of Fabric Gradle plugin
I understand how to generate a signed apk from android studio-> Build menu, but if I have several projects is it possible to automate this task so that for all the projects I could run some script which automatically builds signed apks without me having to generate them one by one ?
Thanks,
Ahmed
Yes this can be done by creating a signed build configuration and specifying the keystore information. This is done by adding a couple sections to build.gradle:
First create the signed build type that uses release mode and runs proguard:
android {
buildTypes {
signed {
debuggable false
minifyEnabled true
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
signingConfig signingConfigs.signed
}
}
}
Then add the signing configuration (supply your own values):
android {
signingConfigs {
signed {
storeFile file('keystore.jks')
storePassword 'storepassword'
keyAlias 'key'
keyPassword 'keypassword'
}
}
}
Then, you can build from the command line by typing ./gradlew assembleSigned (for Mac OSX) or gradlew assembleSigned (for Windows).
You can also use the installSigned build task to build and install on a connected device.
I downloaded the zip file of an Android app on github and I'm trying to run it, but I get a dialog with this message
app-release-unsigned.apk is not signed. Please configure the signing information for the selected flavor using the Project Structure dialog.
I'm using Android Studio.
What am I supposed to do?
If anyone wants to debug release build using Android Studio, follow these steps:
Set build variant to release mode.
Right click on app in left navigation pane, click Open Module Settings.
Go to Signing Tab. Add a signing config and fill in information. Select your keychain as well.
Go to Build Type tab. Select release mode and set:
-Debuggable to true.
-Signing Config to the config. (The one you just created).
Sync your gradle. Enjoy!
Make sure the build variant is set to debug (and not release) in Android Studio (check the build variants panel).
If set to debug, it should automatically sign the app with the auto-generated debug keystore, without editing the build scripts.
However you will need to create and configure a specific keystore for release.
Official documentation, covering debug and release modes: https://developer.android.com/tools/publishing/app-signing.html
Always sign your build using your build.gradle DSL script like this:
android {
signingConfigs {
debug {
storeFile file("debug.keystore")
}
myConfig {
storeFile file("other.keystore")
storePassword "android"
keyAlias "androidotherkey"
keyPassword "android"
}
}
buildTypes {
bar {
debuggable true
jniDebugBuild true
signingConfig signingConfigs.debug
}
foo {
debuggable false
jniDebugBuild false
signingConfig signingConfigs.myConfig
}
}
}
If you want to understand a little more of the Gradle build system associated to Android Studio just pay a visit to:
Gradle Plugin User Guide
If anyone wants to debug and release separate build variant using Android Studio 3.5, follow the below steps:
1. Set build variant to release mode.
Go to File >> Project Structure
Select Modules, then Signing Config
Click in the Plus icon under Signing Config
Select release section and Provide your release App Information then Apply and OK.
Go to your app level build.gradle and change your buildTypes > "release" section like below Screenshot.
Then Run your Project. Happy Coding.
I was successfully able to debug signed APK , Follow this procedure:-
Choose "release" version in "Build Variant" ToolBar
In the Build.gradle for the module set debuggable true for release build type
Go to File->Project Structure->under signing tab fill all info->Under Flavours
tab->Choose signing Config You just created
Set the breakpoints
Run the application in the debug mode
For gradle Kotlin dsl
signingConfigs {
create("releaseConfig") {
storeFile = file("your keystore file path")
storePassword = "storePassword"
keyAlias = "keyAlias"
keyPassword = "keyPassword"
}
}
buildTypes {
getByName("release") {
signingConfig = signingConfigs.getByName("releaseConfig")
isMinifyEnabled = true
isShrinkResources = true
proguardFiles(getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro")
}
}
signingConfigs should be before buildTypes
signingConfigs {
debug {
storeFile file("debug.keystore")
}
myConfig {
storeFile file("other.keystore")
storePassword "android"
keyAlias "androidotherkey"
keyPassword "android"
}
}
buildTypes {
bar {
debuggable true
jniDebugBuild true
signingConfig signingConfigs.debug
}
foo {
debuggable false
jniDebugBuild false
signingConfig signingConfigs.myConfig
}
}
if you want to run app in debug mode
1) Look at Left Side bottom, above Favorites there is Build Variants
2) Click on Build Variants. Click on release and choose debug
it works perfect !!!
The app project you downloaded may include a signed info in the file of build.gradle. If you saw codes like these:
buildTypes {
debug {
signingConfig signingConfigs.release
}
release {
signingConfig signingConfigs.release
}
}
you could delete them and try again.
My problem was solved by changing the build variant as suggested by Stéphane , if anyone was struggling to find the "Build variants" as I did here is a screenshot where you can find it .
For security reasons, you cannot install an unsigned apk on Android. So if you only have the unsigned apk: you must sign it. Here is how to do that : link
Note that you can sign the apk with a self-signed certificate.
An alternative can be either :
to download the signed apk if available.
to download the sources, compile them (with Android-Studio or gradle or ...). It will produce multiple apks and one of them will be signed with your debug-key (and so you will be able to install it)
How i solved this
This error occurs because you have set your build variants to release mode. set it to build mode and run project again.
If you want to run in release mode, just generate a signed apk the way we do it normally when releasing the app
In tool window bar select Build Variants
Change Build Variant from Release to Debug
My solution was to change the name of my signing config from the default "config" to "debug". To verify, I changed it to some other random name and got the error again, and then changed it back to "debug" and the error was gone. So while it seems artificial and I tend to not believe this is the whole story, give this solution a try.
i also appear this problem,and my code below
storeFile file(properties.getProperty("filepath"))
storePassword properties.getProperty("keypassword")
keyAlias properties.getProperty("keyAlias")
keyPassword properties.getProperty("keypassword")
the reason is property name error,it should be keyPassword not keypassword
What finally worked for me, and I have no idea why, is:
Went to LastPass (the service I use to keep all my passwords)
Select my password by putting the cursor on top of the password and double clicking
Once selected I press cmd C to copy
Went to Android study and cmd V to paste
Notice I did try to copy many times by selecting the password by clicking at the end of the password and selecting the password by moving the mouse.
It is strange but it only worked by double clicking on top of the password to copy it.
Also I did use the Open Module Settings > Signing... method explained by #NightFury on this post.
adding below lines of code in build.gradel file worked for me, add them under buildTypes block below release as shown
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
debug {
applicationIdSuffix ".debug"
debuggable true
}
I've got a project where I have several device-specific product flavors, and each flavor needs to be signed with a different config:
productFlavors {
nexus7 {
signingConfig signingConfigs.nexus7
}
nexus4 {
signingConfig signingConfigs.nexus4
}
}
This works great when building a 'release' variant. However, when using a 'debug' variant (e.g. when I build Nexus4Debug), Gradle is using the default android debug key. In my case, I'm highly dependent on these builds being signed the right way, and my application is relatively useless if signed with the default debug key. Anyone know if there's a way to specify the signing config for each variant?
I know I can do it per build type, a la:
buildTypes {
debug {
signingConfig signingConfigs.nexus4
}
}
but this limits me to always using the same signing config for debug builds of both flavors.
PS - Understand this is a little bit of an edge use case here. This is for an enterprise project where we're testing custom ROMs and system-signed apps on a number of different Nexus devices.
Try adding this to your build.gradle. It will specify which signingConfig to use for each flavor when building the debug build type:
buildTypes {
debug {
productFlavors.nexus4.signingConfig signingConfigs.nexus4
productFlavors.nexus7.signingConfig signingConfigs.nexus7
}
}
I got another solution after android plugin build. 1.1.3
productFlavors {
nexus7 {
signingConfig signingConfigs.nexus7
}
nexus4 {
signingConfig signingConfigs.nexus4
}
}
buildTypes {
release {
debuggable false
zipAlignEnabled true
}
debug {
initWith release
debuggable true
zipAlignEnabled false
}
}
As build type "release" will use flavor signing config (as there is no specification), after debug init with release build, it will also has the same signing config.
Build type "debug" needs to be init with "release" as if signing config is not provided, it will use Android default debug signing key.
Update
The problem is that android.buildTypes.debug.signingConfig has a default value while release does not.
The solution may be breakage in the future.
Anyway, still work with android plugin build 2.3.2
Works on 2.2.1
buildTypes {
release {
}
debug {
signingConfig android.buildTypes.release.signingConfig
}
}
This may work:
buildTypes {
release {
productFlavors.nexus7.signingConfig signingConfigs.nexus7
productFlavors.nexus4.signingConfig signingConfigs.nexus4
}
debug {
signingConfig android.buildTypes.release.signingConfig
}
}
The answer is:
buildTypes {
debug {
signingConfig null
}
}
It's quitely hidden in #Harvey's comment and it takes me too much time to find it. I think it's better to leave it as an answer.
You can find the comment and give it the thumbs-up if it works for you as well.
Thanks for this. It led to me to figure out this: signingConfig null. The problem is that android.buildTypes.debug.signingConfig has a default value while release does not. If set, buildType configurations override anything you set in a flavor. The real trick is to unset the property in buildTypes.debug so it will act just like release. –
Harvey