android_icecream/app/src/main/java/com/bgy/autosale/helpers/CleanScheduleHelper.java

package com.bgy.autosale.helpers;

import android.graphics.Color;
import android.text.SpannableString;
import android.text.Spanned;
import android.text.style.ForegroundColorSpan;

import com.bgy.autosale.App;
import com.bgy.autosale.Constant;
import com.bgy.autosale.IceCreamDeviceConstants;
import com.bgy.autosale.R;
import com.bgy.autosale.ui.operator.fragments.CleanConfigFragment;
import com.bgy.autosale.utils.PlcLog;
import com.bgy.autosale.utils.ReadCacheInfoUtils;
import com.bgy.autosale.utils.SPUtils;

import java.util.concurrent.TimeUnit;

import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;

/**
 * Created by cjx on 2021-01-12
 * 说明：清洗提醒控制类
 */
public class CleanScheduleHelper {

    private final String TAG = "CleanScheduleHelper";

    private final String SHARE_PREFERENCE_CLEAN_WARN = "SHARE_PREFERENCE_CLEAN_WARN";

    private long CLEAN_RECYCLE_TIME = 259200000; // 清洗周期 默认3天
    private long WARN_FIRST_TIME = 43200000; // 第一次清洗提醒, 比清洗周期少12小时
    private long WARN_SECOND_TIME = 21600000; // 最后一次清洗提醒, 比清洗周期少6小时
    private long ERROR_MESSAGE_TIME = 3600000; // 第二次清洗提醒通知, 比清洗周期多1小时

    private static CleanScheduleHelper helper;

    private Disposable timeSchedule;
    private Disposable warnSchedule;

    // 为了避免多次进入发送消息的模块
    private boolean checkWarn = false;
    private boolean checkError = false;

    private boolean cleanTimeOutDisable = false; // 到期未清洗禁止点餐

    public static CleanScheduleHelper getInstance() {
        if (helper == null) {
            synchronized (CleanScheduleHelper.class) {
                if (helper == null) {
                    helper = new CleanScheduleHelper();
                }
            }
        }
        return helper;
    }

    private CleanScheduleHelper() {
    }

    public void destroy() {
        checkWarn = false;
        checkError = false;
        SPUtils.getInstance(App.app).putInt(SHARE_PREFERENCE_CLEAN_WARN, 0);
        if (timeSchedule != null) {
            timeSchedule.dispose();
            timeSchedule = null;
        }
        if (warnSchedule != null) {
            warnSchedule.dispose();
            warnSchedule = null;
        }
    }

    // 获取当前清洗开关
    public void initCleanScheduleParams() {
        cleanTimeOutDisable = SPUtils.getInstance(App.app).getBoolean(CleanConfigFragment.SHARED_PREFERENCE_LOCK_SWITCH, false);
        if (!cleanTimeOutDisable) {
            ErrorViewHelper.getInstance().hideErrorView(R.string.error_device_clean);
        }
        // 清洗功能开关
        boolean cleanScheduleSwitch = SPUtils.getInstance(App.app).getBoolean(CleanConfigFragment.SHARED_PREFERENCE_CLEAN_SWITCH, false);

        try {
            int days = SPUtils.getInstance(App.app).getInt(CleanConfigFragment.SHARED_PREFERENCE_CLEAN_SCHEDULE, 3);
            log(String.format(App.app.getString(R.string.clean_recycle), days));
            long time = days * 86400000L; // 3600000; // 86400000;
            if (time > 0) {
                CLEAN_RECYCLE_TIME = time;
            }
            int first = SPUtils.getInstance(App.app).getInt(CleanConfigFragment.SHARED_PREFERENCE_CLEAN_FIRST, 12);
            WARN_FIRST_TIME = first * 3600000L;

            int second = SPUtils.getInstance(App.app).getInt(CleanConfigFragment.SHARED_PREFERENCE_CLEAN_SECOND, 6);
            WARN_SECOND_TIME = second * 3600000L;

            int last = SPUtils.getInstance(App.app).getInt(CleanConfigFragment.SHARED_PREFERENCE_CLEAN_LAST, 1);
            ERROR_MESSAGE_TIME = last * 3600000L;

        } catch (Exception e) {
            e.printStackTrace();
        }
        if (cleanScheduleSwitch) {
            destroy();
            startCleanSchedule();
        }
    }

