decord/beta/source/modules/analytics_sessions/SessionHeartbeatScheduler.tsx

// Module ID: 6970
// Function ID: 6971
// Name: SessionHeartbeatScheduler
// Dependencies: [5, 5436, 502, 5567, 4913, 1085, 1102, 3, 6971, 6972, 6973, 1242, 6974, 6977, 1252, 6978, 510, 6980, 1350, 584, 504, 1266, 2]
// Exports: getActiveSessionUnsafe, initSessionHeartbeatScheduler

// Module 6970 (SessionHeartbeatScheduler)
import LoggerDefault from "Logger" /* 3 */;
import Storage2 from "Storage" /* 510 */;
import DispatcherDefault from "Dispatcher" /* 584 */;
import DurationsDefault from "Durations" /* 1102 */;
import SentryUtilsDefault from "SentryUtils" /* 1242 */;
import MonotonicClock from "MonotonicClock" /* 6973 */;
import Clickstream from "Clickstream" /* 6974 */;
import SkippedClientHeartbeatUtil from "SkippedClientHeartbeatUtil" /* 6978 */;
import SessionUtils from "SessionUtils" /* 6980 */;
import _asyncToGenerator from "_asyncToGenerator" /* 5 */;
import GatewayConnectionStore from "GatewayConnectionStore" /* 5436 */;
import AuthenticationStore from "AuthenticationStore" /* 502 */;
import IdleStore from "IdleStore" /* 5567 */;
import RTCConnectionStore from "RTCConnectionStore" /* 4913 */;
import Constants from "Constants" /* 1085 */;
import react_native from "react-native" /* 6971 */;
import SessionRouteUtils from "SessionRouteUtils" /* 6972 */;
import size from "module_2" /* 2 */;

const require = globalThis.__r;
let c3, closure_21, monotonicNowMsResult;

