A "weapon" for mobile game developers: Introduction to Apple's App Thinning feature

At the Apple WWDC15 conference that ended on June 9, Apple launched a number of new technologies. However, for mobile game developers, perhaps the most revolutionary one is the App Thinning feature, which Cook did not mention at the press conference. It is one of the features of its Xcode 7 beta version.

According to Apple's official explanation, the app slimming function is divided into three parts: the first is the Slicing function, which can segment the app/game content and distribute customized download packages based on the user's device type and screen resolution. Developers only need to upload the contents of the complete app package to iTunes Connect.

In addition, this feature also includes the intermediate code function (Bitcode), which allows Apple to optimize your application again in the future, avoiding the trouble of releasing a new version and greatly reducing the debugging workload.
The third function of app slimming is on-demand resources. Developers can classify and package the resources that are not needed for app initialization and upload them to the App Store. When users use the resources, the system will call the resources when necessary based on the resource tags. When certain resources are no longer in use, they will be automatically cleared by the system. This not only reduces the download and loading time of the app, but also greatly reduces the installation package size.

For developers, this feature can reduce a lot of bug debugging time, make the game package smaller, and improve the gaming experience of users of various devices. It can be said that Apple's technology has largely solved the performance differences between different devices and achieved the one-for-all requirement. However, Gamelook believes that if this feature can be used on the Android channel, it will greatly reduce the adaptation difficulties caused by device fragmentation to developers and narrow the gap between Android and iOS devices.

Please see below for a detailed introduction to the app slimming function and on-demand resource content compiled by Gamelook (please refer to the official English address for more details):

Part 1: App Slimming and its Functions

The App Store and operating systems (iOS and watchOS) optimize app installations based on the user's specific device capabilities to minimize device space usage. This optimization process, called app thinning, allows you to create apps that take advantage of the most device features, take up the least disk space, and adjust for future updates from Apple. Faster downloads and less space usage lead to a better user experience.

This section describes the three major components of application slimming: application segmentation (Slicing), intermediate code (Bitcode), and on-demand resources (Resources).

Application segmentation function (Slicing, only for iOS platform)

Slicing is the process of creating and delivering variants of your app designed for different target devices. A customized download package only contains the executable architecture and resources required for a specific device. You can continue to develop and upload the full version of your app to iTunes Connect, and the App Store will create and deliver the corresponding app based on the player's device type and resolution. Here, you can think of the resources being divided into multiple types based on the player's device resolution and type, and the GPU resources being divided based on the device's capabilities. When users install the app, they can download and install the customized app package that's right for their device.

Xcode simulates partitioning during development, so you can create and test custom app bundles locally. When you develop and run your app on a device, Xcode partitions it. When you create an archive, Xcode includes the full version of your app but allows you to output different custom app bundles from the archive.

Reminder: For iOS apps, app segmentation only supports the latest version of iTunes and devices running iOS 9.0 or higher. Otherwise, the App Store will distribute a unified installation package to users.

Segmentation function flow chart

Application segmentation is carried out during the development and distribution process. The basic process is as follows:

1. In Xcode, locate the target device and provide multiple resolution graphics in the resource catalog. You must use resource catalogs to perform segmentation.

2. Develop and run the application on a simulator or a device.

3. Xcode will generate variant packages for the selected device type, improve debugging sales and allow you to test variant packages on local devices.

4. Create an application archive and output the corresponding variant application package for a specific device.

5. Test all variant packages on the target device to detect hardware configuration problems earlier.

6. Upload the app to iTunes Connect.

7. The App Store creates separate custom app packages from the archive. The number of custom packages depends on the number of architectures and resources that exist in the Xcode project.

8. In iTunes Connect, distribute the beta version of the app to designated testers.

9. Testers install the test version on the devices supported by your application through TestFlight. TestFlight will download specific variant application packages based on the user's device.

Note: To test the variants that the App Store creates for you before publishing your app, it's best to invite only internal testers (iTunes Connect users on your team) and use TestFlight to download the variants. If you invite external testers (for example, those who log in only by email address), they must wait for Beta App Review to approve your app before they can download the variants.

10. Then publish your app in iTunes Connect.

11. The user installs the application on a device that supports the application, and the App Store application download will distribute variant application packages based on the user's device type.

Intermediate code function (Bitcode, for iOS and watchOS)

Bitcode is an intermediate representation of a compiled program. If the app you upload to iTunes Connect contains bitcode, it can be compiled and linked to the App Store. Adding Bitcode allows Apple to optimize your app binary again in the future without you having to submit a new version to the App Store.

Note: Bitcode is the default but optional for iOS apps. If you provide Bitcode, all apps and frameworks in your app bundle need to include Bitcode, and watchOS apps must include Bitcode.

On-Demand Resources (for iOS)

On-Demand resources refer to resources that you can group and categorize by keywords and commands, such as images and audio. The App Store will place these resources on Apple servers and manage downloads for you. On-Demand resources can speed up downloads and reduce the size of the app package, improving the user's first login experience. For example, a game app can group resources according to levels and tasks, and subsequent resources will only be used after the player reaches the next level or completes a task. Similarly, the app can only provide corresponding resources when the user makes an IAP purchase.

When some on-demand resources are no longer needed and disk space is low, the operating system will automatically clear them. If you test or distribute your app outside the App Store, you will need to manage these on-demand resources yourself. It should be noted that executable on-demand resources are not supported, and the App Store will also segment on-demand resources (the slicing mentioned above) to further improve the user experience.

For users, on-demand resources operate transparently in the background and are provided when users need corresponding functions.

#p#

Part 2: What are On-Demand Resources?

