设为首页收藏本站
开启辅助访问

信息发布软件,b2b软件,广告发布软件

 找回密码
 立即注册
搜索
返回列表 发新帖
查看: 568|回复: 0
打印 上一主题 下一主题

[宣传软件网站动态] AIWROK软件支持悬浮窗自由定位和拖拽功能

[复制链接]
信息发布软件

780

主题

864

帖子

5536

积分

积分
5536
跳转到指定楼层
宣传软件楼主
发表于 2025-9-29 08:08:21 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式

资讯缩略图：

资讯发布日期：2025-09-29

资讯发布简介：AIWROK软件支持悬浮窗自由定位和拖拽功能

资讯关键词：AIWROK软件支持悬浮窗自由定位和拖拽功能

资讯所属分类：IT资讯 

联系：

① 本信息收集于网络，如有不对的地方欢迎联系我纠正！
② 本信息免费收录，不存在价格的问题！
③ 如果您的网站也想这样出现在这里，请您加好友情链接，我当天会审核通过！

④友情链接关键字：软件网站分类目录 网址：http://www.postbbs.com/

资讯详细描述
AIWROK软件支持悬浮窗自由定位和拖拽功能
AIWROK软件支持悬浮窗自由定位和拖拽功能 b2b软件

AIWROK软件支持悬浮窗自由定位和拖拽功能 b2b软件
  1. //通过floatUI创建悬浮窗
  2. //适用于ES5系统安卓 JavaScript引擎Rhino
  3. //基于AIWROK软件安卓开发框架
  4. //支持悬浮窗自由定位和拖拽功能
  5. //🍎交流QQ群711841924群一，苹果内测群，528816639


  8. if (!String.prototype.repeat) {
  9.     String.prototype.repeat = function(count) {
  10.         'use strict';
  11.         if (this == null) {
  12.             throw new TypeError('can\'t convert ' + this + ' to object');
  13.         }
  14.         var str = String(this);
  15.         count = +count;
  16.         if (count != count) {
  17.             count = 0;
  18.         }
  19.         if (count < 0) {
  20.             throw new RangeError('repeat count must be non-negative');
  21.         }
  22.         if (count == Infinity) {
  23.             throw new RangeError('repeat count must be less than infinity');
  24.         }
  25.         count = Math.floor(count);
  26.         if (str.length == 0 || count == 0) {
  27.             return '';
  28.         }
  29.         // 确保重复的字符串不会超出字符串长度限制
  30.         if (str.length * count >= 1 << 28) {
  31.             throw new RangeError('repeat count must not overflow maximum string size');
  32.         }
  33.         var rpt = '';
  34.         for (var i = 0; i < count; i++) {
  35.             rpt += str;
  36.         }
  37.         return rpt;
  38.     };
  39. }

  41. // ES5兼容的String.prototype.padStart polyfill
  42. if (!String.prototype.padStart) {
  43.     String.prototype.padStart = function(targetLength, padString) {
  44.         targetLength = targetLength >> 0; // 转换为整数
  45.         padString = String((typeof padString !== 'undefined' ? padString : ' '));
  46.         if (this.length > targetLength) {
  47.             return String(this);
  48.         } else {
  49.             targetLength = targetLength - this.length;
  50.             if (targetLength > padString.length) {
  51.                 padString += padString.repeat(targetLength / padString.length); // 截断或重复填充字符串
  52.             }
  53.             return padString.slice(0, targetLength) + String(this);
  54.         }
  55.     };
  56. }

  58. /*
  59.    安卓可移动侧栏日志吐司
  60.    功能：
  61.    1. 可拖拽移动的侧栏悬浮窗
  62.    2. 支持日志信息实时显示
  63.    3. 支持展开/收起功能
  64.    4. 支持自定义日志颜色
  65. */

  67. // 定义侧栏日志悬浮窗构造函数
  68. function 侧栏日志() {
  69.     this.screenHeight = 1920; // 默认屏幕高度
  70.     this.screenWidth = 1080;  // 默认屏幕宽度
  71.     this.isExpanded = false;  // 展开状态标志
  72.     this.logs = [];           // 日志数组
  73.     this.maxLogs = 50;        // 最大日志条数
  74.     this.dragging = false;    // 拖拽状态标志
  75.     this.lastX = 0;           // 上次触摸X坐标
  76.     this.lastY = 0;           // 上次触摸Y坐标
  77. }

  79. // 创建侧栏日志悬浮窗
  80. 侧栏日志.prototype.create = function() {
  81.     try {
  82.         // 检查floatUI是否可用
  83.         if (typeof floatUI === 'undefined') {
  84.             printl("❌ 错误：未找到floatUI库");
  85.             return false;
  86.         }
  87.         
  88.         // 创建floatUI实例
  89.         var fui = new floatUI();
  90.         
  91.         // 获取实际屏幕尺寸
  92.         try {
  93.             if (context && context.getResources && context.getResources().getDisplayMetrics) {
  94.                 var metrics = context.getResources().getDisplayMetrics();
  95.                 this.screenHeight = metrics.heightPixels || 1920;
  96.                 this.screenWidth = metrics.widthPixels || 1080;
  97.                 printl("✅ 获取屏幕尺寸: " + this.screenWidth + "x" + this.screenHeight);
  98.             } else {
  99.                 printl("⚠️ 无法获取屏幕尺寸，使用默认值");
  100.                 this.screenHeight = 1920; // 默认屏幕高度
  101.                 this.screenWidth = 1080;  // 默认屏幕宽度
  102.             }
  103.         } catch(e) {
  104.             printl("⚠️ 获取屏幕尺寸失败，使用默认值: " + e);
  105.             this.screenHeight = 1920;
  106.             this.screenWidth = 1080;
  107.         }
  108.         
  109.         // 定义侧边栏宽度和高度
  110.         var sidebarWidth = 100;  // 更窄的侧边栏宽度
  111.         var sidebarMinWidth = 30; // 更窄的收起时最小宽度
  112.         var sidebarHeight = 100; // 固定小高度，不再依赖屏幕比例
  113.         
  114.         // 加载XML布局
  115.         try {
  116.             fui.loadXML(`
  117.                 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  118.                     android:layout_width="${sidebarWidth}dp"
  119.                     android:layout_height="${sidebarHeight}dp"
  120.                     android:background="#CC000000"
  121.                     android:orientation="vertical"
  122.                     android:id="main_container">
  123.                     
  124.                     <!-- 可拖动的标题栏 -->
  125.                     <LinearLayout
  126.                         android:id="title_bar"
  127.                         android:layout_width="match_parent"
  128.                         android:layout_height="35dp"
  129.                         android:background="#666666"
  130.                         android:orientation="horizontal"
  131.                         android:gravity="center_vertical">
  132.                         
  133.                         <!-- 拖动区域 -->
  134.                         <View
  135.                             android:layout_width="${sidebarMinWidth}dp"
  136.                             android:layout_height="match_parent"
  137.                             android:background="#444444"/>
  138.                         
  139.                         <!-- 标题文字（仅在展开时可见） -->
  140.                         <TextView
  141.                             android:id="title_text"
  142.                             android:layout_width="0dp"
  143.                             android:layout_height="match_parent"
  144.                             android:layout_weight="1"
  145.                             android:text="运行日志"
  146.                             android:textColor="#FFFFFF"
  147.                             android:gravity="center"
  148.                             android:textSize="14sp"/>
  149.                            
  150.                         <!-- 关闭按钮（仅在展开时可见） -->
  151.                             <Button
  152.                                 android:id="close_button"
  153.                                 android:layout_width="30dp"
  154.                                 android:layout_height="30dp"
  155.                                 android:text="✕"
  156.                                 android:textColor="#FFFFFF"
  157.                                 android:background="#FF4444"
  158.                                 android:textSize="14sp"
  159.                                 android:padding="0dp"
  160.                                 android:gravity="center"/>
  161.                     </LinearLayout>
  162.                     
  163.                     <!-- 日志显示区域（仅在展开时可见） -->
  164.                     <ScrollView
  165.                         android:id="log_container"
  166.                         android:layout_width="match_parent"
  167.                         android:layout_height="match_parent"
  168.                         android:background="#111111">
  169.                         
  170.                         <TextView
  171.                             android:id="log_text"
  172.                             android:layout_width="match_parent"
  173.                             android:layout_height="wrap_content"
  174.                             android:textColor="#00FF00"
  175.                             android:textSize="11sp"
  176.                             android:padding="3dp"
  177.                             android:lineSpacingExtra="1dp"/>
  178.                     </ScrollView>
  179.                     
  180.                     <!-- 展开/收起按钮 -->
  181.                     <Button
  182.                         android:id="toggle_button"
  183.                         android:layout_width="match_parent"
  184.                         android:layout_height="25dp"
  185.                         android:text="≡"
  186.                         android:textColor="#FFFFFF"
  187.                         android:background="#555555"
  188.                         android:textSize="16sp"/>
  189.                 </LinearLayout>
  190.             `);
  191.             printl("✅ XML布局加载成功");
  192.         } catch (xmlError) {
  193.             printl("❌ XML布局加载失败: " + xmlError);
  194.             return false;
  195.         }
  196.         
  197.         // 保存UI实例
  198.         this.ui = fui;
  199.         
  200.         // 保存宽度设置供toggleExpand方法使用
  201.         this.sidebarWidth = sidebarWidth;
  202.         this.sidebarMinWidth = sidebarMinWidth;
  203.         
  204.         // 获取UI元素
  205.         try {
  206.             this.titleBar = fui.findViewById("title_bar");
  207.             this.titleText = fui.findViewById("title_text");
  208.             this.logContainer = fui.findViewById("log_container");
  209.             this.logText = fui.findViewById("log_text");
  210.             this.toggleButton = fui.findViewById("toggle_button");
  211.             this.closeButton = fui.findViewById("close_button"); // 获取关闭按钮
  212.             this.mainContainer = fui.findViewById("main_container");
  213.             
  214.             // 检查关键元素是否存在
  215.             var missingElements = [];
  216.             if (!this.titleBar) missingElements.push("titleBar");
  217.             if (!this.logText) missingElements.push("logText");
  218.             if (!this.toggleButton) missingElements.push("toggleButton");
  219.             if (!this.mainContainer) missingElements.push("mainContainer");
  220.             
  221.             if (missingElements.length > 0) {
  222.                 printl("⚠️ 缺失关键UI元素: " + missingElements.join(", "));
  223.             } else {
  224.                 printl("✅ 所有UI元素获取成功");
  225.             }
  226.         } catch (findError) {
  227.             printl("❌ 获取UI元素失败: " + findError);
  228.         }
  229.         
  230.         // 设置初始位置（屏幕左侧）
  231.         try {
  232.             this.setPos(0, (this.screenHeight - 100) / 2);
  233.             printl("✅ 初始位置设置成功");
  234.         } catch (posError) {
  235.             printl("❌ 设置初始位置失败: " + posError);
  236.         }
  237.         
  238.         // 初始化事件
  239.         try {
  240.             this.initEvents();
  241.             printl("✅ 事件初始化成功");
  242.         } catch (eventError) {
  243.             printl("❌ 事件初始化失败: " + eventError);
  244.         }
  245.         
  246.         // 显示初始化日志
  247.         this.log("✅ 侧栏日志已启动", "#00FF00");
  248.         
  249.         return true;
  250.     } catch (e) {
  251.         printl("❌ 创建侧栏日志失败: " + e);
  252.         return false;
  253.     }
  254. };

  256. // 初始化事件
  257. 侧栏日志.prototype.initEvents = function() {
  258.     var self = this;
  259.    
  260.     // 设置拖拽事件 - 添加更完善的错误处理
  261.     try {
  262.         if (typeof View !== 'undefined' && typeof MotionEvent !== 'undefined' && this.titleBar && this.titleBar.setOnTouchListener) {
  263.             this.titleBar.setOnTouchListener(new View.OnTouchListener({
  264.                 onTouch: function(view, event) {
  265.                     try {
  266.                         switch (event.getAction()) {
  267.                             case MotionEvent.ACTION_DOWN:
  268.                                 self.dragging = true;
  269.                                 self.lastX = event.getRawX();
  270.                                 self.lastY = event.getRawY();
  271.                                 break;
  272.                             case MotionEvent.ACTION_MOVE:
  273.                                 if (self.dragging) {
  274.                                     var dx = event.getRawX() - self.lastX;
  275.                                     var dy = event.getRawY() - self.lastY;
  276.                                     
  277.                                     // 获取当前位置
  278.                                     var currentX = view.getX();
  279.                                     var currentY = view.getY();
  280.                                     
  281.                                     // 计算新位置（考虑整个容器的位置）
  282.                                     var newX = currentX + dx;
  283.                                     var newY = currentY + dy;
  284.                                     
  285.                                     // 边界检查
  286.                                     if (newX < 0) newX = 0;
  287.                                     if (newY < 0) newY = 0;
  288.                                     if (newX > self.screenWidth - (self.isExpanded ? self.sidebarWidth : self.sidebarMinWidth))
  289.                                         newX = self.screenWidth - (self.isExpanded ? self.sidebarWidth : self.sidebarMinWidth);
  290.                                     if (newY > self.screenHeight - 100)
  291.                                         newY = self.screenHeight - 100;
  292.                                     
  293.                                     // 设置新位置
  294.                                     self.setPos(newX, newY);
  295.                                     
  296.                                     // 更新上次触摸位置
  297.                                     self.lastX = event.getRawX();
  298.                                     self.lastY = event.getRawY();
  299.                                 }
  300.                                 break;
  301.                             case MotionEvent.ACTION_UP:
  302.                                 self.dragging = false;
  303.                                 break;
  304.                         }
  305.                         return true;
  306.                     } catch (touchError) {
  307.                         // 静默处理触摸事件错误，避免崩溃
  308.                         return false;
  309.                     }
  310.                 }
  311.             }));
  312.         } else {
  313.             printl("⚠️ 无法设置拖拽事件，缺少必要组件");
  314.         }
  315.     } catch (touchSetupError) {
  316.         printl("❌ 设置拖拽事件失败: " + touchSetupError);
  317.     }
  318.    
  319.     // 展开/收起按钮点击事件
  320.     try {
  321.         if (this.toggleButton && this.toggleButton.setOnClickListener) {
  322.             this.toggleButton.setOnClickListener(function() {
  323.                 try {
  324.                     self.toggleExpand();
  325.                 } catch (toggleError) {
  326.                     printl("❌ 执行展开/收起操作失败: " + toggleError);
  327.                 }
  328.             });
  329.         }
  330.     } catch (toggleSetupError) {
  331.         printl("❌ 设置展开/收起事件失败: " + toggleSetupError);
  332.     }
  333.    
  334.     // 关闭按钮点击事件
  335.     try {
  336.         if (this.closeButton && this.closeButton.setOnClickListener) {
  337.             this.closeButton.setOnClickListener(function() {
  338.                 try {
  339.                     self.close();
  340.                 } catch (closeError) {
  341.                     printl("❌ 执行关闭操作失败: " + closeError);
  342.                 }
  343.             });
  344.         }
  345.     } catch (closeSetupError) {
  346.         printl("❌ 设置关闭事件失败: " + closeSetupError);
  347.     }
  348. };

  350. // 获取当前时间用于日志
  351. 侧栏日志.prototype.getCurrentTime = function() {
  352.     var now = new Date();
  353.     var hours = now.getHours().toString().padStart(2, '0');
  354.     var minutes = now.getMinutes().toString().padStart(2, '0');
  355.     var seconds = now.getSeconds().toString().padStart(2, '0');
  356.     return hours + ':' + minutes + ':' + seconds;
  357. };

  359. // 切换展开/收起状态
  360. 侧栏日志.prototype.toggleExpand = function() {
  361.     try {
  362.         var self = this;
  363.         
  364.         // 记录当前状态变更（使用printl避免递归）
  365.         printl("[" + self.getCurrentTime() + "] " + (self.isExpanded ? "&#128317; 侧栏正在收起" : "&#128316; 侧栏正在展开"));
  366.         // 定义要设置的目标宽度 - 修复逻辑：当前展开时应该设置为收起宽度，当前收起时应该设置为展开宽度
  367.         var targetWidth = this.isExpanded ? this.sidebarMinWidth : this.sidebarWidth;
  368.         
  369.         // 切换展开状态标志
  370.         this.isExpanded = !this.isExpanded;
  371.         
  372.         // 确保在主线程中执行UI操作
  373.         var uiOperation = function() {
  374.             self.performToggleExpand(targetWidth);
  375.         };
  376.         
  377.         // 尝试多种UI线程调度方案
  378.         var threadScheduled = false;
  379.         
  380.         // 方案1: 使用context.runOnUiThread
  381.         try {
  382.             if (context && context.runOnUiThread) {
  383.                 // 使用ES5兼容的方式创建Runnable对象
  384.                 var runnable = {
  385.                     run: function() {
  386.                         try {
  387.                             uiOperation();
  388.                         } catch (e) {
  389.                             printl("❌ UI线程执行失败: " + e);
  390.                         }
  391.                     }
  392.                 };
  393.                 context.runOnUiThread(runnable);
  394.                 threadScheduled = true;
  395.                 printl("✅ 使用context.runOnUiThread调度UI线程");
  396.             }
  397.         } catch (e) {
  398.             printl("❌ 方案1: context.runOnUiThread失败: " + e);
  399.         }
  400.         
  401.         // 方案2: 使用View.post (如果有任何View对象可用)
  402.         if (!threadScheduled) {
  403.             try {
  404.                 var viewToUse = self.mainContainer || self.titleBar || self.toggleButton;
  405.                 if (viewToUse && viewToUse.post) {
  406.                     viewToUse.post(function() {
  407.                         try {
  408.                             uiOperation();
  409.                         } catch (e) {
  410.                             printl("❌ View.post执行失败: " + e);
  411.                         }
  412.                     });
  413.                     threadScheduled = true;
  414.                     printl("✅ 使用View.post调度UI线程");
  415.                 }
  416.             } catch (e) {
  417.                 printl("❌ 方案2: View.post失败: " + e);
  418.             }
  419.         }
  420.         
  421.         // 方案3: 尝试使用Handler (如果可用)
  422.         if (!threadScheduled) {
  423.             try {
  424.                 if (typeof Handler !== 'undefined' && typeof Looper !== 'undefined' && Looper.getMainLooper) {
  425.                     var handler = new Handler(Looper.getMainLooper());
  426.                     handler.post(function() {
  427.                         try {
  428.                             uiOperation();
  429.                         } catch (e) {
  430.                             printl("❌ Handler执行失败: " + e);
  431.                         }
  432.                     });
  433.                     threadScheduled = true;
  434.                     printl("✅ 使用Handler调度UI线程");
  435.                 }
  436.             } catch (e) {
  437.                 printl("❌ 方案3: Handler失败: " + e);
  438.             }
  439.         }
  440.         
  441.         // 方案4: 直接执行作为最后备选 (可能会失败但提供降级方案)
  442.         if (!threadScheduled) {
  443.             printl("⚠️ 所有线程调度方案失败，尝试直接执行UI操作");
  444.             try {
  445.                 uiOperation();
  446.             } catch (directError) {
  447.                 printl("❌ 直接执行UI操作失败: " + directError);
  448.             }
  449.         }
  450.     } catch (e) {
  451.         printl("❌ 切换展开状态失败: " + e);
  452.     }
  453. };
  454. // 执行UI操作的核心方法（应在主线程中调用）
  455. 侧栏日志.prototype.performToggleExpand = function(targetWidth) {
  456.     try {
  457.         var self = this;
  458.         
  459.         // 切换UI元素可见性
  460.         if (!this.isExpanded) {
  461.             // 收起状态
  462.             if (this.titleText && typeof this.titleText.setVisibility === 'function') {
  463.                 try {
  464.                     this.titleText.setVisibility(View.GONE);
  465.                 } catch (e) {
  466.                     printl("❌ 设置titleText可见性失败: " + e);
  467.                 }
  468.             }
  469.             if (this.logContainer && typeof this.logContainer.setVisibility === 'function') {
  470.                 try {
  471.                     this.logContainer.setVisibility(View.GONE);
  472.                 } catch (e) {
  473.                     printl("❌ 设置logContainer可见性失败: " + e);
  474.                 }
  475.             }
  476.             if (this.closeButton && typeof this.closeButton.setVisibility === 'function') {
  477.                 try {
  478.                     this.closeButton.setVisibility(View.GONE); // 收起时隐藏关闭按钮
  479.                 } catch (e) {
  480.                     printl("❌ 设置closeButton可见性失败: " + e);
  481.                 }
  482.             }
  483.         } else {
  484.             // 展开状态
  485.             if (this.titleText && typeof this.titleText.setVisibility === 'function') {
  486.                 try {
  487.                     this.titleText.setVisibility(View.VISIBLE);
  488.                 } catch (e) {
  489.                     printl("❌ 设置titleText可见性失败: " + e);
  490.                 }
  491.             }
  492.             if (this.logContainer && typeof this.logContainer.setVisibility === 'function') {
  493.                 try {
  494.                     this.logContainer.setVisibility(View.VISIBLE);
  495.                 } catch (e) {
  496.                     printl("❌ 设置logContainer可见性失败: " + e);
  497.                 }
  498.             }
  499.             if (this.closeButton && typeof this.closeButton.setVisibility === 'function') {
  500.                 try {
  501.                     this.closeButton.setVisibility(View.VISIBLE); // 展开时显示关闭按钮
  502.                 } catch (e) {
  503.                     printl("❌ 设置closeButton可见性失败: " + e);
  504.                 }
  505.             }
  506.         }
  507.         
  508.         // 尝试多种方法来设置宽度，增加更多的备选方案
  509.         var widthSetSuccessfully = false;
  510.         var errorMessages = [];
  511.         
  512.         // 获取屏幕密度
  513.         var getDensity = function() {
  514.             try {
  515.                 if (context && context.getResources && context.getResources().getDisplayMetrics) {
  516.                     return context.getResources().getDisplayMetrics().density;
  517.                 }
  518.             } catch (e) {
  519.                 printl("⚠️ 获取屏幕密度失败: " + e);
  520.             }
  521.             return 3; // 默认密度
  522.         };
  523.         
  524.         // 方法1: 尝试通过FloatUI对象的可能方法
  525.         try {
  526.             if (this.ui && typeof this.ui.setLayoutWidth === 'function') {
  527.                 this.ui.setLayoutWidth(targetWidth);
  528.                 widthSetSuccessfully = true;
  529.                 printl("方法1: 使用setLayoutWidth设置宽度成功");
  530.             }
  531.         } catch (e) {
  532.             errorMessages.push("方法1: " + (e.message || String(e)));
  533.         }
  534.         
  535.         // 方法2: 尝试通过LayoutParams设置宽度
  536.         if (!widthSetSuccessfully) {
  537.             try {
  538.                 if (this.mainContainer && typeof this.mainContainer.getLayoutParams === 'function' &&
  539.                     typeof this.mainContainer.setLayoutParams === 'function') {
  540.                     var params = this.mainContainer.getLayoutParams();
  541.                     if (params) {
  542.                         // 尝试将dp转换为像素
  543.                         var pixelWidth = Math.round(targetWidth * getDensity());
  544.                         
  545.                         // 安全地设置宽度
  546.                         try {
  547.                             params.width = pixelWidth;
  548.                             this.mainContainer.setLayoutParams(params);
  549.                             widthSetSuccessfully = true;
  550.                             printl("方法2: 使用LayoutParams设置宽度成功");
  551.                         } catch (setParamsError) {
  552.                             errorMessages.push("方法2: " + (setParamsError.message || String(setParamsError)));
  553.                         }
  554.                     }
  555.                 }
  556.             } catch (e) {
  557.                 errorMessages.push("方法2: " + (e.message || String(e)));
  558.             }
  559.         }
  560.         
  561.         // 方法3: 尝试直接设置视图宽度
  562.         if (!widthSetSuccessfully) {
  563.             try {
  564.                 if (this.mainContainer && typeof this.mainContainer.setWidth === 'function') {
  565.                     // 使用已经计算好的像素宽度
  566.                     var pixelWidth = Math.round(targetWidth * getDensity());
  567.                     this.mainContainer.setWidth(pixelWidth);
  568.                     widthSetSuccessfully = true;
  569.                     printl("方法3: 使用setWidth设置宽度成功");
  570.                 }
  571.             } catch (e) {
  572.                 errorMessages.push("方法3: " + (e.message || String(e)));
  573.             }
  574.         }
  575.         
  576.         // 方法4: 尝试修改XML布局参数
  577.         if (!widthSetSuccessfully) {
  578.             try {
  579.                 if (this.ui && typeof this.ui.setLayoutParams === 'function') {
  580.                     // 尝试获取并修改FloatUI的布局参数
  581.                     var floatParams = (typeof this.ui.getLayoutParams === 'function') ? this.ui.getLayoutParams() : null;
  582.                     if (floatParams) {
  583.                         floatParams.width = Math.round(targetWidth * getDensity());
  584.                         this.ui.setLayoutParams(floatParams);
  585.                         widthSetSuccessfully = true;
  586.                         printl("方法4: 使用FloatUI.setLayoutParams设置宽度成功");
  587.                     }
  588.                 }
  589.             } catch (e) {
  590.                 errorMessages.push("方法4: " + (e.message || String(e)));
  591.             }
  592.         }
  593.         
  594.         // 方法5: 尝试使用layout方法直接设置位置和大小
  595.         if (!widthSetSuccessfully) {
  596.             try {
  597.                 if (this.mainContainer && typeof this.mainContainer.layout === 'function') {
  598.                     var left = 0;
  599.                     var top = 0;
  600.                     try {
  601.                         left = this.mainContainer.getLeft();
  602.                         top = this.mainContainer.getTop();
  603.                     } catch (positionError) {
  604.                         // 使用默认位置
  605.                     }
  606.                     var pixelWidth = Math.round(targetWidth * getDensity());
  607.                     var height = 0;
  608.                     try {
  609.                         height = this.mainContainer.getHeight();
  610.                     } catch (heightError) {
  611.                         height = 100; // 默认高度
  612.                     }
  613.                     this.mainContainer.layout(left, top, left + pixelWidth, top + height);
  614.                     widthSetSuccessfully = true;
  615.                     printl("方法5: 使用layout方法设置宽度成功");
  616.                 }
  617.             } catch (e) {
  618.                 errorMessages.push("方法5: " + (e.message || String(e)));
  619.             }
  620.         }
  621.         
  622.         // 尝试UI刷新方法
  623.         if (widthSetSuccessfully) {
  624.             try {
  625.                 if (this.ui && typeof this.ui.updateLayout === 'function') {
  626.                     this.ui.updateLayout();
  627.                     printl("UI布局已更新");
  628.                 } else if (this.mainContainer && typeof this.mainContainer.requestLayout === 'function') {
  629.                     this.mainContainer.requestLayout();
  630.                     printl("请求重新布局");
  631.                 } else if (this.mainContainer && typeof this.mainContainer.invalidate === 'function') {
  632.                     this.mainContainer.invalidate();
  633.                     printl("视图已刷新");
  634.                 }
  635.             } catch (e) {
  636.                 printl("刷新布局失败: " + e);
  637.             }
  638.         }
  639.         
  640.         // 设置按钮文本
  641.         if (this.toggleButton && typeof this.toggleButton.setText === 'function') {
  642.             try {
  643.                 this.toggleButton.setText("≡");
  644.             } catch (e) {
  645.                 printl("❌ 设置按钮文本失败: " + e);
  646.             }
  647.         }
  648.         
  649.         // 延迟100ms后记录状态更新，确保UI已更新
  650.         setTimeout(function() {
  651.             try {
  652.                 if (widthSetSuccessfully) {
  653.                     printl("✅ " + (self.isExpanded ? "侧栏已展开" : "侧栏已收起"));
  654.                 } else {
  655.                     // 只记录第一个错误信息，避免日志过多
  656.                     var mainError = errorMessages.length > 0 ? errorMessages[0] : "未知错误";
  657.                     printl(mainError);
  658.                     printl("⚠️ 侧栏" + (self.isExpanded ? "展开" : "收起") + "但宽度调整失败");
  659.                 }
  660.             } catch (e) {
  661.                 // 静默处理日志错误
  662.             }
  663.         }, 100);
  664.         
  665.         return widthSetSuccessfully;
  666.     } catch (e) {
  667.         printl("❌ 执行切换展开/收起操作失败: " + e);
  668.         return false;
  669.     }
  670. };

  672. // 添加日志
  673. 侧栏日志.prototype.log = function(message, color) {
  674.     try {
  675.         // 生成时间戳
  676.         var now = new Date();
  677.         var timeStr = now.getHours().toString().padStart(2, '0') + ":" +
  678.                       now.getMinutes().toString().padStart(2, '0') + ":" +
  679.                       now.getSeconds().toString().padStart(2, '0');
  680.         
  681.         // 格式化日志条目
  682.         var logEntry = "[" + timeStr + "] " + message;
  683.         
  684.         // 添加到日志数组
  685.         this.logs.push({text: logEntry, color: color || "#00FF00"});
  686.         
  687.         // 限制日志数量
  688.         if (this.logs.length > this.maxLogs) {
  689.             this.logs.shift(); // 移除最早的日志
  690.         }
  691.         
  692.         // 更新显示
  693.         this.updateLogDisplay();
  694.         
  695.         // 同时打印到控制台
  696.         printl(logEntry);
  697.     } catch (e) {
  698.         printl("❌ 添加日志失败: " + e);
  699.     }
  700. };

  702. // 更新日志显示
  703. 侧栏日志.prototype.updateLogDisplay = function() {
  704.     try {
  705.         var self = this;
  706.         var uiOperation = function() {
  707.             self.performUpdateLogDisplay();
  708.         };
  709.         
  710.         // 尝试多种UI线程调度方案
  711.         var threadScheduled = false;
  712.         
  713.         // 方案1: 使用context.runOnUiThread
  714.         try {
  715.             if (context && context.runOnUiThread) {
  716.                 var runnable = {
  717.                     run: function() {
  718.                         try {
  719.                             uiOperation();
  720.                         } catch (e) {
  721.                             printl("❌ UI线程执行日志更新失败: " + e);
  722.                         }
  723.                     }
  724.                 };
  725.                 context.runOnUiThread(runnable);
  726.                 threadScheduled = true;
  727.             }
  728.         } catch (e) {
  729.             printl("❌ 方案1: context.runOnUiThread调度日志更新失败: " + e);
  730.         }
  731.         
  732.         // 方案2: 使用View.post
  733.         if (!threadScheduled) {
  734.             try {
  735.                 var viewToUse = self.logText || self.logContainer || self.mainContainer;
  736.                 if (viewToUse && viewToUse.post) {
  737.                     viewToUse.post(function() {
  738.                         try {
  739.                             uiOperation();
  740.                         } catch (e) {
  741.                             printl("❌ View.post执行日志更新失败: " + e);
  742.                         }
  743.                     });
  744.                     threadScheduled = true;
  745.                 }
  746.             } catch (e) {
  747.                 printl("❌ 方案2: View.post调度日志更新失败: " + e);
  748.             }
  749.         }
  750.         
  751.         // 方案3: 尝试使用Handler
  752.         if (!threadScheduled) {
  753.             try {
  754.                 if (typeof Handler !== 'undefined' && typeof Looper !== 'undefined' && Looper.getMainLooper) {
  755.                     var handler = new Handler(Looper.getMainLooper());
  756.                     handler.post(function() {
  757.                         try {
  758.                             uiOperation();
  759.                         } catch (e) {
  760.                             printl("❌ Handler执行日志更新失败: " + e);
  761.                         }
  762.                     });
  763.                     threadScheduled = true;
  764.                 }
  765.             } catch (e) {
  766.                 printl("❌ 方案3: Handler调度日志更新失败: " + e);
  767.             }
  768.         }
  769.         
  770.         // 方案4: 直接执行作为最后备选
  771.         if (!threadScheduled) {
  772.             try {
  773.                 uiOperation();
  774.             } catch (directError) {
  775.                 printl("❌ 直接执行日志更新失败: " + directError);
  776.             }
  777.         }
  778.     } catch (e) {
  779.         printl("❌ 更新日志显示失败: " + e);
  780.     }
  781. };

  783. // 执行日志显示更新的核心方法（应在主线程中调用）
  784. 侧栏日志.prototype.performUpdateLogDisplay = function() {
  785.     try {
  786.         // 检查logText是否存在
  787.         if (!this.logText || typeof this.logText.setText !== 'function') {
  788.             printl("⚠️ 日志显示组件不可用");
  789.             return;
  790.         }
  791.         
  792.         // 构建日志文本
  793.         var logText = "";
  794.         var useHtml = false;
  795.         
  796.         // 尝试HTML格式
  797.         try {
  798.             if (typeof android.text.Html !== 'undefined' && typeof android.text.Html.fromHtml === 'function') {
  799.                 var htmlText = "";
  800.                 for (var i = 0; i < this.logs.length; i++) {
  801.                     var log = this.logs[i];
  802.                     var color = log.color || "#00FF00";
  803.                     htmlText += "<font color=\"" + color + "\">" + log.text + "</font><br/>";
  804.                 }
  805.                
  806.                 try {
  807.                     var spanned = android.text.Html.fromHtml(htmlText);
  808.                     this.logText.setText(spanned);
  809.                     useHtml = true;
  810.                     printl("✅ 日志使用HTML格式显示");
  811.                 } catch (htmlError) {
  812.                     printl("⚠️ HTML格式化失败，回退到纯文本: " + htmlError);
  813.                 }
  814.             }
  815.         } catch (e) {
  816.             printl("⚠️ HTML支持不可用: " + e);
  817.         }
  818.         
  819.         // 如果HTML格式失败，使用纯文本格式
  820.         if (!useHtml) {
  821.             for (var i = 0; i < this.logs.length; i++) {
  822.                 logText += this.logs[i].text + "\n";
  823.             }
  824.             
  825.             try {
  826.                 this.logText.setText(logText);
  827.                 printl("✅ 日志使用纯文本格式显示");
  828.             } catch (textError) {
  829.                 printl("❌ 设置日志文本失败: " + textError);
  830.             }
  831.         }
  832.         
  833.         // 尝试滚动到底部
  834.         var self = this;
  835.         try {
  836.             if (this.logContainer && typeof this.logContainer.post === 'function') {
  837.                 this.logContainer.post(function() {
  838.                     try {
  839.                         if (self.logContainer && typeof self.logContainer.fullScroll === 'function') {
  840.                             self.logContainer.fullScroll(android.widget.ScrollView.FOCUS_DOWN);
  841.                         }
  842.                     } catch (scrollError) {
  843.                         // 静默处理滚动错误
  844.                     }
  845.                 });
  846.             } else if (this.logContainer && typeof this.logContainer.fullScroll === 'function') {
  847.                 this.logContainer.fullScroll(android.widget.ScrollView.FOCUS_DOWN);
  848.             }
  849.         } catch (e) {
  850.             // 静默处理滚动错误
  851.         }
  852.     } catch (e) {
  853.         printl("❌ 执行日志显示更新失败: " + e);
  854.     }
  855. };

  857. // 设置悬浮窗位置
  858. 侧栏日志.prototype.setPos = function(x, y) {
  859.     try {
  860.         var self = this;
  861.         
  862.         // 参数验证
  863.         if (typeof x !== 'number' || typeof y !== 'number') {
  864.             printl("❌ setPos参数错误: x和y必须是数字");
  865.             return false;
  866.         }
  867.         
  868.         // 边界检查
  869.         var currentWidth = this.isExpanded ? this.sidebarWidth : this.sidebarMinWidth;
  870.         try {
  871.             if (context && context.getResources && context.getResources().getDisplayMetrics) {
  872.                 var density = context.getResources().getDisplayMetrics().density;
  873.                 currentWidth *= density;
  874.             }
  875.         } catch (e) {
  876.             currentWidth *= 3; // 使用默认密度倍数
  877.         }
  878.         
  879.         if (x < 0) x = 0;
  880.         if (y < 0) y = 0;
  881.         if (x > this.screenWidth - currentWidth) x = this.screenWidth - currentWidth;
  882.         if (y > this.screenHeight - 100) y = this.screenHeight - 100;
  883.         
  884.         // 使用printl避免递归调用
  885.         printl("&#128260; 设置悬浮窗位置: x=" + x + ", y=" + y);
  886.         
  887.         // 定义UI操作函数
  888.         var uiOperation = function() {
  889.             self.performSetPos(x, y);
  890.         };
  891.         
  892.         // 尝试多种UI线程调度方案
  893.         var threadScheduled = false;
  894.         
  895.         // 方案1: 使用context.runOnUiThread
  896.         try {
  897.             if (context && context.runOnUiThread) {
  898.                 var runnable = {
  899.                     run: function() {
  900.                         try {
  901.                             uiOperation();
  902.                         } catch (e) {
  903.                             printl("❌ UI线程执行位置设置失败: " + e);
  904.                         }
  905.                     }
  906.                 };
  907.                 context.runOnUiThread(runnable);
  908.                 threadScheduled = true;
  909.                 printl("✅ 使用context.runOnUiThread调度位置设置");
  910.             }
  911.         } catch (e) {
  912.             printl("❌ 方案1: context.runOnUiThread调度位置设置失败: " + e);
  913.         }
  914.         
  915.         // 方案2: 使用View.post
  916.         if (!threadScheduled) {
  917.             try {
  918.                 var viewToUse = self.mainContainer || self.titleBar || self.toggleButton;
  919.                 if (viewToUse && typeof viewToUse.post === 'function') {
  920.                     viewToUse.post(function() {
  921.                         try {
  922.                             uiOperation();
  923.                         } catch (e) {
  924.                             printl("❌ View.post执行位置设置失败: " + e);
  925.                         }
  926.                     });
  927.                     threadScheduled = true;
  928.                     printl("✅ 使用View.post调度位置设置");
  929.                 }
  930.             } catch (e) {
  931.                 printl("❌ 方案2: View.post调度位置设置失败: " + e);
  932.             }
  933.         }
  934.         
  935.         // 方案3: 尝试使用Handler
  936.         if (!threadScheduled) {
  937.             try {
  938.                 if (typeof Handler !== 'undefined' && typeof Looper !== 'undefined' && Looper.getMainLooper) {
  939.                     var handler = new Handler(Looper.getMainLooper());
  940.                     handler.post(function() {
  941.                         try {
  942.                             uiOperation();
  943.                         } catch (e) {
  944.                             printl("❌ Handler执行位置设置失败: " + e);
  945.                         }
  946.                     });
  947.                     threadScheduled = true;
  948.                     printl("✅ 使用Handler调度位置设置");
  949.                 }
  950.             } catch (e) {
  951.                 printl("❌ 方案3: Handler调度位置设置失败: " + e);
  952.             }
  953.         }
  954.         
  955.         // 方案4: 直接执行作为最后备选
  956.         if (!threadScheduled) {
  957.             printl("⚠️ 所有线程调度方案失败，尝试直接执行位置设置");
  958.             try {
  959.                 uiOperation();
  960.             } catch (directError) {
  961.                 printl("❌ 直接执行位置设置失败: " + directError);
  962.             }
  963.         }
  964.         
  965.         return true;
  966.     } catch (e) {
  967.         printl("❌ 设置位置失败: " + e);
  968.         return false;
  969.     }
  970. };

  972. // 执行设置位置的核心方法（应在主线程中调用）
  973. 侧栏日志.prototype.performSetPos = function(x, y) {
  974.     try {
  975.         var posSetSuccess = false;
  976.         
  977.         // 方案1: 尝试使用floatUI的setPos方法
  978.         try {
  979.             if (this.ui && this.ui.setPos) {
  980.                 this.ui.setPos(x, y);
  981.                 posSetSuccess = true;
  982.                 printl("✅ 方案1: 使用floatUI.setPos设置位置成功");
  983.             }
  984.         } catch (e) {
  985.             printl("❌ 方案1: floatUI.setPos失败: " + e);
  986.         }
  987.         
  988.         // 方案2: 尝试使用floatUI的setPosition方法
  989.         if (!posSetSuccess) {
  990.             try {
  991.                 if (this.ui && this.ui.setPosition) {
  992.                     this.ui.setPosition(x, y);
  993.                     posSetSuccess = true;
  994.                     printl("✅ 方案2: 使用floatUI.setPosition设置位置成功");
  995.                 }
  996.             } catch (e) {
  997.                 printl("❌ 方案2: floatUI.setPosition失败: " + e);
  998.             }
  999.         }
  1000.         
  1001.         // 方案3: 尝试使用setX和setY方法（如果可用）
  1002.         if (!posSetSuccess) {
  1003.             try {
  1004.                 if (this.ui && typeof this.ui.setX === 'function' && typeof this.ui.setY === 'function') {
  1005.                     this.ui.setX(x);
  1006.                     this.ui.setY(y);
  1007.                     posSetSuccess = true;
  1008.                     printl("✅ 方案3: 使用ui.setX/setY设置位置成功");
  1009.                 }
  1010.             } catch (e) {
  1011.                 printl("❌ 方案3: ui.setX/setY失败: " + e);
  1012.             }
  1013.         }
  1014.         
  1015.         // 方案4: 尝试通过mainContainer设置位置
  1016.         if (!posSetSuccess) {
  1017.             try {
  1018.                 if (this.mainContainer && typeof this.mainContainer.setX === 'function' && typeof this.mainContainer.setY === 'function') {
  1019.                     this.mainContainer.setX(x);
  1020.                     this.mainContainer.setY(y);
  1021.                     posSetSuccess = true;
  1022.                     printl("✅ 方案4: 使用mainContainer.setX/setY设置位置成功");
  1023.                 }
  1024.             } catch (e) {
  1025.                 printl("❌ 方案4: mainContainer.setX/setY失败: " + e);
  1026.             }
  1027.         }
  1028.         
  1029.         // 方案5: 尝试通过直接访问mainContainer设置位置
  1030.         if (!posSetSuccess) {
  1031.             try {
  1032.                 if (this.mainContainer && typeof this.mainContainer.layout === 'function' && typeof this.mainContainer.getWidth === 'function' && typeof this.mainContainer.getHeight === 'function') {
  1033.                     this.mainContainer.layout(x, y, x + this.mainContainer.getWidth(), y + this.mainContainer.getHeight());
  1034.                     posSetSuccess = true;
  1035.                     printl("✅ 方案5: 使用layout方法设置位置成功");
  1036.                 }
  1037.             } catch (e) {
  1038.                 printl("❌ 方案5: layout方法失败: " + e);
  1039.             }
  1040.         }
  1041.         
  1042.         // 刷新UI确保位置更新生效
  1043.         if (posSetSuccess) {
  1044.             try {
  1045.                 // 尝试多种刷新方法
  1046.                 if (this.mainContainer) {
  1047.                     if (typeof this.mainContainer.invalidate === 'function') {
  1048.                         this.mainContainer.invalidate();
  1049.                     }
  1050.                     if (typeof this.mainContainer.requestLayout === 'function') {
  1051.                         this.mainContainer.requestLayout();
  1052.                     }
  1053.                 }
  1054.                 printl("✅ 位置设置刷新完成");
  1055.             } catch (refreshError) {
  1056.                 printl("⚠️ 刷新位置时出错: " + refreshError);
  1057.             }
  1058.         } else {
  1059.             printl("⚠️ 位置设置完成但可能未生效");
  1060.         }
  1061.         
  1062.         return posSetSuccess;
  1063.     } catch (e) {
  1064.         printl("❌ 执行位置设置失败: " + e);
  1065.         return false;
  1066.     }
  1067. };

  1069. // 清空日志
  1070. 侧栏日志.prototype.clearLogs = function() {
  1071.     try {
  1072.         // 清空日志数组
  1073.         this.logs = [];
  1074.         
  1075.         // 清空日志显示
  1076.         if (this.logText && this.logText.setText) {
  1077.             try {
  1078.                 this.logText.setText("");
  1079.             } catch (setTextError) {
  1080.                 printl("⚠️ 清空日志显示失败: " + setTextError);
  1081.             }
  1082.         }
  1083.         
  1084.         // 记录清空操作
  1085.         this.log("&#128465;️ 日志已清空", "#FF0000");
  1086.         return true;
  1087.     } catch (e) {
  1088.         printl("❌ 清空日志失败: " + e);
  1089.         return false;
  1090.     }
  1091. };

  1093. // 关闭悬浮窗
  1094. 侧栏日志.prototype.close = function() {
  1095.     try {
  1096.         var self = this;
  1097.         
  1098.         // 使用printl避免递归调用
  1099.         printl("&#128260; 正在关闭侧栏日志悬浮窗...");
  1100.         
  1101.         // 定义UI操作函数
  1102.         var uiOperation = function() {
  1103.             self.performClose();
  1104.         };
  1105.         
  1106.         // 尝试多种UI线程调度方案
  1107.         var threadScheduled = false;
  1108.         
  1109.         // 方案1: 使用context.runOnUiThread
  1110.         try {
  1111.             if (context && context.runOnUiThread) {
  1112.                 var runnable = {
  1113.                     run: function() {
  1114.                         try {
  1115.                             uiOperation();
  1116.                         } catch (e) {
  1117.                             printl("❌ UI线程执行关闭操作失败: " + e);
  1118.                         }
  1119.                     }
  1120.                 };
  1121.                 context.runOnUiThread(runnable);
  1122.                 threadScheduled = true;
  1123.                 printl("✅ 使用context.runOnUiThread调度关闭操作");
  1124.             }
  1125.         } catch (e) {
  1126.             printl("❌ 方案1: context.runOnUiThread调度关闭操作失败: " + e);
  1127.         }
  1128.         
  1129.         // 方案2: 使用View.post
  1130.         if (!threadScheduled) {
  1131.             try {
  1132.                 var viewToUse = self.mainContainer || self.titleBar || self.toggleButton;
  1133.                 if (viewToUse && typeof viewToUse.post === 'function') {
  1134.                     viewToUse.post(function() {
  1135.                         try {
  1136.                             uiOperation();
  1137.                         } catch (e) {
  1138.                             printl("❌ View.post执行关闭操作失败: " + e);
  1139.                         }
  1140.                     });
  1141.                     threadScheduled = true;
  1142.                     printl("✅ 使用View.post调度关闭操作");
  1143.                 }
  1144.             } catch (e) {
  1145.                 printl("❌ 方案2: View.post调度关闭操作失败: " + e);
  1146.             }
  1147.         }
  1148.         
  1149.         // 方案3: 尝试使用Handler
  1150.         if (!threadScheduled) {
  1151.             try {
  1152.                 if (typeof Handler !== 'undefined' && typeof Looper !== 'undefined' && Looper.getMainLooper) {
  1153.                     var handler = new Handler(Looper.getMainLooper());
  1154.                     handler.post(function() {
  1155.                         try {
  1156.                             uiOperation();
  1157.                         } catch (e) {
  1158.                             printl("❌ Handler执行关闭操作失败: " + e);
  1159.                         }
  1160.                     });
  1161.                     threadScheduled = true;
  1162.                     printl("✅ 使用Handler调度关闭操作");
  1163.                 }
  1164.             } catch (e) {
  1165.                 printl("❌ 方案3: Handler调度关闭操作失败: " + e);
  1166.             }
  1167.         }
  1168.         
  1169.         // 方案4: 直接执行作为最后备选
  1170.         if (!threadScheduled) {
  1171.             printl("⚠️ 所有线程调度方案失败，尝试直接执行关闭操作");
  1172.             try {
  1173.                 uiOperation();
  1174.             } catch (directError) {
  1175.                 printl("❌ 直接执行关闭操作失败: " + directError);
  1176.             }
  1177.         }
  1178.     } catch (e) {
  1179.         printl("❌ 关闭侧栏日志悬浮窗失败: " + e);
  1180.     }
  1181. };

  1183. // 执行关闭操作的核心方法（应在主线程中调用）
  1184. 侧栏日志.prototype.performClose = function() {
  1185.     try {
  1186.         printl("&#128260; 执行悬浮窗关闭操作...");
  1187.         
  1188.         // 尝试多种关闭方案
  1189.         var closeSuccess = false;
  1190.         
  1191.         // 方案1: 尝试使用close方法
  1192.         try {
  1193.             if (this.ui && typeof this.ui.close === 'function') {
  1194.                 this.ui.close();
  1195.                 closeSuccess = true;
  1196.                 printl("✅ 方案1: 使用ui.close()成功关闭");
  1197.             }
  1198.         } catch (e) {
  1199.             printl("❌ 方案1: 使用ui.close()关闭失败: " + e);
  1200.         }
  1201.         
  1202.         // 方案2: 尝试使用destroy方法
  1203.         if (!closeSuccess) {
  1204.             try {
  1205.                 if (this.ui && typeof this.ui.destroy === 'function') {
  1206.                     this.ui.destroy();
  1207.                     closeSuccess = true;
  1208.                     printl("✅ 方案2: 使用ui.destroy()成功关闭");
  1209.                 }
  1210.             } catch (e) {
  1211.                 printl("❌ 方案2: 使用ui.destroy()关闭失败: " + e);
  1212.             }
  1213.         }
  1214.         
  1215.         // 方案3: 尝试从父容器移除
  1216.         if (!closeSuccess) {
  1217.             try {
  1218.                 if (this.mainContainer && typeof this.mainContainer.getParent === 'function') {
  1219.                     var parent = this.mainContainer.getParent();
  1220.                     if (parent && typeof parent.removeView === 'function') {
  1221.                         parent.removeView(this.mainContainer);
  1222.                         closeSuccess = true;
  1223.                         printl("✅ 方案3: 从父容器移除成功");
  1224.                     }
  1225.                 }
  1226.             } catch (e) {
  1227.                 printl("❌ 方案3: 从父容器移除失败: " + e);
  1228.             }
  1229.         }
  1230.         
  1231.         // 方案4: 尝试隐藏视图
  1232.         if (!closeSuccess) {
  1233.             try {
  1234.                 if (this.mainContainer && typeof this.mainContainer.setVisibility === 'function') {
  1235.                     this.mainContainer.setVisibility(View.GONE);
  1236.                     closeSuccess = true;
  1237.                     printl("✅ 方案4: 隐藏视图成功");
  1238.                 }
  1239.             } catch (e) {
  1240.                 printl("❌ 方案4: 隐藏视图失败: " + e);
  1241.             }
  1242.         }
  1243.         
  1244.         // 清理资源
  1245.         try {
  1246.             // 清除事件监听器
  1247.             if (this.titleBar && typeof this.titleBar.setOnTouchListener === 'function') {
  1248.                 this.titleBar.setOnTouchListener(null);
  1249.             }
  1250.             if (this.toggleButton && typeof this.toggleButton.setOnClickListener === 'function') {
  1251.                 this.toggleButton.setOnClickListener(null);
  1252.             }
  1253.             if (this.closeButton && typeof this.closeButton.setOnClickListener === 'function') {
  1254.                 this.closeButton.setOnClickListener(null);
  1255.             }
  1256.             
  1257.             // 清除引用，帮助垃圾回收
  1258.             this.ui = null;
  1259.             this.mainContainer = null;
  1260.             this.titleBar = null;
  1261.             this.toggleButton = null;
  1262.             this.closeButton = null;
  1263.             this.titleText = null;
  1264.             this.logContainer = null;
  1265.             this.logText = null;
  1266.             this.logs = null;
  1267.             
  1268.             printl("✅ 资源清理完成");
  1269.         } catch (cleanupError) {
  1270.             printl("⚠️ 资源清理时出错: " + cleanupError);
  1271.         }
  1272.         
  1273.         // 更新状态
  1274.         sidebarLogger = null;
  1275.         
  1276.         // 记录关闭结果
  1277.         if (closeSuccess) {
  1278.             printl("✅ 侧栏日志悬浮窗已成功关闭");
  1279.         } else {
  1280.             printl("⚠️ 侧栏日志悬浮窗尝试关闭，但可能未完全成功");
  1281.         }
  1282.         
  1283.         return closeSuccess;
  1284.     } catch (e) {
  1285.         printl("❌ 执行关闭操作失败: " + e);
  1286.         return false;
  1287.     }
  1288. };

  1290. // 创建并启动侧栏日志悬浮窗
  1291. var sidebarLogger = null;

  1293. // 版本信息
  1294. const SIDEBAR_LOGGER_VERSION = "1.2.0";

  1296. // 初始化悬浮窗
  1297. function initSidebarLogger(options) {
  1298.     try {
  1299.         // 防止重复初始化
  1300.         if (sidebarLogger) {
  1301.             printl("⚠️ 侧栏日志已经初始化，无需重复创建");
  1302.             return sidebarLogger;
  1303.         }
  1304.         
  1305.         // 合并默认选项和用户选项
  1306.         options = options || {};
  1307.         
  1308.         // 环境检查
  1309.         if (typeof floatUI === 'undefined') {
  1310.             printl("❌ 错误：未找到floatUI库，请确保在AIWROK环境中运行！");
  1311.             return null;
  1312.         }
  1313.         
  1314.         // 打印启动信息
  1315.         printl("====================================");
  1316.         printl("&#128260; 侧栏日志悬浮窗初始化中...");
  1317.         printl("&#128241; 版本: " + SIDEBAR_LOGGER_VERSION);
  1318.         printl("====================================");
  1319.         
  1320.         // 创建悬浮窗实例
  1321.         sidebarLogger = new 侧栏日志();
  1322.         
  1323.         // 创建悬浮窗
  1324.         if (sidebarLogger.create()) {
  1325.             printl("✅ 侧栏日志悬浮窗已创建成功！");
  1326.             
  1327.             // 添加欢迎日志
  1328.             sidebarLogger.log("&#127881; 欢迎使用侧栏日志工具", "#00FFFF");
  1329.             sidebarLogger.log("&#128241; 版本: " + SIDEBAR_LOGGER_VERSION, "#00FFFF");
  1330.             sidebarLogger.log("&#128161; 点击≡按钮展开/收起侧栏", "#FFFF00");
  1331.             sidebarLogger.log("&#128260; 拖动标题栏可移动悬浮窗", "#FFFF00");
  1332.             sidebarLogger.log("&#128465;️ 右上角关闭按钮可关闭悬浮窗", "#FFFF00");
  1333.             sidebarLogger.log("&#128161; 可使用sidebarLogger.log()添加自定义日志", "#00FF00");
  1334.             
  1335.             // 自动展开悬浮窗，让用户看到关闭按钮
  1336.             try {
  1337.                 setTimeout(function() {
  1338.                     if (sidebarLogger && typeof sidebarLogger.toggleExpand === 'function') {
  1339.                         sidebarLogger.toggleExpand();
  1340.                     }
  1341.                 }, 500);
  1342.             } catch (autoExpandError) {
  1343.                 printl("⚠️ 自动展开失败: " + autoExpandError);
  1344.             }
  1345.             
  1346.             return sidebarLogger;
  1347.         } else {
  1348.             printl("❌ 侧栏日志悬浮窗创建失败！");
  1349.             sidebarLogger = null;
  1350.             return null;
  1351.         }
  1352.     } catch (e) {
  1353.         printl("❌ 初始化侧栏日志失败: " + e);
  1354.         sidebarLogger = null;
  1355.         return null;
  1356.     }
  1357. }

  1359. // 安全获取侧栏日志实例
  1360. function getSidebarLogger() {
  1361.     return sidebarLogger;
  1362. }

  1364. // 安全地记录日志（即使悬浮窗未初始化也不会报错）
  1365. function safeLog(message, color) {
  1366.     if (sidebarLogger && typeof sidebarLogger.log === 'function') {
  1367.         try {
  1368.             sidebarLogger.log(message, color);
  1369.             return true;
  1370.         } catch (e) {
  1371.             printl("⚠️ 记录日志失败: " + e);
  1372.         }
  1373.     }
  1374.     // 降级到console.log
  1375.     printl(message || "");
  1376.     return false;
  1377. }

  1379. // 启动悬浮窗
  1380. try {
  1381.     // 延迟初始化，确保环境准备就绪
  1382.     setTimeout(function() {
  1383.         initSidebarLogger();
  1384.     }, 100);
  1385. } catch (startupError) {
  1386.     printl("❌ 启动悬浮窗失败: " + startupError);
  1387.     // 作为最后的备选，尝试直接初始化
  1388.     try {
  1389.         initSidebarLogger();
  1390.     } catch (finalError) {
  1391.         printl("❌ 直接初始化也失败: " + finalError);
  1392.     }
  1393. }
