18xchat/assets/Scripts/Main/Channel/bdSDK.ts

import { randomRange } from "cc"
import GlobalValue from "../Common/GlobalValue"
import { I_SDK_UserInfo, I_SDK_UserInfo_Callback, SDKManager } from "./SDKManager"
import SubManager from "../../Sub/SubManager"
import Utils from "../Common/Utils"
import { InnerMsgCode } from "../Config/InnerMsgCode"
import HttpUnit from "../Common/HttpUnit"
import { logger } from "db://assets/Scripts/Main/Common/Logger";

//广告ID
const AD_AWARD = "1ntrdiqhmdket7v5fe"
const AD_SPLASH = "test"
const AD_BANNER = "test"
const AD_BANNER_INTERVAL = 30
const AD_BANNER_HEIGHT = 130

export class ByteDanceSDK{

    private bd_video:any = null;
    private bd_splash:any = null;
    private bd_banner:any = null;
    private bd_video_callback:Function = null;
    private bd_video_tag:number = null;
    
    private ShareSTime: any;
    private ShareCb: any; //分享回调
    private shareTxt = ["分享失败", "请分享到一个群", "请分享给一位好友", "分享过于频繁"]

    
    /**侧边栏状态 =0不显示  =1显示前往按钮  =2从侧边栏返回  =3奖励已领取  */
    private static _SidebarState:number = 0;
    public static get SidebarState():number{
        return ByteDanceSDK._SidebarState;
    }


    /**检测侧边栏功能是否可用 */
    public static CheckSidebarState(cb:Function=null){
        if (HttpUnit.IsBDSidebarReceive()) {
            ByteDanceSDK._SidebarState = 3;
            cb && cb(true);
            return;
        }
        if (ByteDanceSDK._SidebarState > 0){
            cb && cb(true);
            return;
        }
        window['tt'].checkScene({
            scene: "sidebar",
            success: (res) => {
                logger.log("抖音 检测侧边栏功能->", res)
                if (res.isExist == true) {
                    if (ByteDanceSDK._SidebarState == 0) {
                        ByteDanceSDK._SidebarState = 1
                    }
                }
                cb && cb(res.isExist == true);
            },
            fail: (res) => {
                logger.log("抖音 检测侧边栏功能失败->", res)
                cb && cb(false);
            }
        })
    }
    /**前往侧边栏 */
    public static GotoSidebar(cb:Function = null){
        logger.log("抖音 正在前往侧边栏...")
        window["tt"].navigateToScene({
            scene: "sidebar",
            success(res) {
                logger.log("抖音 前往侧边栏 成功")
                cb && cb(true);
            },
            fail(res) {
                logger.log("抖音 前往侧边栏 失败", res)
            }
        })
    }

    
    //初始化
    init(cb: Function = null) {
        logger.log("init 抖音 初始化...")
        // 保持屏幕常亮
        window["tt"].setKeepScreenOn({
            keepScreenOn: true,
            success(res) {
            },
            fail(res) {
            },
        });

        
        //小游戏回到前台
        window['tt'].onShow((res)=>{
            logger.log("抖音 小游戏回到前台->", res)
            if (!res) {
                return;
            }
            // logger.log("启动参数：", res.query);
            // logger.log("来源信息：", res.refererInfo);
            // logger.log("场景值：", res.scene);
            // logger.log("启动场景字段：", res.launch_from, ", ", res.location);

            //返回小游戏场景值
            if (res.query && res.query.ShareCode) {
                GlobalValue.ShareTocusid = res.query.ShareCode
            }

            //从侧边栏返回
            if (res.launch_from == "homepage" && res.location == "sidebar_card") {
                logger.log("从侧边栏返回, SidebarState=", ByteDanceSDK._SidebarState)
                if (ByteDanceSDK._SidebarState == 1) {
                    ByteDanceSDK._SidebarState = 2
                    Utils.sendInnerMsg(InnerMsgCode.UI_BD_Sidebar, {})
                    //获取奖励
                    HttpUnit.ins.getBDSidebarReward({}, (data) => {
                        Utils.sendInnerMsg(InnerMsgCode.Data_BDSidebarReward, {})
                        SubManager.ShowConfirm({
                            content: "侧边栏奖励领取成功，相亲次数+1",
                            hideNo: true, //隐藏取消按钮
                            yesCallback: () => {
                            }
                        })
                    })
                }
            }
            
            //处理分享事件
            if (this.ShareCb) {
                if (this.ShareSTime) {
                    let nT = new Date().getTime();
                    logger.log("分享时间差 计算：",nT, this.ShareSTime);
                    if (nT - this.ShareSTime > 1500) {
                        let cb = this.ShareCb.succ
                        cb && cb()
                    } else {
                        this.tostErr()
                    }
                }
                this.ShareCb = null;
            }
        });
        //小游戏被隐藏 记个时间
        window['tt'].onHide(() => {
            if (this.ShareCb) {
                this.ShareSTime = new Date().getTime();
                logger.log("分享时间差 记录：", this.ShareSTime);
            }
        });


        this.init_video();
        this.init_splash();
        this.init_banner();
        this.qiangzhiUpdata();    //检测更新
        cb && cb();
    }
    