    public void checkIfNeedShowError(boolean startTimeSchedule) {
        long startTime = ReadCacheInfoUtils.getInstance().getCleanDate();
        if (startTime == 0L) {
            return;
        }
        long cleanTime = NetTimeClock.getInstance().getNetLongTime() - startTime;
        if (cleanTime > CLEAN_RECYCLE_TIME) {
            showCleanError(cleanTime);
        } else if (startTimeSchedule) {
            checkWarnMessage(cleanTime);
            if (timeSchedule != null) {
                timeSchedule.dispose();
            }
            timeSchedule = AndroidSchedulers.mainThread().scheduleDirect(new Runnable() {
                @Override
                public void run() {
                    showCleanError(CLEAN_RECYCLE_TIME);
                }
            }, CLEAN_RECYCLE_TIME - cleanTime, TimeUnit.MILLISECONDS);
        }
    }

    // 检查当前清洗状态
    private void check() {
        if (timeSchedule != null) {
            return;
        }
        checkIfNeedShowError(true);
    }

    // 满足条件， 开始清洗倒计时
    public void startCleanSchedule() {
        long time = ReadCacheInfoUtils.getInstance().getCleanDate();
        if (time == 0L) {
            SPUtils.getInstance(App.app).putInt(SHARE_PREFERENCE_CLEAN_WARN, 0);
            log("开始记录清洗倒计时");
            ReadCacheInfoUtils.getInstance().saveCleanDate(NetTimeClock.getInstance().getNetLongTime());
            log("记录清洗时间 " + NetTimeClock.getInstance().getNetLongTime());
        }
        check();
    }

    // 清洗完成/强制解除 重置清洗倒计时
    public void resetCleanSchedule() {
        destroy();
        if (NetTimeClock.getInstance().netTimeReady()) {
            ReadCacheInfoUtils.getInstance().saveCleanDate(NetTimeClock.getInstance().getNetLongTime());
            log("记录清洗时间 " + NetTimeClock.getInstance().getNetLongTime());
        } else {
            ReadCacheInfoUtils.getInstance().saveCleanDate(0);
            log("记录清洗时间 0");
            Schedulers.io().scheduleDirect(runnable, 30, TimeUnit.SECONDS);
        }
        ErrorViewHelper.getInstance().hideErrorView(R.string.error_device_clean);
        log("重置了清洗倒计时");
        check();
    }

    private Runnable runnable = new Runnable() {
        @Override
        public void run() {
            if (NetTimeClock.getInstance().netTimeReady()) {
                ReadCacheInfoUtils.getInstance().saveCleanDate(NetTimeClock.getInstance().getNetLongTime());
                log("2记录清洗时间 " + NetTimeClock.getInstance().getNetLongTime());
            }
        }
    };

    // 显示当前清洗时间周期
    public SpannableString getCleanTime() {
        long startTime = ReadCacheInfoUtils.getInstance().getCleanDate();
        if (startTime == 0L) {
            return null;
        }
        SpannableString spannableString;
        if (!NetTimeClock.getInstance().netTimeReady()) {
            spannableString = new SpannableString(App.app.getString(R.string.time_ready));
            spannableString.setSpan(new ForegroundColorSpan(Color.RED), 0, spannableString.length(), Spanned.SPAN_EXCLUSIVE_INCLUSIVE);
            return spannableString;
        }
        long cleanTime = NetTimeClock.getInstance().getNetLongTime() - startTime;
        if (cleanTime > CLEAN_RECYCLE_TIME) {
            spannableString = new SpannableString(App.app.getString(R.string.setting_clean_countdown_time_out) + getTimeString(cleanTime - CLEAN_RECYCLE_TIME));
            spannableString.setSpan(new ForegroundColorSpan(Color.RED), 0, spannableString.length(), Spanned.SPAN_EXCLUSIVE_INCLUSIVE);
        } else {
            String start = App.app.getString(R.string.setting_clean_countdown_time);
            spannableString = new SpannableString(start + getTimeString(CLEAN_RECYCLE_TIME - cleanTime));
            spannableString.setSpan(new ForegroundColorSpan(Color.RED), start.length(), spannableString.length(), Spanned.SPAN_EXCLUSIVE_INCLUSIVE);
        }

        return spannableString;
    }

