feat: .

src/App.vue

@@ -219,7 +219,7 @@ const handleUpdateValue = (value: string) => {
   console.log(value)
 }
 onMounted(() => {
-  setSceneLink('/page/spg.html?m=KJ-t-9xlMZ5ZVCfR')
+  setSceneLink('/page/spg.html?m=KJ-t-3Y6dxgyehDk')
   setSceneRef(sceneRef.value)
 })
 </script>

src/Deferred.js

@@ -0,0 +1,382 @@
+function isArray(arr) {
+    return Object.prototype.toString.call(arr) === '[object Array]'
+}
+
+function foreach(arr, handler) {
+    if (isArray(arr)) {
+        for (var i = 0; i < arr.length; i++) {
+            handler(arr[i])
+        }
+    } else handler(arr)
+}
+
+function D(fn) {
+    var status = 'pending',
+        doneFuncs = [],
+        failFuncs = [],
+        progressFuncs = [],
+        resultArgs = null,
+        promise = {
+            done: function () {
+                for (var i = 0; i < arguments.length; i++) {
+                    // skip any undefined or null arguments
+                    if (!arguments[i]) {
+                        continue
+                    }
+
+                    if (isArray(arguments[i])) {
+                        var arr = arguments[i]
+                        for (var j = 0; j < arr.length; j++) {
+                            // immediately call the function if the deferred has been resolved
+                            if (status === 'resolved') {
+                                arr[j].apply(this, resultArgs)
+                            }
+
+                            doneFuncs.push(arr[j])
+                        }
+                    } else {
+                        // immediately call the function if the deferred has been resolved
+                        if (status === 'resolved') {
+                            arguments[i].apply(this, resultArgs)
+                        }
+
+                        doneFuncs.push(arguments[i])
+                    }
+                }
+
+                return this
+            },
+
+            fail: function () {
+                for (var i = 0; i < arguments.length; i++) {
+                    // skip any undefined or null arguments
+                    if (!arguments[i]) {
+                        continue
+                    }
+
+                    if (isArray(arguments[i])) {
+                        var arr = arguments[i]
+                        for (var j = 0; j < arr.length; j++) {
+                            // immediately call the function if the deferred has been resolved
+                            if (status === 'rejected') {
+                                arr[j].apply(this, resultArgs)
+                            }
+
+                            failFuncs.push(arr[j])
+                        }
+                    } else {
+                        // immediately call the function if the deferred has been resolved
+                        if (status === 'rejected') {
+                            arguments[i].apply(this, resultArgs)
+                        }
+
+                        failFuncs.push(arguments[i])
+                    }
+                }
+
+                return this
+            },
+
+            always: function () {
+                return this.done.apply(this, arguments).fail.apply(this, arguments)
+            },
+
+            progress: function () {
+                for (var i = 0; i < arguments.length; i++) {
+                    // skip any undefined or null arguments
+                    if (!arguments[i]) {
+                        continue
+                    }
+
+                    if (isArray(arguments[i])) {
+                        var arr = arguments[i]
+                        for (var j = 0; j < arr.length; j++) {
+                            // immediately call the function if the deferred has been resolved
+                            if (status === 'pending') {
+                                progressFuncs.push(arr[j])
+                            }
+                        }
+                    } else {
+                        // immediately call the function if the deferred has been resolved
+                        if (status === 'pending') {
+                            progressFuncs.push(arguments[i])
+                        }
+                    }
+                }
+
+                return this
+            },
+
+            then: function (done, fail, progress) {
+                /*
+                // fail callbacks
+                if (arguments.length > 1 && arguments[1]) {
+                    this.fail(arguments[1])
+                }
+
+                // done callbacks
+                if (arguments.length > 0 && arguments[0]) {
+                    this.done(arguments[0])
+                }
+
+                // notify callbacks
+                if (arguments.length > 2 && arguments[2]) {
+                    this.progress(arguments[2])
+                }
+
+                return this
+                */
+
+                return D(function (def) {
+                    foreach(done, function (func) {
+                        // filter function
+                        if (typeof func === 'function') {
+                            deferred.done(function () {
+                                var returnval = func.apply(this, arguments)
+                                // if a new deferred/promise is returned, its state is passed to the current deferred/promise
+                                if (returnval && typeof returnval === 'function') {
+                                    returnval.promise().then(def.resolve, def.reject, def.notify)
+                                } else {
+                                    // if new return val is passed, it is passed to the piped done
+                                    def.resolve(returnval)
+                                }
+                            })
+                        } else {
+                            deferred.done(def.resolve)
+                        }
+                    })
+
+                    foreach(fail, function (func) {
+                        if (typeof func === 'function') {
+                            deferred.fail(function () {
+                                var returnval = func.apply(this, arguments)
+
+                                if (returnval && typeof returnval === 'function') {
+                                    returnval.promise().then(def.resolve, def.reject, def.notify)
+                                } else {
+                                    def.reject(returnval)
+                                }
+                            })
+                        } else {
+                            deferred.fail(def.reject)
+                        }
+                    })
+                }).promise()
+            },
+            catch: function () {
+                for (var i = 0; i < arguments.length; i++) {
+                    // skip any undefined or null arguments
+                    if (!arguments[i]) {
+                        continue
+                    }
+
+                    if (isArray(arguments[i])) {
+                        var arr = arguments[i]
+                        for (var j = 0; j < arr.length; j++) {
+                            // immediately call the function if the deferred has been resolved
+                            if (status === 'rejected') {
+                                arr[j].apply(this, resultArgs)
+                            }
+
+                            failFuncs.push(arr[j])
+                        }
+                    } else {
+                        // immediately call the function if the deferred has been resolved
+                        if (status === 'rejected') {
+                            arguments[i].apply(this, resultArgs)
+                        }
+
+                        failFuncs.push(arguments[i])
+                    }
+                }
+
+                return this
+            },
+
+            promise: function (obj) {
+                if (obj == null) {
+                    return promise
+                } else {
+                    for (var i in promise) {
+                        obj[i] = promise[i]
+                    }
+                    return obj
+                }
+            },
+
+            state: function () {
+                return status
+            },
+
+            debug: function () {
+                console.log('[debug]', doneFuncs, failFuncs, status)
+            },
+
+            isRejected: function () {
+                return status === 'rejected'
+            },
+
+            isResolved: function () {
+                return status === 'resolved'
+            },
+
+            pipe: function (done, fail, progress) {
+                return D(function (def) {
+                    foreach(done, function (func) {
+                        // filter function
+                        if (typeof func === 'function') {
+                            deferred.done(function () {
+                                var returnval = func.apply(this, arguments)
+                                // if a new deferred/promise is returned, its state is passed to the current deferred/promise
+                                if (returnval && typeof returnval === 'function') {
+                                    returnval.promise().then(def.resolve, def.reject, def.notify)
+                                } else {
+                                    // if new return val is passed, it is passed to the piped done
+                                    def.resolve(returnval)
+                                }
+                            })
+                        } else {
+                            deferred.done(def.resolve)
+                        }
+                    })
+
+                    foreach(fail, function (func) {
+                        if (typeof func === 'function') {
+                            deferred.fail(function () {
+                                var returnval = func.apply(this, arguments)
+
+                                if (returnval && typeof returnval === 'function') {
+                                    returnval.promise().then(def.resolve, def.reject, def.notify)
+                                } else {
+                                    def.reject(returnval)
+                                }
+                            })
+                        } else {
+                            deferred.fail(def.reject)
+                        }
+                    })
+                }).promise()
+            },
+        },
+        deferred = {
+            resolveWith: function (context) {
+                if (status === 'pending') {
+                    status = 'resolved'
+                    var args = (resultArgs = arguments.length > 1 ? arguments[1] : [])
+                    for (var i = 0; i < doneFuncs.length; i++) {
+                        doneFuncs[i].apply(context, args)
+                    }
+                }
+                return this
+            },
+
+            rejectWith: function (context) {
+                if (status === 'pending') {
+                    status = 'rejected'
+                    var args = (resultArgs = arguments.length > 1 ? arguments[1] : [])
+                    for (var i = 0; i < failFuncs.length; i++) {
+                        failFuncs[i].apply(context, args)
+                    }
+                }
+                return this
+            },
+
+            notifyWith: function (context) {
+                if (status === 'pending') {
+                    var args = (resultArgs = arguments.length > 1 ? arguments[1] : [])
+                    for (var i = 0; i < progressFuncs.length; i++) {
+                        progressFuncs[i].apply(context, args)
+                    }
+                }
+                return this
+            },
+
+            resolve: function () {
+                return this.resolveWith(this, arguments)
+            },
+
+            reject: function () {
+                return this.rejectWith(this, arguments)
+            },
+
+            notify: function () {
+                return this.notifyWith(this, arguments)
+            },
+            resolveValue: function(val) {
+                status = 'resolved'
+                var args = (resultArgs = val == void 0 ? [] : [val])
+                for (var i = 0; i < doneFuncs.length; i++) {
+                    doneFuncs[i].apply(this, args)
+                }
+                return this
+            }
+        }
+
+    var obj = promise.promise(deferred)
+
+    if (fn) {
+        fn.apply(obj, [obj])
+    }
+
+    return obj
+}
+
+D.when = function () {
+    if (arguments.length < 2) {
+        var obj = arguments.length ? arguments[0] : undefined
+        if (obj && typeof obj.isResolved === 'function' && typeof obj.isRejected === 'function') {
+            return obj.promise()
+        } else {
+            return D().resolve(obj).promise()
+        }
+    } else {
+        return (function (args) {
+            var df = D(),
+                size = args.length,
+                done = 0,
+                rp = new Array(size) // resolve params: params of each resolve, we need to track down them to be able to pass them in the correct order if the master needs to be resolved
+
+            for (var i = 0; i < args.length; i++) {
+                ;(function (j) {
+                    var obj = null
+
+                    if (args[j].done) {
+                        args[j]
+                            .done(function () {
+                                rp[j] = arguments.length < 2 ? arguments[0] : arguments
+                                if (++done == size) {
+                                    df.resolve.apply(df, rp)
+                                }
+                            })
+                            .fail(function () {
+                                df.reject(arguments)
+                            })
+                    } else {
+                        obj = args[j]
+                        args[j] = new Deferred()
+
+                        args[j]
+                            .done(function () {
+                                rp[j] = arguments.length < 2 ? arguments[0] : arguments
+                                if (++done == size) {
+                                    df.resolve.apply(df, rp)
+                                }
+                            })
+                            .fail(function () {
+                                df.reject(arguments)
+                            })
+                            .resolve(obj)
+                    }
+                })(i)
+            }
+
+            return df.promise()
+        })(arguments)
+    }
+}
+
+export const Defer = D
+
+export default function () {
+    return new D()
+}

