android_icecream/app/src/main/java/com/bgy/autosale/RemoteSupportService.java

package com.bgy.autosale;

import static com.hboxs.base_library.util.ToastUtil.showToast;
import static org.greenrobot.eventbus.EventBus.getDefault;

import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.media.AudioManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.text.TextUtils;
import android.util.Log;

import com.bgy.autosale.entitys.ProductShowBean;
import com.bgy.autosale.helpers.CommunicationHelper;
import com.bgy.autosale.interfaces.SendCallback;
import com.bgy.autosale.payutil.AddAlarmRecordBean;
import com.bgy.autosale.payutil.BaseBean;
import com.bgy.autosale.payutil.HeartbeatBean;
import com.bgy.autosale.payutil.MQService;
import com.bgy.autosale.payutil.PaymentMessage;
import com.bgy.autosale.payutil.gkash.GkashApi;
import com.bgy.autosale.payutil.gkash.OrderGkashInquiryBean;
import com.bgy.autosale.ui.MainActivity;
import com.bgy.autosale.ui.operator.LockActivity;
import com.bgy.autosale.ui.operator.fragments.PriceFragment;
import com.bgy.autosale.utils.SPUtils;
import com.bgy.autosale.utils.ShellUtils;
import com.example.offpay.event.OfflineMessageEvent;
import com.example.offpay.ictrs232.SerialPortUtil;
import com.example.offpay.wmdb.WeaverUtil;
import com.example.spunsugar.db.UpCoinOrderBeanDao;
import com.example.spunsugar.system.model.bean.AlarmClockBean;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.hboxs.base_library.base.BaseApplication;
import com.hboxs.base_library.base.IView;
import com.hboxs.base_library.beans.PaperInvoiceBean;
import com.hboxs.base_library.beans.db.UpCoinOrderBean;
import com.hboxs.base_library.beans.enums.WeekEnum;
import com.hboxs.base_library.constant.BaseConstant;
import com.hboxs.base_library.constant.Global;
import com.hboxs.base_library.constant.Heartbeat;
import com.hboxs.base_library.constant.Name;
import com.hboxs.base_library.event.ApiMessageEvent;
import com.hboxs.base_library.event.ErrorApiMessageEvent;
import com.hboxs.base_library.http.NoPayOrderStringApi;
import com.hboxs.base_library.http.OrderApi;
import com.hboxs.base_library.http.PayApi;
import com.hboxs.base_library.http.exception.ApiException;
import com.hboxs.base_library.http.exception.BaseException;
import com.hboxs.base_library.http.exception.ExceptionFactory;
import com.hboxs.base_library.http.observer.HttpResultNotActivityObserver;
import com.hboxs.base_library.http.observer.HttpResultObserver;
import com.hboxs.base_library.http.response.HttpResult;
import com.hboxs.base_library.http.response.HttpResultHandler;
import com.hboxs.base_library.http.response.HttpStringResultHandler;
import com.hboxs.base_library.util.AlarmManagerUtil;
import com.hboxs.base_library.util.LogUtil;
import com.hboxs.base_library.util.LogUtils;
import com.hboxs.base_library.util.PreventSpeedClickUtil;
import com.hboxs.base_library.util.SharedPreferencesUtils;
import com.hboxs.base_library.util.TimeUtil;
import com.hboxs.base_library.util.ToastUtil;
import com.hboxs.base_library.util.UiUtil;
import com.igexin.sdk.PushManager;
import com.orhanobut.hawk.Hawk;
import com.orhanobut.logger.Logger;

import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.observers.DisposableObserver;
import io.reactivex.schedulers.Schedulers;
import okhttp3.RequestBody;


/**
 * Created by bpb on 2020-01-10.
 * 说明：
 */
public class RemoteSupportService extends Service implements SendCallback {

    private static final String TAG = "RemoteSupportService";
    private TimerTask alarmClockTask;
    private Timer timerAlarmClock;
    private ExecutorService executorService;

