@rk911/tracker-sdk 1.7.15 → 1.7.17

package/native/harmony/HarmonyTracker.ets

@@ -0,0 +1,434 @@
+import { http } from '@kit.NetworkKit';
+import { preferences } from '@kit.ArkData';
+import { deviceInfo } from '@kit.BasicServicesKit';
+import { hilog } from '@kit.PerformanceAnalysisKit';
+import { connection } from '@kit.NetworkKit';
+import { PreferencesUtil } from '../../PreferencesUtil';
+import { CommonConstants } from '../http/CommonConstants';
+
+export interface TrackerEvent {
+  eventId: string;
+  eventType: string;
+  eventName: string;
+  timestamp: number;
+  sequence: number;
+  sessionId: string;
+  userId?: string;
+  pageRoute?: string;
+  pageTitle?: string;
+  referrer?: string;
+  os: string;
+  deviceBrand: string;
+  deviceModel: string;
+  osVersion: string;
+  networkType?: string;
+  duration?: number;
+  elementId?: string;
+  elementText?: string;
+  frontUrl?: string;
+  postParam?: string;
+  extraData?: string;
+}
+
+export class HarmonyTracker {
+  private static instance: HarmonyTracker | null = null;
+  private serverUrl: string = 'https://state.renruikeji.cn/api/point/task/trackBatch';
+  private appId: string = '22';
+  private sessionId: string = '';
+  private deviceId: string = '';
+  private userId: string = '';
+  private phone: string = '';
+  private storeName: string = '';
+  private userName: string = '';
+  private pflag: number = -1;
+  private platformName: string = '鸿蒙';
+  private sequence: number = 0;
+  private currentPageRoute: string = '';
+  private referrerPageRoute: string = '';
+  private lastPageStartTime: number = 0;
+  private eventQueue: Array<TrackerEvent> = [];
+  private isFlushing: boolean = false;
+  private flushTimerId: number = -1;
+
+  private static readonly LOG_TAG: string = 'HarmonyTracker';
+  private static readonly LOG_DOMAIN: number = 0xFF01;
+  private static readonly CACHE_KEY: string = 'rk_tracker_events_cache';
+  private static readonly MAX_QUEUE_SIZE: number = 1000;
+  private static readonly BATCH_SIZE: number = 20;
+  private static readonly FLUSH_INTERVAL_MS: number = 3000;
+
+  private static readonly friendlyTitles: Record<string, string> = {
+    'HomeMainPage': 'APP主页/首页Tab',
+    'CircleMainPage': '圈子/健康圈',
+    'MallMainPage': '商城/商城首页',
+    'VideoMainPage': '小视频推荐',
+    'MemberMainPage': '个人中心/我的',
+    'WebViewApp': '通用Web容器',
+    'Login': '登录页',
+    'VoicePunchIn': '语音打卡',
+    'HealthMascot': '健康助手'
+  };
+
+  private constructor() {
+    this.sessionId = 'harmony_' + Date.now() + '_' + Math.floor(Math.random() * 9000 + 1000);
+    this.deviceId = 'harmony_dev_' + Math.floor(Math.random() * 1000000000);
+    this.loadCachedEvents();
+    this.startTimer();
+  }
+
+  public static getInstance(): HarmonyTracker {
+    if (!HarmonyTracker.instance) {
+      HarmonyTracker.instance = new HarmonyTracker();
+    }
+    return HarmonyTracker.instance;
+  }
+
+  public init(serverUrl?: string, deviceId?: string, userId?: string, phone?: string, storeName?: string, userName?: string): void {
+    if (serverUrl) {
+      if (!serverUrl.includes('/api/point/task/trackBatch')) {
+        this.serverUrl = serverUrl.endsWith('/') ? serverUrl + 'api/point/task/trackBatch' : serverUrl + '/api/point/task/trackBatch';
+      } else {
+        this.serverUrl = serverUrl;
+      }
+    }
+    if (deviceId) this.deviceId = deviceId;
+    if (userId) this.userId = userId;
+    if (phone) this.phone = phone;
+    if (storeName) this.storeName = storeName;
+    if (userName) this.userName = userName;
+    this.flushAsync();
+  }
+
+  public updateUser(userId?: string, phone?: string, storeName?: string, userName?: string): void {
+    if (userId !== undefined) this.userId = userId;
+    if (phone !== undefined) this.phone = phone;
+    if (storeName !== undefined) this.storeName = storeName;
+    if (userName !== undefined) this.userName = userName;
+  }
+
+  public setPlatform(pflag: number, platformName?: string): void {
+    this.pflag = pflag;
+    if (platformName) this.platformName = platformName;
+  }
+
+  public resetSession(): void {
+    this.sequence = 0;
+    this.sessionId = 'harmony_' + Date.now() + '_' + Math.floor(Math.random() * 9000 + 1000);
+  }
+
+  public getSessionId(): string { return this.sessionId; }
+  public getDeviceId(): string { return this.deviceId; }
+  public getUserId(): string { return this.userId; }
+  public getPhone(): string { return this.phone; }
+  public getStoreName(): string { return this.storeName; }
+  public getUserName(): string { return this.userName; }
+  public getPflag(): number { return this.pflag; }
+  public getPlatformName(): string { return this.platformName; }
+  public getCurrentSequence(): number { return this.sequence; }
+
+  public getFriendlyTitle(route: string): string {
+    if (HarmonyTracker.friendlyTitles[route]) return HarmonyTracker.friendlyTitles[route];
+    for (const key in HarmonyTracker.friendlyTitles) {
+      if (route.includes(key)) return HarmonyTracker.friendlyTitles[key];
+    }
+    return route;
+  }
+
+  public getNativeContextJson(): string {
+    const ctx: Record<string, Object> = {
+      'appId': this.appId,
+      'deviceId': this.deviceId,
+      'userId': this.userId,
+      'phone': this.phone,
+      'sessionId': this.sessionId,
+      'appVersion': '1.0.0',
+      'platform': 'harmony',
+      'os': 'HarmonyOS',
+      'brand': deviceInfo.brand || 'HUAWEI',
+      'deviceBrand': deviceInfo.brand || 'HUAWEI',
+      'model': deviceInfo.productModel || '',
+      'deviceModel': deviceInfo.productModel || '',
+      'osVersion': deviceInfo.osFullName || '',
+      'currentSequence': this.sequence,
+      'pflag': this.pflag,
+      'pFlagName': this.platformName
+    };
+    return JSON.stringify(ctx);
+  }
+
+  public track(eventName: string, properties?: Record<string, Object>): void {
+    this.trackCustom(eventName, '', properties);
+  }
+
+  public trackCustom(eventName: string, elementText?: string, properties?: Record<string, Object>): void {
+    const event = this.createBaseEvent('custom', eventName);
+    if (elementText) event.elementText = elementText;
+    if (properties) {
+      const extra = this.buildBaseExtra();
+      for (const k in properties) extra[k] = properties[k];
+      event.extraData = JSON.stringify(extra);
+    }
+    this.enqueueEvent(event);
+    this.flushAsync();
+  }
+
+  public trackPageView(pageRoute: string, pageTitle?: string): void {
+    if (pageRoute === this.currentPageRoute && (Date.now() - this.lastPageStartTime < 500)) return;
+    this.referrerPageRoute = this.currentPageRoute;
+    this.currentPageRoute = pageRoute;
+    this.lastPageStartTime = Date.now();
+
+    const title = pageTitle && pageTitle.length > 0 ? pageTitle : this.getFriendlyTitle(pageRoute);
+    const event = this.createBaseEvent('page_view', 'page_view');
+    event.pageRoute = pageRoute;
+    event.pageTitle = title;
+    this.enqueueEvent(event);
+    this.flushAsync();
+  }
+
+  public trackPageStay(pageRoute: string, pageTitle?: string, durationMs?: number): void {
+    const dur = durationMs ? durationMs : (Date.now() - this.lastPageStartTime);
+    if (dur < 500) return;
+    const title = pageTitle && pageTitle.length > 0 ? pageTitle : this.getFriendlyTitle(pageRoute);
+    const event = this.createBaseEvent('page_stay', 'page_stay');
+    event.pageRoute = pageRoute;
+    event.pageTitle = title;
+    event.duration = dur;
+    this.enqueueEvent(event);
+    this.flushAsync();
+  }
+
+  public trackVideo(eventName: string, videoId: number, videoTitle?: string, customProperties?: Record<string, Object>): void {
+    const event = this.createBaseEvent('video', eventName);
+    event.elementId = 'video_' + videoId;
+    if (videoTitle) event.elementText = videoTitle;
+    const extra = this.buildBaseExtra();
+    extra['videoId'] = videoId;
+    if (videoTitle) extra['videoTitle'] = videoTitle;
+    if (customProperties) {
+      for (const k in customProperties) extra[k] = customProperties[k];
+      if (typeof customProperties['playDurationMs'] === 'number') {
+        event.duration = customProperties['playDurationMs'] as number;
+      }
+    }
+    event.extraData = JSON.stringify(extra);
+    this.enqueueEvent(event);
+    this.flushAsync();
+  }
+
+  public trackApi(url: string, method: string, statusCode: number, duration: number, reqParam?: string, respData?: string, error?: string): void {
+    if (!url || url.includes('/api/point/task/trackBatch')) return;
+    const isError = statusCode >= 400 || (error !== undefined && error !== null && error.length > 0);
+    const eventType = isError ? 'api_error' : 'api_request';
+    const apiPath = this.extractApiPath(url);
+    const event = this.createBaseEvent(eventType, apiPath);
+
+    const extra = this.buildBaseExtra();
+    extra['url'] = url;
+    extra['apiPath'] = apiPath;
+    extra['method'] = (method || 'GET').toUpperCase();
+    extra['statusCode'] = statusCode;
+    extra['duration'] = duration;
+    if (reqParam) extra['requestParams'] = reqParam.substring(0, 2048);
+    if (respData) extra['responseData'] = respData.substring(0, 2048);
+    if (error) extra['error'] = error.substring(0, 512);
+
+    event.extraData = JSON.stringify(extra);
+    this.enqueueEvent(event);
+    if (isError) this.flushAsync();
+  }
+
+  public trackFrontUrl(frontUrl: string, elementId?: string, postParam?: string): void {
+    let eventType = 'click';
+    if (elementId && (elementId.startsWith('look') || elementId.startsWith('show') || elementId.includes('Exposure'))) {
+      eventType = 'exposure';
+    }
+    const event = this.createBaseEvent(eventType, 'legacy_dadian');
+    event.frontUrl = frontUrl;
+    if (elementId) event.elementId = elementId;
+    if (postParam) event.postParam = postParam;
+    this.enqueueEvent(event);
+    this.flushAsync();
+  }
+
+  private createBaseEvent(eventType: string, eventName: string): TrackerEvent {
+    this.sequence++;
+    const evt: TrackerEvent = {
+      eventId: 'e_' + Date.now() + '_' + Math.floor(Math.random() * 1000),
+      eventType: eventType,
+      eventName: eventName,
+      timestamp: Date.now(),
+      sequence: this.sequence,
+      sessionId: this.sessionId,
+      os: 'HarmonyOS',
+      deviceBrand: deviceInfo.brand || 'HUAWEI',
+      deviceModel: deviceInfo.productModel || '',
+      osVersion: deviceInfo.osFullName || '',
+      networkType: this.getNetworkType()
+    };
+    if (this.userId) evt.userId = this.userId;
+    if (this.currentPageRoute) {
+      evt.pageRoute = this.currentPageRoute;
+      evt.pageTitle = this.getFriendlyTitle(this.currentPageRoute);
+    }
+    if (this.referrerPageRoute) evt.referrer = this.referrerPageRoute;
+
+    const baseExtra = this.buildBaseExtra();
+    evt.extraData = JSON.stringify(baseExtra);
+    return evt;
+  }
+
+  private buildBaseExtra(): Record<string, Object> {
+    const extra: Record<string, Object> = { 'platform': 'harmony' };
+    if (this.phone) extra['phone'] = this.phone;
+    if (this.storeName) extra['storeName'] = this.storeName;
+    if (this.userId) extra['userId'] = this.userId;
+    if (this.pflag !== -1) extra['pflag'] = this.pflag;
+    if (this.platformName) extra['platformName'] = this.platformName;
+    return extra;
+  }
+
+  private extractApiPath(url: string): string {
+    try {
+      const qIdx = url.indexOf('?');
+      const clean = qIdx >= 0 ? url.substring(0, qIdx) : url;
+      const schemeIdx = clean.indexOf('://');
+      if (schemeIdx >= 0) {
+        const pathIdx = clean.indexOf('/', schemeIdx + 3);
+        if (pathIdx >= 0) return clean.substring(pathIdx);
+      }
+      return clean;
+    } catch (e) {
+      return url;
+    }
+  }
+
+  private getNetworkType(): string {
+    try {
+      if (!connection.hasDefaultNetSync()) return '';
+      const netHandle = connection.getDefaultNetSync();
+      const cap = connection.getNetCapabilitiesSync(netHandle);
+      if (cap && cap.bearerTypes) {
+        if (cap.bearerTypes.includes(connection.NetBearType.BEARER_WIFI)) return 'wifi';
+        if (cap.bearerTypes.includes(connection.NetBearType.BEARER_CELLULAR)) return '4g';
+        if (cap.bearerTypes.includes(connection.NetBearType.BEARER_ETHERNET)) return 'ethernet';
+      }
+      return 'other';
+    } catch (e) {
+      return '';
+    }
+  }
+
+  private enqueueEvent(event: TrackerEvent): void {
+    this.eventQueue.push(event);
+    if (this.eventQueue.length > HarmonyTracker.MAX_QUEUE_SIZE) {
+      this.eventQueue.splice(0, this.eventQueue.length - HarmonyTracker.MAX_QUEUE_SIZE);
+    }
+    this.saveQueueToDisk();
+  }
+
+  private async saveQueueToDisk(): Promise<void> {
+    try {
+      const util = new PreferencesUtil();
+      await util.saveCache(HarmonyTracker.CACHE_KEY, JSON.stringify(this.eventQueue));
+    } catch (e) {}
+  }
+
+  private async loadCachedEvents(): Promise<void> {
+    try {
+      const util = new PreferencesUtil();
+      const cache = await util.getCache(HarmonyTracker.CACHE_KEY);
+      if (cache && typeof cache === 'string') {
+        const parsed = JSON.parse(cache) as Array<TrackerEvent>;
+        if (Array.isArray(parsed) && parsed.length > 0) {
+          this.eventQueue = parsed.concat(this.eventQueue);
+        }
+      }
+    } catch (e) {}
+  }
+
+  private startTimer(): void {
+    if (this.flushTimerId !== -1) return;
+    this.flushTimerId = setInterval(() => {
+      this.flushAsync();
+    }, HarmonyTracker.FLUSH_INTERVAL_MS);
+  }
+
+  public flushAsync(): void {
+    if (this.isFlushing || this.eventQueue.length === 0) return;
+    this.flushInternal();
+  }
+
+  public async flushSync(): Promise<void> {
+    await this.flushInternal();
+  }
+
+  private async flushInternal(): Promise<void> {
+    if (this.isFlushing || this.eventQueue.length === 0) return;
+    this.isFlushing = true;
+
+    try {
+      let maxBatches = 5;
+      while (maxBatches-- > 0 && this.eventQueue.length > 0) {
+        const batch = this.eventQueue.slice(0, HarmonyTracker.BATCH_SIZE);
+        const success = await this.sendBatch(batch);
+        if (success) {
+          this.eventQueue.splice(0, batch.length);
+          await this.saveQueueToDisk();
+        } else {
+          break;
+        }
+      }
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+
+  private async sendBatch(records: Array<TrackerEvent>): Promise<boolean> {
+    if (!this.serverUrl || records.length === 0) return false;
+    const httpRequest = http.createHttp();
+
+    try {
+      let batchSessionId = this.sessionId;
+      let batchUserId = this.userId;
+      if (records[0].sessionId) batchSessionId = records[0].sessionId;
+      if (records[0].userId) batchUserId = records[0].userId;
+
+      const body: Record<string, Object> = {
+        'appId': parseInt(this.appId, 10),
+        'sessionId': batchSessionId,
+        'deviceId': this.deviceId,
+        'userId': batchUserId,
+        'phone': this.phone,
+        'storeName': this.storeName,
+        'userName': this.userName,
+        'platform': 'harmony',
+        'events': records
+      };
+      if (this.pflag !== -1) body['pflag'] = this.pflag;
+      if (this.platformName) body['platformName'] = this.platformName;
+
+      const bodyStr = JSON.stringify(body);
+      const options: http.HttpRequestOptions = {
+        method: http.RequestMethod.POST,
+        header: {
+          'Content-Type': 'application/json; charset=UTF-8',
+          'appId': this.appId,
+          'deviceId': this.deviceId
+        },
+        extraData: bodyStr,
+        expectDataType: http.HttpDataType.STRING,
+        connectTimeout: 5000,
+        readTimeout: 5000
+      };
+
+      const resp = await httpRequest.request(this.serverUrl, options);
+      return resp.responseCode >= 200 && resp.responseCode < 300;
+    } catch (e) {
+      hilog.error(HarmonyTracker.LOG_DOMAIN, HarmonyTracker.LOG_TAG, 'sendBatch failed: %{public}s', JSON.stringify(e));
+      return false;
+    } finally {
+      httpRequest.destroy();
+    }
+  }
+}