    // 是否发送清洗预警通知
    private void checkWarnMessage(long time) {
        if (checkWarn) {
            return;
        }
        checkWarn = true;
        int progress = SPUtils.getInstance(App.app).getInt(SHARE_PREFERENCE_CLEAN_WARN, 0);
        if (progress > 1) {
            return;
        }
        if (time >= CLEAN_RECYCLE_TIME - WARN_SECOND_TIME) {
            log(App.app.getString(R.string.clean_lock_notify_last));
            SPUtils.getInstance(App.app).putInt(SHARE_PREFERENCE_CLEAN_WARN, 2);
            // TODO 发送预警通知到云端
            return;
        }
        if (progress == 0) { // 没有提醒过
            if (warnSchedule != null) {
                warnSchedule.dispose();
            }
            long d = CLEAN_RECYCLE_TIME - WARN_FIRST_TIME - time;
            if (d < 0) {
                d = 0;
            }
            warnSchedule = AndroidSchedulers.mainThread().scheduleDirect(new Runnable() {
                @Override
                public void run() {
                    log(App.app.getString(R.string.clean_lock_notify_first));
                    SPUtils.getInstance(App.app).putInt(SHARE_PREFERENCE_CLEAN_WARN, 1);
                    // TODO 发送预警通知到云端

                    long delay = WARN_FIRST_TIME - WARN_SECOND_TIME;
                    // 开启第二次预警倒计时
                    warnSchedule = AndroidSchedulers.mainThread().scheduleDirect(new Runnable() {
                        @Override
                        public void run() {
                            log(App.app.getString(R.string.clean_lock_notify_second));
                            SPUtils.getInstance(App.app).putInt(SHARE_PREFERENCE_CLEAN_WARN, 2);
                            // TODO 发送预警通知到云端
                        }
                    }, delay, TimeUnit.MILLISECONDS);

                }
            }, d, TimeUnit.MILLISECONDS);
        } else if (progress == 1) { // 提醒过一次
            if (warnSchedule != null) {
                warnSchedule.dispose();
            }
            long delay = CLEAN_RECYCLE_TIME - WARN_SECOND_TIME - time;
            warnSchedule = AndroidSchedulers.mainThread().scheduleDirect(new Runnable() {
                @Override
                public void run() {
                    log(App.app.getString(R.string.clean_lock_notify_second));
                    SPUtils.getInstance(App.app).putInt(SHARE_PREFERENCE_CLEAN_WARN, 2);
                    // TODO 发送预警通知到云端
                }
            }, delay, TimeUnit.MILLISECONDS);
        }
    }

    private void checkErrorMessage(long time) {
        if (checkError) {
            return;
        }
        checkError = true;
        int progress = SPUtils.getInstance(App.app).getInt(SHARE_PREFERENCE_CLEAN_WARN, 0);
        if (progress > 3) {
            return;
        }

        if (time >= ERROR_MESSAGE_TIME + CLEAN_RECYCLE_TIME) {
            log(App.app.getString(R.string.clean_lock_warning_last));
            SPUtils.getInstance(App.app).putInt(SHARE_PREFERENCE_CLEAN_WARN, 4);
            // TODO 发送锁屏警告到云端
        } else if (progress < 3) {
            log(App.app.getString(R.string.clean_lock_warning_first));
            SPUtils.getInstance(App.app).putInt(SHARE_PREFERENCE_CLEAN_WARN, 3);
            // TODO 发送锁屏警告到云端
            if (warnSchedule != null) {
                warnSchedule.dispose();
            }
            warnSchedule = AndroidSchedulers.mainThread().scheduleDirect(new Runnable() {
                @Override
                public void run() {
                    log(App.app.getString(R.string.clean_lock_warning_second));
                    SPUtils.getInstance(App.app).putInt(SHARE_PREFERENCE_CLEAN_WARN, 4);
                    // TODO 发送锁屏警告到云端
                }
            }, ERROR_MESSAGE_TIME + CLEAN_RECYCLE_TIME - time, TimeUnit.MILLISECONDS);
        }
    }

    private String getTimeString(long cleanTime) {
        String timeString;
        if (cleanTime > 3600000) {
            timeString = (cleanTime / 3600000) + App.app.getString(R.string.setting_clean_countdown_time_hour);
        } else {
            timeString = (cleanTime / 60000) + App.app.getString(R.string.setting_clean_countdown_time_minute);
        }
        return timeString;
    }

    private String getTimeDetailString(long cleanTime) {
        StringBuilder timeString = new StringBuilder();
        if (cleanTime > 3600000) {
            timeString.append(cleanTime / 3600000).append("小时");
        }
        cleanTime = cleanTime % 3600000;

        timeString.append(cleanTime / 60000).append("分钟");
        cleanTime = cleanTime % 60000;
        timeString.append(cleanTime / 1000).append("秒");
        return timeString.toString();
    }

    private void showCleanError(long time) {
        checkErrorMessage(time);
        if (!cleanTimeOutDisable) {
            return;
        }
        if (Constant.inSaleView) {
            return;
        }
        String[] lastErrorMessage = new String[]{App.app.getString(R.string.setting_clean_countdown_error_tip),
                App.app.getString(R.string.setting_clean_countdown_error_describe)};
        ErrorViewHelper.getInstance().showErrorView(R.string.error_device_clean, lastErrorMessage);
    }

    private void log(String message) {
        PlcLog.getInstance().e_s(TAG, message);
    }
}