yiliangyiyun-app/websocket_sdk.js

import packetCode from './PacketCodeC.js'
import store from './store/index.js'
import * as config from './config'
export default class Websocket {
    constructor({
        heartCheck,
        isReconnection
    }) {
        // 是否连接
        this._isLogin = false;
        // 当前网络状态
        this._netWork = true;
        // 是否人为退出
        this._isClosed = false;
        // 心跳检测频率
        this._timeout = 3000;
        this._timeoutObj = null;
        // 当前重连次数
        this._connectNum = 0;
        // 心跳检测和断线重连开关，true为启用，false为关闭
        this._heartCheck = heartCheck;
        this._isReconnection = isReconnection;
		this._showLoginDialog = true
        // this._onSocketOpened();
    }
    // 心跳重置
    _reset() {
        clearTimeout(this._timeoutObj);
        return this;
    }
    // 心跳开始
    _start(options) {
        let _this = this;
        this._timeoutObj = setInterval(() => {
            //发送心跳
            _this.sendHeartbeatData(options);
			_this.getTips()
			_this.getInfo()
        }, this._timeout);
    }
    // 监听websocket连接关闭
    onSocketClosed(options) {
		uni.onSocketError(err => {
			console.log('当前websocket连接已关闭,错误信息为:' + JSON.stringify(err));
			// 停止心跳连接
			if (this._heartCheck) {
			    this._reset();
			}
			// 关闭已登录开关
			this._isLogin = false;
			// 检测是否是用户自己退出小程序
			console.log('------------------开启重连--------------------------------')
			if (!this._isClosed) {
			    // 进行重连
			    if (this._isReconnection) {
			        this._reConnect(options)
			    }
			}
			
		})
        uni.onSocketClose(err => {
        })
    }
    // 检测网络变化
    onNetworkChange(options) {
        uni.onNetworkStatusChange(res => {
            console.log('当前网络状态:' + res.isConnected);
            if (!this._netWork) {
                this._isLogin = false;
                // 进行重连
                if (this._isReconnection) {
                    this._reConnect(options)
                }
            }
        })
    }
    _onSocketOpened(options) {
        uni.onSocketOpen(res => {
            console.log('【websocket】已打开');
            // 打开已登录开关
            this._isLogin = true;
            // 发送心跳
            if (this._heartCheck) {
                this._reset()._start(options);
            }
            // 发送登录信息
            this.sendLoginData();
            // 打开网络开关
            this._netWork = true;
        })
    }
    // 接收服务器返回的消息
    onReceivedMsg(callBack) {
        uni.onSocketMessage(event => {
            if (typeof callBack == "function") {
                callBack(event)
            } else {
                console.log('参数的类型必须为函数')
            }
        })
    }

    // 建立websocket连接
    initWebSocket(options) {
        let _this = this;
        if (this._isLogin) {
            console.log("您已经登录了");
        } else {
            // 检查网络
            uni.getNetworkType({
                success(result) {
                    if (result.networkType != 'none') {
                        // 开始建立连接
                        console.log('建立websocket连接' + options.url);
                        uni.connectSocket({
                            url: options.url,
                            success(res) {
                                if (typeof options.success == "function") {
                                    options.success(res)
                                    _this._onSocketOpened(options);
                                } else {
                                    console.log('参数的类型必须为函数')
                                }
                            },
                            fail(err) {
                                if (typeof options.fail == "function") {
                                    options.fail(err)
                                } else {
                                    console.log('参数的类型必须为函数')
                                }
                            }
                        })
                    } else {
                        console.log('网络已断开');
                        _this._netWork = false;
                        // 网络断开后显示model
                        uni.showModal({
                            title: '网络错误',
                            content: '请重新打开网络',
                            showCancel: false,
                            success: function(res) {
                                if (res.confirm) {
                                    console.log('用户点击确定')
                                }
                            }
                        })
                    }
                }
            })
        }
    }
    // 发送websocket消息
    sendWebSocketMsg(options) {
        this.sendBinary(1,options);
    }

    //发送心跳连接
    sendHeartbeatData(options) {
		var that = this
		let packet = {
		  version: 1,
		  command: 17,
		  token: store.state.userData.token
		}
		this.sendBinary(99, {
		    data: packet,
		    success(res) {
		      // console.log('【websocket】心跳连接成功');
			  if(!that._showLoginDialog){
				  that._showLoginDialog= true
			  }
		    },
		    fail(err) {
		        console.log('【websocket】心跳连接失败');
		        console.log(err)
		        console.log('this._showLoginDialog',that._showLoginDialog )
				uni.hideLoading()
				that._isLogin = false
				that._reConnect(options)
		    }
		});
		
		
    }
	//发送第一次连接数据
    sendLoginData() {
        this.sendBinary(99, {
            data: {},
            success(res) {
                console.log('【websocket】第一次连接成功')
            },
            fail(err) {
                console.log('【websocket】第一次连接失败')
                console.log(err)
            }
        });
        // this.sendBinary(99, {});
        // socket.sendSocketMessage({
        //  // 这里是第一次建立连接所发送的信息，应由前后端商量后决定
        //  data: JSON.stringify({
        //      "key": 'value'
        //  })
        // })
    }

