WatcherWebService2

package com.omniteaching.otscale.system.webservices.Watcher;

import com.google.gson.Gson;
import com.omniteaching.otscale.model.webservices.PRecord;
import com.omniteaching.otscale.model.webservices.WebServicesRespone;
import com.omniteaching.otscale.utils.Globals;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.LinkedBlockingDeque;

/**
 * Created by OMS on 2016/12/19.
 */

public class WatcherWebService extends WatcherScaleWebService
{
    private static final String DEAFULT_TOKEN = "md5(omsiden16)"; // 获取物料token
    private String WatcherID;
    private static final String Method_WatcherRecord = "WatcherRecord";
    public static final int STATE_SUCCESS = 1; // 成功
    public static final int STATE_Fail = 0; // 失败
    private boolean isRecevice = true;
    private WebThread mWebThread;
    private int timeOut = 0;
    private boolean frist;
    private static final int zero = 0;
    private boolean send = true;
    private LinkedBlockingDeque<PRecord> sendMsgQuene;

    private interface WatcherLinkStateListen
    {
        void successful(String guid, WatcherWebService watcherWebService);

        void failure(String guid, WatcherWebService watcherWebService);

        void onException(String guid, WatcherWebService watcherWebService, String exception);
    }

    private WatcherLinkStateListen mLinkStateListen;
    private WatcherReceiveListen mWatcherReceiveListen;

    public WatcherWebService(String guid)
    {
        WatcherID = guid;
        closeWebThread();
        send = true;
        if(sendMsgQuene==null)
        {
        sendMsgQuene = new LinkedBlockingDeque<PRecord>();
        }
        if(mWebThread==null)
        {
            mWebThread = new WebThread();
        }

        if(!mWebThread.isAlive())
        {
            mWebThread.start();
        }
    }

    /**
     * 呼叫启动WebServer
     *
     * @param Record
     */
    private void callRecord(PRecord Record, String watcherID)
    {
        Gson gson = new Gson();
        String jsonRecord = gson.toJson(Record);
        Globals.log("2 sendDataWebThread sendWatcherWebService ", "发送数据->jsonRecord : " + jsonRecord);
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("pToken", DEAFULT_TOKEN);
        params.put("pRecord", jsonRecord);

        try
        {
            WebServicesRespone respone = (WebServicesRespone) callServer(Method_WatcherRecord, params);
//            String szData = (String) decodeRespone(respone.getValue());
              String szData = respone.getValue().toString();
            Globals.log("3 sendDataWebThread sendWatcherWebService-> ", "发送数据-> szData " + szData);
            // 有内容
            if (!NULL_CONTENT.equals(szData))
            {
                Integer i = Integer.valueOf(szData);
                switch (i)
                {
                    case STATE_SUCCESS:
                        Globals.log("4 sendDataWebThread sendWatcherWebService-> ", "发送成功-> szData " + szData);
                        if (mLinkStateListen != null)
                            mLinkStateListen.successful(watcherID, this);
                        break;

                    case STATE_Fail:
                        if (mLinkStateListen != null)
                            mLinkStateListen.failure(watcherID, this);
                        break;
                }
                return;
            }
            if (mLinkStateListen != null)
                mLinkStateListen.failure(watcherID, this);
        } catch (Exception e)
        {
            e.printStackTrace();
            if (mLinkStateListen != null)
                mLinkStateListen.onException(watcherID, this, e.getMessage());
        }
    }

    public String getWatcherID()
    {
        return WatcherID;
    }

    public void setWatcherID(String watcherID)
    {
        WatcherID = watcherID;
    }

    /**
     * 内部监听器回调
     *
     * @param linkStateListen
     */
    private synchronized void setLinkStateListen(WatcherLinkStateListen linkStateListen)
    {
        mLinkStateListen = linkStateListen;
    }

    private class WebThread extends Thread
    {
        private PRecord mRecord;
        private String mWatcherID;

        private WebThread(PRecord Record, String watcherID)
        {
            mRecord = Record;
            mWatcherID = watcherID;
        }
        private WebThread()
        {
            if(!this.isAlive())
            {
                this.start();
            }

        }

        @Override
        public void run()
        {
            super.run();
            setLinkStateListen(new WatcherLinkStateListen()
            {
                @Override
                public void successful(String guid, WatcherWebService watcherWebService)
                {
                    timeOut = 0;
                    if (mWatcherReceiveListen != null)
                        mWatcherReceiveListen.successful(guid, watcherWebService);
                    Globals.log("5 sendWatcherWebService-> ", "发送数据-> guid:  " + guid);
                }

                @Override
                public void failure(String guid, WatcherWebService watcherWebService)
                {

                    timeOut = 0;
                    if (mWatcherReceiveListen != null)
                        mWatcherReceiveListen.failure(guid, watcherWebService);
                    Globals.log("失败 sendWatcherWebService-> 发送数据->", "");
                }

                @Override
                public void onException(String guid, WatcherWebService watcherWebService, String exception)
                {
                    timeOut = 0;
                    Globals.log("sendDataWebThread sendWatcherWebService-> 发送数据-> 错误 ：", exception);
                    if (mWatcherReceiveListen != null)
                        mWatcherReceiveListen.onException(guid, watcherWebService, exception);

                }
            });
                while (send)
                {
                    try
                    {
                        PRecord take = sendMsgQuene.take();
//                        setRecevice(false,8);
                        callRecord(take, take.getWatcherID());
                    } catch (InterruptedException e)
                    {
                        closeWebThread();
                        e.printStackTrace();
                        return;
                    }
                }
        }
    }

    public void sendDataWebThread(PRecord Record, String watcherID)
    {
        send = true;
        if (isRecevice())
        {
            Globals.log("11 sendWatcherWebService-> ", "sendDataWebThread watcherID : " );
            try
            {
                sendMsgQuene.put(Record);
                setRecevice(false,9);
            } catch (InterruptedException e)
            {
                Globals.log("异常 11 sendWatcherWebService-> ", "sendDataWebThread watcherID : " );
                e.printStackTrace();
            }
//            getBytesToHexString(msg);
        }
    }

    public void closeWebThread()
    {
        Globals.log("closeWebThread sendDataWebThread ");
        send = false;
        if (mWebThread != null)
        {
            mWebThread.interrupt();
            mWebThread = null;
            if (mLinkStateListen != null)
                setLinkStateListen(null);
//            setFrist(true);
        }
            setRecevice(true,1);
        if (sendMsgQuene!=null)
        {
            sendMsgQuene.clear();
            sendMsgQuene = null;
        }
    }

    /**
     * 设置连接监听回调
     *
     * @param watcherReceiveListen
     */
    public void setWatcherReceiveListen(WatcherReceiveListen watcherReceiveListen)
    {
        mWatcherReceiveListen = watcherReceiveListen;
    }


    public  boolean isRecevice()
    {
        return isRecevice;
    }

    public synchronized void setRecevice(boolean flag, int a)
    {
        Globals.log("sendDataWebThread OMSwatcher setRecevice : ", "" + flag + " a : " + a);
        isRecevice = flag;
    }

}