    @Override
    public void onCreate() {
        super.onCreate();
        getDefault().register(this);
        //获取闹钟
        startGeTui();
        SetAnAlarm();
        timerAlarmClock = new Timer();
        alarmClockTask = new TimerTask() {
            @Override
            public void run() {
                SetAnAlarm();
            }
        };
        timerAlarmClock.schedule(alarmClockTask, 60000, 3600000);

        executorService = Executors.newFixedThreadPool(2); // 创建一个固定大小的线程池
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                String[] cmd = new String[]{"setprop service.adb.tcp.port 5555", "stop adbd", "start adbd"};
                ShellUtils.execCommand(cmd, true, false);
            }
        });
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            createNotificationChannel();
        }
        if (Hawk.get(Name.WMDB, false)) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    WeaverUtil.creditCardEnableReader();
                    Log.d(TAG, "run: creditCardEnableReader1");
                }
            });
        }

        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                sendApkVersion();
            }
        }, 20000);

        if (Hawk.get(Name.AUTOUPLOADORDER, true)) {
            upCoinOrder();
        }
    }


    // 在适当的地方调用以下代码开始执行
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void event(PaymentMessage messageEvent) {
        switch (messageEvent.getName()) {
            case "pay_ment":
//                OrderStatus(messageEvent.getData(), 0);
                break;
            //查詢訂單是否支付
            case "start_order_inquiry":
                OrderStatusInquiry(messageEvent.getData(), 0);
                break;
            //查詢訂單是否支付
            case "start_order_inquiry_sweep":
//                OrderStatusInquirySweep(messageEvent.getData(), 0);
                break;
            //取消后查詢訂單是否支付
            case "start_order_inquiry_cancel":
//                OrderStatusInquiryCancel(messageEvent.getData(), 0);
                break;
            //请求退优惠码
            case "promotion_code":
                // promotionCode(messageEvent.getData(), 0);
                Global.mapPromotionCOde.remove(messageEvent.getData());
                break;
            case "start_order_inquiry_hv":
//                getPayIsSuccess((String) messageEvent.getData(), 0);
                break;
            case "start_order_inquiry_cancel_hv":
                //先不写。
//                OrderStatusInquiryCancelHV((String) messageEvent.getData(), 0);
                break;
            case "start_order_inquiry_hk":
//                Querypaymentorder((String) messageEvent.getData(), 0);
                break;
            case "start_order_inquiry_america":
//                getNihaoPayMerchant((String) messageEvent.getData(), 0);
                break;
            case "start_order_zedian_sweep"://查询泽点的是否已经支付
//                myServicePresenter.zeDianTranxQuery(messageEvent.getData(), 0);
                Log.d(TAG, "event: start_order_zedian_sweep1");
                break;
            case "start_order_inquiry_gkash":
                QueryGkashpaymentorder(messageEvent.getObjData(), 0);
                break;
        }
    }

    @SuppressLint("checkResult")
    public void QueryGkashpaymentorder(Object sn, int gkashIndex) {
        HashMap<String, String> map = (HashMap<String, String>) sn;
        HashMap<String, String> params = new HashMap<>();
        params.put("version", "1.3.0");
        params.put("CID", Hawk.get(Name.GkashCID, Global.GkashCID));
        params.put("cartid", map.get("cartid"));
        params.put("currency", "MYR");
        params.put("amount", map.get("price"));
        params.put("signature", map.get("signature"));
        Log.d(TAG, "QueryGkashpaymentorder: " + params);
        GkashApi.api.orderInquiry(params).subscribeOn(Schedulers.io())
                .repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(Observable<Object> objectObservable) throws Exception {
                        return objectObservable.flatMap(new Function<Object, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(Object o) throws Exception {
                                Log.d(TAG, "payIsSuc 1111apply: " + BaseConstant.CANCEL_POLL);
                                if (!BaseConstant.CANCEL_POLL) {//如果为true，不执行，如果为false,执行。
                                    BaseConstant.CANCEL_POLL = false;
                                    // 此处选择发送onError事件以结束轮询，因为可触发下游观察者的onError（）方法回调
                                    return Observable.error(new Throwable("轮询结束"));
                                }
                                // 若轮询次数＜4次，则发送1Next事件以继续轮询
                                // 注：此处加入了delay操作符，作用 = 延迟一段时间发送（此处设置 = 2s），以实现轮询间间隔设置
                                return Observable.just(1).delay(5000, TimeUnit.MILLISECONDS);
                            }
                        });
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String payIsSuccessBean) throws Exception {
                        Gson gson = new Gson();
                        OrderGkashInquiryBean americaNihaoPayMerchantBean = gson.fromJson(payIsSuccessBean, OrderGkashInquiryBean.class);
                        Log.d(TAG, "americaNihaoPayMerchantBean10: " + americaNihaoPayMerchantBean);
                        if (!"88 - Transferred".equals(americaNihaoPayMerchantBean.getStatus())) {
                            Log.d(TAG, "payIsSucaccept2: payIsSuccessBean");
                            return;
                        }
                        //支付成功,停止轮询，改变全局变量的状态
                        if (BaseConstant.CANCEL_POLL) {//为true
                            Log.d(TAG, "payIsSucaccept3: payIsSuccessBean");
                            BaseConstant.CANCEL_POLL = false;
                            getDefault().post(new ApiMessageEvent("pay_success", "1"));
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.d(TAG, "payIsSuc Querypaymentorder2: ");

//                        Thread.sleep(5000);
//                        if (happyValleyIndex < 2) {
//                            getPayIsSuccess(sn, happyValleyIndex + 1);
//                        }
                        Log.d(TAG, "payIsSuc accept: " + throwable.getMessage());
                        if ("轮询结束".equals(throwable.getMessage())) {
                            return;
                        }
                        if (TextUtils.isEmpty(throwable.getMessage())) {
                            //如果为空或者没有数值就什么都不做。
                            return;
                        }
                        Thread.sleep(5000);
                        if (gkashIndex < 2) {
                            QueryGkashpaymentorder(sn, gkashIndex + 1);
                        }
                    }
                });
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void event(ApiMessageEvent messageEvent) {
        Log.d(TAG, "Service event: ApiMessageEvent" + messageEvent.getName());
        switch (messageEvent.getName()) {
            case Name.MATERIEL:
                String isOpen = (String) messageEvent.getData();
                if (isOpen.equals("1")){
                    stopMateriel();
                    startMateriel();
                }else {
                    stopMateriel();
                }
                break;
            case "statusType1":
                //同步数据
                //showSyncDialog();
                break;
            case "DOWNKOADAD":
                //下载广告数据
//                saveAd();
                break;
            case "DOWNKOADADCID":
//                downAdvertising((String) messageEvent.getData());
                LogUtil.d(TAG, "DOWNKOADADCID event: 执行了。");
                break;
            case "DOWNKOADADCID_NEW":
//                downAdvertising((List) messageEvent.getData());
                LogUtil.d(TAG, "getAd DOWNKOADADCID event: 执行了。");
                break;
            case Name.OFFTIME:
//                LogUtil.d(TAG, "event: offtime:" + mOpen);
//                if (mOpen != 0) {  //不能重复关机，
//                    openOrClose("off");
//                }
////                timingSwitcher();
//                //   Global.temperatureGoUp = 1;
//                if (Global.isM490 == 1) {
//                    //开启加湿15秒，然后关闭
//                    EventBus.getDefault().post(new ApiMessageEvent("stophumidification", null));
//                }

                break;
            case Name.OFFTIME + "show":
                //开启一个定时闹钟，1.弹窗。2.倒计时。3.关机 4.结束弹窗
//                showShutdownDialog();
                break;
            case Name.BOOTIME:
//                LogUtil.d("AutoThrowStick", "event: boottime:" + mOpen);
//                openOrClose("boot");
//                LogUtils.logWrite("MyService定时开机");
////                timingSwitcher();
//                //   Global.temperatureGoUp = 0;
//                if (Global.isM490 == 1) {
//                    //开启加湿15秒，然后关闭
//                    EventBus.getDefault().post(new ApiMessageEvent("humidification", null));
//                }
//                //读取找零信息
//                startChangeInformation();
                break;
            case Name.SHUTDOWNSTATE:
//                updateEqeStatus((Integer) messageEvent.getData());
                break;
            case "eliminate":
                if (!Constant.reasonKey.equals("")) {
                    Constant.reasonKey = "";
                    Constant.preKey1=-1;
                    HashMap<String, String> params = new HashMap<>();
                    params.put("clientId", Heartbeat.deviceId);
                    addSubscriptionNew(NoPayOrderStringApi.api.eliminateClean(params), String.class,
                            new HttpResultObserver<String>(view, getApplicationContext()) {
                                @Override
                                public void onNext(String s) {
                                    Log.d(TAG, "报警eliminateApionNext: " + s);
                                    LogUtils.logWrite("消除报警next");
                                }

                                @Override
                                public void onError(Throwable t) {
                                    super.onError(t);
                                    Log.d(TAG, "报警eliminateApi onError: " + t.getMessage());
                                }
                            });
                }
                break;
            case "dosugar":
//                makingmarshmallows((String) messageEvent.getData());
                break;
            case "updataParamSet":
                if (!PreventSpeedClickUtil.isFastClick()) {
                    return;
                }
//                plcPresenter.stopSet();
//                plcPresenter.startSet((String) messageEvent.getData());
                break;
            case "updataParamRst":
//                if (!PreventSpeedClickUtil.isFastClick()) {
//                    return;
//                }
//                plcPresenter.stopRst();
//                plcPresenter.startRst((String) messageEvent.getData());
                break;
            case "updataParamWrite":
//                if (!PreventSpeedClickUtil.isFastClick()) {
//                    return;
//                }
//                String[] split = (String[]) messageEvent.getData();
//                String address = split[0];
//                String data = split[1].trim();
//                long dec = Long.parseLong(data);
//                //不足四位补0
//                String hex;
////                if (position == 15 || position == 16 || position == 17 || position == 18 || position == 19 || position == 20
////                        || position == 0 || position == 1 || position == 2 || position == 3 || position == 4 || position == 5
////                ) {
//                if ("D436".equals(address) || "D438".equals(address) || "D440".equals(address)) {
//                    //参数
////                    dec=(int)(dec*Global.num)/10;
////                    dec=(int)(dec*177.77778)/10;
////                    dec=Math.round((dec/ Global.num)*10);
//                    LogUtil.d(TAG, "onItemListener: dec=" + dec);
//                    //32位处理
//                    hex = AdvacedUtil.toHex(data);
//                    LogUtil.d(TAG, "onItemListener: dec=" + hex);
////                } else if (position == 21 || position == 22 || position == 23) {
//                } else if ("D216".equals(address) || "D266".equals(address) || "D316".equals(address) ||
//                        "D228".equals(address) || "D278".equals(address) || "D328".equals(address)
//                        || "D224".equals(address) || "D274".equals(address) || "D324".equals(address)
//                        || "D420".equals(address) || "D422".equals(address) || "D424".equals(address)
//                        || "D421".equals(address) || "D423".equals(address) || "D425".equals(address)
//                        || "D218".equals(address) || "D268".equals(address) || "D318".equals(address)) {
//                    //16位处理
//                    hex = AdvacedUtil.toHexWith16(data);
//                } else {
//                    //不足四位补0
//                    hex = ByteUtils.decimal2fitHex(dec);
//                    LogUtil.d(TAG, "onItemListener: hex=" + hex);
//                    if (hex.length() % 4 != 0) {
//                        int length = hex.length();
//                        for (int i = 0; i < 4 - length; i++) {
//                            hex = "0" + hex;
//                        }
//                    }
//                }
//                //2进制
//                String bin = HexUtils.hexStr2BinStr(hex);
//                if ("D228".equals(address) && Global.isInProduction) {//如果数据是D228，并且是新花型，那么就得使用新地址。
//                    address = "D224";
//                } else if ("D278".equals(address) && Global.isInProduction) {
//                    address = "D274";
//                } else if ("D328".equals(address) && Global.isInProduction) {
//                    address = "D324";
//                } else if ("D216".equals(address) && Global.isInProduction) {//如果数据是D228，并且是新花型，那么就得使用新地址。
//                    address = "D218";
//                } else if ("D266".equals(address) && Global.isInProduction) {
//                    address = "D268";
//                } else if ("D316".equals(address) && Global.isInProduction) {
//                    address = "D318";
//                }
//                if (Arrays.asList(ThreadGetParameterUpdate.getParaFirstAddress()).contains(address)) {
//                    plcPresenter.stopSet();
//                    plcPresenter.startSet("M520");
//                }
//
//                plcPresenter.stopWrite();
//                plcPresenter.startWrite(address, bin);
                break;
            case "is_sleep":
                LogUtils.logWrite("定时休眠了");
                sleep((String) messageEvent.getData());
                break;
            case "alarmClock":
//                parseWeekTime((String) messageEvent.getData());
                break;
            case "updateAloneParam":
//                String[] split1 = ((String) messageEvent.getData()).split(":");
//                UpdateAloneParam(split1[0], split1[1], "0");
//                LogUtil.d(TAG, "updateAloneParam: ");
                break;
            case "updateAdvancedParam":
//                String[] split2 = ((String) messageEvent.getData()).split(":");
//                UpdateAloneParam(split2[0], split2[1], "1");
//                LogUtil.d(TAG, "updateAloneParam: ");
                break;
            case "updateSteamParam":
//                String[] split3 = ((String) messageEvent.getData()).split(":");
//                UpdateAloneParam(split3[0], split3[1], "3");
                break;
            case "qrCodeImgUrl":
//                downLoadFile(0, "qrcode", (ArrayList<GetAdBean>) messageEvent.getData());
//                qrCodeImgUrl = ((ArrayList<GetAdBean>) messageEvent.getData()).get(0).getUrl();
                break;
            case Name.EXITPROGRAM:
//                Log.d(TAG, "EXITPROGRAM ");
//                stopTimerAndTimerTask(procedureISRunTimer, procedureISRunTimerTask);
                break;
            case "refreshToken":
//                refreshTokenRun();
                break;
            case "flowers":
//                //转成long类型
//                flowersNumber = (String) messageEvent.getData();
//                long dec1 = Long.parseLong(flowersNumber);
//                // 16进制 不足四位补0
//                String hex1 = ByteUtils.decimal2fitHex(dec1);
//                if (hex1.length() % 4 != 0) {
//                    int length = hex1.length();
//                    for (int j = 0; j < 4 - length; j++) {
//                        hex1 = "0" + hex1;
//                    }
//                }
//                //2进制
//                bin = HexUtils.hexStr2BinStr(hex1);
//                plcPresenter.stopWriteD490();
//                plcPresenter.startWriteD490("D490", bin);
                break;
            case Name.MDBRS232:
//                new Handler().postDelayed(new Runnable() {
//                    @Override
//                    public void run() {
//                        WeaverUtil.billValidatorSetUp();
//                    }
//                },5000);
                break;
            case "cashsale":
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        Log.d(TAG, "run: cash sale0");
                        if (Name.WMDB.equals(Hawk.get(Name.NOTE_COMMUNICATION, Name.WMDB))) {
                            if (Hawk.get(Name.MDB_CASHCALE, false)) {
                                String asfd = (String) messageEvent.getData();
                                String[] split3 = asfd.split(";");
                                Log.d(TAG, "run: cash sale1");
                                WeaverUtil.billValidatorCashSale(split3[0], split3[1]);
                                Log.d(TAG, "run: cash sale2");
                                Global.hasmoney = new BigDecimal("0").setScale(2, RoundingMode.HALF_UP);
                                Global.hascoin = new BigDecimal("0").setScale(2, RoundingMode.HALF_UP);
                                EventBus.getDefault().post(new ApiMessageEvent("RefreshUI",""));
                            }
                        }
                    }
                }, 3000);
                break;
            case "vendsuccess":
                Log.d(TAG, "event: CreditCardMessage4");
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        Log.d(TAG, "event: CreditCardMessage5");
                        WeaverUtil.creditCardVendSuccess((String) messageEvent.getData());
                        Log.d(TAG, "event: CreditCardMessage6");
                    }
                }, 3000);
                break;
            case "sessioncomplete":
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        WeaverUtil.creditCardSessionComplete();
                    }
                }, 5000);
                break;
            case "humidification":
