yrjy_mini_sdk 1.0.0

package/src/struct/trackCore.js

@@ -0,0 +1,531 @@
+// 引入配置文件
+import config from "../config/index.js";
+import { reportLog } from "../axios/api.js";
+import { safeJsonParse } from "../utils/common.js";
+class Track {
+  // 定义配置项（后端接口、开关控制）
+  static config = {
+    reportUrl: config.logURL, // 后端埋点上报接口 （默认使用配置文件中的logURL）
+    enabled: true, // 是否启用埋点（默认开启）
+  };
+
+  //获取当前小程序的缓存信息
+  static storageDataFromMiniPro = (() => {
+    try {
+      const storageData = uni.getStorageSync("storageName");
+      return safeJsonParse(storageData, {});
+    } catch (error) {
+      console.error("❌ 解析缓存数据失败：", error);
+      return {};
+    }
+  })();
+
+  // 记录小程序启动时间
+  static launchTime = null;
+  // 缓存网络状态
+  static cachedNetworkType = "";
+  // 小程序初始化时的基本信息
+  static MiniProBaseInfo = {};
+  // 网络状态
+  static networkType = "";
+  // 小程序启动时的参数
+  static launchOptions = {};
+  // 便于后续埋点使用的参数=======================================================
+  // 一级栏目
+  static primaryCategory = "";
+  // 二级栏目
+  static secondaryCategory = "";
+
+  /**
+   * 配置埋点参数,权限校验,初始化埋点（UniApp 启动时调用一次，全局唯一）
+   */
+  static async init(options) {
+    // 初始化时获取一次网络状态并缓存
+    await this._updateNetworkType();
+    // 记录小程序启动时间
+    this.launchTime = Date.now();
+    // 合并默认配置和有效用户配置
+    this.config = { ...this.config, ...options };
+    // 获取小程序的基础信息
+    this.MiniProBaseInfo = await this.getBaseInf();
+    // 获取小程序启动时的参数
+    this.launchOptions = this.getLaunchOptionsSync();
+    // 获取并缓存用户信息
+    this.cachedUserInfo = this.getUserInfo();
+
+    // 监听网络状态变化，实时更新缓存
+    uni.onNetworkStatusChange((res) => {
+      this.networkType = res.networkType || "";
+    });
+    this.report({ name: "initEvent",action:'埋点初始化' });
+    // 添加调试信息，初始化的参数
+    console.log("✅ 埋点初始化成功", {
+      launchTime: this.launchTime,
+      enabled: this.config.enabled,
+      reportUrl: this.config.reportUrl,
+      MiniProBaseInfo: this.MiniProBaseInfo,
+      networkType: this.networkType,
+      launchOptions: this.launchOptions,
+      cachedUserInfo: this.cachedUserInfo,
+    });
+  }
+  /**
+   * 获取一级栏目
+   * @returns {string} 当前的一级栏目值
+   */
+  static getPrimaryCategory() {
+    return this.primaryCategory;
+  }
+  /**
+   * 设置一级栏目
+   * @param {Array<{ title: string }>} categoryList - 栏目列表，每个元素需包含 title 字段
+   * @param {number} selectedIndex - 当前选中的索引
+   */
+  static setPrimaryCategory(categoryList, selectedIndex) {
+    this._setCategory(categoryList, selectedIndex, "primaryCategory", "一级栏目" );
+  }
+  /**
+   * 获取二级栏目
+   * @returns {string} 当前的二级栏目值
+   */
+  static getSecondaryCategory() {
+    return this.secondaryCategory;
+  }
+  /**
+   * 设置二级栏目
+   * @param {Array<{ title: string }>} itemList - 栏目列表，每个元素需包含 title 字段
+   * @param {number} selectedIndex - 当前选中的索引
+   */
+  static setSecondaryCategory(itemList, selectedIndex) {
+    this._setCategory(itemList, selectedIndex, "secondaryCategory", "二级栏目");
+  }
+  /**
+   * 设置栏目
+   * @private
+   * @param {Array<{ title: string }>} list - 栏目列表，每个元素需包含 title 字段
+   * @param {number} selectedIndex - 当前选中的索引
+   * @param {string} propertyName - 要设置的属性名
+   * @param {string} categoryType - 栏目类型（用于日志）
+   */
+  static _setCategory(list, selectedIndex, propertyName, categoryType) {
+    // 参数校验：确保 list 是非空数组，selectedIndex 是有效数字
+    if (!Array.isArray(list) || list.length === 0) {
+      this[propertyName] = "";
+      console.warn(`❌ ${categoryType}列表必须是非空数组`);
+      return;
+    }
+
+    if (
+      typeof selectedIndex !== "number" ||
+      selectedIndex < 0 ||
+      selectedIndex >= list.length
+    ) {
+      this[propertyName] = "";
+      console.warn(`❌ ${categoryType}的selectedIndex无效或超出范围`);
+      return;
+    }
+
+    // 获取当前选中项
+    const currentItem = list[selectedIndex];
+
+    // 校验当前项是否包含有效的 title 字段
+    if (
+      !currentItem ||
+      typeof currentItem.title !== "string" ||
+      currentItem.title.trim() === ""
+    ) {
+      this[propertyName] = "";
+      console.warn(`❌ ${categoryType}的当前选中项不存在或title为空`);
+      return;
+    }
+
+    // 设置栏目并记录日志
+    this[propertyName] = currentItem.title;
+    console.log(`✅ ${categoryType}已设置为：${currentItem.title}`);
+  }
+/**
+ * 重置或设置栏目信息
+ * @param {string} type - 操作类型，可选值："primary"（一级栏目）、"secondary"（二级栏目）、"both"（两者都操作）
+ * @param {string|Object} [value] - 可选，要设置的值。
+ *   - 当 type 为 "primary" 或 "secondary" 时，value 应为字符串
+ *   - 当 type 为 "both" 时，value 可以是字符串（同时设置两个栏目为相同值）或对象（分别设置两个栏目）
+ *   - 如果不提供，则重置为默认值（空字符串）
+ */
+static resetCategory(type = "secondary", value) {
+  // 参数校验
+  if (!["primary", "secondary", "both"].includes(type)) {
+    console.warn("❌ 操作类型无效，可选值为：primary、secondary、both");
+    return;
+  }
+
+  // 如果未提供 value，则统一重置为默认值（空字符串）
+  if (value === undefined) {
+    switch (type) {
+      case "primary":
+        this.primaryCategory = "";
+        console.log("✅ 一级栏目已重置");
+        break;
+      case "secondary":
+        this.secondaryCategory = "";
+        console.log("✅ 二级栏目已重置");
+        break;
+      case "both":
+        this.primaryCategory = "";
+        this.secondaryCategory = "";
+        console.log("✅ 一级栏目和二级栏目均已重置");
+        break;
+    }
+    return;
+  }
+
+  // 校验值的类型
+  if (type === "both") {
+    // 当 type 为 "both" 时，value 可以是字符串或对象
+    if (typeof value !== "string" && (typeof value !== "object" || value === null)) {
+      console.warn("❌ 当操作类型为 both 时，值必须是字符串或对象");
+      return;
+    }
+    // 如果是对象，校验对象结构
+    if (typeof value === "object") {
+      if (value.primary !== undefined && typeof value.primary !== "string") {
+        console.warn("❌ 一级栏目值必须是字符串类型");
+        return;
+      }
+      if (value.secondary !== undefined && typeof value.secondary !== "string") {
+        console.warn("❌ 二级栏目值必须是字符串类型");
+        return;
+      }
+    }
+  } else {
+    // 当 type 为 "primary" 或 "secondary" 时，value 必须是字符串
+    if (typeof value !== "string") {
+      console.warn("❌ 栏目值必须是字符串类型");
+      return;
+    }
+  }
+
+  // 根据类型和提供的值来操作对应栏目
+  switch (type) {
+    case "primary":
+      this.primaryCategory = value;
+      console.log(`✅ 一级栏目已设置为：${value}`);
+      break;
+    case "secondary":
+      this.secondaryCategory = value;
+      console.log(`✅ 二级栏目已设置为：${value}`);
+      break;
+    case "both":
+      if (typeof value === "object" && value !== null) {
+        // 如果 value 是对象，分别设置两个栏目
+        const primaryValue = value.primary !== undefined ? value.primary : "";
+        const secondaryValue = value.secondary !== undefined ? value.secondary : "";
+        this.primaryCategory = primaryValue;
+        this.secondaryCategory = secondaryValue;
+        console.log(`✅ 一级栏目已设置为：${primaryValue}，二级栏目已设置为：${secondaryValue}`);
+      } else {
+        // 如果 value 不是对象，使用相同的值
+        this.primaryCategory = value;
+        this.secondaryCategory = value;
+        console.log(`✅ 一级栏目和二级栏目均已设置为：${value}`);
+      }
+      break;
+  }
+}
+
+  /**
+   * 更新网络状态缓存
+   * @private
+   */
+  static _updateNetworkType() {
+    return new Promise((resolve) => {
+      uni.getNetworkType({
+        success: (res) => {
+          this.networkType = res.networkType || "";
+          resolve();
+        },
+        fail: (err) => {
+          console.error("❌ 获取网络状态失败（API调用失败）：", err);
+          this.networkType = "";
+          resolve();
+        },
+      });
+    });
+  }
+  /**
+   * 获取基本信息（小程序，操作系统，品牌）
+   */
+  static async getBaseInf() {
+    try {
+      // 从 小程序缓存 中提取可能存在的系统信息
+      let systemInfo = this.storageDataFromMiniPro?.systemInfo?.data;
+
+      // 如果 storageName 中没有系统信息，使用独立缓存
+      if (!systemInfo) {
+        const systemInfoCacheKey = "track_system_info";
+        if (
+          typeof uni === "object" &&
+          uni !== null &&
+          typeof uni.getStorageSync === "function"
+        ) {
+          systemInfo = uni.getStorageSync(systemInfoCacheKey);
+        }
+
+        // 如果独立缓存也没有，获取新数据
+        if (
+          !systemInfo &&
+          typeof uni === "object" &&
+          uni !== null &&
+          typeof uni.getSystemInfo === "function"
+        ) {
+          const freshSystemInfo = await uni.getSystemInfo();
+          systemInfo = {
+            system: freshSystemInfo.system || "",
+            uniPlatform: freshSystemInfo.uniPlatform || "",
+            deviceBrand: freshSystemInfo.deviceBrand || "",
+            deviceType: freshSystemInfo.deviceType || "",
+          };
+
+          //  存储到独立缓存中
+          if (typeof uni.setStorageSync === "function") {
+            uni.setStorageSync(systemInfoCacheKey, systemInfo);
+          }
+        }
+      }
+
+      //  获取小程序信息
+      const miniProgramInfo = this._getMiniProgramInfo(systemInfo?.uniPlatform);
+      let obj = { ...systemInfo, ...miniProgramInfo };
+      // 返回完整的基础信息
+      return obj;
+    } catch (error) {
+      console.error("❌ 获取基础信息失败：", error);
+      return {
+        system: "",
+        uniPlatform: "",
+        deviceBrand: "",
+        platform: "",
+        appId: "",
+      };
+    }
+  }
+
+  /**
+   * 获取小程序信息（私有方法）
+   * @private
+   */
+  static _getMiniProgramInfo(platform) {
+    let appId = "";
+    let version = "";
+    let envVersion = "";
+    try {
+      if (platform === "mp-weixin") {
+        const info = wx.getAccountInfoSync();
+        appId = info.miniProgram?.appId || "";
+        version = info.miniProgram?.version || "";
+        envVersion = info.miniProgram?.envVersion || "";
+      } else if (platform === "mp-douyin") {
+        const info = tt.getEnvInfoSync();
+        appId = info.microapp?.appId || "";
+        version = info.microapp?.mpVersion || "";
+        envVersion = info.microapp?.envType || "";
+      }
+    } catch (error) {
+      console.warn("获取平台小程序信息失败：", error);
+    }
+    let obj = {
+      appId,
+      version,
+      envVersion,
+    };
+    return obj;
+  }
+
+  /**
+   * 获取用户信息（包括用户ID和手机号）
+   */
+  static getUserInfo() {
+    try {
+      // 从 小程序缓存 中提取用户信息
+      const userInfo = this.storageDataFromMiniPro?.userInfoDeatil?.data;
+      if (userInfo) {
+        const userId = userInfo.id || ""; // 用户ID
+        const userPhone = userInfo.mobile || ""; // 用户手机号
+
+        return {
+          userId: userId,
+          userPhone: userPhone,
+        };
+      } else {
+        return {
+          userId: "",
+          userPhone: "",
+        };
+      }
+    } catch (err) {
+      console.error("❌ 获取用户信息失败：", err);
+      return {
+        userId: "",
+        userPhone: "",
+      };
+    }
+  }
+  /**
+   * 设置用户信息（包括用户ID和手机号）
+   * @param {Object} userInfo 用户信息对象，包含 userId 和 userPhone 字段
+   */
+  static setUserInfo(userInfo) {
+    if (!userInfo || !userInfo.userId) {
+      console.error("❌ 设置用户信息失败：缺少必要的 userId 字段");
+      return;
+    }
+
+    try {
+      // 更新缓存的用户信息
+      this.cachedUserInfo = {
+        userId: userInfo.userId || "",
+        userPhone: userInfo.userPhone || "",
+      };
+      console.log("✅ 用户信息设置成功");
+    } catch (err) {
+      console.error("❌ 设置用户信息失败：", err);
+    }
+  }
+
+  /**
+   * 清除用户信息（登出时调用）
+   */
+  static clearUserInfo() {
+    try {
+      // 清除缓存的用户信息
+      this.cachedUserInfo = {};
+      console.log("✅ 用户信息已清除");
+    } catch (err) {
+      console.error("❌ 清除用户信息失败：", err);
+    }
+  }
+  /**
+   * 开启埋点功能
+   */
+  static enable() {
+    this.config.enabled = true;
+    console.log("✅ 埋点功能已开启");
+  }
+
+  /**
+   * 关闭埋点功能
+   */
+  static disable() {
+    this.config.enabled = false;
+    console.log("✅ 埋点功能已关闭");
+  }
+  /**
+   * 获取启动时的参数
+   */
+  static getLaunchOptionsSync() {
+    try {
+      if (
+        typeof uni === "object" &&
+        uni !== null &&
+        typeof uni.getLaunchOptionsSync === "function"
+      ) {
+        const { path, scene, query } = uni.getLaunchOptionsSync() || {};
+        return {
+          launchPath: path,
+          launchScene: scene,
+          launchParams: JSON.stringify(query),
+          subChannel: query.subChannel || ""
+        };
+      } else {
+        return {};
+      }
+    } catch (err) {
+      console.error("❌ 获取启动参数失败：", err);
+      return {};
+    }
+  }
+
+  /**
+   * 单个埋点上报
+   * @param {Object} trackData 埋点数据
+   */
+  static submitTrackLog(trackData) {
+    reportLog(this.config.reportUrl, trackData)
+      .then((res) => {        
+        if (res && res.statusCode === 200) {
+          console.log(`✅ 埋点上报成功`);
+        } else {
+          console.warn("⚠️ 埋点上报返回异常：", res.data);
+        }
+      })
+      .catch((err) => {
+        console.error("❌ 埋点上报失败（网络/接口异常）：", err);
+      });
+  }
+  /**
+   * 统一埋点数据上报（核心方法）
+   * @param {Object} trackData 业务埋点数据
+   */
+  static report(trackData) {
+    // 补充全局统一字段
+    const completeTrackData = {
+      launchTime: this.launchTime,
+      currentTime: Date.now(),
+      ...this.launchOptions,
+      ...this.MiniProBaseInfo,
+      ...this.cachedUserInfo,
+      networkType: this.networkType, //网络状态
+      ...trackData, //自定义埋点数据
+    };
+
+    // 上报到后端接口
+    console.warn("埋点数据", completeTrackData);
+    this.submitTrackLog(completeTrackData);
+  }
+  /*
+   * 自定义埋点上报
+   *action 埋点行为名称
+   *data 行为携带参数
+   *name 埋点类型
+   *needColumn  是否需要栏目信息
+   */
+  static customReport(
+    action,
+    data = {},
+    name = "clickEvent",
+    needColumn = true
+  ) {
+    // 检查埋点开关是否开启
+    if (!this.config.enabled) {
+      return;
+    }
+    // 校验必要参数
+    if (!action || !name) {
+      console.error("❌ 埋点上报失败：缺少必要的 name 或者 action 字段");
+      return;
+    }
+
+    // 构建基础 trackData
+    const trackData = {
+      action,
+      name,
+    };
+
+    // 根据 needColumn 决定是否添加栏目信息
+    if (needColumn) {
+      const categoryFields = {
+        ...(this.primaryCategory && { primaryCategory: this.primaryCategory }),
+        ...(this.secondaryCategory && { secondaryCategory: this.secondaryCategory }),
+      };
+      Object.assign(trackData, categoryFields);
+    }
+
+    // 如果 data 存在且不为空，则添加到 trackData 中
+    if (data && Object.keys(data).length > 0) {
+      trackData.data = JSON.stringify(data);
+    }
+    // 上报数据
+    this.report(trackData);
+  }
+}
+// 导出 Track 类
+export default Track;

