Android supports the technology realization and optimization exploration of the technical implementation and optimization of the technology in the Java library
Android supports the technology realization and optimization exploration of the technical implementation and optimization of the technology in the Java library
introduction:
In most Android applications, the filling of the layout is a common but relatively time -consuming operation.Under normal circumstances, the use of Layoutinflaater filling layout in the main thread will cause UI blocking, and the user interface becomes not smooth, reducing the performance of the application.
To solve this problem, the Android support library introduces the Asynclayoutinflator class, which can fill the layout in the background thread asynchronously, thereby avoiding the UI blockage on the main thread and improving the performance of the application.This article will introduce and optimize the technical implementation and optimization exploration of Asynclayoutinflator.
Technical realization:
Asynclayoutinflator uses Handler and MESSAGEQUEUE mechanisms to achieve asynchronous layout filling.When the layout needs to be filled, Asynclayoutinflater will create a background thread and perform the layout filling operation in the thread.The specific implementation steps are as follows:
1. First, create an asynchronous task asynctask, and perform layout filling operations in the background thread.
private static class InflateTask extends AsyncTask<Void, Void, View> {
private WeakReference<AsyncLayoutInflater> inflaterReference;
private int layoutResId;
private ViewGroup parent;
private LayoutInflater layoutInflater;
public InflateTask(AsyncLayoutInflater inflater, int layoutResId, ViewGroup parent) {
inflaterReference = new WeakReference<>(inflater);
this.layoutResId = layoutResId;
this.parent = parent;
layoutInflater = inflater.getContext().getLayoutInflater().cloneInContext(inflater.getContext());
}
@Override
protected View doInBackground(Void... params) {
return layoutInflater.inflate(layoutResId, parent, false);
}
@Override
protected void onPostExecute(View view) {
AsyncLayoutInflater inflater = inflaterReference.get();
if (inflater != null) {
if (view != null) {
// Fill successfully, call the callback method notification
inflater.onInflateFinished(view, layoutResId, parent);
} else {
// Fill in failure
throw new NullPointerException("Failed to inflate resource: " + layoutResId);
}
}
}
}
2. In Asynclayoutinflator, define the corresponding callback interface onInflaatefinishedListener to notify the application when the asynchronous task is completed.
public interface OnInflateFinishedListener {
void onInflateFinished(View view, int layoutResId, ViewGroup parent);
}
3. When calling the INFLATE method, create Inflatedask and perform asynchronous task operations.
public void inflate(@LayoutRes final int resource, @Nullable final ViewGroup root,
@NonNull final OnInflateFinishedListener callback) {
if (callback == null) {
throw new NullPointerException("callback argument must not be null!");
}
InflateTask task = new InflateTask(this, resource, root);
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
4. In Asynclayoutinflaater, it is only executed by using the IDLEHANDLER mechanism of MESSAGEQUEUE to ensure that asynchronous tasks are performed in the IDLE state to avoid affecting the UI thread.
private void scheduleNextInflate() {
MessageQueue queue = Looper.myQueue();
queue.addIdleHandler(new MessageQueue.IdleHandler() {
@Override
public boolean queueIdle() {
if (mInflateThreadHandler == null) {
mInflateThread.quit();
mInflateThread = null;
mInflateThreadHandler = null;
} else {
if (mInflateThreadHandler.post(mRunnable)) {
mInflateThreadHandler = null;
}
}
return false;
}
});
}
Optimized exploration:
When using Asynclayoutinflator, you can consider the following optimization measures to improve performance:
1. Reuse LayoutInflator: Because the layoutInflator needs to be used for layout in the asynchronous task, the Layoutinflater can be created in each asynchronous task by creating and reusing the Layoutinflator instance in advance to improve performance.
2. Batch filling layout: When multiple layouts need to be filled, the filling operation of multiple layouts can be merged into an asynchronous task to reduce the overhead of thread creation and context switching.
in conclusion:
Asynclayoutinflator provides an asynchronous layout filling method. By performing layout filling operations in the background thread, it avoids the UI obstruction on the main thread and improves the performance of the application.In actual use, the above optimization measures can be combined to further improve performance.By using Asynclayoutinflator reasonably, you can provide a smoother user experience for Android applications.