    // 重连方法，会根据时间频率越来越慢
    _reConnect(options) {
        let timer, _this = this;
        if (this._connectNum < 20) {
            timer = setTimeout(() => {
                this.initWebSocket(options)
            }, 500)
            this._connectNum += 1;
        } else if (this._connectNum < 50) {
            timer = setTimeout(() => {
                this.initWebSocket(options)
            }, 1000)
            this._connectNum += 1;
        } else {
            timer = setTimeout(() => {
                this.initWebSocket(options)
            }, 3000)
            this._connectNum += 1;
        }
    }
    // 关闭websocket连接
    closeWebSocket() {
        uni.closeSocket();
        this._isClosed = true;
    }

    //发送二进制
    sendBinary(commendType, options) {
        uni.sendSocketMessage({
            data: packetCode.encode(options.data),
            success(res) {
                if (typeof options.success == "function") {
                    options.success(res)
                } else {
                    console.log('参数的类型必须为函数')
                }
            },
            fail(err) {
                if (typeof options.fail == "function") {
                    options.fail(err)
                } else {
                    console.log('参数的类型必须为函数')
                }
            }
        });
    }
	getTips(){
		return new Promise(resolve => {
			let baseUrl = config.def().baseUrl
			let baseUrlNew = config.def().baseUrlNew
			var userInfo
			if (!userInfo || !userInfo.accessToken) {
				userInfo = uni.getStorageSync('userInfo')
			}
			var pcUserInfo=uni.getStorageSync('pcUserInfo')
			if(!pcUserInfo){
				uni.request({
					url: baseUrlNew + '/auth/api/loginEnhanced',
					data: {
						companyName: "佳屹农",
						password: "y123456",
						username: "jyn"
					},
					method: 'POST',
					success: (res) => {						
						if (res.statusCode === 200) {
							uni.setStorageSync('pcUserInfo', res.data)
						}
					}
				})
			}
			let accessToken = userInfo ? userInfo.accessToken : ''
			var data = {}
			var _mt = 'getTips'
			var _gp = 'integral'
			uni.request({
				url: baseUrl + '/m.api',
				data: {
					...data,
					_gp,
					_mt
				},
				method: 'POST',
				header: {
					'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
					'ACCESSTOKEN': accessToken
				},
				success: (res) => {						
					if (res.statusCode === 200) {
						let name = 'myTip';
						let value = res.data.data.myTips;
						store.commit('$uStore', {
							name,
							value
						});
						name = 'taskTip';
						value = res.data.data.task;
						store.commit('$uStore', {
							name,
							value
						});
						name = 'contractTip';
						value = res.data.data.contract;
						store.commit('$uStore', {
							name,
							value
						});
					}
				}
			})
		})
	}
	getInfo(){
		return new Promise(resolve => {
			var hour = new Date().getHours();
			if((hour >= 9 && hour < 12) ||(hour >= 13 && hour < 15)){
				var infoList = [];
				uni.request({
				    url: "https://hq.sinajs.cn/list=C0,C2109,C2111,C2201,C2203,C2205,C2207,A0,A2109,A2111,A2201,A2203,A2205,A2207",
				    // url: "https://hq.sinajs.cn/list=C2109",
				    header: {
				        'content-type': 'application/x-www-form-urlencoded'
				    },
				    success: function(result) {
				        // resolve调用后，即可传递到调用方使用then或者async+await同步方式进行处理逻辑
						var tmp = result.data.split('"')
						for(var i = 1; i<tmp.length;i=i+2){
							var list = tmp[i].split(",")
							var data = {
								goodsName:list[0],
								newPrice:list[6],
								openPrice:list[2]
							}
							if(data.goodsName){
								infoList.push(data)
							}
						}
						let name = 'infoList';
						let value = infoList;
						store.commit('$uStore', {
							name,
							value
						});
						// console.log("infoList",infoList)
				    },
				    fail: function(e) {
				        console.log('error in...')
				        // reject调用后，即可传递到调用方使用catch或者async+await同步方式进行处理逻辑
				        reject(e)
				    },
				})
			}
		})
	}
}