    //分享失败
    tostErr() {
        let rint = Math.floor( randomRange(0, this.shareTxt.length - 1) )
        SubManager.ShowPrompt(this.shareTxt[rint])
        if (this.ShareCb) {
            let cb = this.ShareCb.fail
            cb && cb()
        }
    }

    //检查权限
    checkAutoSetting(autoKey:string, cb:Function = null) {
        // cb && cb(true);
        if (autoKey == "userInfo") {
            autoKey = "scope.userInfo"
        }
        window['tt'].authorize({
            scope: autoKey,
            success(res:any) {
                logger.log("抖音 - 检测权限状态 succ:", JSON.stringify(res))
                if (autoKey == "scope.userInfo" && res.data['scope.userInfo']) {
                    cb && cb(true)
                } else {
                    cb && cb(false)
                }
            },
            fail(res:any) {
                logger.log("抖音 - 检测权限状态 fail:",JSON.stringify(res))
                cb && cb(false)
            }
        })
    }

    //获取用户信息
    getUserInfo(cb:I_SDK_UserInfo_Callback = null) {
        // cb && cb({ nickName:"", avatarUrl:"" });
        //getUserProfile报错未找到
        window["tt"].getUserInfo({
            force: false, //当宿主未登录时，是否强制拉起登录框
            success(res) {
                logger.log("抖音 - 获取用户信息成功：", res);
                cb && cb({avatarUrl:res.userInfo.avatarUrl, nickName:res.userInfo.nickName}) //encryptedData
            },
            fail(res) {
                logger.log("抖音 - 获取用户信息失败", res);
            },
        })
    }

    //region 登录
    login(cb: Function = null) {
        // cb && cb({ platform:2, code: null });
        window["tt"].login({
            force: false, //未登录时, 是否强制调起登录框
            success(res) {
                logger.log(`抖音 - 登录成功 code=${res.code}, anonymousCode=${res.anonymousCode}`);
                cb && cb({ platform:2, code: res.code });
            },
            fail(res) {
                logger.log(`抖音 - 登录失败`, res);
                cb && cb({ platform:2, code: null });
            },
        })
    }

    private init_banner() {
        if (AD_BANNER as any == "test") {
            logger.log("抖音 横幅广告id未配置，跳过此类型初始化")
            return
        }

        if (!window["tt"] || !window["tt"].createBannerAd) return
    
        const systemInfo = window["tt"].getSystemInfoSync();
        //if (systemInfo.appName.toUpperCase() == 'DOUYIN') return
        //if (systemInfo.appName.toUpperCase() == 'TOUTIAO' && systemInfo.platform == "ios") return
    
        if (systemInfo.appName.toUpperCase() == 'DOUYIN' || systemInfo.platform == "ios") return
    
        const { windowWidth, windowHeight } = window["tt"].getSystemInfoSync();
        var targetBannerAdWidth = 128+ 100
        var targetBannerAdHeight = AD_BANNER_HEIGHT
        // 创建一个居于屏幕底部正中的广告
        this.bd_banner = window["tt"].createBannerAd({
            adUnitId: AD_BANNER,
            adIntervals: AD_BANNER_INTERVAL,
            style: {
                width: targetBannerAdWidth,
                left:(windowWidth - targetBannerAdWidth) / 2,
                top: windowHeight - targetBannerAdHeight
            },
        });
        
        // 尺寸调整时会触发回调
        // 注意：如果在回调里再次调整尺寸，要确保不要触发死循环！！！
        this.bd_banner.onResize(size => {
            this.bd_banner.style.left = (windowWidth - size.width) / 2;
            this.bd_banner.style.top = windowHeight - size.height;
        });
        
        // bd_banner.onLoad(() => {
        //   bd_banner
        //     .show()
        //     .then(() => {
        //       logger.log("init_banner 广告显示成功");
        //     })
        //     .catch((err) => {
        //       logger.log("init_banner 广告组件出现问题", err);
        //     });
        // })
    }
    
    private init_splash() {
        
        this.preload_splash()
    }

