The Best Chinese Android Store to Download Apk Games for Lollipop 5.1.1

If you lot publish your app to Google Play, yous should build and upload an Android App Bundle. When you do and then, Google Play automatically generates and serves optimized APKs for each user's device configuration, so they download only the code and resource they need to run your app. Publishing multiple APKs is useful if y'all are not publishing to Google Play, just you must build, sign, and manage each APK yourself.

Multiple APK support is a feature on Google Play that allows you to publish different APKs for your application that are each targeted to different device configurations. Each APK is a complete and independent version of your awarding, but they share the same application listing on Google Play and must share the same package name and be signed with the same release key. This feature is useful for cases in which your awarding cannot reach all desired devices with a single APK.

Android-powered devices may differ in several ways and it's important to the success of your application that y'all make information technology available to as many devices every bit possible. Android applications usually run on well-nigh compatible devices with a unmarried APK, by supplying alternative resources for unlike configurations (for example, different layouts for different screen sizes) and the Android organisation selects the appropriate resources for the device at runtime. In a few cases, nonetheless, a single APK is unable to back up all device configurations, because alternative resources brand the APK file besides big or other technical challenges prevent a unmarried APK from working on all devices.

To help you publish your application for equally many devices as possible, Google Play allows you to publish multiple APKs nether the same application listing. Google Play then supplies each APK to the appropriate devices based on configuration support you've declared in the manifest file of each APK.

By publishing your application with multiple APKs, y'all can:

• Back up different OpenGL texture compression formats with each APK.
• Support different screen sizes and densities with each APK.
• Support different device characteristic sets with each APK.
• Back up different platform versions with each APK.
• Support different CPU architectures with each APK (such every bit for ARM or x86, when your app uses the Android NDK).
• Optimize for entry-level devices such as those running Android (Get edition).

Currently, these are the only device characteristics that Google Play supports for publishing multiple APKs as the same awarding.

Note: To learn well-nigh preparing and publishing APKs on Google Play, run into the Gear up & roll-out releases back up article.

How multiple APKs work

The concept for using multiple APKs on Google Play is that you have but one entry in Google Play for your awarding, but dissimilar devices might download a dissimilar APK. This means that:

• You maintain just i set of product details (app description, icons, screenshots, etc.). This also ways y'all cannot charge a unlike cost for different APKs.
• All users see but one version of your application on Google Play, then they are not confused by different versions you may have published that are "for tablets" or "for phones."
• All user reviews are practical to the aforementioned application listing, even though users on unlike devices may have different APKs.
• If you publish different APKs for dissimilar versions of Android (for different API levels), and then when a user'south device receives a organization update that qualifies them for a different APK yous've published, Google Play updates the user'due south application to the APK designed for the college version of Android. Whatsoever system information associated with the application is retained (the same as with normal application updates when using a single APK).

Supported filters

Which devices receive each APK is determined by Google Play filters that are specified past elements in the manifest file of each APK. Still, Google Play allows you to publish multiple APKs only when each APK uses filters to support a variation of the following device characteristics:

• OpenGL texture compression formats

  This is based on your manifest file's <supports-gl-texture> element(s).

  For instance, when developing a game that uses OpenGL ES, you lot can provide one APK for devices that support ATI texture compression and a split APK for devices that back up PowerVR compression (among many others).

• Screen size (and, optionally, screen density)

  This is based on your manifest file's <supports-screens> or <compatible-screens> element. You should never employ both elements and y'all should use only <supports-screens> when possible.

  For example, you can provide one APK that supports minor and normal size screens and another APK that supports large and xlarge screens. To learn more nearly generating separate APKs based on screen size or density, go to Build Multiple APKs.

  Consider the following best practices to back up all screen sizes:

  • The Android organisation provides stiff back up for applications to support all screen configurations with a unmarried APK. You should avert creating multiple APKs to support dissimilar screens unless admittedly necessary and instead follow the guide to Supporting Multiple Screens so that your awarding is flexible and can conform to all screen configurations with a single APK.
  • By default, all screen size attributes in the <supports-screens> element are "truthful" if you lot do non declare them otherwise. Notwithstanding, because the android:xlargeScreens aspect was added in Android 2.3 (API level 9), Google Play volition assume that information technology is "false" if your application does not set either android:minSdkVersion or android:targetSdkVersion to "ix" or college.
  • You lot should non combine both <supports-screens> and <compatible-screens> elements in your manifest file. Using both increases the chances that y'all'll introduce an error due to conflicts between them. For help deciding which to utilize, read Distributing to Specific Screens. If you can't avert using both, be enlightened that for any conflicts in understanding between a given size, "false" will win.
