android_icecream/app/src/main/java/com/bgy/autosale/payutil/MQService.java

package com.bgy.autosale.payutil;

import static com.hboxs.base_library.base.BaseApplication.getContext;
import static com.hboxs.base_library.util.ToastUtil.showToast;

import android.annotation.SuppressLint;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.AudioManager;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.support.annotation.RequiresApi;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentTransaction;
import android.util.Log;


import com.alibaba.android.arouter.facade.annotation.Route;
import com.bgy.autosale.App;
import com.bgy.autosale.Constant;
import com.bgy.autosale.IceCreamDeviceConstants;
import com.bgy.autosale.R;
import com.bgy.autosale.RemoteSupportService;
import com.bgy.autosale.entitys.MakeIceCreamBean;
import com.bgy.autosale.helpers.CommunicationHelper;
import com.bgy.autosale.interfaces.SendCallback;
import com.bgy.autosale.ui.consumer.PaySuccessFragment;
import com.bgy.autosale.ui.operator.LockActivity;
import com.bgy.autosale.ui.MainActivity;
import com.bgy.autosale.ui.operator.fragments.ControlFragment;
import com.bgy.autosale.ui.operator.fragments.PriceFragment;
import com.bgy.autosale.utils.SPUtils;
import com.example.spunsugar.http.bean.GetAdBean;
import com.hboxs.base_library.event.ApiMessageEvent;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.hboxs.base_library.base.IView;
import com.hboxs.base_library.beans.ProductsBean;
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.http.NoPayOrderApi;
import com.hboxs.base_library.http.NoPayOrderStringApi;
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.FileUtil;
import com.hboxs.base_library.util.LogUtil;
import com.hboxs.base_library.util.LogUtils;
import com.hboxs.base_library.util.SharedPreferencesUtils;
import com.hboxs.base_library.util.ToastUtil;
import com.hboxs.base_library.util.UiUtil;
import com.orhanobut.hawk.Hawk;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

import org.greenrobot.eventbus.EventBus;

import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import io.reactivex.Observable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.observers.DisposableObserver;
import io.reactivex.schedulers.Schedulers;

@Route(path = "/module_app/mqservice")
public class MQService extends Service implements SendCallback {

