@jolibox/implement 1.1.4-beta.4

package/src/common/report/errors/report/index.ts

@@ -0,0 +1,63 @@
+/**
+ * report-error
+ */
+import { EventEmitter } from '@jolibox/common';
+import { debounce } from '@jolibox/common';
+import { BaseError } from '@jolibox/common';
+
+/**
+ * native/h5 实现 errorReportEmitter的监听和上报逻辑
+ */
+export const errorReportCollector = new EventEmitter<ErrorEventMap>();
+export const errorReportEmitter = new EventEmitter<{
+  GLOBAL_ERROR: [Error | BaseError, ErrorData];
+  GLOBAL_USER_ERROR: [Error | BaseError, ErrorData];
+}>();
+export interface PromiseEvent {
+  reason: unknown;
+  promise: Promise<unknown>;
+}
+
+export interface EventMap {
+  [ERROR: string]: [
+    {
+      error: Error | PromiseEvent;
+      isFromUser: boolean;
+    }
+  ];
+}
+
+export interface ErrorEventMap {
+  [ERROR_REPORT: string]: Array<{
+    error: Error | BaseError;
+    options: ErrorOptions | GlobalErrorOptions;
+  }>;
+}
+
+export interface ErrorOptions {
+  isNativeCallback?: boolean;
+  promiseEvent?: PromiseEvent;
+  environment?: 'native' | 'h5';
+}
+export interface GlobalErrorOptions extends ErrorOptions {
+  globalType: 'global' | 'promise';
+}
+
+export interface ErrorData {
+  user_id: string;
+  device_id: string;
+  timestamp: number;
+  isFromUser: boolean;
+  tag: string; // for report
+}
+
+export function reportError(error: BaseError, options?: ErrorOptions): void;
+export function reportError(error: Error | BaseError, options: GlobalErrorOptions): void;
+export function reportError(error: Error | BaseError, options: ErrorOptions | GlobalErrorOptions = {}): void {
+  errorReportCollector.emit('ERROR_REPORT', {
+    error,
+    options
+  });
+}
+
+reportError.debounce = debounce(reportError, 50, { leading: true });

package/src/common/report/errors/report/listeners.ts

@@ -0,0 +1,80 @@
+import { BaseError, InternalReporterError, UserError } from '@jolibox/common';
+import { errorReportCollector, errorReportEmitter } from './index';
+import { context } from '@/common/context';
+import type { ErrorOptions, GlobalErrorOptions } from './index';
+import { logger } from '@jolibox/common';
+
+let reportFlag = false;
+
+const hasIn = (object: Record<string, unknown> | Error, path: string): boolean => {
+  if (object == null) return false;
+  return path in object;
+};
+const isBaseError = (error: Error): error is BaseError => {
+  return hasIn(error, 'kind');
+};
+
+const toCamelCase = (snakeStr: string): string => {
+  const words = snakeStr.toLowerCase().split('_');
+  return (
+    words[0] +
+    words
+      .slice(1)
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join('')
+  );
+};
+
+const innerErrorReport = (
+  error: BaseError | Error,
+  options: ErrorOptions | GlobalErrorOptions = {},
+  isFromUser: boolean
+) => {
+  const priority = (error as BaseError).priority ?? 'P1';
+
+  const common = {
+    user_id: context.hostUserInfo?.uid ?? '',
+    device_id: context.deviceInfo.did ?? '',
+    timestamp: Date.now(),
+    tag: toCamelCase(error.name)
+  };
+
+  const reports = { ...common, env: options.environment, isFromUser };
+  if (isFromUser) {
+    errorReportEmitter.emit('GLOBAL_USER_ERROR', error, reports);
+  } else {
+    errorReportEmitter.emit('GLOBAL_ERROR', error, reports);
+  }
+};
+
+const isUserError = (error: Error): error is UserError => {
+  //eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  //@ts-ignore
+  return hasIn(error, 'kind') && error['kind'] === 'USER_ERROR';
+};
+
+errorReportCollector.on('ERROR_REPORT', ({ error, options }) => {
+  // avoid cycle report
+  if (reportFlag) return;
+  reportFlag = true;
+
+  const raw = isBaseError(error) && error.raw ? error.raw : error;
+  try {
+    const isFromUser = isUserError(error);
+
+    innerErrorReport(error, options, isFromUser);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const reportError = new InternalReporterError(`${message}, origin error: ${raw.message}`);
+    logger.error(reportError);
+    innerErrorReport(
+      new InternalReporterError(reportError.message),
+      {
+        environment: options.environment
+      },
+      false
+    );
+  } finally {
+    reportFlag = false;
+  }
+});