src/sdk.js

@@ -1,22 +1,57 @@
+import Deferred from './Deferred'
 
 let __sdk = null
+let __doc = null
+let __mount_list = []
 
-const withResolvers = function () {
-    let resolve 
-    let reject
-    const promise = new Promise((res, rej) => {
-        resolve = res
-        reject = rej
-    })
-    return { promise, resolve, reject }
+const deferred = Deferred()
+
+export const sdk = deferred.promise()
+export const sdk_mounted = (cb) => {
+  __mount_list.push(cb)
+  if (__sdk) {
+    cb(__sdk)
+  }
 }
 
-const { promise, resolve, reject } = withResolvers()
+export function setupSDK(iframe) {
+  __sdk = iframe.contentWindow.__sdk
+  __doc = iframe.contentDocument
+  __mount_list.forEach((cb) => cb(__sdk))
+  deferred.resolveValue(__sdk)
+}
 
-export const sdk = promise
+export function insertStyle(style) {
+    __doc.body.insertAdjacentHTML('beforeend', style)
+}
 
-export function setupSDK(iframe) {
-    __sdk = iframe.contentWindow.__sdk
-    // @ts-ignore
-    resolve(__sdk)
-}
+export function clearScreen(clear) {
+  if (__doc) {
+    const button = __doc.body.querySelector('.clear-screen-btn')
+    if (button) {
+      if (clear) {
+        if (button.querySelector('i').classList.contains('icon-hide_y')) {
+          button.style.visibility = 'hidden'
+          button.click()
+        }
+      } else {
+        button.style.visibility = 'visible'
+        if (button.querySelector('i').classList.contains('icon-hide_n')) {
+          button.click()
+        }
+      }
+    }
+  }
+}
+
+sdk_mounted(()=>{
+    insertStyle(
+        `<style cssr-id="ddddddddddddd">
+            .kankan-app__split .player[name='main'] {
+                width:100% !important;
+            }
+            .kankan-app__split .player[name='copy'] {
+                display:none !important;
+            }
+        </style>`)
+})

src/store/main.ts

@@ -13,13 +13,17 @@ export const useMainStore = defineStore('main', {
       digitalHumanList: [],
       sceneLink: '',
       sceneMode: 'pc',
-      sceneConfig: {},
+      sceneConfig: {
+        message:'verify'
+      },
       basicConfig: {
         mode: 'pc',//true pc false mobile
         themes: '',
         autoRotate: false, //true 自动播放 
-        lever: false, //true 显示
-        leverPosition: 'left', //left right center 
+        joystick: {
+          show:false,
+          position: 'left'
+        },
         age: 18
       },
       digitalHumanList: [],
@@ -28,6 +32,7 @@ export const useMainStore = defineStore('main', {
   getters: {
     sceneURL: ({sceneLink,sceneConfig,sceneMode})=> {
       if(sceneLink){
+        console.log(sceneLink+`&mobile=${sceneMode == 'mobile' ? 'true' : 'false'}&config=`+JSON.stringify(sceneConfig || {}))
         return sceneLink+`&mobile=${sceneMode == 'mobile' ? 'true' : 'false'}&config=`+JSON.stringify(sceneConfig || {})
       }
     },

src/views/basicSettings/index.vue

@@ -32,11 +32,11 @@
           </div>
           <div class="flex justify-between my-2.5">
             <span>操纵杆</span>
-            <n-switch v-model:value="basicConfig.lever" />
+            <n-switch v-model:value="basicConfig.joystick.show" />
           </div>
-          <div class="flex justify-between my-2.5" v-if="basicConfig.lever">
+          <div class="flex justify-between my-2.5" v-if="basicConfig.joystick.show">
             <n-radio-group
-              v-model:value="basicConfig.leverPosition"
+              v-model:value="basicConfig.joystick.position"
               name="radiobuttongroup1"
               size="small"
             >
@@ -52,7 +52,7 @@
 </template>
 
 <script setup lang="ts">
-import { ref, watch, computed, onMounted } from 'vue'
+import { ref, watch, computed, onMounted,onDeactivated, onUnmounted } from 'vue'
 import { useMainStore } from '@/store'
 import { sdk } from '@/sdk'
 // import { useMessage } from 'naive-ui'
@@ -87,6 +87,12 @@ const options = [
   }
 ]
 
+watch(basicConfig.value.joystick,
+  (val) => {
+    main.setSceneConfig({joystick:val})
+  }
+)
+
 watch(
   () => basicConfig.value.autoRotate,
   (val) => {
@@ -125,8 +131,15 @@ function changeActive() {
   console.log('changeActive', active.value)
 }
 onMounted(() => {
+  
   // active.value = true
 })
+onUnmounted(()=>{
+  if(basicConfig.value.mode == 'mobile') {
+    main.setSceneMode('pc')
+  }
+  
+})
 </script>
 
 <style lang="sass" scoped>

src/views/message/index.vue

@@ -4,7 +4,8 @@
 
 <script setup lang="ts">
 defineProps<{ msg: string }>()
-
+// __sdk.TagManager.openTag('1730448544227') // 打开热点
+// __sdk.TagManager.removeTag('1730448544227') // 移除热点
 </script>
 
 <style lang="sass" scoped>

src/views/topicNavigation/index.vue

@@ -75,7 +75,7 @@
 
 <script setup lang="ts">
 import { ref } from 'vue'
-import { sdk } from '@/sdk'
+import { sdk,clearScreen } from '@/sdk'
 import { onMounted, onUnmounted } from 'vue'
 import { NRadio, NPopover, useDialog, useMessage } from 'naive-ui'
 import { WalkSharp, TrashOutline, EllipsisHorizontal } from '@vicons/ionicons5'
@@ -93,6 +93,7 @@ onMounted(() => {
   sdk.then((sdk) => {
     sdk.Scene.whenLoaded(() => {
       sdk.PanoCheckManager.enter()
+      clearScreen(true)
     })
   })
 })
@@ -100,6 +101,7 @@ onMounted(() => {
 onUnmounted(() => {
   sdk.then((sdk) => {
     sdk.PanoCheckManager.leave()
+    clearScreen(false)
   })
 })