Its possible now, refer to this link.
https://developer.android.com/studio/build/configure-apk-splits.html
UPDATE :
You need to add the following code in module level build.gradle inside the android tag:
splits
{
// Configures multiple APKs based on ABI.
abi {
// Enables building multiple APKs per ABI.
enable true
// By default all ABIs are included, so use reset() and include to specify that we only
// want APKs for x86, armeabi-v7a, and mips.
// Resets the list of ABIs that Gradle should create APKs for to none.
reset()
// Specifies a list of ABIs that Gradle should create APKs for.
include "x86", "armeabi-v7a", "mips"
// Specifies that we do not want to also generate a universal APK that includes all ABIs.
universalApk false
}
}
This will give you multiple apks to upload for different architecture. According to Android :
Different Android handsets use different CPUs, which in turn support
different instruction sets. Each combination of CPU and instruction
sets has its own Application Binary Interface, or ABI. The ABI
defines, with great precision, how an application's machine code is
supposed to interact with the system at runtime.
Also, do remember to push both the apks with different versionCode. A convinient way to that would be to use the following script, provided on the same url later :
// Map for the version code that gives each ABI a value.
ext.abiCodes = ['armeabi-v7a':1, mips:2, x86:3]
// For per-density APKs, create a similar map like this:
// ext.densityCodes = ['mdpi': 1, 'hdpi': 2, 'xhdpi': 3]
import com.android.build.OutputFile
// For each APK output variant, override versionCode with a combination of
// ext.abiCodes * 1000 + variant.versionCode. In this example, variant.versionCode
// is equal to defaultConfig.versionCode. If you configure product flavors that
// define their own versionCode, variant.versionCode uses that value instead.
android.applicationVariants.all { variant ->
// Assigns a different version code for each output APK
// other than the universal APK.
variant.outputs.each { output ->
// Stores the value of ext.abiCodes that is associated with the ABI for this variant.
def baseAbiVersionCode =
// Determines the ABI for this variant and returns the mapped value.
project.ext.abiCodes.get(output.getFilter(OutputFile.ABI))
// Because abiCodes.get() returns null for ABIs that are not mapped by ext.abiCodes,
// the following code does not override the version code for universal APKs.
// However, because we want universal APKs to have the lowest version code,
// this outcome is desirable.
if (baseAbiVersionCode != null) {
// Assigns the new version code to versionCodeOverride, which changes the version code
// for only the output APK, not for the variant itself. Skipping this step simply
// causes Gradle to use the value of variant.versionCode for the APK.
output.versionCodeOverride =
baseAbiVersionCode * 1000 + variant.versionCode
}
}
}
This goes below the splits code. This gives you multiple apks with your orignal version code multiplied by the architecture code given in abiCodes array in the script above. Eg : if your version code is 5, the mips builds code would be 2005. A universal apk will also be created if you universalApk is true in splits code. The can be a fallover apk in case no architecture build apk is found for a certain device.