package/src/struct/trackPageMixin.js

@@ -0,0 +1,93 @@
+/**
+ * 全局页面埋点混入
+ */
+import Track from './trackCore.js';
+import { getCurrentPages, getPagePath } from '../utils/common.js';
+
+// 定义页面埋点混入
+export const trackPageMixin = {
+  /**
+   * UniApp 页面生命周期 - onLoad
+   * 初始化页面埋点数据缓存
+   */
+  onLoad(options) {
+    // 使用公共方法获取页面栈
+    const pages = getCurrentPages();
+    const currentPage = pages[pages.length - 1] || {};
+    
+    // 使用公共方法获取页面路径
+    const pagePath = getPagePath(currentPage, this.$scope);
+    
+    // 更新全局当前页面路径
+    Track.currentPagePath = pagePath || '';
+
+    // 页面埋点数据缓存对象
+    const pageTrackData = {
+      trackType: 'pageview',
+      viewPagePath: pagePath || '',
+      viewPageLoadTime: Date.now(), // 记录页面首次加载的时间
+      viewPageParams: options || {} // 页面参数
+    };
+
+    this.$pageTrackCache = pageTrackData;
+  },
+
+  /**
+   * UniApp 页面生命周期 - onUnload
+   */
+  onUnload() {
+    this._reportPageTrack('unload');
+  },
+
+  /**
+   * UniApp 页面生命周期 - onHide
+   */
+  onHide() {
+    this._reportPageTrack('hide');
+  },
+
+  /**
+   * UniApp 页面生命周期 - onShow
+   */
+  onShow() {
+    // 如果页面从隐藏状态切回，更新开始时间
+    if (this.$pageTrackCache) {
+      // 记录页面重新显示的时间 记录页面最近一次显示的时间
+      this.$pageTrackCache.lastShowTime = Date.now();
+    }
+    
+    // 更新全局当前页面路径
+    if (this.$pageTrackCache && this.$pageTrackCache.viewPagePath) {
+      Track.currentPagePath = this.$pageTrackCache.viewPagePath;
+    }
+  },
+
+  // 修复原语法错误：methods是混入的一级属性，与onLoad/onShow同级
+  methods: {
+    /**
+     * 页面埋点统一上报方法
+     * @param {string} reportType 上报类型：'unload' 或 'hide'
+     */
+    _reportPageTrack(reportType) {
+      if (!this.$pageTrackCache) return;
+      // 计算页面停留时间
+      const startTime = this.$pageTrackCache.lastShowTime || this.$pageTrackCache.viewPageLoadTime;
+      const stayTime = Date.now() - startTime;
+      
+      // 重新组装数据结构
+      const customParams = {
+        viewPagePath: this.$pageTrackCache.viewPagePath || "",
+        viewPageLoadTime: this.$pageTrackCache.viewPageLoadTime || Date.now(),
+        viewPageParams: this.$pageTrackCache.viewPageParams || {},
+        stayTime: stayTime
+      };
+
+      Track.customReport('页面曝光', customParams, "pageviewEvent", false);
+      
+      // 清除缓存：hide时清空（切页/退后台），unload时保留至上报完成（页面销毁）
+      if (reportType === 'hide') {
+        this.$pageTrackCache = null;
+      }
+    }
+  }
+};