TimerUtil 일정시간이후 특정동작 지정 수행

개발을 할 때 지정해준 시간 이후 지정하는 동작을 수행하는 Util이 필요한데

 

따로 저장해두면 편할 거 같아 블로그에 남긴다. 

abstract class TimerUtil {
    private var mDelayTime = 1000L // default ms
    private var mName = "none"
    var isStart = false
    
    companion object {
        private const val WHAT = 100
    }
    
    constructor(){}

    constructor(name: String) {
        mName = name
    }
    
    constructor(name: String, milisecond: Long) {
        mName = name
        mDelayTime = milisecond
    }

    abstract fun onTime(what: Int)

    fun setTime(ms: Long) {
        mDelayTime = ms
    }

    val name: String
        get() = if (!mName.equals("none", ignoreCase = true)) {
            mName
        } else "none"

    @JvmOverloads
    fun start(milisecond: Long = mDelayTime) {
        if (mDelayTime <= 0) {
            Log.e("start error", "delaytime이 0보다 커야 함, name:\$mName, delay:\$mDelayTime")
            return
        }
        if (!TextUtils.isEmpty(mName)) { Log.e("text empty", "name:\$mName, delay:\$mDelayTime") }
        isStart = true
        mDelayTime = milisecond
        mHandler.removeMessages(WHAT)
        mHandler.sendEmptyMessageDelayed(WHAT, mDelayTime)
    }

    fun stop() {
        if (!TextUtils.isEmpty(mName)) { Log.e("text empty", "name:\$mName") }
        isStart = false
        mHandler.removeMessages(WHAT)
    }

    @SuppressLint("HandlerLeak")
    private val mHandler: Handler = object : Handler(Looper.getMainLooper()) {
        override fun handleMessage(msg: Message?) {
            if (!TextUtils.isEmpty(mName)) {
                Log.e("text empty", "handleMessage name:\$mName onTime()...")
            }
            isStart = false
            this.removeMessages(WHAT)
            onTime(WHAT)
            super.handleMessage(msg)
        }
    }
}

 

이후 사용하고 싶은곳에서 사용하면 된다

object : TimerUtil("PRV_TEXT", 4000) {  //임시 4초 생성자로 지정시
                override fun onTime(what: Int) {
                    //이후 처리
                }
            }.start()

 

 

아래는 Java 버전

public abstract class TimerUtil {
    private long mDelayTime = 1000L; // default ms
    private static final int WHAT = 100;
    private boolean mIsStart = false;
    private String mName = "none";

    public abstract void onTime(int what);

    public TimerUtil() {
    }

    public TimerUtil(String name, long milisecond) {
        this.mName = name;
        this.mDelayTime = milisecond;
    }

    public TimerUtil(String name) {
        this.mName = name;
    }

    public void setTime(long ms) {
        this.mDelayTime = ms;
    }

    public String getName() {
        if(!this.mName.equalsIgnoreCase("none")) {
            return this.mName;
        }
        return "none";
    }

    public void start() {
        start(mDelayTime);
    }

    public void start(long milisecond) {
        if (mDelayTime <= 0) {
            Log.e("start error","delaytime이 0보다 커야 함, name:$mName, delay:$mDelayTime");
            return;
        }
        if (!TextUtils.isEmpty(mName)) {
            Log.e("text empty", "name:$mName, delay:$mDelayTime");
        }

        mIsStart = true;
        this.mDelayTime = milisecond;
        mHandler.removeMessages(WHAT);
        mHandler.sendEmptyMessageDelayed(WHAT, mDelayTime);
    }

    public void stop() {
        if (!TextUtils.isEmpty(mName)) {
            Log.e("text empty", "name:$mName");
        }
        mIsStart = false;
        mHandler.removeMessages(WHAT);
    }

    public boolean isStart() {
        return mIsStart;
    }

    @SuppressLint("HandlerLeak")
    private final Handler mHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            if (!TextUtils.isEmpty(mName)) {
                Log.e("text empty", "handleMessage name:$mName onTime()...");
            }

            mIsStart = false;
            mHandler.removeMessages(WHAT);
            onTime(WHAT);

            super.handleMessage(msg);
        }
    };
}