Tip: This is an overview of an API or technology under development. Apple provides this information primarily to help you plan your use of these technologies or programming interfaces with Apple products. This information may change in the future. The software mentioned in this article should be subject to the final release of the operating system testing and final documentation. New versions of the documentation may be provided in the future.

On-demand resources refer to application content that is stored in the App Store and is separate from the application download package. Using On-demand resources can make the application package smaller and the installation time shorter.

This document mainly provides the information you need to use on-demand resources in your application. Before reading this document, you should first be familiar with resource programming. For more information, please refer to the Resource Programming Guide.

On-Demand resources have a lifecycle

On-Demand resources can make the app package smaller, download faster, and have richer app content. This is mainly achieved by storing resources in the App Store, which is separate from your app package.

Apple's operating system manages the download and storage of on-demand resources based on your application's request. The basic operation process is as follows: the application requests resources - uses resources - and then releases the request. After being downloaded, these resources will remain on the user's device through multiple logins, making the application experience faster.

On-Demand resources are automatically enabled by default, provided that your project supports the corresponding OS version.

Tags are mainly used to identify and group on-demand resources.

During the development process, tags are used to identify and group on-demand resources, and tag names can be used to identify the relationship between resources and applications. Xcode provides tools for creating and managing tags, and also specifies special tags after the application is installed or after installation is complete.

At runtime, the application is responsible for managing tags.

The application request is tagged by the operating system, which then downloads and checks the component resources and downloads any required resources that are not already on the user's device. During this process, the application can track the download progress and adjust the priority if necessary.

After a tag is used up, when removing it from storage, the application can set a system reserved priority, and tags with lower priorities will be cleared first.

Two classes are used when interacting with the system: NsbundleResourceRequest is used to manage the use of tags, track downloads and adjust download priorities; an extension class of NSBundle is used to set the reservation priority of tags.

On-demand resources can be of many types, except executable code.

Some information about the resource

In computer programming, resources are data files that exist alongside the executable code of the program. With resource files, your code can be greatly simplified, without having to write complex code to create complex data or graphics settings. For example, instead of creating an image pixel by pixel with code, creating resources in a graphics editor can be more efficient and practical. To take full advantage of resources, your code only needs to load and use them at runtime.

In addition to simplifying your code, resources are also a very important part of all application internationalization management. Instead of writing strings and other user-visible content in your application, you can put these contents in external resource files, which makes it very simple to localize your application. You only need to create new versions of resource files for each supported language. OS X and iOS also use this method to manage localized resources, loading the required resource files according to the user's preferred language.

This document provides information about the types of resources supported by OS X and iOS systems and guidance on how to use these resources when writing code. This document does not target the resource creation process, most resources are provided by third parties or developers' own tools. In addition, although this article describes the use of resources in applications, this information also applies to other types of executable packages, including frameworks and plug-ins.

Before reading this document, you need to be familiar with the organizational structure of the application package. Understanding this structure can make management easier and it is also more convenient to find the resources that your application needs.

Your app can contain many types of resources, but some resources are supported directly by iOS and OS X.

Nib files store your app's UI objects

Nib files are the classic file type used to create iOS and Mac applications. A nib file is a freeze-dried data archive of objects that you want to recreate at runtime. Nib files are usually used to store pre-set windows, views, and other visual objects, but can also be used to store non-visual objects, such as controllers.

You can edit Nib files in Xcode through Interface Builder, which provides an additional graphical editor for managing objects. When you subsequently load a nib file into an application, the nib loading code instantiates each object in the file and restores it to the state you defined in Interface Builder. This way, what you see in Interface Builder is consistent with what you see when the application is running.

String resources contain localizable text.

In iOS and Mac applications, images, audio and video resources are very important. Images can be used to create a unique visual style. Audio and video files can also enhance the overall user experience of the application and simplify the code. Both operating systems support loading and presenting these resources in the application.

Which applications are suitable for using the On-Demand resource function?

On-demand resources refer to application content that is separate from the application download package and stored on the App Store. The application requests a series of on-demand resources, and the operating system manages the download and storage. Application packages that can use on-demand resources to gain advantages:

1. Applications that delay loading of initialization resources. Some resources of these applications belong to the main functions of the application, but they are not used during the first login. The resources will be marked as requiring initialization. When the application is running, the operating system will automatically download these resources, such as graphic editing applications.

2. Applications that require delayed loading of application resources: This type of application only uses some resources in specific circumstances. For example, in a game with many levels, the corresponding resources are only needed when players enter a specific level.

3. Applications that need to remotely store low-usage resources: Some resources in this type of application have very low usage rates and are only loaded when needed. For example, the novice tutorial resources of some applications are only used when the application is opened for the first time and may never be used again. Later, some functional tutorials are only loaded when they are used and then never used again.

4. Applications that need to store IAP resources remotely: These applications provide additional resources through IAP. These resources will only be used when users purchase them. For example, when a user purchases the SuperGeeky emoticon pack, this emoticon resource will be used.

5. Applications that need to load resources when logging in for the first time: Some resources of this type of application only need to be loaded when logging in for the first time, and are not used when logging in again. For example, an application that only adds teaching content when logging in for the first time.

During the development process, developers can assign one or more tags to on-demand resources, which are strings that you use to identify specific resources. You can use the name of the tag to determine the use of the corresponding resource in the application. For example, the resources used in the fifth level of the game can use tags related to level5.

On-Demand Resource Cycle

The process of using resources with tags is as follows:

Tagged resources are stored in the App Store - apps request to use resources through tags - the system downloads the resource package - saves the resource package - the system releases the resource package after use.

Storage size limit

The App Store has storage space restrictions for on-demand resources. Please refer to the table below for details.