    private preload_splash() {
        if (AD_SPLASH as any == "test") {
            logger.log("抖音 插屏广告id未配置，跳过此类型初始化")
            return
        }

        if (!window["tt"] || !window["tt"].createInterstitialAd) return
    
        if (this.bd_splash) {
            if (this.bd_splash['custom_show_stautus']) {
                this.bd_splash.destroy()
                this.bd_splash = null
            } else {
                if (!this.bd_splash['custom_load_stautus']) {
                    this.bd_splash
                        .load()
                        .catch(err => {
                            logger.log("preload_splash err:",err);
                        })
                }
            }
        }

        if (this.bd_splash) return
    
        // 创建插屏广告实例，会自动进行一次load
        this.bd_splash = window["tt"].createInterstitialAd({
            adUnitId: AD_SPLASH
        })
        this.bd_splash.onLoad(function(){
            this.bd_splash['custom_load_stautus'] = true
        })
        this.bd_splash.onClose(function(){
            this.bd_splash.destroy()
            this.bd_splash = null
    
            this.preload_splash()
        })
        this.bd_splash.onError(function(err){
            logger.log("bd_splash err:",err)
        })
    
    }
    
    private init_video() {
        if (AD_AWARD as any == "test") {
            logger.log("抖音 激励广告id未配置，跳过此类型初始化")
            return
        }

        if (!window["tt"] || !window["tt"].createRewardedVideoAd) return
    
        this.bd_video = window["tt"].createRewardedVideoAd({
            adUnitId: AD_AWARD,
        });
    
        this.bd_video.onClose(res => {
            if (res.isEnded) {
                if (this.bd_video_callback) {
                    this.bd_video_callback(this.bd_video_tag);
                }
            }
            SDKManager.video_ad_back();
        });
    
        this.bd_video.onError((err) => {
        });
    
    }

    //显示视频广告
    show_video(callback:Function, tag:number) {
        if (AD_AWARD as any == 'test') {
            logger.log('未接入广告ID，视频广告请求直接返回');
            callback && callback();
            SDKManager.video_ad_back();
            return;
        }

        if (!this.bd_video) return

        this.bd_video_callback = callback;
        this.bd_video_tag = tag

        this.bd_video
            .load()
            .then(() => {
                this.bd_video.show()
            })
            .catch(err => {
                
            });
    }

    //显示插屏
    show_splash() {

        //已加载 未展示
        if (this.bd_splash && this.bd_splash['custom_load_stautus'] && !this.bd_splash['custom_show_stautus']) {
            this.bd_splash.show().then(() => {
                this.bd_splash['custom_show_stautus'] = true
                logger.log("插屏广告展示成功");
            })
        } else {
            logger.log("插屏广告展示失败");
            this.preload_splash()
        }  
        
    }

    //显示Banner
    show_banner() {
        if (this.bd_banner) {
            this.bd_banner.show(); //banner 默认隐藏(hide) 要打开
        }
    }

    //隐藏Banner
    hide_banner() {
        if (this.bd_banner) {
            this.bd_banner.hide(); //banner 默认隐藏(hide) 要打开
        }
    }

    //移除
    clear_banner() {
        if (this.bd_banner) {
            this.bd_banner.destroy(); //banner 默认隐藏(hide) 要打开
            this.bd_banner = null;
        }
    }


    //分享信息
    shareInfo() {
        return {
            title: "告白契约", //Resource.getText(_shareInfo.invite_des),
            query: "ShareCode=" + "user_default", //ModelPlayer.I.getPlayerId(),
        }
    }
    //主动拉起分享
    show_share(rewardCB?:Function) {
        // rewardCB && rewardCB()
        logger.log("主动拉起分享");
        let info:any = this.shareInfo();
        info.succ = rewardCB;

        info.success = (res) => {
            logger.log("抖音 主动拉起分享成功", res);
        }
        info.fail = (err) => {
            logger.log("抖音 主动拉起分享失败", err);
        }
        // info.complete = (res) => {
        //     logger.log("抖音 主动拉起分享完成", res);
        // }

        this.ShareCb = info;
        window['tt'].shareAppMessage(info);
    }
    
    //获取设备分辨率
    getWindowSize() {
        return {width:screen.width, height: screen.height};
    }

    //显示游戏圈
    show_gameClub(leftRatio, topRatio, widthRatio, heightRatio) {
        
    }
    //隐藏游戏圈
    hide_gameClub() {
        
    }
    