• Device feature sets

  This is based on your manifest file's <uses-characteristic> chemical element(s).

  For example, you tin can provide i APK for devices that support multitouch and another APK for devices that do not back up multitouch. Run across Features Reference for a list of features supported past the platform.

• Android (Go edition)

  To target devices running Android (Go edition), your APK needs to declare <uses-feature android:name="android.hardware.ram.low" android:required="true">, target at to the lowest degree API Level 26, and accept a higher version lawmaking than your non-Become edition APK.

• API level

  This is based on your manifest file's <uses-sdk> chemical element. You lot can utilise both the android:minSdkVersion and android:maxSdkVersion attributes to specify support for dissimilar API levels.

  For case, you can publish your application with one APK that supports API levels 16 - nineteen (Android four.1.x - 4.4.4)—using only APIs available since API level 16 or lower—and another APK that supports API levels 21 and higher up (Android 5.0+)—using APIs available since API level 21 or lower. To learn how to build separate APKs that each target a unlike range of APIs, go to Configure Product Flavors.

  If you use this characteristic as the factor to distinguish multiple APKs, then the APK with a higher android:minSdkVersion value must take a higher android:versionCode value. This is also true if two APKs overlap their device support based on a different supported filter. This ensures that when a device receives a system update, Google Play can offer the user an update for your application (because updates are based on an increase in the app version code). This requirement is described further in the department beneath about Rules for multiple APKs.

  Yous should avoid using android:maxSdkVersion in general, considering as long equally you've properly developed your awarding with public APIs, it is always compatible with future versions of Android. If you want to publish a different APK for higher API levels, you lot still exercise not need to specify the maximum version, because if the android:minSdkVersion is "xvi" in one APK and "21" in another, devices that support API level 21 or higher volition e'er receive the 2d APK (considering its version code is college, as per the previous note).



• CPU architecture (ABI)

  Some native libraries provide separate packages for specific CPU architectures, or Application Binary Interfaces (ABIs). Instead of packaging all available libraries into one APK, y'all tin build a carve up APK for each ABI and include just the libraries yous need for that ABI. To learn more most generating divide APKs based on target ABI, go to Build Multiple APKs.

Other manifest elements that enable Google Play filters—merely are not listed in a higher place—are still applied for each APK as usual. However, Google Play does not let you lot to publish separate APKs based on variations of those device characteristics. Thus, you cannot publish multiple APKs if the higher up listed filters are the same for each APK (but the APKs differ based on other characteristics in the manifest or APK). For example, y'all cannot provide different APKs that differ purely on the <uses-configuration> characteristics.

Rules for multiple APKs

Before you publish multiple APKs for your awarding, you need to understand the following rules:

• All APKs y'all publish for the same application must have the aforementioned package name and be signed with the same document central.
• Each APK must have a different version code, specified by the android:versionCode attribute.
• Each APK must not exactly lucifer the configuration support of another APK.

  That is, each APK must declare slightly different support for at least ane of the supported Google Play filters (listed above).

  Usually, you will differentiate your APKs based on a specific feature (such every bit the supported texture compression formats), and thus, each APK will declare support for unlike devices. Still, information technology's OK to publish multiple APKs that overlap their back up slightly. When two APKs do overlap (they support some of the same device configurations), a device that falls inside that overlap range will receive the APK with a higher version code (divers past android:versionCode).