    private static final String TAG = "MQService";
    ConnectionFactory factory;
    private String userName = "admin";
    private String passWord = "admin";
    private String hostName = "112.74.63.148";
    //    private String hostName = "192.168.0.184";//
    private int portNum = 5672;
    private String queueName = Heartbeat.deviceId;   //队列
    public static volatile Boolean connect = false;
    final Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            Log.d(TAG, "handleMessage: " + msg);
            getMessage(msg);
        }
    };
    public int pushNumber = 0;

    private List<PriceFragment.PriceBean> priceBeans; //保存价格
    private File file = new File(FileUtil.FILEPATH + FileUtil.getFileName());
    private File fileMkdirs = new File(FileUtil.FILEPATH);
    private SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private String date = format.format(new Date(System.currentTimeMillis()));
    private FileOutputStream mFileOutputStream;
    private boolean isSetSuccess = false;   //是否置为成功
    private boolean isRstSuccess = false;   //是否复位成功
    private NetWorkBroadCastReciver mNetWorkBroadCastReciver;
    private boolean isManualMake = false;


    @SuppressLint("NewApi")
    private void getMessage(Message msg) {

        String message = msg.getData().getString("msg");
        Gson gson = new Gson();
        Log.d(TAG, ":BJQXUserlogin getMessage: " + message);

        BaseBean baseBean = gson.fromJson(message, BaseBean.class);
        Log.d(TAG, baseBean.getKind() + ":BJQXUserlogin getMessage: " + message + baseBean);
        String kind = baseBean.getKind();
//        if (TextUtils.isEmpty(Heartbeat.managerId)) return;
        Log.d(TAG, "MQ getMessage: " + kind);
        switch (kind) {
            //显示花型
            case "updateProductsShow":
//                updateProductsShow(gson, baseBean, kind);
                break;
            case "products":
                //保存价格到本地
                savePriceData(gson, baseBean, kind);
                break;
            case "guestPwd":
//                savePas(gson, baseBean, Name.GUEST);
                break;
            case "adminPwd":
                savePas(gson, baseBean, Name.ADMIN);
                break;
            case "pay_success":
                pay(gson, baseBean, kind);
                break;
            case "statusType"://连接服务器
                statusType(gson, baseBean, kind);
                break;
            case "push":
                //更新广告
//                String json = baseBean.getKind_data();
//                if (json.equals("更新广告")) {
//                    saveAd();
//                }
                break;
            case "phone":
                //联系方式
                saveContacts(gson, baseBean, kind);
                break;
            case "pushTimeRule"://广告是按照这里来的。
                //广告规则
//                if (Hawk.get(Name.ADVERTISING_RULES, true)) {
//                    Log.d(TAG, "pushTimeRule etMessage1: ");
//                    changeAdRules(gson, baseBean, kind);
//                } else {
//                    if (pushNumber > 7) {
//                        Log.d(TAG, "pushTimeRule etMessage2: ");
//                        changeAdRules(gson, baseBean, kind);
//
//                    } else {
//                        pushNumber++;
//
//                    }
//                }
                break;
            case "machineReset":
                CommunicationHelper.getInstance().sendControl(IceCreamDeviceConstants.ORDER_RESET, this);
                break;
            case "eqeStatus":
                //远程开关机
                openOrClose(gson, baseBean, kind);
                break;
            case "block":
                //锁机
//                block(baseBean.getKind_data());
                break;
            case "is_sleep":
//                LogUtils.logWrite("远程操作休眠");
                sleep(baseBean.getKind_data());
                break;
            case "Param"://远程修改参数
//                UpdateAloneParam(baseBean.getKind_data());
//                LogUtils.logWrite("远程修改参数:" + baseBean.getKind_data());
                break;
            case "tuoji":
                //清除连接成功的数据
//                SharedPreferencesUtils.setParam(Name.CONNECT_STATE, 0);
//                Heartbeat.managerId = "";
//                SharedPreferencesUtils.setParam(Name.SYSTEM_ID, Heartbeat.managerId);
                break;
            case "log":
//                LogUtil.d(TAG, "logdata" + baseBean.getKind_data());
//                远程上传日志文件
                uploadLogApi(baseBean.getKind_data());
                break;
            case "onoffstatus":
//                Log.d(TAG, "onReceiveMessageData: onoffstatusonoffstatus");
//                updateEqeStatus((Integer) SharedPreferencesUtils.getParam("open", 0));
                break;
            case "updateBootTime":
//                LogUtil.d(TAG, "onReceiveMessageData: updateBootTime:" + baseBean.getKind_data());
//                updateOfforBootTime(baseBean, "boot");
                break;
            case "updateOffTime":
//                LogUtil.d(TAG, "onReceiveMessageData: updateOffTime:" + baseBean.getKind_data());
//                updateOfforBootTime(baseBean, "off");
                break;
            case "pay_faile":
//                todo  反扫失败，我们需要提示支付失败，请重新提供码
//                EventBus.getDefault().post(new ApiMessageEvent("pay_faile", null));
                break;
            case "eliminate":
                //todo 消除报警，并且告知后台消除报警成功。

//                if (IceCreamErrorUtils.getInstance().getErrorMessage()!=null){
//                    EventBus.getDefault().post(new ApiMessageEvent(Name.WARNING_ALARM,IceCreamErrorUtils.getInstance().getErrorMessage()));
//                }
                eliminateApi(gson, baseBean, kind);
                break;
            case "dosugar":
                //远程制作棉花糖
//                CommunicationHelper.getInstance().sendControl(IceCreamDeviceConstants.ORDER_OPERATE_CLEAN, this);
//                EventBus.getDefault().post(new ApiMessageEvent("dosugar", baseBean.getKind_data()));
                LinkedList<MakeIceCreamBean> iceCreamOrders = new LinkedList<>();
                MakeIceCreamBean detail = new MakeIceCreamBean();
                String strData = baseBean.getKind_data();
                String[] stringArray = strData.replaceAll("[\\[\\] ]", "").split(",");
                detail.makeCodes= Arrays.stream(stringArray)
                        .mapToInt(Integer::parseInt)
                        .toArray();
                iceCreamOrders.add(detail);
                Log.d(TAG, "getMessage: dosugar"+iceCreamOrders);
                CommunicationHelper.getInstance().setMakingIceCreams(iceCreamOrders);
                break;
            case "alarmClock":
                //远程星期调节闹钟
//                if (!Hawk.get(Name.ALARMCLOCK_TYPE, false)) {
//                    parseWeekTime(gson, baseBean);
//                }
                //EventBus.getDefault().post(new ApiMessageEvent("alarmClock", baseBean.getKind_data()));
                break;
            case "volume":
                String kind_data = baseBean.getKind_data();
                try {
                    int i = Integer.parseInt(kind_data);
                    if (i >= 0 && i <= 15) {
                        AudioManager am = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
                        am.setStreamVolume(AudioManager.STREAM_MUSIC, i, 0);
                        LogUtils.logWrite("MQ的音量：" + i);
                    }
                } catch (Exception e) {
                }
                break;
            case "selfName"://客户自填地址
//                PushToinform(Name.SELFNAME, baseBean.getKind_data());
                break;
            case "operational"://运营名字：联系电话。
//                PushToinform(Name.OPERATIONAL, baseBean.getKind_data());
                break;
            case "qrCodeImgUrl"://公众号图片地址：http://47.112.127.131/img/qr.jpg
//                qrCodeImgUrl(kind, baseBean.getKind_data());
                break;
            case "flowers"://远程修改花型
//                if (Global.isInProduction) {//是否支持修改，如果支持就修改。
//                    //首先判断是否支持，如果支持，直接修改plc，plc修改成功后，通知后台，通知成功后，再次进行增加花型。
//                    Log.d(TAG, "flowers getMessage: " + kind + ":" + baseBean.getKind_data());
//                    EventBus.getDefault().post(new ApiMessageEvent("flowers", baseBean.getKind_data()));
//                }
                break;
            case "payType":
                //支付方式
//                savaPayType(gson, baseBean, kind);
                break;
            case "updateLogo":
                //修改logo
                updateLogo(gson, baseBean, kind);
                EventBus.getDefault().post(new ApiMessageEvent("updateUI", "1"));
                break;
            case "updateProductsPrice"://更新价格
                getProductPrice();
                break;
            case "humidityParameters"://区间参数
//                humidityParameters(baseBean.getKind_data());
//                LogUtils.logWrite("远程参数：" + baseBean.getKind_data());
                break;
            case "buliao"://补料
//                EventBus.getDefault().post(new ApiMessageEvent("buliao", baseBean.getKind_data()));
                break;
            case "appStatusType"://获取app的状态
//                Log.d(TAG, "appStatusType getMessage: appStatusTypeappStatusTypeappStatusTypeappStatusType");
                appStatusType(gson, baseBean, kind);
                break;
            case "indoor"://远程开关内门
//                EventBus.getDefault().post(new ApiMessageEvent("indoor", baseBean.getKind_data()));
                break;
            case "outdoor"://远程开关外门
                CommunicationHelper.getInstance().sendControl(IceCreamDeviceConstants.ORDER_DOOR_CLEAR, this);
                break;
            case "youxun_pay_success":
//                pay(gson, baseBean, kind);
                break;
            case "sleepDesc":
                String hibernation = baseBean.getKind_data();
                sleepDesc(hibernation);
                break;
            case "paymentType"://修改支付方式
//                String kind_data1 = baseBean.getKind_data();
//                if (kind_data1 != null) {
//                    EventBus.getDefault().post(new ApiMessageEvent("paymentType", baseBean.getKind_data()));
//                }
                break;
            case "cardPayXCX":
//                LogUtils.logWrite("cardPayXCX:" + baseBean.getKind_data());
//                EventBus.getDefault().post(new ApiMessageEvent("cardPayXCX", baseBean.getKind_data()));
                break;
            case "updateApk":
//                EventBus.getDefault().post(new ApiMessageEvent("updateApk", baseBean.getKind_data()));
                break;
            case "refuse_success"://删除排队中的某个订单
//                EventBus.getDefault().post(new ApiMessageEvent("refuse_success", baseBean.getKind_data()));
                break;
            case "couponStatus"://  关闭优惠券识别字符串 0：关闭，1：开启
//                EventBus.getDefault().post(new ApiMessageEvent("couponStatus", baseBean.getKind_data()));
                break;
            case "restartAndroid"://重启安卓屏
                try {
                    Process proc = Runtime.getRuntime().exec(new String[]{"su", "-c", "reboot"});
                    proc.waitFor();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
                break;
            case "workingMode"://雪糕机的工作模式（0：制冷，1：搅拌，2：保鲜，3：解冻）
                String mode = baseBean.getKind_data();
                if (mode.equals("0")) {
                    LogUtils.logWrite("远程制冷");
                    CommunicationHelper.getInstance().sendControl(IceCreamDeviceConstants.ORDER_REFRIGERATION, this);
                } else if (mode.equals("1")) {
                    LogUtils.logWrite("远程搅拌");
                    CommunicationHelper.getInstance().sendControl(IceCreamDeviceConstants.ORDER_CLEAN, this);
                } else if (mode.equals("2")) {
                    LogUtils.logWrite("远程保鲜");
                    CommunicationHelper.getInstance().sendControl(IceCreamDeviceConstants.ORDER_KEEP_FRESH, this);
                } else if (mode.equals("3")) {
                    LogUtils.logWrite("远程解冻");
                    CommunicationHelper.getInstance().sendControl(IceCreamDeviceConstants.ORDER_STOP, this);
                    new Handler().postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            CommunicationHelper.getInstance().sendControl(IceCreamDeviceConstants.ORDER_THAW, MQService.this);
                        }
                    },500);
                }
                break;
            default:
                break;
        }
    }

    private boolean isManualMode() {
        return App.app.payChannel != Constant.PAY_FREE;
    }

    public void getProductPrice() {
        HashMap<String, String> params = new HashMap<>();
        params.put("clientId", Heartbeat.deviceId);
        addSubscriptionNew(NoPayOrderStringApi.api.getproducts(params), String.class,
                new HttpResultObserver<String>(view, getApplicationContext()) {
                    @Override
                    public void onNext(String result) {
                        Log.d(TAG, "getProductPrice type onNext: " + result);
                        Gson gson = new Gson();
                        List<ProductsBean> userList = gson.fromJson(result, new TypeToken<List<ProductsBean>>() {
                        }.getType());
                        if (result != null) {
                            ArrayList<PriceFragment.PriceBean> priceBeans = Hawk.get("PRICEBEAN", new ArrayList<PriceFragment.PriceBean>());
                            //取出list
                            for (ProductsBean productsBean : userList) {
                                String productName;
                                String no = productsBean.getNo();
                                if (productsBean.getName() != null && !"".equals(productsBean.getName())) {
                                    productName = productsBean.getName();
                                } else {
                                    productName = productsBean.getProductName();
                                }
                                Log.d(TAG, ":1getproducts onNext: " + productName + ":" + productsBean.getRmbPrice());
                                for (PriceFragment.PriceBean priceBean : priceBeans) {
                                    Log.d(TAG, "getNoonNext: " + priceBean.getNo() + ":" + no);
                                    if (priceBean.getNo().equals(no)) {
                                        priceBean.setPriceKey(String.valueOf(productsBean.getRmbPrice()));
                                    }
                                    if (priceBean.getChineseName().equals(productName)) {
                                        priceBean.setPriceKey(String.valueOf(productsBean.getRmbPrice()));
                                        Log.d(TAG, "PriceFragment.PriceBean onNext: " + priceBean.getNameKey() + ":" + String.valueOf(productsBean.getRmbPrice()));
                                    }
                                }
                            }
                            Hawk.put("PRICEBEAN", priceBeans);
                            for (int i = 0; i < 6; i++) {
                                SPUtils.getInstance(App.app).putString((PriceFragment.ProductAbout.priceKey[i]), priceBeans.get(i).getPriceKey());
                            }
                            EventBus.getDefault().post(new ApiMessageEvent("updateUI", 1));
                        }
                    }

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

    private void pay(Gson gson, BaseBean baseBean, String kind) {
        //支付成功
        String json = baseBean.getKind_data();
        PaySucessBean paySucessBean = gson.fromJson(json, PaySucessBean.class);
        PaySuccessConstant.sn = paySucessBean.getSn();
        PaySuccessConstant.productName = paySucessBean.getProductName();
        LogUtils.logWrite("第一步：存儲信息,支付成功");
        EventBus.getDefault().post(new ApiMessageEvent(kind, "7"));
    }

    private void cheeckConnectState(boolean isFrist) {
        int connectState = (int) SharedPreferencesUtils.getParam(Name.CONNECT_STATE, -1);
        LogUtil.d(TAG, "cheeckConnectState: 当前状态为" + connectState);
        Log.e(TAG, "cheeckConnectState: " + connectState);
        if (connectState == 2) {
            String param = (String) SharedPreferencesUtils.getParam(Name.SYSTEM_ID, "");
            Log.e(TAG, isFrist + ":cheeckConnectState:连接成功： " + connectState);
            SharedPreferencesUtils.setParam(Name.CONNECT_STATE, 2);
            Heartbeat.deviceId = FileUtil.getDeviceId();
            if (isFrist) {
                //开始心跳
                Intent intent = new Intent(this, RemoteSupportService.class);
                Bundle bundle = new Bundle();
                bundle.putInt("heartbeat", 3);
                intent.putExtras(bundle);
                startService(intent);
            }
            if (Hawk.get("show_out", null) == null ||
                    Hawk.get("showAdA", null) == null) {
                EventBus.getDefault().post(new ApiMessageEvent("rule", null));
            }

        }
    }

    private void appStatusType(Gson gson, BaseBean baseBean, String kind) {
        Log.d(TAG, "appStatusType: " + baseBean);
        String json = baseBean.getKind_data();
        Log.d(TAG, "appStatusType: " + json);
        AppStatusType appStatusType = gson.fromJson(json, AppStatusType.class);
        Log.d(TAG, "appStatusType: " + appStatusType);
        if (appStatusType.getStatus().equals("rejected")) {
            //拒绝
            showToast(UiUtil.getStringRes(R.string.rejected));
            SharedPreferencesUtils.setParam(Name.CONNECT_STATE, 0);
            Log.e(TAG, "statusType: 申请拒绝");
        } else if (appStatusType.getStatus().equals("agreed")) {
            //申请通过
            showToast(UiUtil.getStringRes(R.string.rejected1));
            SharedPreferencesUtils.setParam(Name.CONNECT_STATE, 2);
            Log.e(TAG, "statusType: 申请通过");
            SharedPreferencesUtils.setParam(Name.SYSTEM_ID, appStatusType.getManagerId());
        } else if (appStatusType.getStatus().equals("agreed1")) {
            showToast("第二次");
            showToast(UiUtil.getStringRes(R.string.rejected1));
            SharedPreferencesUtils.setParam(Name.CONNECT_STATE, 2);
            Log.e(TAG, "statusType: 申请通过");
            SharedPreferencesUtils.setParam(Name.SYSTEM_ID, appStatusType.getManagerId());
            // interService 不能弹出弹窗 在 service中弹出

        }
        EventBus.getDefault().post(new ApiMessageEvent("statusType", null));
        cheeckConnectState(true);

    }


    /**
     * 初始化回调
     *
     * @param gson
     * @param baseBean
     * @param kind
     */
    private void statusType(Gson gson, BaseBean baseBean, String kind) {
        String json = baseBean.getKind_data();
        String s = gson.fromJson(json, String.class);
        if (s.equals("rejected")) {
            //拒绝
            showToast(UiUtil.getStringRes(R.string.rejected));
            SharedPreferencesUtils.setParam(Name.CONNECT_STATE, 0);
            Log.e(TAG, "statusType: 申请拒绝");
        } else if (s.equals("agreed")) {
            //申请通过
            showToast(UiUtil.getStringRes(R.string.rejected1));
            SharedPreferencesUtils.setParam(Name.CONNECT_STATE, 2);
            Log.e(TAG, "statusType: 申请通过");
            SharedPreferencesUtils.setParam(Name.SYSTEM_ID, Heartbeat.managerId);
        } else if (s.equals("agreed1")) {
            showToast("第二次");
            showToast(UiUtil.getStringRes(R.string.rejected1));
            SharedPreferencesUtils.setParam(Name.CONNECT_STATE, 2);
            Log.e(TAG, "statusType: 申请通过");
            SharedPreferencesUtils.setParam(Name.SYSTEM_ID, Heartbeat.managerId);
            // interService 不能弹出弹窗 在 service中弹出
            EventBus.getDefault().post(new ApiMessageEvent(kind + "1", null));

        }
        EventBus.getDefault().post(new ApiMessageEvent(kind, null));
    }


    //增加一个前置条件
    private void saveAdRulesBefore(String id) {
        //如果id为1，并且这里是全屏，那么就推送235的
        if (Hawk.get(Name.DEFAULT_FULL_SCREEN, true) && "1".equals(id) && !Hawk.get(Name.PLAY_MODE, false)) {
            saveAdRules("779");
        } else {
            saveAdRules(id);
        }

    }

    /**
     * 保存广告id
     */
    private void saveAdRules(String id) {
        Long lid = Long.valueOf(id);
        Map<String, Long> params = new HashMap<>();
        params.put("id", lid);
        addSubscriptionNew(NoPayOrderStringApi.api.getTimeRule(params), String.class,
                new HttpResultNotActivityObserver<String>(view, getApplicationContext()) {

                    @Override
                    public void onNext(String s) {
                        LogUtil.d(TAG, "1ad_rules s ->" + s);
                        //保存广告规则json
                        SharedPreferencesUtils.setParam("ad_time_rule", s);
                        //广告数据
                        rule(s);
                        //发送设备id
                        getAdByEquipment(s);
                        LogUtil.d(TAG, "onNextgetAdByEquipment: ");
                    }

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

                });

    }

    int ruleNumber = 0;

    /**
     * 和旧系统不同之处
     *
     * @param s
     */
    private void rule(String s) {
        Gson gson = new Gson();
        List<String> list = gson.fromJson(s, new TypeToken<List<String>>() {
        }.getType());
        //每个id对应的时间数
        Map<String, String> adRulesMap = new HashMap<>();
        List<GetAdBean> adRulesList = new ArrayList<>();
        for (int j = 0; j < list.size(); j++) {
            //每个规则里对应的广告
            String ad = list.get(j);
            Map<String, String> params = new HashMap<>();
            params.put("id", ad);
            addSubscription(NoPayOrderApi.api.getAd(params).compose(HttpResultHandler.<String>transformer()),
                    new HttpResultNotActivityObserver<String>(view, getApplicationContext()) {
                        @Override
                        public void onNext(String s) {
                            ruleNumber++;
                            List<GetAdBean> userList = gson.fromJson(s, new TypeToken<List<GetAdBean>>() {
                            }.getType());
                            String model = Hawk.get(Name.MACHINE_TYPE, Name.SI320);
                            GetAdBean getAdBean = userList.get(0);
                            String equipmentType = getAdBean.getEquipmentType();

                            if (Global.isVersions == 2) {
                                //国外330
                                if (equipmentType.contains("en")) {//必须是国外的
                                    if (model.equals("SI320")) {
                                        if (equipmentType.equals("SI320")) {
                                            adRulesMap.put(ad, s);
                                            adRulesList.add(userList.get(0));
                                        }
                                    } else if (model.equals("SI320")) {
                                        if (equipmentType.equals("SI320")) {
                                            adRulesMap.put(ad, s);
                                            adRulesList.add(userList.get(0));
                                        }
                                    }
                                }
                            } else if (Global.isVersions == 1) {
                                if (!equipmentType.contains("en")) {//必须是国内的
                                    if (model.equals("SI320")) {
                                        if (equipmentType.equals("SI320")) {
                                            adRulesMap.put(ad, s);
                                            adRulesList.add(userList.get(0));
                                        }
                                    } else if (model.equals("SI320")) {
                                        if (equipmentType.equals("SI320")) {
                                            adRulesMap.put(ad, s);
                                            adRulesList.add(userList.get(0));
                                        }
                                    }
                                }
                            }
                            Log.d(TAG, list.size() + ":getAd onNext: " + ruleNumber + ":" + s);
                            if (ruleNumber == list.size()) {
                                Log.d(TAG, "getAd onNext: ");
                                ruleNumber = 0;
                                //说明全部请求完成
                                Hawk.put("ad_rules_map", adRulesMap);
                                Log.d(TAG, "ad_rules_map onNext: " + adRulesMap.size());
                                String s1 = gson.toJson(adRulesList);
//                                EventBus.getDefault().post(new ApiMessageEvent("DOWNKOADADCID_NEW", adRulesList));
                                Log.d(TAG, adRulesList.size() + ":getAd onNext2: " + s1);
                            }
                        }

                        @Override
                        public void onError(Throwable t) {
                            super.onError(t);
                            BaseException exception = ExceptionFactory.create(t);
                        }
                    });
        }
        //保存对应的id对应的广告规则

    }

    /**
     * 上传设备id和型号 和旧系统不同之处
     */
    int downRuleNumber = 0;

    private void getAdByEquipment(String s) {
        Gson gson = new Gson();
        List<String> list = gson.fromJson(s, new TypeToken<List<String>>() {
        }.getType());
        //每个id对应的时间数
        Map<String, String> adRulesMap = new HashMap<>();
        List<GetAdBean> adRulesList = new ArrayList<>();
        for (int j = 0; j < list.size(); j++) {
            //每个规则里对应的广告
            String ad = list.get(j);
            Map<String, String> params = new HashMap<>();
            params.put("id", ad);
            addSubscription(NoPayOrderApi.api.getAd(params).compose(HttpResultHandler.<String>transformer()),
                    new HttpResultNotActivityObserver<String>(view, getApplicationContext()) {
                        @Override
                        public void onNext(String s) {
                            downRuleNumber++;
                            List<GetAdBean> userList = gson.fromJson(s, new TypeToken<List<GetAdBean>>() {
                            }.getType());


                            String model = Hawk.get(Name.MACHINE_TYPE, Name.SI320);
                            GetAdBean getAdBean = userList.get(0);
                            String equipmentType = getAdBean.getEquipmentType();

                            if (Global.isVersions == 2) {
                                //国外330
                                if (equipmentType.contains("en")) {//必须是国外的
                                    if (model.equals("SI320")) {
                                        if (equipmentType.equals("SI320en")) {
                                            adRulesMap.put(ad, s);
                                            adRulesList.add(userList.get(0));
                                        }
                                    } else if (model.equals("SI320")) {
                                        if (equipmentType.equals("SI320en")) {
                                            adRulesMap.put(ad, s);
                                            adRulesList.add(userList.get(0));
                                        }
                                    }
                                }
                            } else if (Global.isVersions == 1) {
                                if (!equipmentType.contains("en")) {//必须是国内的
                                    if (model.equals("SI320")) {
                                        if (equipmentType.equals("SI320")) {
                                            adRulesMap.put(ad, s);
                                            adRulesList.add(userList.get(0));
                                        }
                                    } else if (model.equals("SI320")) {
                                        if (equipmentType.equals("SI320")) {
                                            adRulesMap.put(ad, s);
                                            adRulesList.add(userList.get(0));
                                        }
                                    }
                                }
                            }
                            Log.d(TAG, list.size() + ":11getAd onNext: " + downRuleNumber + ":" + s);
                            if (downRuleNumber == list.size()) {
                                Log.d(TAG, "getAd onNext: ");
                                downRuleNumber = 0;
                                //说明全部请求完成
                                Hawk.put("ad_rules_map", adRulesMap);
                                Log.d(TAG, "ad_rules_map onNext: " + adRulesMap.size());
                                String s1 = gson.toJson(adRulesList);
                                EventBus.getDefault().post(new ApiMessageEvent("DOWNKOADADCID_NEW", adRulesList));
                                Log.d(TAG, adRulesList.size() + ":11getAd onNext2: " + s1);
                            }
                        }

                        @Override
                        public void onError(Throwable t) {
                            super.onError(t);
                            BaseException exception = ExceptionFactory.create(t);
                        }
                    });
        }
    }

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

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate......");
        //连接设置
        setupConnectionFactory();
        //开启消费者线程
        //subscribe(incomingMessageHandler);
        basicConsume(1);
        mNetWorkBroadCastReciver = new NetWorkBroadCastReciver();
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
        intentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
        intentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
        intentFilter.addAction(WifiManager.RSSI_CHANGED_ACTION);
        registerReceiver(mNetWorkBroadCastReciver, intentFilter);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        unregisterReceiver(mNetWorkBroadCastReciver);
        Log.d(TAG, "MQ onDestroy: ");
    }

    /**
     * 连接设置
     */
    private void setupConnectionFactory() {
        factory = new ConnectionFactory();
        factory.setHost(hostName);
        factory.setPort(portNum);
        factory.setUsername(userName);
        factory.setPassword(passWord);
    }

    private int addTime = 0;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (intent != null) {
            Bundle extras = intent.getExtras();
            if (extras != null) {
                int first = extras.getInt("connect");
                if (first == 1) {//5分钟来一次。
                    basicConsume(6);
                }
            }
        }
        int connectState = (int) SharedPreferencesUtils.getParam(Name.CONNECT_STATE, 999);
        Log.d(TAG, "onStartCommand......" + connectState);
        if (connectState == 999) {//如果说是第一次，则表示还没有创建
            initView();
        } else {//如果说是第二次，则可以直接打开。因为已经创建出来了。
            initView1();
        }

        //消费者服务线程
        return super.onStartCommand(intent, flags, startId);
    }

    //旧方法
    private void initView() {
        String data = (String) SharedPreferencesUtils.getParam(Name.QUEUE_DATA, "");  //连接设备id
        Log.d(TAG, "data initView: " + data);
//        String updateMaterialStatus = (String) SharedPreferencesUtils.getParam(Name.SEPARATE_SUCCESS, "");  //脱离系统
        String updateMaterialStatus = (String) SharedPreferencesUtils.getParam(Name.SYSTEM_ID, "");
        if ("".equals(updateMaterialStatus)) {//因为脱离系统了，那么就清空，重新创建
            data = "";
        }
        String machineType = Hawk.get(Name.MACHINE_TYPE, Name.SI320);
        Log.d(TAG, data + ": mq getAddQueue: " + machineType);
        // SharedPreferencesUtils.setParam(Name.QUEUE_DATA, data);
        if ("".equals(Heartbeat.deviceId)) {
            //如果没有id，肯定是新机器，无创建过队列，直接 return;
            Log.d(TAG, "mq1,没有id,直接跳出");
            return;
        } else {
            Log.d(TAG, "mq1,有id的情况");
            if (data.equals("成功")) {
                //创建过队列。
                Log.d(TAG, "mq1,创建过队列，开启过线程，直接退出");
                return;
            } else {
                if (addTime > 0) {
                    return;
                } else {
                    Log.d(TAG, "mq1,没有创建过队列，没有开启过线程，现在开始创建和开启");
                    getAddQueue();  //创建mq
                    getChannel();   //修改通道
                }
            }

        }
        Log.d(TAG, "mq,这里都会执行");
        //开启消费者线程
        //subscribe(incomingMessageHandler);
        if (!connect) {
            basicConsume(2);
        }
    }

    private void initView1() {
        String data = (String) SharedPreferencesUtils.getParam(Name.QUEUE_DATA, "");  //连接设备id
        Log.d(TAG, "1data initView: " + data);
//        String updateMaterialStatus = (String) SharedPreferencesUtils.getParam(Name.SEPARATE_SUCCESS, "");  //脱离系统
        String updateMaterialStatus = (String) SharedPreferencesUtils.getParam(Name.SYSTEM_ID, "");
//        if ("".equals(updateMaterialStatus)) {//因为脱离系统了，那么就清空，重新创建
//            data = "";
//        }
        String machineType = Hawk.get(Name.MACHINE_TYPE, Name.SI320);
        Log.d(TAG, data + ": mq getAddQueue: " + machineType);
        // SharedPreferencesUtils.setParam(Name.QUEUE_DATA, data);
        if ("".equals(FileUtil.getDeviceId1())) {
            //如果没有id，肯定是新机器，无创建过队列，直接 return;
            Log.d(TAG, "mq,没有id,直接跳出");
            return;
        } else {
            Log.d(TAG, "mq,有id的情况");
            if (data.equals("成功")) {
                //创建过队列。
                Log.d(TAG, "mq,创建过队列，开启过线程，直接退出");
                return;
            } else {
                if (addTime > 0) {
                    return;
                } else {
                    Log.d(TAG, "mq,没有创建过队列，没有开启过线程，现在开始创建和开启" + Heartbeat.deviceId);
                    getAddQueue();  //创建mq
                    getChannel();   //修改通道
                }
            }

        }
        Log.d(TAG, "mq,这里都会执行");
        //开启消费者线程
        //subscribe(incomingMessageHandler);
        if (!connect) {
            basicConsume(2);
        }
    }

    private int networkState = 100;

    //接收网络状态改变的广播
    public class NetWorkBroadCastReciver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            isNetConnected(context);
            Log.d(TAG, "NetWorkBroadCastReciver: ");
        }
    }

    public boolean isNetConnected(Context context) {
        ConnectivityManager connectivity = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        Log.d(TAG, "isNetConnected0: ");
        if (connectivity != null) {
            Log.d(TAG, "isNetConnected1: ");
            NetworkInfo info = connectivity.getActiveNetworkInfo();
            if (info != null) {
                Log.d(TAG, "isNetConnected2: ");
                if (info.getType() == networkState) {
                    return false;
                }
                networkState = info.getType();
                if (info.getType() == (ConnectivityManager.TYPE_WIFI)) {
                    if (!connect) {
                        Log.d(TAG, "isNetConnectedTYPE_WIFI: 执行了一次。");
                        basicConsume(3);
                    }
                    LogUtil.d("type1RemoteSupportService", "TYPE_WIFI: ");
                    return true;
                } else if (info.getType() == (ConnectivityManager.TYPE_MOBILE)) {
                    if (!connect) {
                        Log.d(TAG, "isNetConnectedTYPE_MOBILE: 执行了一次。");
                        basicConsume(4);
                    }
                    LogUtil.d("type1RemoteSupportService", "TYPE_MOBILE: ");
                    return true;
                } else if (info.getType() == (ConnectivityManager.TYPE_ETHERNET)) {
                    Log.d(TAG, "isNetConnected3: ");
                    if (!connect) {
                        Log.d(TAG, "isNetConnected4: ");
                        LogUtil.d("type1RemoteSupportService", "TYPE_ETHERNET: ");
                        basicConsume(7);
                    }
                    return true;
                }
            }
        }
        LogUtil.d("type1RemoteSupportService", "TYPE_NONE: ");
        return false;
    }

    /**
     * 收消息（从发布者那边订阅消息）
     */
    private void basicConsume(int id) {
        Log.d(TAG, "basicConsume: " + id);
        new Thread(new Runnable() {
            @Override
            public void run() {
                if (connect != true) {
                    synchronized (handler) {
                        if (connect != true) {
                            int connectState = (int) SharedPreferencesUtils.getParam(Name.CONNECT_STATE, 999);
                            if (connectState == 999) {
                                queueName = Heartbeat.deviceId;
                                LogUtils.logWrite("测试MQ1是不是为空" + Heartbeat.deviceId);
                            } else {
                                queueName = FileUtil.getDeviceId1();
                                LogUtils.logWrite("测试MQ2是不是为空" + FileUtil.getDeviceId1());
                            }
                            try {
                                //连接
                                Connection connection = factory.newConnection();
                                //通道
                                final Channel channel = connection.createChannel();
                                Log.d(TAG, "mqrun: 4" + queueName);
                                //实现Consumer的最简单方法是将便捷类DefaultConsumer子类化。可以在basicConsume 调用上传递此子类的对象以设置订阅：
                                channel.basicConsume(queueName, false, new DefaultConsumer(channel) {
                                    @Override
                                    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                                        super.handleDelivery(consumerTag, envelope, properties, body);
                                        Log.d(TAG, "mqrun: 5");
                                        String msg = new String(body, "utf-8");
                                        Log.d(TAG, "msg->" + msg);
                                        long deliveryTag = envelope.getDeliveryTag();


                                        Log.d(TAG, "deliveryTag->" + deliveryTag);
                                        channel.basicAck(deliveryTag, false);
//                    从message池中获取msg对象更高效
                                        Message uimsg = handler.obtainMessage();
                                        Bundle bundle = new Bundle();
                                        bundle.putString("msg", msg);
                                        uimsg.setData(bundle);
                                        handler.sendMessage(uimsg);
                                    }
                                });
                                connect = true;
                                Log.d(TAG, "basicConsume run: " + connect);
                                LogUtils.logWrite("mq连接成功");
                            } catch (Exception e) {
                                networkState = 100;
                                e.printStackTrace();
                                LogUtils.logWrite("mq连接失败" + netConnectedNumber + "次");
                                new Thread(new Runnable() {
                                    @Override
                                    public void run() {
                                        while (netConnectedNumber < 10) { // 当重连次数小于10时执行循环
                                            try {
                                                Log.d(TAG, "isNetConnected7: " + netConnectedNumber);
                                                Thread.sleep(10000); // 等待10秒后再次执行
                                                isNetConnected(getApplicationContext());
                                                netConnectedNumber++; // 增加重连次数
                                                Log.d(TAG, "isNetConnected8: ");
                                            } catch (InterruptedException e) {
                                                e.printStackTrace();
                                            }
                                        }
                                    }
                                }).start();
                                Log.d(TAG, "mqrun basicConsume: IOException");
                                Log.d(TAG, "mqrun basicConsume: IOException" + e.getMessage());
                            }
                        }
                    }
                }
            }
        }).start();
    }

    private int netConnectedNumber = 0;

    //获取mq中的相关信息
    private void getAddQueue() {
        addTime = 1;
        Map<String, Object> params = new HashMap<>();
        Log.d(TAG, "Heartbeat.deviceId-->" + Heartbeat.deviceId);
        String machineType = Hawk.get(Name.MACHINE_TYPE, Name.SI320);
        params.put("exchange", machineType);  //交换机的名称，机型
        params.put("queue", Heartbeat.deviceId);  //队列的名称，机器的设备编码
        params.put("routingKey", Heartbeat.deviceId);  //队列的key，机器的设备编码
        params.put("durable", true);  //队列的key，机器的设备编码
        Log.d(TAG, Heartbeat.deviceId + ": mq getAddQueue: " + machineType);
        addSubscriptionNew(NoPayOrderStringApi.api.addQueue(params), String.class,
                new HttpResultNotActivityObserver<String>(view, getApplicationContext()) {
                    @Override
                    public void onNext(String data) {
                        SharedPreferencesUtils.setParam(Name.QUEUE_DATA, data);
                        Log.d(TAG, "getAddQueue发送成功mqservice" + data);
                    }

                    @Override
                    public void onError(Throwable t) {
                        super.onError(t);
                        Log.d(TAG, "getAddQueue发送失败onError: " + t.getMessage());
                    }
                });
    }

    /**
     * 修改通道
     */
    private void getChannel() {
        addTime = 1;
        Map<String, Object> params = new HashMap<>();
        params.put("clientId", Heartbeat.deviceId);  //设备编号
        params.put("type", "2");  //type：信道的方式：1：个推，2：Mq ，默认是2
        addSubscriptionNew(NoPayOrderStringApi.api.updateChannel(params), String.class,
                new HttpResultNotActivityObserver<String>(view, getApplicationContext()) {
                    @Override
                    public void onNext(String data) {
                        SharedPreferencesUtils.setParam(Name.CHANNEL_DATA, data);
                        Log.d(TAG, "getChannel发送成功mqservice修改通道" + data);
                    }

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

    /**
     * 远程上传日志文件
     *
     * @param kindData
     */
    public void uploadLogApi(String kindData) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                File file = new File("/storage/emulated/0/logdata/" + kindData + ".txt");
                LogUtil.d(TAG, "uploadLogApi: " + kindData);
                if (file.exists()) {
                    if (file.isFile()) {
                        DataInputStream in = null;
                        OutputStream out = null;
                        HttpURLConnection conn = null;
                        InputStream ins = null;
                        ByteArrayOutputStream outStream = null;
                        try {
                            URL url = new URL(BaseConstant.ONLINE_BASE_URL + "/api/app_equipment/index/sendLog.htm?fileName=" + kindData);

                            conn = (HttpURLConnection) url.openConnection();
                            // 发送POST请求必须设置如下两行
                            conn.setDoOutput(true);
                            conn.setUseCaches(false);
                            conn.setRequestMethod("POST");
                            conn.setRequestProperty("Content-Type", "text/html");
                            conn.setRequestProperty("Cache-Control", "no-cache");
                            conn.setRequestProperty("Charsert", "UTF-8");
                            conn.connect();
                            conn.setConnectTimeout(10000);
                            out = conn.getOutputStream();
//            sb.append("Content-Disposition: form-data;  fileName=\""
//                    + file.getName() + "\"" + LINE_END);
//            sb.append("Content-Type: text/plain;");
//            sb.append(LINE_END);
//            out.write(sb.toString().getBytes());
                            in = new DataInputStream(new FileInputStream(file));

                            int bytes = 0;
                            byte[] buffer = new byte[1024];
                            while ((bytes = in.read(buffer)) != -1) {
                                out.write(buffer, 0, bytes);
                            }

                            out.flush();

                            // 返回流
                            if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
                                ins = conn.getInputStream();
                                outStream = new ByteArrayOutputStream();
                                byte[] data = new byte[1024];
                                int count = -1;
                                while ((count = ins.read(data, 0, 1024)) != -1) {
                                    outStream.write(data, 0, count);
                                    LogUtil.d(TAG, "uploadLogApi: " + new String(data));
                                }

                            } else {
                                LogUtil.d(TAG, "uploadLogApi: " + conn.getResponseCode());
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                            Log.d(TAG, "uploadLogApi: " + e.toString());
                            Log.d(TAG, "uploadLogApi: " + e.getLocalizedMessage());
                        } finally {
                            if (in != null) {
                                try {
                                    in.close();
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                            if (out != null) {
                                try {
                                    out.close();
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                            if (ins != null) {
                                try {
                                    ins.close();
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                            if (outStream != null) {
                                try {
                                    outStream.close();
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                            if (conn != null) {
                                conn.disconnect();
                            }
                        }
                    }
                }
            }
        }).start();
    }

    private void savePriceData(Gson gson, BaseBean baseBean, String kind) {
        if (kind.equals("products")) {
            priceBeans = new ArrayList<>();
            String kind_data = baseBean.getKind_data();
            Log.d(TAG, "savePriceData: " + kind_data);
            ArrayList<ProductBean> list = gson.fromJson(kind_data, new TypeToken<List<ProductBean>>() {
            }.getType());
            for (int i = 0; i < list.size(); i++) {
                ProductBean productBean = list.get(i);
                PriceFragment.PriceBean priceBean = new PriceFragment.PriceBean();
                priceBean.setPriceDefault(String.valueOf(productBean.getRmbPrice()));
                priceBean.setChineseName(PriceFragment.ProductAbout.chineseName[i]);
                priceBean.setTitle(PriceFragment.ProductAbout.title[i]);
                priceBean.setDefaultName(getString(PriceFragment.ProductAbout.defaultName[i]));
                priceBeans.add(priceBean);
                Log.d(TAG, "savePriceData: " + priceBean);

            }
            //保存价格到本地
            Hawk.put("PRICEBEAN", priceBeans);
            //通知刷新界面
            EventBus.getDefault().post(new ApiMessageEvent(kind, null));
        }
    }

    private CompositeDisposable mDisposables;
    private IView view;

    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);
    }

    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);
    }

    @Override
    public void callBack(boolean ok, int[] result) {
        AndroidSchedulers.mainThread().scheduleDirect(new Runnable() {
            @Override
            public void run() {
                showToast(ok ? App.app.getString(R.string.setting_plc_send_success) : App.app.getString(R.string.setting_plc_send_fail));
            }
        });
    }

    private void updateLogo(Gson gson, BaseBean baseBean, String kind) {
        String s = baseBean.getKind_data();
        Log.d(TAG, "updateLogo: " + s);
//        if ("1".equals(s) || "2".equals(s) || "3".equals(s) || "4".equals(s) ||
//                "5".equals(s) || "6".equals(s) || "7".equals(s) || "8".equals(s)||
//                "9".equals(s)|| "10".equals(s)|| "11".equals(s)|| "12".equals(s)|| "14".equals(s)) {
        if ("SUNZ".equals(s) || "7770".equals(s) || "8647".equals(s) || "7264".equals(s) || "1932".equals(s) ||
                "2381".equals(s) || "0291".equals(s) || "1313".equals(s) || "3103".equals(s) ||
                "4873".equals(s) || "5291".equals(s) || "9284".equals(s) || "2222".equals(s)
                || "3212".equals(s) || "3535".equals(s) || "1921".equals(s) || "3624".equals(s)
                || "2019".equals(s) || "7391".equals(s) || "0924".equals(s) || "9427".equals(s) || "0735".equals(s)
                || "5769".equals(s) || "6894".equals(s) || "8123".equals(s) || "5217".equals(s) || "6431".equals(s)
                || "7777".equals(s) || "8080".equals(s) || "6702".equals(s) || "7772".equals(s) || "7761".equals(s)
                || "7773".equals(s) || "7774".equals(s) || "7786".equals(s) || "7775".equals(s)|| "7754".equals(s)) {
            Hawk.put("logo", s);
            Hawk.get("logo", "7777");
        }
    }

    /**
     * 远程开关机
     *
     * @param gson
     * @param baseBean
     * @param kind
     */
    private void openOrClose(Gson gson, BaseBean baseBean, String kind) {
        String kind_data = baseBean.getKind_data();
        Log.d(TAG, "openOrClose: " + baseBean);
        if ((int) SharedPreferencesUtils.getParam(Name.toComplete, 0) == 1) {
            Global.isSave = true;
        }
        if (kind_data.equals("0")) {
            CommunicationHelper.getInstance().sendControl(IceCreamDeviceConstants.ORDER_CUT_DOWN, this);
        } else if (kind_data.equals("1")) {
            CommunicationHelper.getInstance().sendControl(IceCreamDeviceConstants.ORDER_CUT_DOWN, this);
        }
    }

    private void sleep(String baseBean) {
        if (baseBean.equals("1")) {
            //睡眠
            Intent intent = new Intent(this, LockActivity.class);
            intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
            startActivity(intent);
        } else {
            SharedPreferencesUtils.setParam("sleep", 1);
            Intent intent = new Intent(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) {

                        }

                        @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) {

                                }

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

                                }
                            });
                }
                SharedPreferencesUtils.setParam("block_state", false);

            }
        }, 1000 * 10);
    }

    private void sleepDesc(String hibernation) {
        if (hibernation != null && !"".equals(hibernation)) {
            Hawk.put(Name.HIBERNATION, hibernation);
        } else {
            Hawk.put(Name.HIBERNATION, "");
        }
        EventBus.getDefault().post(new ApiMessageEvent("sleepDesc", null));
    }

    private void saveContacts(Gson gson, BaseBean baseBean, String kind) {
        String json = baseBean.getKind_data();
        Log.e(TAG, "saveContacts:json= " + json);
        Log.e(TAG, "saveContacts:  " + json.contains(":"));

        if (json.contains(":")) {
            //获取：后的数据(广告规则id)
            String contactsWay = json.substring(json.lastIndexOf(":") + 1, json.length());
            Log.e(TAG, "saveContacts: 联系方式=" + contactsWay);
            //去掉：的值
            String contactsName = json.substring(0, json.lastIndexOf(":"));
            Log.e(TAG, "saveContacts: 联系人=" + contactsName);
            Hawk.put(Name.CONTACTS_NUM, contactsName);
            Hawk.put(Name.CONTACTS_NAME, contactsWay);
            EventBus.getDefault().post(new ApiMessageEvent(kind, null));
        }
    }

    private void savePas(Gson gson, BaseBean baseBean, String type) {
        String json = baseBean.getKind_data();
        String s = gson.fromJson(json, String.class);
        SPUtils.getInstance(this).putString(Constant.SHARE_PREFERENCE_MANAGER_PWD, s);
    }

    /**
     * 上传服务器发送过来的报警id
     */
    private void eliminateApi(Gson gson, BaseBean baseBean, String kind) {
        String json = baseBean.getKind_data();
        EliminateBean eliminateApi = gson.fromJson(json, EliminateBean.class);
        EventBus.getDefault().post(new ApiMessageEvent("eliminate", eliminateApi.getId()));

    }
}