let c10;
let c9;
let metroImportAll;
let tmp;
const get_initializedDefault = tmp(504);
function trackHeartbeat() {
  return obj(...arguments);
}
let obj = function _trackHeartbeat() {
  obj = _asyncToGenerator(async (arg0, value) => {
    let closure_1;
    let obj12;
    if (c4 === 2) {
      c4 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        const obj3 = { value, done: true };
        return obj3;
      } else {
        return { value: "IconComponent", done: null };
      }
    } else {
      try {
        let tmp;
        let closure_2;
        let closure_3;
        let obj13;
        let closure_0;
        c4 = 2;
        if (0 === c3) {
          if (arg0 === 1) {
            c4 = 3;
            throw value;
          } else if (arg0 === 2) {
            c4 = 3;
            const obj4 = { value, done: true };
            return obj4;
          } else {
            tmp = undefined;
            closure_2 = undefined;
            closure_3 = undefined;
            obj13 = undefined;
            const _Date2 = Date;
            closure_0 = Date.now();
            c3 = 1;
            c4 = 1;
            const obj5 = { value: getSession(), done: false };
            return obj5;
          }
        } else if (arg0 === 1) {
          c4 = 3;
          throw value;
        } else if (arg0 === 2) {
          c4 = 3;
          const obj7 = { value, done: true };
          return obj7;
        } else {
          tmp = value;
          const _Date3 = Date;
          closure_2 = Date.now();
          if (null != tmp) {
            const obj11 = { category, message: "Tracking Heartbeat", data: obj12 };
            obj12 = { initialized: tmp.createdAtTimestamp };
            const obj2 = closure_130_1(closure_130_2[11]);
            obj2.addBreadcrumb(obj11);
            obj13 = { client_heartbeat_initialization_timestamp: tmp.createdAtTimestamp, client_heartbeat_version: 31 };
            obj6 = closure_130_0(closure_130_2[13]);
            const merged = Object.assign(obj6.getClientHeartbeatPiggybackProperties());
            const idleSince = closure_130_6.getIdleSince();
            let c0 = idleSince;
            if (idleSince == null) {
              c0 = 0;
            }
            closure_3 = c0;
            const obj14 = { is_idle: closure_130_6.isIdle(), idle_duration_ms: Date.now() - closure_3, is_afk: closure_130_6.isAFK(), is_system_suspended: closure_130_6.getSystemSuspended(), is_system_locked: closure_130_6.getSystemLocked() };
            const _Date = Date;
            const merged1 = Object.assign(obj14);
            const obj8 = closure_130_1(closure_130_2[14]);
            obj8.track(constants.CLIENT_HEARTBEAT, obj13);
            const obj9 = closure_130_0(closure_130_2[10]);
            let closure_19 = obj9.monotonicNowMs();
            const obj10 = closure_130_0(closure_130_2[12]);
            obj10.drainClickstream();
          } else {
            const _Error = Error;
            const _HermesInternal = HermesInternal;
            obj = closure_130_1(closure_130_2[11]);
            obj.captureException(Error("Null session when tracking session heartbeat. Waited " + closure_2 - closure_0 + "ms"));
          }
          c4 = 3;
          return { value: "IconComponent", done: null };
        }
      } catch (tmp49) {
        c4 = 3;
        throw tmp49;
      }
    }
  });
  return obj(...arguments);
};
function isActive() {
  const items = [];
  const tmp = null != token && closure_23;
  if (tmp) {
    const tmp2 = closure_22;
    if (tmp2) {
      items.push("foregrounded");
    }
    if (closure_21 === constants2.RTC_CONNECTED) {
      items.push("rtc_connected");
    }
  }
  return items.length > 0;
}
function scheduleHeartbeatTracking() {
  const f137893 = () => {
    trackHeartbeat();
    obj = {
      type: "interval",
      id: setInterval(() => {
        closure_1_25();
      }, closure_1_11)
    };
  };
  obj = SentryUtilsDefault;
  const obj2 = { message: `Heartbeat Track State Parameters Changed. Foregrounded ${closure_22}, Connection State: ${closure_21}` };
  obj.addBreadcrumb(obj2);
  const items = [];
  const tmp4 = null != token && closure_23;
  if (tmp4) {
    const tmp5 = closure_22;
    if (tmp5) {
      items.push("foregrounded");
    }
    if (closure_21 === constants2.RTC_CONNECTED) {
      items.push("rtc_connected");
    }
  }
  if (items.length > 0) {
    if (null == user) {
      let num = 0;
      if (0 !== c19) {
        obj6 = MonotonicClock;
        num = closure_11 - (obj6.monotonicNowMs() - c19);
      }
      const _HermesInternal = HermesInternal;
      const obj3 = { message: "Received Last Heartbeat Event Timestamp. Time Until Next Heartbeat: " + num / 1000 + " seconds. Scheduling Heartbeat" };
      const addBreadcrumb = SentryUtilsDefault.addBreadcrumb;
      SentryUtilsDefault;
      addBreadcrumb(obj3);
      const _setTimeout = setTimeout;
      user = { type: "timeout", id: setTimeout(f137893, num) };
      const obj4 = { type: "timeout", id: setTimeout(f137893, num) };
    }
  } else {
    let flag = false;
    if (null != user) {
      const type = user.type;
      if ("timeout" === type) {
        const _clearTimeout = clearTimeout;
        clearTimeout(user.id);
      } else if ("interval" === type) {
        const _clearInterval = clearInterval;
        clearInterval(user.id);
      } else {
        const type2 = user.type;
      }
      user = null;
      flag = true;
    }
    if (flag) {
      const obj7 = { category: user, message: "Stopping Analytics Heartbeat" };
      const tmpResult2 = SentryUtilsDefault;
      tmpResult2.addBreadcrumb(obj7);
      const obj5 = Clickstream;
      obj5.drainClickstream();
    }
  }
  const socket = GatewayConnectionStore.getSocket();
  if (socket != null) {
    let tmp31 = null != token;
    const handleActiveStateChange = socket.handleActiveStateChange;
    if (tmp31) {
      tmp31 = closure_23;
    }
    const items1 = [];
    if (tmp31) {
      const tmp32 = closure_22;
      if (tmp32) {
        items1.push("foregrounded");
      }
      if (closure_21 === constants2.RTC_CONNECTED) {
        items1.push("rtc_connected");
      }
    }
    const obj8 = { active: items1.length > 0, ver: 31, reasons: items1 };
    const result = handleActiveStateChange(obj8);
  }
}
function validateClientSession(version) {
  let tmp = null;
  if (null != version) {
    let tmp4 = version;
    const tmp2 = require;
    if (version.version !== SessionUtils.CLIENT_SESSION_STORAGE_VERSION) {
      const _HermesInternal = HermesInternal;
      logger.warn("Throwing away client session with invalid version: " + version.version + ", expected " + tmp2(6980).CLIENT_SESSION_STORAGE_VERSION);
      tmp4 = null;
    }
    tmp = tmp4;
  }
  return tmp;
}
function forceDispatchSessionIdUpdate() {
  return obj(...arguments);
}
obj = function _forceDispatchSessionIdUpdate() {
  obj = _asyncToGenerator(async (arg0, value) => {
    let createdAtTimestamp;
    let uuid;
    if (c3 === 2) {
      c3 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        obj = { value, done: true };
        return obj;
      } else {
        return { value: "IconComponent", done: null };
      }
    } else {
      try {
        let closure_0;
        c3 = 2;
        if (0 === c2) {
          if (arg0 === 1) {
            c3 = 3;
            throw value;
          } else if (arg0 === 2) {
            c3 = 3;
            const obj2 = { value, done: true };
            return obj2;
          } else {
            let closure_1 = tmp4;
            closure_0 = undefined;
            c2 = 1;
            c3 = 1;
            const obj3 = { value: getSession(false), done: false };
            return obj3;
          }
        } else if (arg0 === 1) {
          c3 = 3;
          throw value;
        } else if (arg0 === 2) {
          c3 = 3;
          const obj4 = { value, done: true };
          return obj4;
        } else {
          closure_0 = value;
          if (null != closure_0) {
            const socket = closure_129_4.getSocket();
            if (socket != null) {
              ({ createdAtTimestamp, uuid } = closure_0);
              const result = socket.handleUpdateTimeSpentSessionId(createdAtTimestamp, uuid, closure_129_0(closure_129_2[18]).clientLaunchId);
            }
          }
          c3 = 3;
          return { value: "IconComponent", done: null };
        }
      } catch (tmp15) {
        c3 = 3;
        throw tmp15;
      }
    }
  });
  return obj(...arguments);
};
function handleAuthenticationChange() {
  token = AuthenticationStore.getToken();
  if (token !== token) {
    const Storage = Storage2.Storage;
    Storage.remove(LAST_CLIENT_HEARTBEAT_SESSION);
    closure_20 = { state: "loaded", session: null };
    let flag = false;
    const tmp15 = require;
    if (null != user) {
      const type = user.type;
      if ("timeout" === type) {
        const _clearTimeout = clearTimeout;
        clearTimeout(user.id);
      } else if ("interval" === type) {
        const _clearInterval = clearInterval;
        clearInterval(user.id);
      } else {
        const type2 = user.type;
      }
      user = null;
      flag = true;
    }
    if (flag) {
      const obj2 = { category: user, message: "Stopping Analytics Heartbeat" };
      obj = SentryUtilsDefault;
      obj.addBreadcrumb(obj2);
      const tmp15Result = tmp15(6974);
      tmp15Result.drainClickstream();
    }
    c19 = 0;
  }
  scheduleHeartbeatTracking();
}
function handleRTCStateChange() {
  const state = RTCConnectionStore.getState();
  if (closure_21 !== state) {
    closure_21 = state;
    scheduleHeartbeatTracking();
  }
}
function handleWindowFocus(focused) {
  focused = focused.focused;
  if (closure_22 !== focused) {
    closure_22 = focused;
    scheduleHeartbeatTracking();
  }
}
function handleLocationChange() {
  obj = SessionRouteUtils;
  const isActiveUserRouteResult = obj.isActiveUserRoute();
  if (closure_23 !== isActiveUserRouteResult) {
    closure_23 = isActiveUserRouteResult;
    scheduleHeartbeatTracking();
  }
}
function handleAppStateUpdate(state) {
  if (closure_22 !== state.state === constants.ACTIVE) {
    closure_22 = tmp;
    scheduleHeartbeatTracking();
  }
}
function handleFluxInitialized() {
  const state = RTCConnectionStore.getState();
  obj = react_native;
  closure_22 = obj.isForegrounded();
  const obj2 = SessionRouteUtils;
  closure_23 = obj2.isActiveUserRoute();
  handleAuthenticationChange();
}
function getSession() {
  return obj(...arguments);
}
obj = function _getSession() {
  obj = _asyncToGenerator(async (arg0, value) => {
    let closure_1;
    let createdAtTimestamp;
    let lastUsedTimestamp;
    let obj11;
    let socket;
    let tmp;
    let uuid;
    let uuid1;
    function maybeFlushSessionToStorage(c2) {
      obj = closure_1_0(uuid[10]);
      monotonicNowMsResult = obj.monotonicNowMs();
      const tmp = closure_1_0;
      if (monotonicNowMsResult - monotonicNowMsResult >= closure_1_12) {
        try {
          const Storage = tmp(tmp2[16]).Storage;
          const result = Storage.set(closure_1_13, c2);
        } catch (tmp7) {
          const obj2 = closure_1_1(uuid[11]);
          obj2.captureException(tmp7);
        }
      }
    }
    let closure_0 = arg0;
    let closure_3 = tmp;
    let flag = closure_0;
    if (closure_0 === undefined) {
      flag = true;
    }
    await "Reflect";
    if (1 === tmp4) {
      if (arg0 === 1) {
        let c7 = 3;
        throw value;
      } else if (arg0 === 2) {
        c7 = 3;
        const obj8 = { value, done: true };
        return obj8;
      } else {
        uuid = null;
        let tmp18 = null;
        if ("loaded" === obj11.state) {
          const session = obj11.session;
          uuid1 = undefined;
          if (session != null) {
            uuid1 = session.uuid;
          }
          tmp18 = uuid1;
        }
        uuid1 = tmp18;
        let c4 = 1;
        if ("uninitialized" === obj11.state) {
          lastUsedTimestamp = closure_131_29;
          let Storage = closure_131_0(closure_131_2[16]).Storage;
          let c6 = 3;
          c7 = 1;
          const obj9 = { value: Storage.getAfterRefresh(closure_131_13), done: false };
          return obj9;
        } else {
          uuid = obj11.session;
          c4 = 0;
        }
      }
    } else if (2 === tmp4) {
      c4 = 0;
      let closure_4 = closure_5;
      let obj2 = closure_131_1(closure_131_2[11]);
      const captureExceptionResult = obj2.captureException(closure_4);
    } else if (arg0 === 1) {
      c7 = 3;
      throw value;
    } else if (arg0 === 2) {
      c4 = 0;
      c7 = 3;
      obj = { value, done: true };
      return obj;
    } else {
      lastUsedTimestamp(value);
    }
    const _Date = Date;
    lastUsedTimestamp = Date.now();
    if (closure_131_27()) {
      let isSessionExpiredResult = null == tmp27;
      if (!isSessionExpiredResult) {
        const obj4 = closure_131_0(closure_131_2[17]);
        isSessionExpiredResult = obj4.isSessionExpired(uuid);
      }
      if (isSessionExpiredResult) {
        const obj10 = { uuid: obj6.v4(), createdAtTimestamp: lastUsedTimestamp, lastUsedTimestamp, version: closure_131_0(closure_131_2[17]).CLIENT_SESSION_STORAGE_VERSION };
        obj6 = closure_131_0(closure_131_2[21]);
        uuid = obj10;
        c18 = 0;
      }
      uuid.lastUsedTimestamp = lastUsedTimestamp;
      maybeFlushSessionToStorage(uuid);
    } else {
      let isSessionExpiredResult1 = null != tmp27;
      if (isSessionExpiredResult1) {
        const obj3 = closure_131_0(closure_131_2[17]);
        isSessionExpiredResult1 = obj3.isSessionExpired(uuid);
      }
      if (isSessionExpiredResult1) {
        uuid = null;
      }
    }
    obj11 = { state: "loaded", session: uuid };
    const tmp58 = null != uuid && uuid1 !== uuid.uuid && flag;
    if (tmp58) {
      socket = socket.getSocket();
      if (socket != null) {
        ({ createdAtTimestamp, uuid } = uuid);
        let result = socket.handleUpdateTimeSpentSessionId(createdAtTimestamp, uuid, closure_131_0(closure_131_2[18]).clientLaunchId);
      }
    }
    return uuid;
  });
  return obj(...arguments);
};
({ AnalyticEvents: metroImportAll, AppStates: c9, RTCConnectionStates: c10 } = Constants);
let closure_11 = 15 * DurationsDefault.Millis.MINUTE;
const SECOND = DurationsDefault.Millis.SECOND;
const LAST_CLIENT_HEARTBEAT_SESSION = "LAST_CLIENT_HEARTBEAT_SESSION";
let user = "user";
const tmp3 = new LoggerDefault("SessionHeartbeatScheduler");
const logger = tmp3;
let c16 = null;
let obj6 = null;
let c18 = 0;
let c19 = 0;
let closure_20 = { state: "uninitialized" };
let state = RTCConnectionStore.getState();
let closure_22 = react_native.isForegrounded();
let closure_23 = SessionRouteUtils.isActiveUserRoute();
let token = AuthenticationStore.getToken();
let result = size.fileFinishedImporting("modules/analytics_sessions/SessionHeartbeatScheduler.tsx");