• You cannot activate a new APK that has a version code lower than that of the APK it'southward replacing. For case, say you take an active APK for screen sizes small - normal with version code 0400, then endeavour to supercede it with an APK for the aforementioned screen sizes with version code 0300. This raises an error, considering it means users of the previous APK will not exist able to update the application.
• An APK that requires a college API level must accept a higher version lawmaking.

  This is true only when either: the APKs differ based only on the supported API levels (no other supported filters distinguish the APKs from each other) or when the APKs do use another supported filter, just at that place is an overlap between the APKs within that filter.

  This is of import considering a user'south device receives an application update from Google Play only if the version code for the APK on Google Play is higher than the version code of the APK currently on the device. This ensures that if a device receives a organization update that then qualifies information technology to install the APK for higher API levels, the device receives an application update considering the version lawmaking increases.

  Note: The size of the version code increase is irrelevant; it merely needs to be larger in the version that supports higher API levels.

  Here are some examples:

  • If an APK yous've uploaded for API levels 16 and to a higher place (Android 4.1.ten+) has a version code of 0400, so an APK for API levels 21 and to a higher place (Android 5.0+) must be 0401 or greater. In this case, the API level is the but supported filter used, so the version codes must increment in correlation with the API level support for each APK, so that users get an update when they receive a arrangement update.
  • If you lot take ane APK that's for API level 16 (and higher up) and small - large screens, and another APK for API level 21 (and above) and large - xlarge screens, and so the version codes must increment in correlation with the API levels. In this example, the API level filter is used to distinguish each APK, just so is the screen size. Because the screen sizes overlap (both APKs support large screens), the version codes must still be in club. This ensures that a big screen device that receives a system update to API level 21 will receive an update for the 2nd APK.
  • If you take i APK that's for API level 16 (and to a higher place) and small - normal screens, and some other APK for API level 21 (and above) and big - xlarge screens, and then the version codes do not demand to increase in correlation with the API levels. Because there is no overlap within the screen size filter, there are no devices that could potentially move between these ii APKs, then there's no demand for the version codes to increment from the lower API level to the higher API level.
  • If you have one APK that's for API level xvi (and above) and ARMv7 CPUs, and another APK for API level 21 (and above) and ARMv5TE CPUs, then the version codes must increase in correlation with the API levels. In this case, the API level filter is used to distinguish each APK, but and then is the CPU compages. Because an APK with ARMv5TE libraries is compatible with devices that accept an ARMv7 CPU, the APKs overlap on this characteristic. As such, the version lawmaking for the APK that supports API level 21 and above must be higher. This ensures that a device with an ARMv7 CPU that receives a arrangement update to API level 21 will receive an update for the second APK that's designed for API level 21. Yet, because this kind of update results in the ARMv7 device using an APK that's not fully optimized for that device'south CPU, you should provide an APK for both the ARMv5TE and the ARMv7 architecture at each API level in gild to optimize the app performance on each CPU. Note: This applies only when comparing APKs with the ARMv5TE and ARMv7 libraries, and not when comparison other native libraries.

Failure to abide by the above rules results in an mistake on the Google Play Console when you activate your APKs—you will be unable to publish your awarding until you resolve the error.

There are other conflicts that might occur when you actuate your APKs, but which will result in warnings rather than errors. Warnings can exist caused by the following:

• When you modify an APK to "shrink" the support for a device'southward characteristics and no other APKs support the devices that so autumn outside the supported range. For example, if an APK currently supports small-scale and normal size screens and you modify it to back up only small screens, then you accept shrunk the pool of supported devices and some devices volition no longer see your application on Google Play. You lot can resolve this by adding another APK that supports normal size screens so that all previously-supported devices are withal supported.
• When at that place are "overlaps" between two or more APKs. For example, if an APK supports screen sizes small, normal, and big, while another APK supports sizes large and xlarge, there is an overlap, because both APKs support big screens. If you do not resolve this, then devices that qualify for both APKs (large screen devices in the example) will receive whichever APK has the highest version code.

  Note: If you're creating separate APKs for unlike CPU architectures, exist aware that an APK for ARMv5TE will overlap with an APK for ARMv7. That is, an APK designed for ARMv5TE is compatible with an ARMv7 device, but the reverse is not truthful (an APK with only the ARMv7 libraries is not compatible with an ARMv5TE device).

When such conflicts occur, you will come across a warning message, but you lot can nevertheless publish your application.

Creating multiple APKs

Once you decide to publish multiple APKs, yous probably need to create split up Android projects for each APK yous intend to publish so that you can accordingly develop them separately. You can practice this by simply duplicating your existing project and give information technology a new name. (Alternatively, yous might use a build system that can output different resources—such as textures—based on the build configuration.)

Tip: One way to avoid duplicating large portions of your application lawmaking is to use a library project. A library project holds shared lawmaking and resources, which you can include in your bodily awarding projects.

When creating multiple projects for the same awarding, it's a good practice to identify each one with a name that indicates the device restrictions to be placed on the APK, and so you can easily identify them. For example, "HelloWorld_21" might be a good name for an application designed for API level 21 and above.

Note: All APKs you publish for the same application must have the same package name and exist signed with the same document key. Be certain you also understand each of the Rules for multiple APKs.

