如何在Android Player设置Unity中使用剥离级别/ IL2CPP选项

Question

I am trying to reduce size of APK built from Unity. Looking at Android Player Settings docs , I fugured out that I can use one of following options to reduce size of build:

Stripping Levels:

1. Strip Assemblies
2. Strip ByteCode (iOS only)
3. Use micro mscorlib
4. Strip Engine Code (only available when using IL2CPP)

I have following questions regarding this:

In IOS Build Size Optimization it says:

Strip assemblies level : the scripts' bytecode is analyzed so that classes and methods that are not referenced from the scripts can be removed from the DLLs and thereby excluded from the AOT compilation phase. This optimization reduces the size of the main binary and accompanying DLLs and is safe as long as no reflection is used .

Does it apply on android as well?

If thats the case, I tried to find referrences of System.Reflection in the whole project (including 3rd party plugins). I could only see usage of reflection in Edior scripts or script under #if UNITY_EDITOR . How can I make sure that stripping won't cause any problem in android build?

Is stripping applied on 3rd party .dll code which is not accessible in Visual Studio/ MonoDevelop?

Does usage of IL2CPP or stripping level affect performance of the app in any way?

UPDATE:

I tried IL2CPP in android project and it added aprox 10MB to build size and took ages to build as well.

Thanks

Answer 1

Yes, the iOS Build Size Optimization information about stripping does apply to Android as well. There are some trade-offs here that you should be aware of.

TL;DR: If you are optimizing for build size only , then using Mono with "Strip Assemblies" is the best option.

Compilation options

Of course, there are some subtle issues that might matter for your case. For Android, Unity offers two different compilation modes.

1. Just-in-time (JIT) compilation
2. Ahead-of-time (AOT) compilation

JIT compilation happens with the Mono scripting backend. The managed code in your project is compiled to IL byte code and shipped to the end user as IL assemblies. The IL assemblies are compiled to native machine code on the user's device.

AOT compilation happens with the IL2CPP scripting backend. The managed code in your project is compiled to IL byte code, then translated to C++ code, then compiled on your machine to native machine code. That native machine code is shipped to the end user and run on the user's device.

In almost all cases, the IL byte code is a more compact representation than the native machine code, so the APK size with the Mono scripting backend will be smaller.

Also, the Mono scripting backend does less work on your machine during the build process, so the project build will be faster.

Finally, the IL2CPP scripting backend builds two native binaries by default, one for armv7, and one for x86. You can change the player settings to build only one of them (armv7, likely) if you don't need to support x86.

Stripping options

Unity does two different types of stripping:

1. Managed code stripping
2. Engine code stripping

Managed code stripping is performed on the managed assemblies after the managed compilers run, but before any code is packaged in the APK. This process uses a known set of roots (like any classes deriving from MonoBehaviour in your project) and builds a dependency graph of all code that can be provably called. Any IL code that cannot be provably called will be removed from the IL assembly, and will not be part of the APK.

Is stripping applied on 3rd party .dll code which is not accessible in Visual Studio/ MonoDevelop?

This process is applied to all managed assemblies (.dll files) in the project.

Engine code stripping causes subsystems in the native engine code to be removed by the native linker at the end of the project build process. For example, if engine code stripping is enabled, and your project does not use any 3D physics features, the 3D physics system should not be included in the final APK.

Compilation and stripping

The compilation and stripping options intersect like this:

• Mono scripting backend
  • Default is no managed or engine code stripping
  • Strip Assemblies causes managed code stripping and engine code stripping to be enabled.
• IL2CPP scripting backend
  • Managed code stripping is always enabled.
  • Engine codes stripping is optional.

Compilation, stripping, and reflection

Since the IL2CPP scripting backend is AOT-only, the System.Reflection.Emit namespace is not supported. Any calls into it will throw a NotSupportedException at runtime.

Mono does support the System.Reflection.Emit namespace, but you must be careful about using it and the System.Reflection namespace with managed code stripping enabled. Since the managed code stripper cannot statically prove code that is only accessed be reflection is used, the stripper will remove that code.

How can I make sure that stripping won't cause any problem in android build?

The only good way to know this is with runtime testing. There is no way to be sure, prior to runtime, that the stripper won't be too aggressive and remove code.

Since you have inspected the code in your project, you can be relatively confident, but there is not a way to prove things will work without exercising all of the code paths in the project.