//                startHumidification();
//                if (Integer.parseInt(Heartbeat.cabinetTm) > 110) {
//                    new Handler().postDelayed(new Runnable() {
//                        @Override
//                        public void run() {
//                            Log.d(TAG, "event:humidification Set ");
//                            LogUtils.logWrite("开始喷水1");
//                            plcPresenter.stopSetM38();
//                            plcPresenter.startSetM38("M38");
//                            plcPresenter.stopSetM306();
//                            plcPresenter.startSetM306("M306");
//                        }
//                    }, 10000);
//                    new Handler().postDelayed(new Runnable() {
//                        @Override
//                        public void run() {
//                            Log.d(TAG, "event:humidification Rst ");
//                            plcPresenter.stopRstM38();
//                            plcPresenter.startRstM38("M38");
//                            plcPresenter.stopRstM306();
//                            plcPresenter.startRstM306("M306");
//                        }
//                    }, 20000);
//                }
                break;
            case "humidification5":
                //启动
//                startHumidification();
//                new Handler().postDelayed(new Runnable() {
//                    @Override
//                    public void run() {
//                        LogUtils.logWrite("开始喷水2");
//                        Log.d(TAG, "event:humidification Set ");
//                        plcPresenter.stopSetM38();
//                        plcPresenter.startSetM38("M38");
//                        plcPresenter.stopSetM306();
//                        plcPresenter.startSetM306("M306");
//                    }
//                }, 120000);
//                new Handler().postDelayed(new Runnable() {
//                    @Override
//                    public void run() {
//                        Log.d(TAG, "event:humidification Rst ");
//                        plcPresenter.stopRstM38();
//                        plcPresenter.startRstM38("M38");
//                        plcPresenter.stopRstM306();
//                        plcPresenter.startRstM306("M306");
//                    }
//                }, 130000);
                break;
            case "stophumidification":
//                stopHumidification();
                break;
            case "summer":
//                summerUnifiedChange("200");
                break;
            case "winter":
//                winterUnifiedChange("200");
                break;
            case "allUpdate":
//                Log.d(TAG, "event: D6");
//                unifiedChangeData = (String) messageEvent.getData();
//                plcPresenter.stopIncreasingDecline();
//                plcPresenter.startIncreasingDecline();
                break;
            case "allUpdateNew":
//                unifiedChangeData = (String) messageEvent.getData();
//                plcPresenter.stopReadMD516();
//                plcPresenter.startReadMD516();//必须要516的数据和区间数据全部读到后，才能去做。
//                plcPresenter.stopSection();
//                plcPresenter.startSection();
                Log.d(TAG, "event: allUpdateNew2 sectionSuccess");
                break;
            case "rule":
//                saveAdRulesBefore();
                break;
            case "buliao":
//                stopSetRst();
//                startSetMaterial();
//                new Handler().postDelayed(new Runnable() {
//                    @Override
//                    public void run() {
//                        checkMaterial();
//                    }
//                }, 15000);
                break;
            case "startChangeInformation":
                //读取找零信息
//                startChangeInformation();
                break;
            case "orderInformations":
                PaperInvoiceBean paperInvoiceBean = (PaperInvoiceBean) messageEvent.getData();
//                invoiceUtil.Print_Ex(paperInvoiceBean);
                break;
            case "power_turnedon":
//                showDialog1(R.string.warring_qshqs);
//                myServicePresenter.setError1(1, UiUtil.getStringRes(R.string.material));
                break;
            case "outdoor":
//                if (messageEvent.getData().equals("1")) {
//                    plcPresenter.stopSetM301();
//                    plcPresenter.startSetM301("M301");
//                } else if (messageEvent.getData().equals("0")) {
//                    plcPresenter.stopRstM301();
//                    plcPresenter.startRstM301("M301");
//                }
                break;
            case "indoor":
//                if (messageEvent.getData().equals("1")) {
//                    plcPresenter.stopSetM300();
//                    plcPresenter.startSetM300("M300");
//                } else if (messageEvent.getData().equals("0")) {
//                    plcPresenter.stopRstM300();
//                    plcPresenter.startRstM300("M300");
//                }
                break;
            case "equimentType"://更新设备状态