package/src/common/report/index.ts

@@ -0,0 +1,3 @@
+export * from './create-trace';
+export * from './types';
+export * from './base-tracker';

package/src/common/report/task-track/index.ts

@@ -0,0 +1,97 @@
+import { EventEmitter } from '@jolibox/common';
+
+type TaskEvent =
+  | 'OPEN_GAME'
+  | 'PLAY_GAME'
+  | 'CLOSE_GAME'
+  | 'COMPLETE_QUEST'
+  | 'USE_GAME_ITEM' // 使用道具
+  | 'IN_GAME_PURCHASES' // 游戏内购
+  | 'ADS_UNLOCK_GAME'; // 广告解锁
+export type TaskPoint = {
+  event: TaskEvent;
+  params?: Record<string, unknown>;
+};
+export abstract class TaskTracker {
+  interval: number;
+  lastReportTime = 0;
+  visible = true;
+
+  timer = this.createRAFTimer((duration) => {
+    this.reporter({
+      event: 'PLAY_GAME',
+      params: {
+        duration: duration / 1000 // second
+      }
+    });
+  });
+
+  abstract reporter(point: TaskPoint): void;
+  constructor(eventEmitter: EventEmitter<{ visible: [boolean] }>, interval?: number) {
+    this.interval = interval ?? 10 * 1000;
+
+    eventEmitter.on('visible', (visible) => {
+      this.visible = visible;
+    });
+  }
+
+  start(duration?: number) {
+    this.reporter({
+      event: 'OPEN_GAME',
+      params: {
+        timestamp: Date.now(),
+        duration: duration ?? 0 / 1000 // second
+      }
+    });
+    this.timer.start();
+  }
+
+  close(duration: number) {
+    this.reporter({
+      event: 'CLOSE_GAME',
+      params: {
+        timestamp: Date.now(),
+        duration: duration / 1000 // second
+      }
+    });
+    this.timer.stop();
+  }
+
+  private createRAFTimer(callback: (duration: number) => void) {
+    let lastTime = performance.now();
+    let rafId: number;
+    let isRunning = false;
+    let totalTime = 0;
+
+    const tick = (currentTime: number) => {
+      if (!isRunning) return;
+
+      const deltaTime = currentTime - lastTime;
+      if (deltaTime >= this.interval) {
+        if (this.visible) {
+          totalTime += deltaTime;
+          callback(totalTime);
+        }
+        lastTime = currentTime;
+      }
+
+      rafId = requestAnimationFrame(tick);
+    };
+
+    return {
+      start() {
+        if (!isRunning) {
+          isRunning = true;
+          lastTime = performance.now();
+          rafId = requestAnimationFrame(tick);
+        }
+      },
+      stop() {
+        isRunning = false;
+        if (rafId) {
+          cancelAnimationFrame(rafId);
+        }
+      }
+    };
+  }
+}

package/src/common/report/track.ts

@@ -0,0 +1,49 @@
+import { debounce } from '@jolibox/common';
+import { ReportHandler, Track, TrackPerformance, CommonReportConfig } from './types';
+import { PerformanceType, TrackEvent } from '@jolibox/types';
+import { InternalContextError } from '@jolibox/common';
+import { reportError } from './errors/report';
+
+// Track system event, wrap common config
+export function createTrack(reportHandler: ReportHandler, common: CommonReportConfig): Track {
+  const track = (tag: TrackEvent, info: Record<string, unknown> | null, webviewId?: number): void => {
+    const data = {
+      tag,
+      ...common,
+      extra: {
+        ...info
+      }
+    };
+    if (tag == 'globalJsError') {
+      reportError(new InternalContextError(JSON.stringify(data), 'P0')); // window.onerror, 白屏
+    } else {
+      reportHandler('systemLog', data, webviewId);
+    }
+  };
+
+  track.debounce = debounce(track, 500, { leading: true });
+  return track;
+}
+
+export function createTrackPerformance(track: Track): TrackPerformance {
+  const trackPerformance = (
+    type: PerformanceType,
+    duration: number,
+    data?: Record<string, unknown>
+  ): void => {
+    const length = (data && JSON.stringify(data)) ?? 0;
+    const info = {
+      speed_value_type: type,
+      total_duration: duration
+    };
+    if (length) {
+      Object.assign(info, { extra: length });
+    }
+    track('joliboxSpeedAnalysis', info);
+  };
+  trackPerformance.debounce = debounce(trackPerformance, 500, {
+    leading: true
+  });
+
+  return trackPerformance;
+}