Assigning version codes

Each APK for the same application must take a unique version code, specified by the android:versionCode aspect. You must be careful nearly assigning version codes when publishing multiple APKs, because they must each be different, just in some cases, must or should be defined in a specific lodge, based on the configurations that each APK supports.

Ordering version codes

An APK that requires a higher API level must usually have a college version lawmaking. For case, if you create two APKs to back up unlike API levels, the APK for the higher API levels must have the higher version code. This ensures that if a device receives a system update that then qualifies it to install the APK for higher API levels, the user receives a notification to update the app. For more than information nearly how this requirement applies, see the section above about Rules for multiple APKs.

You lot should besides consider how the lodge of version codes might touch on which APK your users receive either due to overlap between coverage of different APKs or futurity changes you might make to your APKs.

For instance, if you have different APKs based on screen size, such every bit i for minor - normal and one for large - xlarge, but foresee a fourth dimension when you will change the APKs to be one for pocket-size and ane for normal - xlarge, then you should make the version code for the large - xlarge APK be college. That way, a normal size device volition receive the advisable update when you make the change, considering the version code increases from the existing APK to the new APK that now supports the device.

Too, when creating multiple APKs that differ based on support for different OpenGL texture pinch formats, be aware that many devices back up multiple formats. Because a device receives the APK with the highest version code when there is an overlap in coverage between 2 APKs, you should order the version codes amid your APKs so that the APK with the preferred compression format has the highest version code. For example, you might want to perform separate builds for your app using PVRTC, ATITC, and ETC1 compression formats. If you lot prefer these formats in this exact social club, so the APK that uses PVRTC should have the highest version code, the APK that uses ATITC has a lower version code, and the version with ETC1 has the lowest. Thus, if a device supports both PVRTC and ETC1, it receives the APK with PVRTC, because it has the highest version code.

In instance Google Play Store is unable to identify the correct APK to install for a target device, you lot may want to also create a universal APK that includes resources for all the different device variations you desire to support. If you do provide a universal APK, y'all should assign information technology the lowest versionCode. Considering Google Play Store installs the version of your app that is both compatible with the target device and has the highest versionCode, assigning a lower versionCode to the universal APK ensures that Google Play Store tries to install ane of your other APKs earlier falling back to the larger universal APK.

Using a version lawmaking scheme

In club to allow different APKs to update their version codes independent of others (for case, when y'all fix a bug in but one APK, so don't need to update all APKs), y'all should apply a scheme for your version codes that provides sufficient room between each APK so that you tin can increase the lawmaking in one without requiring an increase in others. You should also include your bodily version proper noun in the lawmaking (that is, the user visible version assigned to android:versionName), then that it's piece of cake for you to associate the version code and version proper name.

Annotation: When you increase the version code for an APK, Google Play will prompt users of the previous version to update the application. Thus, to avoid unnecessary updates, you should not increment the version code for APKs that do not really include changes.

We suggest using a version lawmaking with at least seven digits: integers that represent the supported configurations are in the higher order bits, and the version proper name (from android:versionName) is in the lower gild bits. For example, when the application version name is 3.1.0, version codes for an API level 4 APK and an API level 11 APK would exist something like 0400310 and 1100310, respectively. The beginning two digits are reserved for the API Level (four and 11, respectively), the middle two digits are for either screen sizes or GL texture formats (non used in these examples), and the last three digits are for the application'due south version name (3.ane.0). Figure i shows two examples that split based on both the platform version (API Level) and screen size.

Effigy 1. A suggested scheme for your version codes, using the first 2 digits for the API Level, the second and third digits for the minimum and maximum screen size (one - 4 indicating each of the four sizes) or to announce the texture formats and the last three digits for the app version.

This scheme for version codes is just a suggestion for how you should establish a design that is scalable as your application evolves. In item, this scheme doesn't demonstrate a solution for identifying dissimilar texture pinch formats. One option might exist to define your own table that specifies a different integer to each of the different compression formats your application supports (for example, 1 might correspond to ETC1 and two is ATITC, and so on).

You tin can use any scheme you want, but you lot should carefully consider how future versions of your application volition need to increase their version codes and how devices can receive updates when either the device configuration changes (for example, due to a system update) or when you modify the configuration support for one or several of the APKs.

DOWNLOAD HERE

Posted by: greenevister.blogspot.com