android延迟跳转的方法,Android 页面跳转卡顿优化

开发时我们会遇到跳转页面特别慢的问题，在性能越差的设备上越明显。跳转页面卡顿，一般原因都是页面创建时需要处理太多事情导致的。

我们这里可以分步骤并且延时去做页面初始化所需要做的事情，让页面打开的一瞬间不需要做太多的事情，让处理事情的过程更加平滑。从而解决跳转页面卡顿问题

具体代码我们可以这样写：

下面主要用到SubstepDelayedLoad类来做延迟和任务串联，delayed(时长毫秒)来设置延迟(没有设置的话默认是100毫秒), run()是主要执行的任务。

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

import android.util.Log;

import android.view.ViewStub;

public class MainActivity extends AppCompatActivity {

private final String TAG = "delayedLoad";

private ViewStub viewStub;

private SubstepDelayedLoad delayedLoad = new SubstepDelayedLoad();

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

viewStub=findViewById(R.id.viewStub);

Log.i(TAG, "页面打开了");

delayed();

}

/**

* 分步延时处理任务

*/

private void delayed() {

delayedLoad

.delayed(100)

.run(new Runnable() {

@Override

public void run() {

Log.i(TAG, "执行第一个任务");

//延时加载布局

viewStub.inflate();

}

})

.delayed(200)

.run(new Runnable() {

@Override

public void run() {

Log.i(TAG, "执行第二个任务");

//延时做其他耗时任务

}

})

.delayed(300)

.run(new Runnable() {

@Override

public void run() {

Log.i(TAG, "执行第三个任务");

}

})

.delayed(100)

.run(new Runnable() {

@Override

public void run() {

Log.i(TAG, "执行第四个任务");

}

}).start();

}

@Override

protected void onDestroy() {

//如果不需要处理了，释放掉

delayedLoad.clearAllRunable();

super.onDestroy();

}

}

里边用的SubstepDelayedLoad类代码如下：

import android.os.Handler;

import android.os.Message;

import androidx.annotation.NonNull;

import java.lang.ref.WeakReference;

import java.util.LinkedList;

import java.util.Queue;

/**

* ====================================================

* 作者: Clark

* 创建时间: 2020/4/11 16:59

* 类作用描述: 分步延时加载

* ====================================================

*/

public class SubstepDelayedLoad {

//默认延迟

private final long DEF_DELAYED = 100;

//设置的延迟

private long setDelayed = DEF_DELAYED;

//队列保存每一个任务

private Queue queue = new LinkedList<>();

private MyHandler handler;

//静态Handler加弱引用 防止内存泄漏

private static class MyHandler extends Handler{

private WeakReference> mTargetRef;

public MyHandler(Queue queue){

mTargetRef=new WeakReference(queue);

}

@Override

public void handleMessage(@NonNull Message msg) {

if(mTargetRef==null){

return;

}

Queue queue = mTargetRef.get();

if(queue==null){

return;

}

//执行当前任务

RunableBean run=queue.poll();

run.runnable.run();

//延时执行下一个任务

RunableBean runNext=queue.peek();

if(runNext==null){

return;

}

sendEmptyMessageDelayed(1,runNext.delayed);

}

/**

* 清除所有任务

*/

public void clearAllRunable(){

mTargetRef.clear();

mTargetRef=null;

}

}

/**

* 设置下一个任务的延迟时间

* 注：调用delayed()后，再调用run()

* @param millisecond

* @return

*/

public SubstepDelayedLoad delayed(long millisecond) {

this.setDelayed = millisecond;

return this;

}

/**

* 设置一个任务

* 注：调用run()之前，先调用delayed()。不调用就是默认延迟 DEF_DELAYED

* @param runnable

* @return

*/

public SubstepDelayedLoad run(Runnable runnable) {

//任务添加进队列

RunableBean newRun=new RunableBean();

newRun.delayed=this.setDelayed;

newRun.runnable=runnable;

queue.offer(newRun);

//延迟时间恢复默认

this.setDelayed=DEF_DELAYED;

return this;

}

public void start() {

if(handler!=null){

throw new IllegalStateException("It can only be started once");

}

handler = new MyHandler(queue);

RunableBean run=queue.peek();

handler.sendEmptyMessageDelayed(1,run.delayed);

}

/**

* 清掉所有任务

*/

public void clearAllRunable(){

handler.clearAllRunable();

handler=null;

queue.clear();

queue=null;

}

private static class RunableBean {

public long delayed;

public Runnable runnable;

}

}