export const initSessionHeartbeatScheduler = function initSessionHeartbeatScheduler() {
  obj = SentryUtilsDefault;
  obj.addBreadcrumb({ message: "Initializing SessionHeartbeatScheduler" });
  RTCConnectionStore.addChangeListener(handleRTCStateChange);
  AuthenticationStore.addChangeListener(handleAuthenticationChange);
  let obj2 = DispatcherDefault;
  const subscription = obj2.subscribe("WINDOW_FOCUS", handleWindowFocus);
  let obj3 = DispatcherDefault;
  const subscription1 = obj3.subscribe("APP_STATE_UPDATE", handleAppStateUpdate);
  const obj4 = DispatcherDefault;
  const subscription2 = obj4.subscribe("CONNECTION_OPEN", forceDispatchSessionIdUpdate);
  const obj5 = SessionRouteUtils;
  let result = obj5.subscribeToLocationChanges(handleLocationChange);
  scheduleHeartbeatTracking();
  if (null == obj6) {
    const _setInterval = setInterval;
    obj6 = {
      id: setInterval(() => {
          let result = null != token;
          if (result) {
            obj = SkippedClientHeartbeatUtil;
            result = obj.shouldLogClientHeartbeatSkipped();
          }
          if (result) {
            const obj2 = MonotonicClock;
            const tmp5 = dependencyMap;
            if (obj2.monotonicNowMs() - closure_1_19 > closure_1_11) {
              const obj3 = require("AnalyticsUtils");
              obj3.track(constants.CLIENT_HEARTBEAT_SKIPPED, { client_heartbeat_version: 31 });
            }
          }
        }, closure_11),
      type: "interval"
    };
  }
  const initialized = get_initializedDefault.initialized;
  initialized.then(handleFluxInitialized);
};
export { getSession };
export const getActiveSessionUnsafe = function getActiveSessionUnsafe() {
  let session;
  if ("uninitialized" === closure_20.state) {
    const Storage = Storage2.Storage;
    const value = Storage.get(LAST_CLIENT_HEARTBEAT_SESSION);
    let tmp7 = null;
    if (null != value) {
      let tmp8 = value;
      if (value.version !== SessionUtils.CLIENT_SESSION_STORAGE_VERSION) {
        const _HermesInternal = HermesInternal;
        logger.warn("Throwing away client session with invalid version: " + value.version + ", expected " + SessionUtils.CLIENT_SESSION_STORAGE_VERSION);
        tmp8 = null;
      }
      tmp7 = tmp8;
    }
    session = tmp7;
  } else {
    session = closure_20.session;
  }
  let tmp12 = null;
  if (null != session) {
    tmp12 = null;
    obj = SessionUtils;
    if (!obj.isSessionExpired(session)) {
      tmp12 = session;
    }
  }
  return tmp12;
};