Understand the technical principle of Android supporting the technical principle of the ASYNC Layout Inflator in the Java library
The Async Layout Inflaater framework in the Android support library is a technology used in the background thread asynchronous loading and filling layout files in the background thread.It is loaded and filled in the background thread by putting the layout file of the view, thereby avoiding the potential stuck phenomenon caused by these operations on the main thread.
In the traditional layout loading method, when we call Layoutinflator to load the layout file, it will process it in the main thread.However, if the layout file is very complicated or has nested hierarchical structures, the filling process of the layout may be very time -consuming.This will cause the main thread to block, thereby reducing the performance and response of the application.
To solve this problem, Android introduced Async Layout Inflator framework.This framework uses the system's Asynctask to load and fill the layout files in the background thread.Asynctask is a tool class that can perform time -consuming operations in the background and update UI in the main thread.
The following is a sample code using async layout inflaater:
First of all, we need to create a subclass of Asynctask to handle the operation of asynchronous loading and filling layout.We can implement DoinbackGround () and onPostexecute () methods in this subclass.
public class AsyncLayoutInflaterTask extends AsyncTask<Integer, Void, View> {
private LayoutInflater inflater;
private ViewGroup container;
private OnInflateFinishedListener listener;
public AsyncLayoutInflaterTask(Context context, ViewGroup container, OnInflateFinishedListener listener) {
inflater = LayoutInflater.from(context);
this.container = container;
this.listener = listener;
}
@Override
protected View doInBackground(Integer... params) {
int layoutResId = params[0];
return inflater.inflate(layoutResId, container, false);
}
@Override
protected void onPostExecute(View view) {
if (listener != null) {
listener.onInflateFinished(view);
}
}
}
Next, we can create a auxiliary method to facilitate our asynchronous loading and filling layout.
public void asyncInflateLayout(Context context, ViewGroup container, int layoutResId, OnInflateFinishedListener listener) {
AsyncLayoutInflaterTask task = new AsyncLayoutInflaterTask(context, container, listener);
task.execute(layoutResId);
}
Finally, we can use the asyncinflaneLayout () method at the call to load and fill the layout asynchronous.
asyncInflateLayout(context, container, R.layout.my_layout, new OnInflateFinishedListener() {
@Override
public void onInflateFinished(View view) {
// The recovery after the layout is completed
container.addView(view);
}
});
In this example, we will pass the resource ID of the layout file to be filled, and the callback function after loading is completed.When the layout is loaded and filled, the oninflatingFinished () method will be called. In this method, we can add the filled layout to the container.
Using ASYNC Layout Inflater framework can effectively reduce the obstruction of the main thread and improve the performance and response of applications, especially when loading and filling the complex layout.But it should be noted that when using Asynctask, be careful to ensure that the operation will not affect the destroyed Activity or Fragment.This can be implemented by checking the life cycle status of Activity or Fragment in ASYNCTASK.
