微信小游戏子域API简单封装

直接上代码，注释中有使用方法。

/*
onLoad :function() {//组件加载的时候，初始化
    let _window = null;
    if (typeof window === 'undefined') {
        _window = GameGlobal;
    }else{
        _window = window;
    }
    if (!_window.WxUtils){
        _window.WxUtils = require("WxUtils");
    }
    WxUtils.init(this);
}
globalInstance 简单的全局对象，
    friendListOnYourServer 服务器端缓存的玩家好友openid列表，非微信的好友关系。
        通过onPostMessage传递到子域，调用 WxUtils.resetFriendListByStr(‘openid列表通过|链接形成的字符串’); 拆分出来的列表。
    selfAvatarUrl 玩家自己的头像，用来判断是否是自己用的。
        在初始化方法 WxUtils.init(`显示对象组件`) 调用的过程中访问微信获得。
    openidNameDict 玩家的openid和玩家名的关系
        发送给玩家邀请的时候，参数是openid，非闭包的时候，可能会获取不到这个关系。所以，缓存一下。

//调用范例
let _friendListStr = "a|b|c";//openid | 拼接的字符串。
WxUtils.resetFriendListByStr(_friendListStr);//先构建出自己存的好友关系
let _value = 12;
let _key = "rank";
let _shareTicket = "d";
WxUtils.setUserCloudStorage(//传递键值对。先确保自己有数据。
    [{ key:_key , value:_value.toString() }],
    (isSuccess_)=>{//无论成败都会调用
        WxUtils.getCloudStorage([_key],(isSuccess_,userGameDataListDict_)=>{
            if(isSuccess_){//成功
                let _wxFriendList = userGameDataListDict_[_key];
                //TODO 通过 _wxFriendList 创建显示列表
                _wxFriendList.forEach((wxFriendInfo_)=>{//每一个数据格式如下
                    // wxFriendInfo_.avatarUrl
                    // wxFriendInfo_.nickname
                    // wxFriendInfo_.openid
                    // wxFriendInfo_.key// 当前例子是 rank
                    // wxFriendInfo_.value// 为自己的时候是 "12" 注意是字符串
                    // wxFriendInfo_.rank// 为自己的时候是 "12" ，和value应当一致
                    // wxFriendInfo_.isFriend//是否是好友
                    // wxFriendInfo_.isSelf//是否是自己
                    // wxFriendInfo_.idx//值可以排序的时候，会生成这个键。为排序后的序号
                });
            }
        },null);//传递 null 是取好友排行。传递 shareTicket 是取群排行。
        //},_shareTicket);
    }
);

let _toFriendOpenid = "e";//这个用户可能是非好友，比如潜在用户。
WxUtils.shareMessageToFriend(
    _toFriendOpenid,//定向分享
    "邀请文字",
    "图片网址",
    (isSuccess_)=>{
        //TODO 分享成功提示 
        if (isSuccess_){
            //`${globalInstance.openidNameDict[_toFriendOpenid]} 进入游戏即可成为你的好友`
        }else{
            //`${globalInstance.openidNameDict[_toFriendOpenid]} 没有收到你的消息哦`
        }
    }
);
*/