package/src/common/report/types.ts

@@ -0,0 +1,90 @@
+import { PerformanceType, TrackEvent } from '@jolibox/types';
+
+export interface Track {
+  (tag: TrackEvent, info: Record<string, unknown> | null): void;
+  debounce: (tag: TrackEvent, info: Record<string, unknown>) => void;
+}
+
+export interface TrackPerformance {
+  (type: PerformanceType, duration: number): void;
+  debounce: (type: PerformanceType, duration: number) => void;
+}
+
+export type ReportHandler = (
+  event: string,
+  data: { tag: TrackEvent; data?: Record<string, string | number | boolean | null> },
+  webviewId?: number
+) => void;
+
+// common parameters
+export interface CommonReportConfig {
+  type: EProject;
+  platform: 'native' | 'h5';
+  jssdk_version: string;
+  source_id: string;
+  source_version: string;
+  trace_id?: number;
+}
+
+export enum EventType {
+  System = 1000, // used for web sdk
+  ErrorTrace = 1001, // used for web sdk
+  UserDefined = 1002 // used for web sdk
+}
+
+export interface IPage {
+  name: string;
+  params: Record<string, string | boolean | number | null> | null;
+}
+
+export interface IEvent {
+  name: string;
+  type: EventType; // use a higher ts version to get static analysis
+  location: IPage | null;
+  target: IPage | null;
+  extra: Record<string, string | boolean | number | null> | null;
+  timestamp: number; // in unix timestamp
+  userId: string | null; // 没登陆时为空
+}
+
+export enum EProject {
+  MiniGame = 'mini-game',
+  MiniDrama = 'mini-drama',
+  App = 'app',
+  WebSDK = 'web-sdk',
+  AppSDK = 'app-sdk'
+}
+
+export enum EPlatform {
+  App = 0,
+  H5 = 1,
+  Weapp = 2,
+  Alipay = 3,
+  Gcash = 4,
+  Dana = 5,
+  Umma = 6,
+
+  WebSDK = 1000,
+  AppSDK = 1001,
+
+  Other = 9999
+}
+
+export interface IDevice {
+  platform: EPlatform;
+  os: string; // for app: Android、iOS
+  appVersion: string;
+  appId: string; // for external SDK, "1 - game h5", "2 - drama h5", "3 - game h5 ant",  "4 - drama h5 ant"
+  model: string;
+  brand: string;
+  uuid: string; // 前端生成的唯一标识，用来串整个埋点
+  jsSdkVersion: string | null;
+  extra: Record<string, string | boolean | number | null> | null;
+}
+
+export interface IEventPackage {
+  protocolVersion: string;
+  events: IEvent[];
+  device: IDevice;
+  project: EProject;
+}

package/src/h5/ads/ads-action-detection.ts

@@ -0,0 +1,31 @@
+import { track } from '../report';
+
+export class AdsActionDetection {
+  adBreakIsShowing = false;
+
+  private reportPageJumpOut = () => {
+    track('AdBreakJumpOut', {
+      context: 'AdsActionDetection'
+    });
+  };
+
+  private reportPageHide = () => {
+    track('AdBreakHide', {
+      context: 'AdsActionDetection'
+    });
+  };
+
+  constructor() {
+    window.addEventListener('visibilitychange', () => {
+      if (document.hidden && this.adBreakIsShowing) {
+        this.reportPageHide();
+      }
+    });
+
+    window.addEventListener('beforeunload', (e) => {
+      if (this.adBreakIsShowing) {
+        this.reportPageJumpOut();
+      }
+    });
+  }
+}

package/src/h5/ads/anti-cheating.ts