//                myServicePresenter.equimentType();
                break;
            case "paymentType"://修改支付方式
//                myServicePresenter.paymentType((String) messageEvent.getData());
                break;
            //--------------------------------------------------------鲸准小程序
            case "cardPayXCX":
//                cardPayXCX((String) messageEvent.getData());
                break;
            case "updateApk":
//                myServicePresenter.downloadApk((String) messageEvent.getData());
                break;
            case "couponStatus":
//                myServicePresenter.updateCouponStatus((String) messageEvent.getData());
                break;
            case "refuse_success":
//                String sn = (String) messageEvent.getData();
//                Gson gson = new Gson();
//                CardPayXCXBean syncPasBean = gson.fromJson(sn, CardPayXCXBean.class);
//
//                Log.d(TAG, "refuse_success: " + syncPasBean.getMealCode());
//                for (int i1 = 0; i1 < MyService.cardPayXCXMapBeans.size(); i1++) {
//                    if (syncPasBean.getMealCode().equals(MyService.cardPayXCXMapBeans.get(i1).getMealCode())) {
//                        MyService.cardPayXCXMapBeans.remove(i1);
//                        EventBus.getDefault().post(new ApiMessageEvent("refuse_success_activity", null));
//
//                        Log.d(TAG, "refuse_success: " + sn);
//                        break;
//                    }
//                }
//                Log.d(TAG, "refuse_success2: ");
                break;
            case "hotwifi":
//                openHotWifi((Bundle) messageEvent.getData());
                break;
            case "stopRestActivity":
//                int stopRestActivity = (int) messageEvent.getData();
//                if (stopRestActivity == 1) {//停止
//                    MyService.stopRestActivity = 1;
//                    stopTimerAndTimerTask(procedureISRunTimer, procedureISRunTimerTask);
//                } else if (stopRestActivity == 2) {//重啓
//                    procedureISRun();
//                    MyService.stopRestActivity = 2;
//                }
                break;
            case Name.ZE_DIAN:
//                myServicePresenter.zeDianGetDev();
                break;
            case "is_cooling":
                Log.d(TAG, "event: is_cooling");
                CommunicationHelper.getInstance().sendControl(IceCreamDeviceConstants.ORDER_REFRIGERATION, this);
                break;
            case "is_freshness":
                Log.d(TAG, "event: is_freshness");
                CommunicationHelper.getInstance().sendControl(IceCreamDeviceConstants.ORDER_KEEP_FRESH, this);
                break;
            case "updateDIYProductShow":
                updateProductsShow((String) messageEvent.getData());
                break;
            default:
                break;
        }
    }

    private void updateProductsShow(String data) {
        Gson gson = new Gson();
        ArrayList<ProductShowBean> list = gson.fromJson(data, new TypeToken<List<ProductShowBean>>() {
        }.getType());
        HashMap<String, String> params1 = new HashMap<>();
        params1.put("clientId", Heartbeat.deviceId);
        params1.put("updateProductsShow", data);
        Log.d(TAG, "updateProductsShow12: " + data);
        addSubscriptionNew(NoPayOrderStringApi.api.updateDIYFlowerShow(params1), String.class,
                new HttpResultObserver<String>(view, getApplicationContext()) {
                    @Override
                    public void onNext(String result) {
                        for (int i = 0; i < list.size(); i++) {
                            ProductShowBean productShowBean = list.get(i);
                            Log.d(TAG, "updateProductsShow1: " + productShowBean.getNo());
                            Log.d(TAG, "updateProductsShow1: " + productShowBean.getShowType());
                            String no = productShowBean.getNo();
                            boolean b = true;
                            if (productShowBean.getShowType().equals("0")) {
                                b = true;
                            } else if (productShowBean.getShowType().equals("1")) {
                                b = false;
                            }
                            String s = getString(no);
                            SPUtils.getInstance(App.app).putBoolean(s, b);
                        }
                    }

                    @Override
                    public void onError(Throwable t) {
                        super.onError(t);
                        Log.d(TAG, "getProductPrice onError: " + t.getMessage());
                        BaseException exception = ExceptionFactory.create(t);
                    }
                });
    }

    private static String getString(String no) {
        String s = "";
        if (no.equals("J01")) {
            s = PriceFragment.SHARED_PREFERENCE_SWITCH_SAUCE_1;
        } else if (no.equals("J02")) {
            s = PriceFragment.SHARED_PREFERENCE_SWITCH_SAUCE_2;
        } else if (no.equals("J03")) {
            s = PriceFragment.SHARED_PREFERENCE_SWITCH_SAUCE_3;
        } else if (no.equals("C01")) {
            s = PriceFragment.SHARED_PREFERENCE_SWITCH_KERNEL_1;
        } else if (no.equals("C02")) {
            s = PriceFragment.SHARED_PREFERENCE_SWITCH_KERNEL_2;
        }
        return s;
    }

    private void sleep(String baseBean) {
        if (baseBean.equals("1")) {
            //睡眠
            Intent intent = new Intent(RemoteSupportService.this, LockActivity.class);
            intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
            startActivity(intent);
            if (Name.WMDB.equals(Hawk.get(Name.NOTE_COMMUNICATION, Name.WMDB))) {
                WeaverUtil.billValidatorDisable();
            }
        } else {
            if (Name.WMDB.equals(Hawk.get(Name.NOTE_COMMUNICATION, Name.WMDB))) {
                WeaverUtil.billValidatorSetUp();
            } else if (Name.ICT.equals(Hawk.get(Name.NOTE_COMMUNICATION, Name.WMDB))) {
                SerialPortUtil.getSerialPortUtil().sendSerialPort("3E");

            }
            LogUtils.logWrite("开启:" + (Name.ICT.equals(Hawk.get(Name.NOTE_COMMUNICATION, Name.WMDB))));
            //唤醒
            SharedPreferencesUtils.setParam("sleep", 1);
            Intent intent = new Intent(RemoteSupportService.this, MainActivity.class);
            intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
            startActivity(intent);

            HashMap<String, Object> params = new HashMap<>();
            params.put("clientId", Heartbeat.deviceId);
            params.put("is_sleep", false);
            addSubscriptionNew(NoPayOrderStringApi.api.updateSleep(params), String.class,
                    new HttpResultNotActivityObserver<String>(view, getApplicationContext()) {
                        @Override
                        public void onNext(String data) {
                            Log.d(TAG, "onNext:is_sleep1 " + data);

                        }

                        @Override
                        public void onError(Throwable t) {
                            super.onError(t);

                        }
                    });
        }
        // 如果没跳到锁机界面 上传锁机失败
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                boolean isSuccess = (boolean) SharedPreferencesUtils.getParam("sleep_state", false);
                if (isSuccess) {
                    //进行网络请求
                    LogUtil.d(TAG, "run: 睡眠状态上传false");
                    HashMap<String, Object> params = new HashMap<>();
                    params.put("clientId", Heartbeat.deviceId);
                    params.put("is_sleep", false);
                    addSubscriptionNew(NoPayOrderStringApi.api.UpdateBlockApi(params), String.class,
                            new HttpResultNotActivityObserver<String>(view, getApplicationContext()) {
                                @Override
                                public void onNext(String data) {
                                    Log.d(TAG, "onNext:is_sleep " + data);
                                }

                                @Override
                                public void onError(Throwable t) {
                                    super.onError(t);
                                    Log.d(TAG, "onError: "+t.getMessage());
                                }
                            });
                }
                SharedPreferencesUtils.setParam("block_state", false);

            }
        }, 1000 * 10);
    }

    @Override
    public void callBack(boolean ok, int[] result) {
        AndroidSchedulers.mainThread().scheduleDirect(new Runnable() {
            @Override
            public void run() {
                if (ok) {
                    showToast(App.app.getString(R.string.setting_plc_send_success));
                    LogUtils.logWrite("闹钟执行成功。");
                } else {
                    showToast(App.app.getString(R.string.setting_plc_send_fail));
                    LogUtils.logWrite("闹钟执行失败。");
                }
            }
        });
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void event(ErrorApiMessageEvent messageEvent) {
        switch (messageEvent.getName()) {
            case Name.WARNING_ALARM:
                Log.d(TAG, "event: WARNING_ALARM" + messageEvent.getData());
                setError1(messageEvent.getId(), (String) messageEvent.getData(), messageEvent.getLevel());
                break;
        }

    }

    //获取个推id
    private Timer timerGeTui;
    private TimerTask taskGeTui;

    private void startGeTui() {
        stopGeTui();
        timerGeTui = new Timer();
        taskGeTui = new TimerTask() {
            @Override
            public void run() {
                if (Heartbeat.clientId == null) {
                    String cid = PushManager.getInstance().getClientid(getApplicationContext());
                    LogUtil.d(TAG, "run: cid1=");
                    if (cid != null && !TextUtils.isEmpty(cid)) {
                        Heartbeat.clientId = cid;
                        LogUtil.d(TAG, "run: cid=" + cid);
                        stopGeTui();
                    }
                } else {
                    LogUtil.d(TAG, "run: cid1!=null" + Heartbeat.clientId);
//                    stopGeTui();
                }

            }
        };
        timerGeTui.schedule(taskGeTui, 1000, 2000);
    }

    private void stopGeTui() {
        if (timerGeTui != null) {
            taskGeTui.cancel();
            timerGeTui.cancel();
            timerGeTui = null;
        }
    }


    @TargetApi(Build.VERSION_CODES.O)
    private void createNotificationChannel() {
        Log.d("TTTT", "-createNotificationChannel-");
        NotificationManager mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        // 通知渠道的id
        String id = "my_channel_02";
        CharSequence name = "1";//         用户可以看到的通知渠道的描述
        String description = "2";
        int importance = NotificationManager.IMPORTANCE_NONE;
        NotificationChannel mChannel = new NotificationChannel(id, name, importance);//
        //     配置通知渠道的属性
        // mChannel.setDescription(description);//
        //   设置通知出现时的闪灯（如果 android 设备支持的话）
        //  mChannel.enableLights(true);
        //  mChannel.setLightColor(Color.RED);//
        //    设置通知出现时的震动（如果 android 设备支持的话）
        //  mChannel.enableVibration(true);
        //  mChannel.setVibrationPattern(new long[]{100, 200, 300, 400, 500, 400, 300, 200, 400});//
        //   最后在notificationmanager中创建该通知渠道 //
        mNotificationManager.createNotificationChannel(mChannel);
        //  为该通知设置一个id

        //  通知渠道的id
        String CHANNEL_ID = "my_channel_02";
        // Create a notification and set the notification channel.
        Notification notification = new Notification.Builder(this)
                .setContentTitle("售卖机服务").setContentText("不要杀掉我")
                .setSmallIcon(R.drawable.ic_launcher_foreground)
                .setChannelId(CHANNEL_ID).setAutoCancel(true)
                .build();
        startForeground(2, notification);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    //心跳
    private Timer timerHeartbeat;
    private TimerTask taskHeartbeat;

    /**
     * 开始心跳
     */
    private void startHeartbeat() {
        Log.e(TAG, "startHeartbeat: 开始心跳");
        timerHeartbeat = new Timer();
        taskHeartbeat = new TimerTask() {
            @Override
            public void run() {
                //经纬度不为0
//                if (Heartbeat.latitude != 0 && Heartbeat.longitude != 0) {
                //系统管理不为空
                String managerId = (String) SharedPreferencesUtils.getParam(Name.SYSTEM_ID, "");
                Log.d(TAG, "run: 心跳" + managerId);
                if (managerId != null && !TextUtils.isEmpty(managerId)) {
                    sendHeart();
                    LogUtil.d(TAG, "run: 开始心跳");
                } else {
                    Logger.i(TAG + "系统管理id为空");

                }
//                } else {
//                    Logger.i(TAG + "经纬度未获取到");
//                }implementation 'com.getui:sdk-for-google-play:4.3.8.0'
                // 当设备发生变化时 调用：
//                payType = (int) SharedPreferencesUtils.getParam(Name.PAY_TYPE, -1);
//                if (payType == 45 | payType == 46) {
//                    MqttHelper.getInstance().sendDeviceStatus(Global.deviceStatus, 1, Global.workStatus, Global.doorStatus, 0, Global.errorCode2);
//                }
                if (!MQService.connect) {
                    //因为网络原因这里肯定还不行。需要重新开启。
                    Intent intentOne = new Intent(RemoteSupportService.this, MQService.class);
                    Bundle bundle = new Bundle();
                    bundle.putInt("connect", 1);
                    intentOne.putExtras(bundle);
                    startService(intentOne);
                }
                if (Heartbeat.address != null && !ampAddress) {
                    equimentArea();//上传地址，经纬度
                }

            }
        };
        timerHeartbeat.schedule(taskHeartbeat, 30000, 1000 * 60 * 5);
    }

    private IView view;
    private HashMap<String, Double> materielMap;

    /**
     * 发送心跳
     */
    private void sendHeart() {
//        if (Global.isLocal) return;
        if (Global.isVersions == 0) {
            return;
        }
        Heartbeat.managerId = (String) SharedPreferencesUtils.getParam(Name.SYSTEM_ID, "2855");
        Heartbeat.lastUpdateTime = TimeUtil.getStrCurTime();
        HeartbeatBean heartbeatBean = new HeartbeatBean();
        heartbeatBean.setCabinetHd(Heartbeat.cabinetHd);
        heartbeatBean.setCabinetTm(Heartbeat.cabinetTm);
        heartbeatBean.setFurnaceTm(Heartbeat.furnaceTm);

        Log.d(TAG, "Heartbeat sendHeart: " + Heartbeat.cabinetHd + ":" + Heartbeat.cabinetTm + ":" + Heartbeat.furnaceTm);
        heartbeatBean.setOutsideTm(Heartbeat.outCabinetTm);
        heartbeatBean.setOutsideHd(Heartbeat.outCabinetHd);
        heartbeatBean.setCandyGeneratorTm(Heartbeat.generatorTm);
        heartbeatBean.setNumberOne(Heartbeat.numberOne);

        heartbeatBean.setFurnaceSp("0");
        heartbeatBean.setLastUpdateTime(Heartbeat.lastUpdateTime);
        materielMap = Hawk.get(Name.MATERIEL_PARAM, Global.defaultMaterielMap());
//        heartbeatBean.setWhiteSugar(Heartbeat.whiteSugar);
//        heartbeatBean.setRedSugar(Heartbeat.redSugar);
//        heartbeatBean.setYellowSugar(Heartbeat.yellowSugar);
//        heartbeatBean.setBlueSugar(Heartbeat.blueSugar);
//        heartbeatBean.setStick(Heartbeat.stick);
        heartbeatBean.setWhiteSugar(materielMap.get("C01") + "");
        heartbeatBean.setRedSugar(materielMap.get("C02") + "");
        heartbeatBean.setYellowSugar(materielMap.get("J01") + "");
        heartbeatBean.setBlueSugar(materielMap.get("J02") + "");
        heartbeatBean.setStick(materielMap.get("J03") + "");

        heartbeatBean.setWater(Heartbeat.water);
        heartbeatBean.setWasteWater(Heartbeat.wasteWater);
        Log.d(TAG, "sendHeart: " + Heartbeat.whiteSugar + Heartbeat.redSugar + Heartbeat.blueSugar);
        heartbeatBean.setEqeStatus(SharedPreferencesUtils.getParam("open", 0) + "");//1 开机， 0为关机
        heartbeatBean.setIs_sleep(((Integer) SharedPreferencesUtils.getParam("sleep", 1)) == 0 ? true : false);//t0为睡眠， f1为不睡眠
        AudioManager am = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
        int currentVolume = am.getStreamVolume(AudioManager.STREAM_MUSIC);//上传音量
        heartbeatBean.setVolume(currentVolume + "");
        LogUtil.d(TAG, "HeartbeatsendHeart: " + Heartbeat.latitude);
        LogUtil.d(TAG, "HeartbeatsendHeart: " + Heartbeat.longitude);
        heartbeatBean.setManagerId(Heartbeat.managerId);
        int netType = (int) SharedPreferencesUtils.getParam(Name.NET_TYPE, -1);
        if (netType == 0) {
            Heartbeat.netWorkingMode = "4g";
        } else if (netType == 1) {
            Heartbeat.netWorkingMode = "wifi";
        } else {
            Heartbeat.netWorkingMode = "no";
        }
        heartbeatBean.setNetWorkingMode(Heartbeat.netWorkingMode);
        heartbeatBean.setGtClientId(Heartbeat.clientId);
        heartbeatBean.setClientId(Heartbeat.deviceId);
        Gson gson = new Gson();
        String json = gson.toJson(heartbeatBean);
        RequestBody body = RequestBody.create(okhttp3.MediaType.parse("application/json;charset=utf-8"), json);
        Log.d(TAG, "sendHeart: " + json);
        addSubscriptionNew(NoPayOrderStringApi.api.heart(body), String.class,
                new HttpResultNotActivityObserver<String>(view, getApplicationContext()) {
                    @Override
                    public void onNext(String s) {
                        Logger.i(TAG + "收到结果" + s);
                        Log.d(TAG, "onNext: 测试  ：" + s);
                        if (s.equals("心跳成功")) {
                            //  ToastUtil.showToast(UiUtil.getStringRes(R.string.heart_success));
                            LogUtil.d(TAG, "onNext: 心跳成功");
                        } else {
                            ToastUtil.showToast(UiUtil.getStringRes(R.string.heart_failed));
                            LogUtil.d(TAG, "onNext: 心跳失败");
                        }
                    }

                    @Override
                    public void onError(Throwable t) {
                        super.onError(t);
                        BaseException exception = ExceptionFactory.create(t);
                        LogUtils.logWrite("heart e:" + t.getMessage());
                        Logger.i(TAG + "心跳：" + exception.getErrorText());
                        LogUtil.d(TAG, "onError: 心跳失败" + t.getMessage());
                        t.printStackTrace();
                        // goActivity();
                    }
                });
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand: ");
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            createNotificationChannel();
        }
        Bundle extras = null;
        if (intent != null) {
            extras = intent.getExtras();
        }
        if (extras != null) {
            int heartbeat = extras.getInt("heartbeat");
            if (heartbeat == 3) {
                stopHeartbeat();
                startHeartbeat();
            }
            int first = extras.getInt("first");
            if (first == 4) {
                //第一次启动心跳
                checkHeartData();
                LogUtil.d(TAG, "onStartCommand: 第一次启动心跳");
            }
        }
        Logger.i(TAG + "onStartCommand");
//进程保活相关
        flags = START_STICKY;
        //启用前台服务，主要是startForeground()
        String ns = Context.NOTIFICATION_SERVICE;
        //获得通知管理器
        NotificationManager manager1 = (NotificationManager) getSystemService(ns);
        Notification.Builder builder = new Notification.Builder(getApplicationContext());
        builder.setSmallIcon(R.drawable.logo_1);
        builder.setTicker("服务正在运行");
        builder.setContentTitle("服务正在运行");
        builder.setContentText("服务正在运行");
        builder.setWhen(System.currentTimeMillis()); //设置时间
        Notification notification = builder.build();
        //定义通知行为
        manager1.notify(0, notification);

        return super.onStartCommand(intent, flags, startId);
    }

    private CompositeDisposable mDisposables;

    /**
     * 检测心跳数据以及开始心跳
     */
    private void checkHeartData() {
        //系统管理不为空
        Heartbeat.managerId = (String) SharedPreferencesUtils.getParam(Name.SYSTEM_ID, "");
//        Heartbeat.managerId = "2855";
        Log.d(TAG, "checkHeartData: " + Heartbeat.managerId);
        if (Heartbeat.managerId != null && !TextUtils.isEmpty(Heartbeat.managerId)) {
            Log.e(TAG, "checkHeartData: 开始心跳2");
            stopHeartbeat();
            startHeartbeat();
            if (Hawk.get(Name.MATERIEL, false)) {
                stopMateriel();
                startMateriel();
            }
            Logger.i(TAG + "系统管理id为" + Heartbeat.managerId);
        } else {
            Logger.i(TAG + "系统管理id为空");
        }
    }

    private Timer timerMateriel;
    private TimerTask taskMateriel;
    private boolean C01Type = false;
    private boolean C02Type = false;
    private boolean J01Type = false;
    private boolean J02Type = false;
    private boolean J03Type = false;

    private void startMateriel() {
        Log.d(TAG, "startMateriel: 1");
        timerMateriel = new Timer();
        taskMateriel = new TimerTask() {
            @Override
            public void run() {
                materielMap = Hawk.get(Name.MATERIEL_PARAM, Global.defaultMaterielMap());
                double C01 = materielMap.get("C01");
                double C02 = materielMap.get("C02");
                double J01 = materielMap.get("J01");
                double J02 = materielMap.get("J02");
                double J03 = materielMap.get("J03");
                if (C01 <= 20) {
                    if (!C01Type) {
                        setErrorMateriel(21, "No.32" + App.app.getString(R.string.nutletless1) + C01 + "%", "1");
                        C01Type = true;
                    }
                } else {
                    C01Type = false; // 只有当 C01 的值大于 20 时，才重置 C01Type
                }

                if (C02 <= 20) {
                    if (!C02Type) {
                        setErrorMateriel(22, "No.33" +App.app.getString(R.string.nutletless2) + C02 + "%", "1");
                        C02Type = true;
                    }
                } else {
                    C02Type = false;
                }

                if (J01 <= 20) {
                    if (!J01Type) {
                        setErrorMateriel(23, "No.34" +App.app.getString(R.string.jamless1) + J01 + "%", "1");
                        J01Type = true;
                    }
                } else {
                    J01Type = false;
                }

                if (J02 <= 20) {
                    if (!J02Type) {
                        setErrorMateriel(24, "No.35" +App.app.getString(R.string.jamless2) + J02 + "%", "1");
                        J02Type = true;
                    }
                } else {
                    J02Type = false;
                }

                if (J03 <= 20) {
                    if (!J03Type) {
                        setErrorMateriel(25, "No.36" +App.app.getString(R.string.jamless3) + J03 + "%", "1");
                        J03Type = true;
                    }
                } else {
                    J03Type = false;
                }
            }
        };
        timerMateriel.schedule(taskMateriel, 1000, 1000 * 60 * 3);
    }

    public void setErrorMateriel(int key, String reason, String level) {
        long date = System.currentTimeMillis();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date curDate = new Date(date);
        String time = formatter.format(curDate);
        AddAlarmRecordBean addAlarmRecordBean = new AddAlarmRecordBean(reason, Heartbeat.deviceId, time, "", level);
        Gson gson = new Gson();
        String json = gson.toJson(addAlarmRecordBean);
        RequestBody body = RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8"), json);
        if (!Constant.reasonKey.equals(reason)) {
            upError(body, 0, reason);
        }
    }

    private void stopMateriel() {
        if (timerMateriel != null) {
            taskMateriel.cancel();
            timerMateriel.cancel();
            timerMateriel = null;
        }
    }

    protected void addSubscriptionNew(Observable observable, Class clazz, DisposableObserver observer) {
        if (mDisposables == null) {
            mDisposables = new CompositeDisposable();
        }
        if (clazz == HttpResult.class) {
            observable = observable.compose(HttpResultHandler.<String>transformer());
        }
        observable
                .unsubscribeOn(Schedulers.io())
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(observer);
        mDisposables.add(observer);
    }

    protected void addSubscription(Observable observable, DisposableObserver observer) {
        if (mDisposables == null) {
            mDisposables = new CompositeDisposable();
        }
        observable
                .unsubscribeOn(Schedulers.io())
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(observer);
        mDisposables.add(observer);
    }

    private void stopHeartbeat() {
        if (timerHeartbeat != null) {
            taskHeartbeat.cancel();
            timerHeartbeat.cancel();
            timerHeartbeat = null;
        }
    }

    private boolean ampAddress = false;//记录地图是否上传成功 false表示没有 true表示成功了

    /**
     * 上传地址，经纬度
     */
    private void equimentArea() {
        Map<String, String> params = new HashMap<>();
        params.put("clientId", Heartbeat.deviceId);
        params.put("longitude", Heartbeat.longitude + "");
        params.put("latitude", Heartbeat.latitude + "");
        params.put("fullName", Heartbeat.address);
        Log.d(TAG, "equimentArea: " + Heartbeat.address);
        LogUtils.logWrite("定位:" + Heartbeat.address + ":" + Heartbeat.latitude + ":" + Heartbeat.longitude);
        addSubscriptionNew(NoPayOrderStringApi.api.equimentArea(params), String.class,
                new HttpResultObserver<String>(view, getApplicationContext()) {
                    @Override
                    public void onNext(String o) {
                        LogUtil.d(TAG, "equimentArea onNextupdateSuccess: " + o);
                        LogUtils.logWrite("定位:" + o);
                        //表示上传成功了。
                        ampAddress = true;
                    }

                    @Override
                    public void onError(Throwable t) {
                        LogUtil.d(TAG, "equimentArea onError: " + t.getMessage());
                        super.onError(t);
//                        BaseException exception= (BaseException) t;
                        BaseException exception = ExceptionFactory.create(t);
                        t.printStackTrace();
                        LogUtils.logWrite("定位:" + t.getMessage());
                    }
                });
    }

    @SuppressLint("CheckResult")
    private void OrderStatusInquiry(String sn, int i) {
        LogUtils.logWrite("调用OrderStatusInquiry");
        HashMap<String, String> params = new HashMap<>();
        params.put("sn", sn);
        PayApi.api.getOrderStatus(params).subscribeOn(Schedulers.io())
                .repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(Observable<Object> objectObservable) throws Exception {
                        return objectObservable.flatMap(new Function<Object, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(Object o) throws Exception {
                                LogUtil.d(TAG, "acceptmm 正扫 asdfaccept1:" + o + BaseConstant.SWEEP_POLL);
                                if (BaseConstant.SWEEP_POLL) {
                                    BaseConstant.SWEEP_POLL = false;
                                    LogUtil.d(TAG, "正扫轮询结束 asdfaccept1:" + o + BaseConstant.SWEEP_POLL);
                                    return Observable.error(new Throwable("轮询结束"));
                                }
                                // 加入判断条件：当轮询次数 = 5次后，就停止轮询
                                if (!BaseConstant.CANCEL_POLL) {//如果为true，不执行，如果为false,执行。
                                    BaseConstant.CANCEL_POLL = false;
                                    // 此处选择发送onError事件以结束轮询，因为可触发下游观察者的onError（）方法回调
                                    return Observable.error(new Throwable("轮询结束"));
                                }
                                // 若轮询次数＜4次，则发送1Next事件以继续轮询
                                // 注：此处加入了delay操作符，作用 = 延迟一段时间发送（此处设置 = 2s），以实现轮询间间隔设置
                                return Observable.just(1).delay(5000, TimeUnit.MILLISECONDS);
                            }
                        });
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<HttpResult<String>>() {
                    @Override
                    public void accept(HttpResult<String> stringHttpResult) throws Exception {
                        String data = stringHttpResult.getData();
                        LogUtils.logWrite("正扫支付开始" + data);
                        if ("pay".equals(data)) {
                            LogUtils.logWrite("正扫支付成功" + sn);
                            //支付成功,停止轮询，改变全局变量的状态
                            if (BaseConstant.CANCEL_POLL) {//为true
                                BaseConstant.CANCEL_POLL = false;
                                getDefault().post(new ApiMessageEvent("pay_success", "4"));
                                return;
                            }
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable t) throws Exception {
//                        LogUtils.logWrite("正扫支付error1" + data);
                        Log.d(TAG, "acceptmm: 失败了。");
                        if (t instanceof ApiException) {
                            ApiException a = (ApiException) t;
                            //后台返回
                            Log.d(TAG, "acceptmm: " + a.getErrorText());
                        } else {
                            Log.d(TAG, "acceptmm: 网络问题");
                            //没有网络的情况
//                            LogUtils.logWrite("正扫支付error1" + data);
                            int b = i + 1;
                            if (i < 2) {
                                new Handler().postDelayed(new Runnable() {
                                    @Override
                                    public void run() {
                                        OrderStatusInquiry(sn, b);
                                    }
                                }, 3000);
                            }
                        }
                    }
                });
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void event(OfflineMessageEvent messageEvent) {
        switch (messageEvent.getName()) {
            case Name.REMOTEVEND://mdb远程做糖
                break;
            case "sessioncomplete":
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        WeaverUtil.creditCardSessionComplete();
                    }
                }, Hawk.get(Name.SESSION_SUBMISSION_TIME, 5000));
                break;
            case "sessioncomplete500ms":
                Log.d(TAG, "event: sessioncomplete500ms");
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        WeaverUtil.creditCardSessionComplete();
                        getDefault().post(new OfflineMessageEvent(Name.ENDSESSION, null));

                    }
                }, 200);
                break;
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        getDefault().unregister(this);
        stopTimerAndTimerTask(timerAlarmClock, alarmClockTask);

        Log.d(TAG, "RemoteSupportServiceonDestroy: ");
    }

    public void setError1(int key, String reason, String level) {
        long currentTime = System.currentTimeMillis();
        if (currentTime - Constant.lastProcessedTime < 3000) {
            return;
        }
        Constant.lastProcessedTime = currentTime;

        if (Constant.preKey1 != key) {
            Constant.preKey1 = key;
            long date = System.currentTimeMillis();
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date curDate = new Date(date);
            String time = formatter.format(curDate);
            AddAlarmRecordBean addAlarmRecordBean = new AddAlarmRecordBean(reason, Heartbeat.deviceId, time, "", level);
//        WarringBean warringBean = new WarringBean();
//        warringBean.setTime(date);
//        warringBean.setThingError(reason);
//        getBeanDao().insert(warringBean);
            Log.d(TAG, "setError1: " + addAlarmRecordBean.toString());
            Gson gson = new Gson();
            String json = gson.toJson(addAlarmRecordBean);
            Log.d(TAG, "setError2报警: " + json);
            RequestBody body = RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8"), json);
            //上传到服务器
            if (!Constant.reasonKey.equals(reason)) {
                LogUtils.logWrite("与上一次报警不同，上传该报警");
                upError(body, 0, reason);
            }
        }
    }

    private void upError(RequestBody body, int alarmErrorNumber, String reason) {
        addSubscriptionNew(NoPayOrderStringApi.api.addAlarmRecord(body), String.class,
                new HttpResultNotActivityObserver<String>(view, BaseApplication.getContext()) {
                    @Override
                    public void onNext(String o) {
                        Log.d(TAG, "onNext报警测试1: " + o);
                        Constant.reasonKey = reason;
                        if (o != null) {
                            LogUtils.logWrite("报警了，上传报警成功"+reason);
                            Log.d("AddAlarmRecordApi3", "onNext: " + o);
                        }
                    }

                    @Override
                    public void onError(Throwable t) {
                        super.onError(t);
                        Log.d(TAG, "onNext报警测试2: " + t.getMessage());
                        if (t instanceof ApiException) {
                            ApiException a = (ApiException) t;
                            //后台返回
                            Log.d(TAG, "acceptmm: " + a.getErrorText());
                        } else {
                            new Handler().postDelayed(new Runnable() {
                                @Override
                                public void run() {
                                    //需要重新发送报警
                                    if (alarmErrorNumber >= 3) {//重试三次。
                                        return;
                                    }
                                    upError(body, alarmErrorNumber + 1, Constant.reasonKey);
                                    Log.d(TAG, "run: asdfasdfasdf");
                                    LogUtils.logWrite("报警了，但是上传失败，需要重新上传");
                                }
                            }, 1000 * 60 * 5);
                        }

                    }
                });
    }

    int sendApkVersionNumber = 1;


    private void sendApkVersion() {
        //通知到后台
        HashMap<String, String> params = new HashMap<>();
        params.put("clientId", Heartbeat.deviceId);
        params.put("apkVersion", App.app.getVersionName());
        addSubscription(NoPayOrderStringApi.api.sendApkVersion(params).compose(HttpStringResultHandler.<String>transformer()),
                new HttpResultNotActivityObserver<String>(view, BaseApplication.getContext()) {
                    @Override
                    public void onNext(String data) {
                        LogUtil.d("sendApkVersion", "onNext: " + data);
                        LogUtils.logWrite("apkVersion onnext:" + data);
                        sendApkVersionNumber = 1;
                    }

                    @Override
                    public void onError(Throwable t) {
                        super.onError(t);
                        LogUtils.logWrite("apkVersion onerro:" + t.getMessage());

                        LogUtil.d("sendApkVersion", "onerror: " + t.getMessage());
                        if (sendApkVersionNumber < 3) {
                            new Handler().postDelayed(new Runnable() {
                                @Override
                                public void run() {
                                    sendApkVersion();
                                }
                            }, 5000);
                        }
                        sendApkVersionNumber++;
                    }
                });
    }

    private void SetAnAlarm() {
        setAlarmClock();
    }

    public void setAlarmClock() {
        /**
         * 1. 用户点击添加的时候，那么我就开始设置闹钟。
         * 2. 用户点击修改的时候，那么我就开始设置闹钟。
         * 3. id作为这个序号。需要乘以10
         * 4. 增加一个选项，是否开启本地闹钟，如果开启，则使用，不开启则不管。
         */
        ArrayList<AlarmClockBean> alarmClockBeans = Hawk.get(Name.LOCAL_ALARM_CLOCK, new ArrayList<AlarmClockBean>());
        for (AlarmClockBean clockBean : alarmClockBeans) {
            //如果状态是关闭的则不要设置闹钟。
            if (clockBean.getStatus() == false) {
                continue;
            }
            int number = Integer.valueOf(clockBean.getId()) * 10;
            try {
                setAlarmClock(number, clockBean, clockBean.getType().getType() + "", number + 7);
            } catch (ParseException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public int setAlarmClock(int number, AlarmClockBean alarmClockBean, String type, int alarmNumber) throws ParseException {

        for (int i = number; i < alarmNumber; i++) {//清除所有的闹钟
            AlarmManagerUtil.cancelAlarm(BaseApplication.getContext(), AlarmManagerUtil.ALARM_ACTION, i);
        }
        ArrayList<WeekEnum> week = alarmClockBean.getWeek();

        String hour = "";
        String minute = "";
        String msg = "";
        if ("1".equals(type)) {//只有关机的才需要。
            if (Integer.valueOf(alarmClockBean.getMinute()) < 40) {//如果小于5，我们需要做好计算才行。00：00：00
                //小于5，则
                //  alarmClockBean.getHour()-1：
                //  alarmClockBean.getMinute()：4-5=-1,60-1=59,是正确的。
                if (Integer.valueOf(alarmClockBean.getHour()) < 1) {
                    hour = (Integer.valueOf(alarmClockBean.getHour()) - 1 + 24) + "";
                    Log.d(TAG, "setAlarmClock: 小于1");
                } else {
                    hour = (Integer.valueOf(alarmClockBean.getHour()) - 1) + "";
                    Log.d(TAG, "setAlarmClock: 大于1");
                }
                minute = (Integer.valueOf(alarmClockBean.getMinute()) - 40 + 60) + "";
                Log.d(TAG, "setAlarmClock: 小于52:" + minute);
            } else {
                hour = alarmClockBean.getHour();
                minute = (Integer.valueOf(alarmClockBean.getMinute()) - 40) + "";
                Log.d(TAG, "setAlarmClock: 大于51:" + minute);
            }
            Calendar now = Calendar.getInstance();
            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
            //设置时间
            Date date1 = sdf.parse(alarmClockBean.getHour() + ":" +
                    alarmClockBean.getMinute() + ":" +
                    "00");
            Log.d(TAG, "setAlarmClock: service1" + date1.toString());
            //当前时间
            Date date2 = sdf.parse(now.get(Calendar.HOUR_OF_DAY) + ":" +
                    now.get(Calendar.MINUTE) + ":" +
                    now.get(Calendar.SECOND));
            Log.d(TAG, "setAlarmClock: service2" + date2.toString());
            Log.d(TAG, "setAlarmClock: " + alarmClockBean.getMinute() + "-" + now.get(Calendar.MINUTE));

            if (date1.compareTo(date2) > 0) {
                Log.d(TAG, "Date1 时间在 Date2 之后");//没过
                long nowDate = date1.getTime();//当前时间
                long startDateTime = date2.getTime();//真实时间
                int diffSeconds = (int) ((nowDate - startDateTime) / 1000);
                Log.d(TAG, "setAlarmClock: " + diffSeconds);
                if (diffSeconds >= 2400) {
                    alarmClockBean.setHour(hour);
                    alarmClockBean.setMinute(minute);
                    msg = "hotwater";
                    LogUtils.logWrite("自动烧水7");
                    Log.d(TAG, alarmClockBean.getHour() + "setAlarmClock: 弹窗" + alarmClockBean.getMinute());
                } else {
                    //不弹窗
                    Log.d(TAG, "Date1 时间在 Date2 之前");//没过
                    Log.d(TAG, "setAlarmClock1: 不弹窗");

                }
            } else {//过了
                System.out.println("程序怎么会运行到这里?正常应该不会");
                Log.d(TAG, "setAlarmClock1: 不弹窗");

            }
        }

        //时间。
        for (int i = 0; i < week.size(); i++) {
            AlarmManagerUtil.setAlarm(
                    BaseApplication.getContext(),
                    2,
                    Integer.valueOf(alarmClockBean.getHour()),
                    Integer.valueOf(alarmClockBean.getMinute()), 0,
                    Integer.valueOf(alarmClockBean.getId()) * 10 + i,
                    week.get(i).getType(),
                    type + msg);
            Log.d(TAG, "setAlarmClock1: " + Integer.valueOf(alarmClockBean.getHour()));
            Log.d(TAG, "setAlarmClock2: " + Integer.valueOf(alarmClockBean.getMinute()));
            Log.d(TAG, "setAlarmClock3: " + week.get(0).getType());
            Log.d(TAG, "setAlarmClock4: " + (Integer.valueOf(alarmClockBean.getId()) * 1000 + i));
            Log.d(TAG, "setAlarmClock5: " + (type + msg));
        }
        number = number + week.size();//累积。
        return number;
    }

    public void stopTimerAndTimerTask(Timer timer, TimerTask task) {
        if (timer != null) {
            task.cancel();
            timer.cancel();
            task = null;
            timer = null;
        }
    }

    /**
     * 上传网络不好的时候存储在数据库的订单
     */
    public void upCoinOrder() {
        UpCoinOrderBeanDao upCoinOrderBeanDao = BaseApplication.getBaseApplication().getDaoSession().getUpCoinOrderBeanDao();
        List<UpCoinOrderBean> upCoinOrderBeans = upCoinOrderBeanDao.queryBuilder().list();
        if (upCoinOrderBeans.size() <= 0) {
            extracted(1000 * 60 * 5);
            return;
        }
        UpCoinOrderBean selectedUpCoinOrderBean = upCoinOrderBeans.get(0); // 获取第一条数据
        Gson gson = new Gson();
        String json = gson.toJson(selectedUpCoinOrderBean);
        Log.d(TAG, "upCoinOrder json: " + json);
        RequestBody body = RequestBody.create(okhttp3.MediaType.parse("application/json;charset=utf-8"), json);
        addSubscription(OrderApi.api.saveCoinOrder(body).compose(HttpResultHandler.<String>transformer()),
                new HttpResultObserver<String>(view, BaseApplication.getContext()) {
                    @Override
                    public void onNext(String o) {
                        LogUtil.d(TAG, "upCoinOrder onNextupdateSuccess: " + o);
                        upCoinOrderBeanDao.delete(selectedUpCoinOrderBean); // 删除第一条数据
                        extracted(3000);
                    }

                    @Override
                    public void onError(Throwable t) {
                        LogUtil.d(TAG, "upCoinOrder onError: " + t.getMessage());
                        super.onError(t);
                        extracted(1000 * 60 * 5);
                    }
                });
    }

    private void extracted(int delayMillis) {
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                upCoinOrder();
            }
        }, delayMillis);
    }
}