let WxUtils = {
    updateAvatar:function(node_,url_) {
        let _image = wx.createImage();
        _image.onload = () => {
            let _texture = new cc.Texture2D();
            _texture.initWithElement(_image);
            _texture.handleLoadedTexture();
            node_.getComponent(cc.Sprite).spriteFrame = new cc.SpriteFrame(_texture);
        };
        _image.src = url_;
    },
    init:function(displayComponent_){
        globalInstance.displayComponent = displayComponent_;//场景中的节点显示组件
        WxUtils.getSelfInfo((isSuccess_,userInfo_)=>{//获取自己id信息
            if (isSuccess_){//主要是获取头像，通过头像的网址，判端是否是玩家本人。
                globalInstance.selfAvatarUrl = userInfo_.avatarUrl;
            }
        });
    },
    resetFriendListByStr:function(friendOpenidStr_){//好友的openid列表，拼接成|分割的字符串，在子域中拆分
        if (friendOpenidStr_ == ""){
            globalInstance.friendListOnYourServer = [];
        }else{
            globalInstance.friendListOnYourServer = friendOpenidStr_.split("|");
        }
    },
    isFriendFunc:function(wxFriendList_) {//列表中的用户标记是否是好友
        wxFriendList_.forEach((userInfo_)=>{//用户信息
            globalInstance.friendListOnYourServer.some((friendOpenidStr_)=>{//朋友的openid
                if (userInfo_.openid.toString() == friendOpenidStr_){//匹配上的话
                    userInfo_.isFriend = true;
                    return true;
                }
            });
        });
    },
    getSelfInfo:function(completeFunc_){
        let _isSuccess = false;//是否成功执行
        let _userInfo = null;
        let _success = function(args_){
            console.log("getSelfInfo success : ",args_);
            _isSuccess = true;//设置结果为完成
            _userInfo = args_.data[0];
        }
        let _fail = function(args_){
            console.log("getSelfInfo fail : ",args_);
            _isSuccess = false;//设置结果为未完成
        }
        let _complete = function(args_){
            completeFunc_(_isSuccess,_userInfo);//回调请求完毕，将是否完成作为参数传递
        }
        wx.getUserInfo({
            openIdList: ['selfOpenId'],
            success:function(args_){ _success(args_) },
            fail:function(args_){ _fail(args_) },
            complete:function(args_){ _complete(args_) },
        });
        console.log("getSelfInfo : ");
    },
    shareMessageToFriend:function(openId_,title_,imageUrl_,completeFunc_){
        let _isSuccess = false;//是否成功执行
        let _success = function(args_){
            console.log("shareMessageToFriend success : ",args_);
            _isSuccess = true;//设置结果为完成
        }
        let _fail = function(args_){
            console.log("shareMessageToFriend fail : ",args_);
            _isSuccess = false;//设置结果为未完成
        }
        let _complete = function(args_){
            console.log("shareMessageToFriend complete : ",args_);
            completeFunc_(_isSuccess);//回调请求完毕，将是否完成作为参数传递
        }
        wx.shareMessageToFriend({
            openId:openId_,
            title:title_,
            imageUrl:imageUrl_,
            success:function(args_){ _success(args_) },
            fail:function(args_){ _fail(args_) },
            complete:function(args_){ _complete(args_) },
        });
        console.log("shareMessageToFriend : ",openId_,title_,imageUrl_);
    },
    getPotentialFriendList:function(completeFunc_){
        let _isSuccess = false;//是否成功执行
        let _FriendInfoList = [];
        let _success = function(args_){
            console.log("getPotentialFriendList success : ",args_);
            _FriendInfoList = args_.list;
            _isSuccess = true;//设置结果为完成
        }
        let _fail = function(args_){
            console.log("getPotentialFriendList fail : ",args_);
            _isSuccess = false;//设置结果为未完成
        }
        let _complete = function(args_){
            console.log("getPotentialFriendList complete : ",args_);
            completeFunc_(_isSuccess,_FriendInfoList);//回调请求完毕，将是否完成作为参数传递
        }
        wx.getPotentialFriendList({
            success:function(args_){ _success(args_) },
            fail:function(args_){ _fail(args_) },
            complete:function(args_){ _complete(args_) },
        })  
    },
    getUserCloudStorage:function(keyList_,completeFunc_){
        let _isSuccess = false;//是否成功执行
        let _KVDataList = [];
        let _success = function(args_){
            console.log("getUserCloudStorage success : ",args_);
            _KVDataList = args_.KVDataList;
            _isSuccess = true;//设置结果为完成
        }
        let _fail = function(args_){
            console.log("getUserCloudStorage fail : ",args_);
            _isSuccess = false;//设置结果为未完成
        }
        let _complete = function(args_){
            console.log("getUserCloudStorage complete : ",args_);
            completeFunc_(_isSuccess,_KVDataList);//回调请求完毕，将是否完成作为参数传递
        }
        wx.getUserCloudStorage({
            keyList:keyList_,
            success:function(args_){ _success(args_) },
            fail:function(args_){ _fail(args_) },
            complete:function(args_){ _complete(args_) },
        });
        console.log("getUserCloudStorage : ",keyList_);
    },
    // 将键值列表设置到wx服务器上
    setUserCloudStorage:function(keyValueList_,completeFunc_){
        let _isSuccess = false;//是否成功执行
        let _success = function(args_){
            console.log("setUserCloudStorage success : ",args_);
            _isSuccess = true;//设置结果为完成
        }
        let _fail = function(args_){
            console.log("setUserCloudStorage fail : ",args_);
            _isSuccess = false;//设置结果为未完成
        }
        let _complete = function(args_){
            console.log("setUserCloudStorage complete : ",args_);
            completeFunc_(_isSuccess);//回调请求完毕，将是否完成作为参数传递
        }
        wx.setUserCloudStorage({
            KVDataList:keyValueList_,
            success:function(args_){ _success(args_) },
            fail:function(args_){ _fail(args_) },
            complete:function(args_){ _complete(args_) },
        });
        console.log("setUserCloudStorage : ",keyValueList_);
    },
    //通过键列表取得好友或群内的玩家列表。
    getCloudStorage:function (keyList_,completeFunc_,shareTicket_){
        let _isSuccess = false;//是否成功执行
        let _userGameDataListDict = {};//每个键创建一个空列表
        for (let _idx = 0 , _len = keyList_.length; _idx < _len; _idx++) {
            _userGameDataListDict[keyList_[_idx]]=[];//每个键，有自己对应的信息列表。
        }
        let _currentTypeStr = "";
        let _success = function(args_){
            console.log(_currentTypeStr + " success : ",args_);
            let _userGameDataList = args_.data;//返回的玩家信息列表
            if (_userGameDataList == null){
                _isSuccess = false;//设置结果为未完成
                return
            }
            for (let _idx = 0 , _len = _userGameDataList.length; _idx < _len; _idx++) {//循环返回的列表数据
                let _userGameData = _userGameDataList[_idx];//每个玩家的信息
                for (let _idxInside = 0 , _lenInside = _userGameData.KVDataList.length; _idxInside < _lenInside; _idxInside++) {//循环玩家的键值对信息
                    let _KVData = _userGameData.KVDataList[_idxInside];// 获取每一个键值对
                    let _key = _KVData.key;//取键
                    let _value = _KVData.value;//取值
                    for (let _keyIdx = 0 , _keyLeng = keyList_.length; _keyIdx < _keyLeng; _keyIdx++) {//循环键列表
                        if(_key == keyList_[_keyIdx]){//键匹配
                            let _userInfo = {//构建新用户信息，只包含当前键值和基本用户信息
                                avatarUrl:_userGameData.avatarUrl,
                                nickname:_userGameData.nickname,
                                openid:_userGameData.openid,
                                key:_key,
                                value:_value,
                                isFriend:false,
                                isSelf:globalInstance.selfAvatarUrl == _userGameData.avatarUrl,//头像地址是一个，就认为是自己。
                            }
                            _userInfo[_key] = _value;//直接将 key 和 value 对应上。
                            _userGameDataListDict[_key].push(_userInfo);//放置到对应的键列表中
                            break;
                        }
                    }
                }
                //openid 和 玩家名 的关系
                globalInstance.openidNameDict[_userGameData.openid] = _userGameData.nickname;
            }

            let _sortedKeyList = [];
            for (let _idx = 0 , _len = keyList_.length; _idx < _len; _idx++) {//每一个键，对应的列表都排序。循环键列表
                let _key = keyList_[_idx];
                let _userGameDataList = _userGameDataListDict[_key];//每一个键的用户键值信息列表
                WxUtils.isFriendFunc(_userGameDataList);//用户的信息列表，设置其是否是好友
                let _sortedBool = true;
                _userGameDataListDict[_key] = _userGameDataList.sort((a,b)=>{//按照值进行排序
                    let _aFloatValue = parseFloat(a.value);
                    let _bFloatValue = parseFloat(b.value);
                    let _aBool = _aFloatValue.toString() != "NaN";
                    let _bBool = _bFloatValue.toString() != "NaN";
                    if (_aBool && _bBool){//能排序的时候在排序
                        return _bFloatValue - _aFloatValue;
                    }else{//出现任何一个无法排序的就
                        _sortedBool = false;
                        return true;
                    }
                });
                if (_sortedBool){//排序过的话，就记录下键
                    _sortedKeyList.push(_key);
                }
            }
            _sortedKeyList.forEach((key_)=>{//排序过的列表，需要加上一个排序的序号
                let _userGameDictList = _userGameDataListDict[key_];//每一个键的用户键值信息列表
                for (var _idx = 0 , _len = _userGameDictList.length; _idx < _len; _idx++) {
                    _userGameDictList[_idx].idx = _idx;//排序过的需要在添加一个序号属性
                }
            });
            _isSuccess = true;//设置结果为完成
        }
        let _fail = function(args_){
            console.log(_currentTypeStr + " fail : ",args_);
            _isSuccess = false;//设置结果为未完成
        }
        let _complete = function(args_){
            console.log(_currentTypeStr + " complete : ",args_);
            completeFunc_(_isSuccess,_userGameDataListDict);//回调请求完毕，将是否完成作为参数传递
        }
        
        if (shareTicket_ != undefined && shareTicket_ != null){
            _currentTypeStr = "getGroupCloudStorage";
            wx.getGroupCloudStorage({
                shareTicket:shareTicket_,
                keyList:keyList_,
                success:function(args_){ _success(args_) },
                fail:function(args_){ _fail(args_) },
                complete:function(args_){ _complete(args_) },
            });
        }else{
            _currentTypeStr = "getFriendCloudStorage";
            wx.getFriendCloudStorage({
                keyList:keyList_,
                success:function(args_){ _success(args_) },
                fail:function(args_){ _fail(args_) },
                complete:function(args_){ _complete(args_) },
            });
        }
        console.log(_currentTypeStr + " : ",keyList_,shareTicket_);
    },
}
let _window = null;
if (typeof window === 'undefined') {
    _window = GameGlobal;
}else{
    _window = window;
}
if (!_window.globalInstance){
    _window.globalInstance = {};
    globalInstance.displayComponent = null;//场景中的节点显示组件
    globalInstance.friendListOnYourServer = [];//好友 openid 列表
    globalInstance.openidNameDict = {};//好友 openid 和 名称 对应关系
}
module.exports = WxUtils;