@@ -0,0 +1,244 @@
+import { tracker } from '../report/event-tracker';
+
+export type AdsDisplayPermission =
+  | 'BLOCK_INITIAL'
+  | 'BANNED_FOR_SESSION'
+  | 'NETWORK_NOT_OK'
+  | 'WAITING_BANNED_RELEASE'
+  | 'BANNED_FOR_TIME'
+  | 'ALLOWED';
+interface CallAdsHistory {
+  timestamp: number;
+  type: 'reward' | 'interstitial';
+}
+
+const TIMESTAMP_STORAGE_KEY = 'jolibox-sdk-ads-callbreak-timestamps';
+
+interface IAdsAntiCheatingConfig {
+  maxAllowedAdsForTime?: number; // default 8
+  bannedForTimeThreshold?: number; // default 60000 (1 minute)
+  bannedReleaseTime?: number; // default 60000 (1 minute), must be >= checkingTimeThreashold
+  initialThreshold?: number; // default 2000
+  maxAllowedAdsForSession?: number; // default 200
+  bannedForSessionThreshold?: number; // default 600000 (10 minutes)
+}
+
+export class AdsAntiCheating {
+  private maxAllowedAdsForTime = 8;
+  private bannedForTimeThreshold = 60000;
+  private bannedReleaseTime = 60000;
+  private isBanningForTime = false;
+  private releaseBannedForTimeTimeout: number | null = null;
+
+  private maxAllowedAdsForSession = 200;
+  private bannedForSessionThreshold = 600000;
+  private isBanningForSession = false;
+
+  private initialThreshold = 2000;
+
+  private _callAdsTimestampsForTime: CallAdsHistory[] = []; // max x timestamps for time
+  private callAdsTimestampsForSession: CallAdsHistory[] = []; // max x timestamps for session
+
+  private initTimestamp = 0;
+  // private context: JoliboxSDKPipeExecutor;
+  private report = tracker;
+
+  constructor(
+    // context: JoliboxSDKPipeExecutor,
+    config?: IAdsAntiCheatingConfig
+  ) {
+    this.maxAllowedAdsForTime = config?.maxAllowedAdsForTime ?? 8;
+    this.bannedForTimeThreshold = config?.bannedForTimeThreshold ?? 60000;
+    this.bannedReleaseTime = config?.bannedReleaseTime ?? 60000;
+
+    this.maxAllowedAdsForSession = config?.maxAllowedAdsForSession ?? 200;
+    this.bannedForSessionThreshold = config?.bannedForSessionThreshold ?? 600000;
+
+    this.initialThreshold = config?.initialThreshold ?? 2000;
+
+    if (this.maxAllowedAdsForTime <= 1) {
+      throw new Error('maxAllowedAdsForTime must be greater than 1');
+    }
+
+    if (this.bannedForTimeThreshold < 0) {
+      throw new Error('bannedForTimeThreshold must be greater than or equal to 0');
+    }
+
+    if (this.bannedReleaseTime < this.bannedForTimeThreshold) {
+      throw new Error('bannedReleaseTime must be greater than or equal to bannedForTimeThreshold');
+    }
+
+    if (this.initialThreshold < 0) {
+      throw new Error('initialThreshold must be greater than or equal to 0');
+    }
+
+    this.initCallAdsTimestampsForTime();
+    this.initTimestamp = Date.now();
+    // this.context = context;
+  }
+
+  /**
+   * Restore call ads timestamps for time from local storage
+   */
+  private initCallAdsTimestampsForTime = () => {
+    try {
+      const fromStorage = JSON.parse(window.localStorage.getItem(TIMESTAMP_STORAGE_KEY) ?? '[]');
+      if (Array.isArray(fromStorage)) {
+        this._callAdsTimestampsForTime = fromStorage;
+      } else {
+        this._callAdsTimestampsForTime = [];
+      }
+    } catch {
+      this._callAdsTimestampsForTime = [];
+    }
+  };
+
+  /**
+   * Get call ads timestamps for time
+   */
+  private get callAdsTimestampsForTime() {
+    return this._callAdsTimestampsForTime;
+  }
+
+  /**
+   * Set call ads timestamps for time, this will also save to local storage
+   */
+  private set callAdsTimestampsForTime(timestamps: CallAdsHistory[]) {
+    try {
+      window.localStorage.setItem(TIMESTAMP_STORAGE_KEY, JSON.stringify(timestamps));
+    } catch {
+      console.error('Failed to save timestamps');
+    }
+    this._callAdsTimestampsForTime = timestamps;
+  }
+
+  /**
+   * Set a timeout to release the banned for time status
+   */
+  private setReleaseBannedForTime = () => {
+    if (this.releaseBannedForTimeTimeout) {
+      window.clearTimeout(this.releaseBannedForTimeTimeout);
+      this.releaseBannedForTimeTimeout = null;
+    }
+    this.releaseBannedForTimeTimeout = window.setTimeout(() => {
+      this.isBanningForTime = false;
+      this.releaseBannedForTimeTimeout = null;
+    }, this.bannedReleaseTime);
+  };
+
+  /**
+   * Check if we should ban for initial call. By default, if user makes a call less than 2 seconds after the first call, block.
+   * @returns
+   */
+  private checkShouldBannedInitial = () => {
+    const now = Date.now();
+    const diffFromInit = now - this.initTimestamp;
+    // if initial call less than x seconds, block
+    if (diffFromInit <= this.initialThreshold) {
+      return 'BLOCK_INITIAL';
+    }
+  };
+
+  /**
+   * Check if we should ban this user for the whole session. By default, if user makes more than 200 calls in 10 minutes, ban for the session.
+   * @param type
+   * @returns
+   */
+  private checkShouldBannedForSession = (type: 'reward' | 'interstitial') => {
+    if (this.isBanningForSession) {
+      return 'BANNED_FOR_SESSION';
+    }
+
+    const now = Date.now();
+
+    // keep track of call timestamps
+    this.callAdsTimestampsForSession = this.callAdsTimestampsForSession.concat({
+      timestamp: now,
+      type
+    });
+
+    // if only 1 call, no need to check
+    if (this.callAdsTimestampsForSession.length === 1) {
+      return undefined;
+    }
+
+    // keep last x timestamps
+    if (this.callAdsTimestampsForSession.length > this.maxAllowedAdsForSession) {
+      this.callAdsTimestampsForSession = this.callAdsTimestampsForSession.slice(
+        -this.maxAllowedAdsForSession
+      );
+    }
+
+    // if less than x seconds, ban for session
+    if (this.callAdsTimestampsForSession.length === this.maxAllowedAdsForSession) {
+      const diffFromFirst = now - this.callAdsTimestampsForSession[0].timestamp;
+      if (diffFromFirst <= this.bannedForSessionThreshold) {
+        this.isBanningForSession = true;
+        return 'BANNED_FOR_SESSION';
+      }
+    }
+  };
+
+  /**
+   * Check if we should ban this user for a period of time. By default, if user makes more than 8 calls in 1 minute, ban for 1 minute.
+   * After 1 minute, user can make calls again.
+   * @param type
+   * @returns
+   */
+  private checkShouldBannedForTime = (type: 'reward' | 'interstitial') => {
+    if (this.isBanningForTime) {
+      return 'WAITING_BANNED_RELEASE';
+    }
+
+    const now = Date.now();
+
+    // keep track of call timestamps
+    this.callAdsTimestampsForTime = this.callAdsTimestampsForTime.concat({
+      timestamp: now,
+      type
+    });
+
+    // if only 1 call, no need to check
+    if (this.callAdsTimestampsForTime.length === 1) {
+      return undefined;
+    }
+
+    // keep last x timestamps
+    if (this.callAdsTimestampsForTime.length > this.maxAllowedAdsForTime) {
+      this.callAdsTimestampsForTime = this.callAdsTimestampsForTime.slice(-this.maxAllowedAdsForTime);
+    }
+
+    // if less than x seconds, ban for time
+    if (this.callAdsTimestampsForTime.length === this.maxAllowedAdsForTime) {
+      const diffFromFirst = now - this.callAdsTimestampsForTime[0].timestamp;
+      if (diffFromFirst <= this.bannedForTimeThreshold) {
+        this.isBanningForTime = true;
+        this.setReleaseBannedForTime();
+        return 'BANNED_FOR_TIME';
+      }
+    }
+  };
+
+  public checkAdsDisplayPermission: (type: 'reward' | 'interstitial') => AdsDisplayPermission = (type) => {
+    if (!this.report.networkIsOk) {
+      return 'NETWORK_NOT_OK';
+    }
+
+    const shouldBannedInitial = this.checkShouldBannedInitial();
+    if (shouldBannedInitial) {
+      return shouldBannedInitial;
+    }
+
+    const shouldBannedForSession = this.checkShouldBannedForSession(type);
+    if (shouldBannedForSession) {
+      return shouldBannedForSession;
+    }
+
+    const shouldBannedForTime = this.checkShouldBannedForTime(type);
+    if (shouldBannedForTime) {
+      return shouldBannedForTime;
+    }
+
+    return 'ALLOWED';
+  };
+}