I'd like to be able to build and install multiple versions of my app (concurrently), targeting different environments such as Development, Staging and of course Production.
The package name in the AndroidManifest.xml seems to be the major hurdle here, as it is what uniquely identifies the app. I thought it would be possible to simply switch between com.mydomain.prod, com.mydomain.staging and com.mydomain.dev or some sort of similar convention but so far I've had no luck coming up with a package structure that works for this approach.
What strategy can I employ to do this with as little pain as possible?
With Gradle you can specify different "flavors" of your application. This is done in your build.gradle:
android {
// …
defaultConfig {
// …
}
productFlavors {
prod
applicationId "com.mydomain.prod"
}
staging {
applicationId "com.mydomain.staging"
}
dev {
applicationId "com.mydomain.dev"
versionCode 2
}
}
}
Each flavor properties are inherited from defaultConfig.
Now, in the src directory of your app, you can create directories with flavor-specific code/resources in it:
app/
|-- src/
|-- main/
|-- prod/
|-- staging/
|-- dev/
These links might be useful:
How to build customized Android application using Gradle
Gradle Build Variants for your android project
I suggest you use the 'ant' build tool specificaly the 'regexp' task which can be used in order to replace text in certain files (i.e replace your app's package name in the manifest file according to the proper build target). You can also define differnet properties file for each build target (e.g 'build_development.properties' to hold all parameters relevant for building your product for development env.)... hope this is helpful..
Related
I have 3 jar files in my Android project's app/libs folder:
api-dev.jar
api-qa.jar
api-prod.jar
I want to use api-dev.jar when I work on the app in the studio (default), build a version of the app using api-qa.jar which will be tested by the QA team, then release the production app with api-prod.jar.
How should I do?
So far I read that I should add a
configurations {
qaCompile
...
}
element to app/build.gradle and use
android {
buildTypes {
...
qa {
...
}
}
}
to define the builds.
I don't know how to point to the appropriate libs/dependencies, I don't know how to make one the default one either, especially in my case where the default one is not the one for the production release...
Also if the API requires a specific key for dev, qa and prod, how do I set it up?
By the way the features are exactly the same between the different builds, the user experience is exactly the same, it's why I want to use builds, not flavors.
Check this out - Add dependency to specific productFlavor and buildType in gradle
Add you jars to the libs directory
Create a build type and product flavor
Use the name to create a specific compile command
Use that to specify your jar file in the libs directory
We have a platform to read poetry with a SQLITE Database say SHAKESPEARE.DB .
We also have another poetry say Wordsworth.DB.
So for each poetry database we want to create a separate application like Shakespeare.apk and wordsworth.apk.
During build we want to mention the Database and mention the name of the APK.
How do we Change Database during android build through gradle and deploy different APK's
I would want to Create and Deploy Database specific APK using Gradle ?
Step #1: Use a consistent means of embedding the database in the app. For this answer, I will assume that you are using SQLiteAssetHelper, with the database packaged as words.db in assets/.
Step #2: Create two product flavors for your app in your app/ module's build.gradle file. For this answer, I will call these flavors vanilla and chocolate:
productFlavors {
vanilla {
applicationId "com.commonsware.android.gradle.hello.vanilla"
}
chocolate {
applicationId "com.commonsware.android.gradle.hello.chocolate"
}
}
(replace the applicationId values with ones more relevant to your project)
Step #3: Create a sourceset for each flavor (app/src/vanilla, app/src/chocolate/).
Step #4: Put a different words.db in assets/ of the flavor (app/src/vanilla/assets/words.db, app/src/chocolate/assets/words.db).
Now, when you build vanilla, it will use the vanilla edition of words.db. When you build chocolate, it will use the chocolate edition of words.db. No Java code changes are required. You can also put different resources in those flavor-specific sourcesets, for different icons, labels, etc. Because you have different applicationId values, both flavors can be installed on your test devices at the same time, and both flavors can be distributed through app distribution channels like the Play store.
So I have an app that would require to versions with different settings, assets etc but uses the same code base so it will generate two apks. I really have no idea how to do it in gradle. can anyone please point me to a site or a technique in which i can do this? thanks.
Start witch adding product flavors to your build.gradle script and set proper ids
productFlavors {
appOne{
applicationId 'com.app.one'
}
appTwo{
applicationId 'com.app.two'
}
}
When that's done create folders in your src directory called
appOne and appTwo. In those folders you can specify version specific stuff like drawable folders, manifest...
When that's done, remember to choose right build variant in buildvariants menu
I'm trying to understand how i can generate multiple APK from one single project.
I'm using gradle and this is my project's three:
ambrogiocore is the core library module that implements all the common classes and resources.
ambrogioremote is the module that has the :ambrogiocore dependence.
It's work. Now i'm able to generate multiple APK. (just one at the moment)
One apk for each module.
The problem is that i need to manually sync all the AndroidManifest.xml for every future module that i'll include in my project.
Is this the correct way?
Can i automate this operation?
I took a look at productFlavor. Just I don't understand if this tool can help me.
What do you think about?
THANK YOU ALL!
**SOLUTION**
Finally! I found the same solution proposed by #Kai!
Flavor is the way!
This is the best approach for a lots of reasons:
Single-module project
You don't need to copy XML files
RoboGuice will work like a charm. (RoboGuice presents some BIG problem on library projects)
http://www.techotopia.com/index.php/An_Android_Studio_Gradle_Build_Variants_Example
If by "one single source core and multiple project that extends "ProductName", "PackageName" and "resources"" you mean to provide each flavor with unique "ProductName", "PackageName" and "resources", then yes it can be done.
To give each flavor its own unique package, set applicationId for each of your flavors like so:
android {
productFlavors {
flavor_1 {
applicationId = 'com.app.flavor_1'
}
flavor_2 {
applicationId = 'com.app.flavor_2'
}
}
}
To give each flavor its own app name and resources, simply put them in a flavor's own directory, Gralde will merge a flavor's resources with your base resources to create a complete one.
For more detail on how Gralde flavors work, please see Gradle Plugin User Guide
This is my final solution!
All the common files, manifest and base resources are under "src/main"
I moved my projects inside "src/projects"
declared two productFlavor (one per project) specifying applicationId and versionName
created two sourceSet (one per project) indicating the specific res folder.
I have an Android app that will be distributed in two (or more) brands. All java code for each distributions is exactly same, just different assets/resources (like layouts, drawables, dimensions, etc)
What is the best way to organize the project? I am using Git for version control, and trying to keep all distributions developed as a single project. So I can switch asset/resource sets easily for different branding each time needed.
Is there a good approach for it?
One good approach would be turning your main project code in a library and then, for the other projects (brands), import that library and override the assets as you want.
Gradle Build Variants allow you to have a shared main codebase/resources and multiple variants with custom resources/code associated with each - you then can generate a separate APK for each variant. Of course, using Gradle for Android development requires you use Android Studio (which is currently in beta) as well.
As mentioned above, Gradle Build Variants is the best way to handle this. We have 11 variants (and counting) where the only difference are some configuration values. I organized the project as follows:
app/src/configurations/
flavor1/
common/res/...
release/res/...
stage/res/...
where the common directory holds configurations common to that build variant and the release and stage hold custom values for our release and staging versions (they have slightly different configurations as well).
All configurations common to all build variants live in the normal app/src/main/res folder.
Then in the app's build.grade, I have each product flavor defined:
productFlavors {
flavor1 {
applicationId = "com.example.flavor1"
}
flavor1stage {
applicationId = "com.example.flavor1stage"
}
// etc. for each build flavor
}
android.sourceSets.flavor1 {
res {
srcDirs = ['src/configurations/flavor1/release/res', 'src/configurations/flavor1/common/res', 'src/res']
}
}
android.sourceSets.flavor1stage {
res {
srcDirs = ['src/configurations/flavor1/stage/res', 'src/configurations/flavor1/common/res', 'src/res']
}
}