复制代码



AIWROK, aiwrok软件
楼主新帖
楼主热帖
untoAIWROK软件安卓工具箱悬浮窗next安卓toast吐司的各种方法应用实例

相关帖子
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

相关导读
群发软件AIWROK苹果系统实例演示1标签类[Label]方法
AIWROK苹果系统实例演示1标签类[Label]方法
信息发布软件AIWROK软件苹果UI按钮Button方法示例
AIWROK软件苹果UI按钮Button方法示例
信息发布软件AIWROK软件苹果TAB界面视图示例
AIWROK软件苹果TAB界面视图示例
信息发布软件AIWROK苹果系统自带view视图简洁UI界面示例
AIWROK苹果系统自带view视图简洁UI界面示例
信息发布软件汇集HID安卓输入文字的方法和复制粘贴示例
汇集HID安卓输入文字的方法和复制粘贴示例
信息发布软件AIWROK软件找字与OCR方法汇总示例
AIWROK软件找字与OCR方法汇总示例
信息发布软件AIWROK软件找图方法汇总示例
AIWROK软件找图方法汇总示例
信息发布软件AIWROK软件滑动方法集合示例
AIWROK软件滑动方法集合示例
信息发布软件AIWROK软件安卓AIWROK汇集软件点击
AIWROK软件安卓AIWROK汇集软件点击
信息发布软件苹果系统点击方法综合示例
苹果系统点击方法综合示例
信息发布软件AIWROK苹果系统找图方法完整示例集合
AIWROK苹果系统找图方法完整示例集合
信息发布软件苹果系统找图方法完整示例集合
苹果系统找图方法完整示例集合
信息发布软件苹果IOS系统找字OCR方法例子
苹果IOS系统找字OCR方法例子
信息发布软件AIWORK软件数组高级示例
AIWORK软件数组高级示例
信息发布软件AIWROK软件运算符封装库示例
AIWROK软件运算符封装库示例
信息发布软件AIWROK软件语法运行小示例
AIWROK软件语法运行小示例
信息发布软件AIWROK软件JS循环小示例
AIWROK软件JS循环小示例
信息发布软件AIWROK软件H5网页被主脚本获取值用法
AIWROK软件H5网页被主脚本获取值用法
信息发布软件AIWROK软件创建可暂停恢复的多线程任务
AIWROK软件创建可暂停恢复的多线程任务
信息发布软件AIWROK软件类型转换方法例子
AIWROK软件类型转换方法例子
信息发布软件AIWROK软件H5脚本执行与进度显示
AIWROK软件H5脚本执行与进度显示 .
信息发布软件AIWROK软件根据时间段执行异步任务支持多线程并行处理
AIWROK软件根据时间段执行异步任务支持多线程并行处理
信息发布软件H5自动开关执行脚本功能演示
H5自动开关执行脚本功能演示
信息发布软件AIWROK软件H5单选脚本运行示例
AIWROK软件H5单选脚本运行示例
信息发布软件H5任务脚本选择与执行中心
H5任务脚本选择与执行中心
信息发布软件H5里CheckBox控件演示
H5里CheckBox控件演示
信息发布软件AIWROK软件正则用法实际例子
AIWROK软件正则用法实际例子
信息发布软件AIWROK软件权限管理器实现
AIWROK软件权限管理器实现
信息发布软件AIWORK软件节点方法无碍示例子
AIWORK软件节点方法无碍示例子
信息发布软件JSON.stringify 和 JSON.parse 完整示例
JSON.stringify 和 JSON.parse 完整示例
信息发布软件AIWROK软件展示JavaScript各种语句标识符的用法
AIWROK软件展示JavaScript各种语句标识符的用法
信息发布软件JS巧妙地组合使用各种条件语句
JS巧妙地组合使用各种条件语句
信息发布软件AIWROK手机数据库MySQL数据库截图片批量上传操作脚本
AIWROK手机数据库MySQL数据库截图片批量上传操作脚本
信息发布软件HID中文输入智能打字功能
HID中文输入智能打字功能
信息发布软件AIWROK软件对象工具函数库例子
AIWROK软件对象工具函数库例子
信息发布软件AIWROK软件H5交互演示黄色主题
AIWROK软件H5交互演示黄色主题
信息发布软件H5单按钮执行脚本示例
H5单按钮执行脚本示例
信息发布软件苹果H5界面完整调用脚本示例
苹果H5界面完整调用脚本示例
信息发布软件AIWROK软件平台设备信息全面检测工具例子
AIWROK软件平台设备信息全面检测工具例子
信息发布软件AIWROK创建和放大日志窗口并展示动态内容
AIWROK创建和放大日志窗口并展示动态内容
信息发布软件AIWROK软件device相关方法获取设备信息例子
AIWROK软件device相关方法获取设备信息例子[/backcolor]
信息发布软件数据库MySQL实时内容随机调用
数据库MySQL实时内容随机调用
信息发布软件AIWROK软件分享一个特效苹果H5页面
AIWROK软件分享一个特效苹果H5页面
信息发布软件数据库MYQ业务流程心跳程序启动
数据库MYQ业务流程心跳程序启动
信息发布软件数据库MySQL功能支持创建表插入中文数据查询删除功能例子
数据库MySQL功能支持创建表插入中文数据查询删除功能例子
信息发布软件AIWROK软件Zip 高级操作复杂示例
AIWROK软件Zip 高级操作复杂示例
信息发布软件AIWROK软件txt_文件读写方法小结
AIWROK软件txt_文件读写方法小结
信息发布软件AIWROK软件file文件操作方法小结
AIWROK软件file文件操作方法小结
信息发布软件AIWORK软件配置读写H5演示配套脚本
AIWORK软件配置读写H5演示配套脚本
信息发布软件AIWROK配置读写功能演示示例
AIWROK配置读写功能演示示例
信息发布软件AIWROK截图缓存工具
AIWROK截图缓存工具
信息发布软件AIWROK线程许可证工具
AIWROK线程许可证工具
信息发布软件整理了AIWROK环境下常用的Date对象和sleep对象方法
整理了AIWROK环境下常用的Date对象和sleep对象方法
信息发布软件FastUI界面普通用法
FastUI界面普通用法
信息发布软件FastUI界面类[window]方法小结
FastUI界面类[window]方法小结 方法 1：close（关闭指定窗口）方法 2：closeAll（关闭所有窗口）方法 3：loadUI（加载 UI 界面）方法 4：onClose（监听窗口关闭事件）方法 5：onLoad（监听窗口加载事件）方法 6：setFull（设置窗口全屏）方法 7：setHeight（设置窗口高度）方法 8：setHidden（隐藏窗口）方法 9：setLeft（设置窗口 X 轴坐标）方法 10：setTop（设置窗口 Y 轴坐标）方法 11：setVisable（显示隐藏的窗口）方
信息发布软件AIWROK软件按钮监听UI界面与事件监听功能演示
AIWROK软件按钮监听UI界面与事件监听功能演示.
信息发布软件AWIROK软件多选[uiCheckBox]方法小结
AWIROK软件多选方法小结 方法一：findByID 加载多选控件方法二：getAllChecked 获取所有选中项方法三：getAllSelect 获取所有选项方法四：getChecked 获取某个选项是否选中方法五：setChecked 设置某个选项是否选中方法六：setCheckeds 设置多个选项是否选中方法七：setHeight 设置高度
信息发布软件AIWROK日志演示开启日志显示 → 放大 → 关闭代码
AIWROK日志演示开启日志显示 → 放大 → 关闭代码
信息发布软件&#127983;AIWROK数组方法高级应用案例
🏯AIWROK数组方法高级应用案例
信息发布软件AIWROK软件日志悬浮窗简化版自动切换位置
AIWROK软件日志悬浮窗简化版自动切换位置
信息发布软件AIWROK软件String实例演示
AIWROK软件String实例演示
信息发布软件AIWROK软件S内置String类[String]方法小结
AIWROK软件S内置String类[String]方法小结 方法 1：charAt[/backcolor]方法 2：charCodeAt[/backcolor]方法 3：indexOf[/backcolor]方法 4：lastIndexOf[/backcolor]方法 5：length[/backcolor]方法 6：match[/backcolor]方法 7：replace[/backcolor]方法 8：replaceAll[/backcolor]方法 9：split[/backcolor]方法 10：startsWith[/backcolor]方法 11：substr[/backcolor]方法 12：substring[/backcolor]方法 13：trim[/backcol
信息发布软件AIWROK软件完整的WebSocket客户端示例
这段代码是一个完整的WebSocket客户端示例，用于连接到指定的WebSocket服务器并处理各种事件。具体来说，代码的作用如下： 定义服务器地址：首先定义了一个服务器的IP地址和端口号 var ip = "154.37.221.104:8886";。 创建WebSocket对象：尝试创建一个新的WebSocket对象 var ws = new WebSocket();。注意，这里的 new ws() 应该是 new WebSocket()。 添加事件监听器：代码中尝试为WebSocket对象添加事件监听器，但这里有一个错误。
信息发布软件AIWROK软件苹果系统中实现四种基本滑动操作
AIWROK软件苹果系统中实现四种基本滑动操作
信息发布软件hid的滑动没有百分比坐标滑动吗
hid的滑动没有百分比坐标滑动吗

QQ|( 京ICP备09078825号 )

本网站信息发布软件，是可以发布论坛，发送信息到各大博客，各大b2b软件自动发布，好不夸张的说：只要手工能发在电脑打开IE能发的网站，用这个宣传软件就可以仿制动作，进行推送发到您想发送的B2B网站或是信息发布平台上，不管是后台，还是前台，都可以进行最方便的广告发布，这个广告发布软件，可以按月购买，还可以试用软件，对网站的验证码也可以完全自动对信息发布，让客户自动找上门,使企业轻松实现b2b发布，这个信息发布软件，均是本站原创正版开发，拥有正版的血统，想要新功能，欢迎提意见给我，一好的分类信息群发软件在手，舍我其谁。QQ896757558

GMT+8, 2026-2-24 23:41 , Processed in 0.470243 second(s), 51 queries .

宣传软件--信息发布软件--b2b软件【广告发布软件】

快速回复 返回顶部 返回列表