    //检查是否支持base64音频播放
    checkSupportBase64Audio() {
        return true;
    }
    //播放base64音频
    private _innerAudioContext: any = null;
    private _iacIdx = 0 //音频播放索引
    playBase64Audio(base64, loop) {
        if (!this.checkSupportBase64Audio()) {
            return;
        }

        let substring = base64;
        let qianzhui = "data:audio/x-wav;base64,"
        if(base64.startsWith(qianzhui)) {
            substring = base64.substring(qianzhui.length, base64.length)
        }

        let self = this;
        const fs = window['tt'].getFileSystemManager();
        //1.删除上一个音频
        const lastPath = window['tt'].env.USER_DATA_PATH + `/ordernew${self._iacIdx}.mp3`
        logger.log("抖音 正在删除上一个音频 ->", lastPath);
        fs.removeSavedFile({
            filePath: lastPath,
            success(res) {
                logger.log("抖音 删除上一个音频成功", res);
            },
            fail(err) {
                logger.log("抖音 删除上一个音频失败", err);
            },
            complete(res) {
                logger.log("抖音 删除上一个音频完成", res);
                
                //2.保存当前音频
                //这里需要每次保存时换一下名字的原因是：innerAudioContext设置路径时如果路径相同，会认为还是同一个音频，不会重新加载，所以需要每次保存时换一下名字
                self._iacIdx++;
                const audioPath = window['tt'].env.USER_DATA_PATH + `/ordernew${self._iacIdx}.mp3`
                logger.log("抖音 正在保存本次音频 ->", audioPath);
                fs.writeFile({
                    filePath: audioPath,
                    data: substring,
                    encoding: 'base64',
                    success(res) {
                        if (self._innerAudioContext == null){
                            self._innerAudioContext = window['tt'].createInnerAudioContext();
                            // 添加播放结束的回调
                            self._innerAudioContext.onEnded(() => {
                                logger.log("抖音 AI语音播放结束")
                                self._innerAudioContext.stop(); // 使用 stop 方法停止音频并重置播放状态
                                self._innerAudioContext.destroy(); // 销毁音频实例
                                self._innerAudioContext = null;
                            });
                        }
                        logger.log("抖音 播放base64音频", audioPath)
                        self._innerAudioContext.src = audioPath;
                        self._innerAudioContext.play(); // 开始播放音频
                    },
                    fail(err) {
                        logger.log("抖音 保存本次音频失败", err);
                    }
                })
            }
        })
    }

    
    //region版本更新检测
    //微信开发者工具上可以通过「编译模式」下的「下次编译模拟更新」开关来调试
    qiangzhiUpdata() {
        if (window['tt'].getUpdateManager == null) {
            logger.log("抖音 没有更新管理器", window['tt'].getUpdateManager)
            return;
        }

        const updateManager = window['tt'].getUpdateManager();

        //监听向微信后台请求检查更新结果事件。微信在小程序每次启动（包括热启动）时自动检查更新，不需由开发者主动触发。
        updateManager.onCheckForUpdate((res) => {
            // 请求完新版本信息的回调
            logger.log("抖音 检查是否有新版本：", res.hasUpdate)
        });

        //监听小程序有版本更新事件。客户端主动触发下载（无需开发者触发），下载成功后回调
        updateManager.onUpdateReady(async () => {
            window['tt'].showModal({
                title: '更新提示',
                content: '新版本已经准备好，是否重启应用？',
                success: function (res) {
                    if (res.confirm) {
                        // 新的版本已经下载好，调用 applyUpdate 应用新版本并重启
                        updateManager.applyUpdate()
                    }
                }
            })
        });

        //监听小程序更新失败事件。小程序有新版本，客户端主动触发下载（无需开发者触发），下载失败（可能是网络原因等）时回调
        updateManager.onUpdateFailed(function (err) {
            logger.log("抖音 新版本下载失败", err)
        })
    }

    
    //客服功能是否支持
    kefuSupport() {
        logger.log("抖音 不支持联系客服")
        return false;
    }
    //进入联系客服
    openKefu() {
        logger.log("抖音 进入联系客服")
    }
    
    
    //播放背景视频
    playBgAudio(remoteUrl:string, loop:boolean = false, cbStart?: Function, cbEnded?: Function) {

    }


    //region 复制到剪贴板
    /**复制文本到剪贴板 */
    copyToClipboard(text: string, cb?: Function) {
        logger.log("抖音 复制到剪贴板：", text);
        window['tt'].setClipboardData({
            data: text,
            success: () => {
                logger.log("抖音 复制成功");
                cb && cb(true);
            },
            fail: (err) => {
                logger.log("抖音 复制失败：", err);
                cb && cb(false);
            }
        });
    }

    //region 友盟+
    umaInit() {
    }
    //友盟统计是否开启
    umaSwt() {
        return false;
    }
    //友盟事件统计
    umaEvent(eventName: string, value: any = {}) {
	}
}