Optimizing Android Layout Inflation with AsyncLayoutInflater: Analysis and Implementation

Preface

Android layout inflation runs on the main thread by default; complex or redundant layouts can cause UI jank. While common optimizations such as flattening hierarchies, using merge , ViewStub , and avoiding over‑draw help, they may not be sufficient for large‑scale business pages.

LayoutInflater Definition

LayoutInflater is Android's layout loader that turns XML layout files into View objects.

Getting a LayoutInflater instance

LayoutInflater layoutInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
LayoutInflater layoutInflater = LayoutInflater.from(context);

The second call simply wraps the first.

Layout Loading Process Analysis

LayoutInflater provides four overloaded inflate() methods. The call hierarchy is:

Method 1 calls Method 3.

Method 2 and Method 3 eventually call Method 4.

Method 3 obtains an XmlResourceParser via Resources.getLayout(resource) , which reads the XML from disk – an I/O‑bound operation.

Method 4 performs the recursive view creation by traversing the DOM tree, invoking createViewFromTag() for each node.

createViewFromTag Flow

The method first checks mFactory2 , then mFactory , and finally falls back to LayoutInflater.onCreateView() , which uses reflection to instantiate the view class.

Identified Performance Bottlenecks

I/O when parsing XML layout files.

Reflection‑based recursive view creation.

Possible Solutions

Manually instantiate views in code (hard to maintain).

Off‑load layout inflation to a background thread using AsyncLayoutInflater from the AndroidX v4 library.

Monitoring Layout Load Time

Using Android Studio Profiler, the initStyleInfoView method was found to take 61 ms due to layout inflation.

AsyncLayoutInflater Practice

private void initStyleInfoView() {
    if (xxxViewA == null) {
        new AsyncLayoutInflater(this).inflate(R.layout.xxx, null, new AsyncLayoutInflater.OnInflateFinishedListener() {
            @Override
            public void onInflateFinished(@NonNull View view, int i, @Nullable ViewGroup viewGroup) {
                xxxViewA = view;
                xxxViewA.init();
            }
        });
    }
}

After applying asynchronous inflation, the same method’s duration dropped to 1.5 ms.

Frame‑Time Comparison

GPU rendering analysis showed that before optimization, five frames exceeded the 16 ms budget; after optimization, only three frames did, demonstrating a clear performance gain.

AsyncLayoutInflater Implementation Details

The class creates a blocking queue and a dedicated background thread ( InflateThread ). When inflate() is called, a request is enqueued; the thread processes the request, inflates the layout, and posts the result back to the UI thread via a Handler .

Constructor

public AsyncLayoutInflater(@NonNull Context context) {
    mInflater = new BasicInflater(context);
    mHandler = new Handler(mHandlerCallback);
    mInflateThread = InflateThread.getInstance();
}

BasicInflater

private static class BasicInflater extends LayoutInflater {
    private static final String[] sClassPrefixList = {"android.widget.", "android.webkit.", "android.app."};
    BasicInflater(Context context) { super(context); }
    @Override
    public LayoutInflater cloneInContext(Context newContext) { return new BasicInflater(newContext); }
    @Override
    protected View onCreateView(String name, AttributeSet attrs) throws ClassNotFoundException {
        for (String prefix : sClassPrefixList) {
            try { View view = createView(name, prefix, attrs); if (view != null) return view; }
            catch (ClassNotFoundException e) { }
        }
        return super.onCreateView(name, attrs);
    }
}

inflate() Method

@UiThread
public void inflate(@LayoutRes int resid, @Nullable ViewGroup parent, @NonNull OnInflateFinishedListener callback) {
    if (callback == null) { throw new NullPointerException("callback argument may not be null!"); }
    InflateRequest request = mInflateThread.obtainRequest();
    request.inflater = this;
    request.resid = resid;
    request.parent = parent;
    request.callback = callback;
    mInflateThread.enqueue(request);
}

InflateThread

private static class InflateThread extends Thread {
    private static final InflateThread sInstance;
    static { sInstance = new InflateThread(); sInstance.start(); }
    public static InflateThread getInstance() { return sInstance; }
    private ArrayBlockingQueue
mQueue = new ArrayBlockingQueue<>(10);
    private SynchronizedPool
mRequestPool = new SynchronizedPool<>(10);
    public void run() { while (true) { runInner(); } }
    private void runInner() {
        InflateRequest request = mQueue.take();
        try { request.view = request.inflater.mInflater.inflate(request.resid, request.parent, false); }
        catch (RuntimeException e) { }
        Message.obtain(request.inflater.mHandler, 0, request).sendToTarget();
    }
    // obtainRequest, releaseRequest, enqueue methods omitted for brevity
}

Known Pitfalls

The parent view’s generateLayoutParams must be thread‑safe.

Views inflated asynchronously must not create Handlers or call Looper.prepare() because the background thread lacks a Looper.

AsyncLayoutInflater does not support setting a Factory/Factory2, limiting compatibility with some custom views.

Layouts containing Fragment cannot be inflated asynchronously.

The internal single‑threaded queue (size 10) may become a bottleneck under heavy load.

Conclusion

AsyncLayoutInflater effectively reduces main‑thread work for complex layouts, improving frame times. Developers can further customize it—e.g., adding Factory2 support or using a thread pool—to suit larger projects.

References

https://developer.android.google.cn/reference/androidx/asynclayoutinflater/view/AsyncLayoutInflater?hl=en https://developer.android.google.cn/reference/kotlin/android/view/LayoutInflater?hl=en