@applicaster/zapp-react-native-utils 12.0.0-alpha.8242130253 → 12.0.0-alpha.8254217837

package/analyticsUtils/AnalyticsEvents/index.ts

@@ -7,6 +7,10 @@ import { sendHeaderClickEvent } from "./sendHeaderClickEvent";
 import { sendHardwareBackButtonClickEvent } from "./sendHardwareBackButtonClickEvent";
 import { sendDownloadsEvent } from "./sendDownloadsEvent";
 import { sendScreenEvent } from "./sendScreenEvent";
+import {
+  sendSearchCanceledEvent,
+  sendSearchExecutedEvent,
+} from "./searchEvents";
 
 export {
   sendScreenEvent,
@@ -18,4 +22,6 @@ export {
   sendHeaderClickEvent,
   sendHardwareBackButtonClickEvent,
   sendDownloadsEvent,
+  sendSearchCanceledEvent,
+  sendSearchExecutedEvent,
 };

package/analyticsUtils/AnalyticsEvents/searchEvents.ts

@@ -0,0 +1,21 @@
+import { log_debug } from "../logger";
+import { postAnalyticEvent } from "../manager";
+import { ANALYTICS_CORE_EVENTS } from "../events";
+
+export const sendSearchCanceledEvent = (analyticsProps) => {
+  const eventName = ANALYTICS_CORE_EVENTS.SEARCH_CANCELED;
+  postAnalyticEvent(eventName, analyticsProps);
+
+  log_debug(`sendSearchCanceledEvent: send event: ${eventName}`, {
+    analyticsProps,
+  });
+};
+
+export const sendSearchExecutedEvent = (analyticsProps) => {
+  const eventName = ANALYTICS_CORE_EVENTS.SEARCH_EXECUTED;
+  postAnalyticEvent(eventName, analyticsProps);
+
+  log_debug(`sendSearchExecutedEvent: send event: ${eventName}`, {
+    analyticsProps,
+  });
+};

package/analyticsUtils/events.ts

@@ -23,10 +23,16 @@ export const TAPPING_EVENTS = {
   TAP_NAVBAR_BACK_BUTTON: "tap_navbar_back_button",
 };
 
+export const SEARCH_EVENTS = {
+  SEARCH_EXECUTED: "search_executed",
+  SEARCH_CANCELED: "search_canceled",
+};
+
 export const ANALYTICS_CORE_EVENTS = {
   ...LEGACY_EVENTS,
   ...SCREEN_VIEW_EVENTS,
   ...TAPPING_EVENTS,
+  ...SEARCH_EVENTS,
 };
 
 export const WEBVIEW_EVENTS = {

package/analyticsUtils/index.tsx

@@ -18,6 +18,8 @@ import {
   sendHardwareBackButtonClickEvent,
   sendDownloadsEvent,
   sendScreenEvent,
+  sendSearchCanceledEvent,
+  sendSearchExecutedEvent,
 } from "./AnalyticsEvents";
 
 import { postAnalyticEvent } from "./manager";
@@ -66,6 +68,8 @@ type AnalyticsFunctions = {
     item: ZappEntry;
     state: OfflineItemState;
   }) => void;
+  sendSearchCanceledEvent: (props: AnalyticsDefaultProperties) => void;
+  sendSearchExecutedEvent: (props: AnalyticsDefaultProperties) => void;
 };
 
 type GetAnalyticsFunctions = (
@@ -102,6 +106,8 @@ export function getAnalyticsFunctions({
     sendHardwareBackButtonClickEvent,
     sendScreenEvent,
     sendDownloadsEvent,
+    sendSearchCanceledEvent,
+    sendSearchExecutedEvent,
   };
 }
 

package/appUtils/playerManager/DelayedSeekPlayerWrapper.tsx

@@ -0,0 +1,177 @@
+import { Player } from "./player";
+
+export class DelayedSeekPlayerWrapper extends Player {
+  private wrappedPlayer: Player;
+  private delayedSeek: boolean;
+  private wasPlaying: boolean;
+  private delayedSeekTimer: NodeJS.Timeout;
+
+  constructor(props, player: Player) {
+    super(props);
+    // this.playerState = this.wrappedPlayer.playerState;
+    this.wrappedPlayer = player;
+
+    this.wrappedPlayer.addListener({
+      id: "Master-Wrapper-Listener",
+      listener: this,
+    });
+  }
+
+  getListener = (): QuickBrickPlayer.SharedPlayerCallBacks => {
+    return this.wrappedPlayer.getListener();
+  };
+
+  togglePlayPause = () => {
+    this.wrappedPlayer.togglePlayPause();
+  };
+
+  // Implement all default methods by delegating them to wrapped player
+  public seekTo = (position: number) => {
+    this.wrappedPlayer.seekTo(position);
+  };
+
+  public isPlaying = () => {
+    return this.wrappedPlayer.isPlaying();
+  };
+
+  public isPaused = () => {
+    return this.wrappedPlayer.isPaused();
+  };
+
+  public play = () => {
+    this.wrappedPlayer.play();
+  };
+
+  public pause = () => {
+    this.wrappedPlayer.pause();
+  };
+
+  getState = () => {
+    const currentState = this.wrappedPlayer.getState();
+
+    if (!this.delayedSeek) {
+      return currentState;
+    }
+
+    return {
+      ...currentState,
+      contentPosition: this.playerState.seekPosition,
+      isPaused: false,
+      seekPosition: this.playerState.seekPosition,
+    };
+  };
+
+  forward = (deltaTime: number) => {
+    if (this.delayedSeek || this.delayedSeekTimer) {
+      if (this.playerState.seekPosition == null) {
+        return;
+      }
+
+      this.playerState.seekPosition += deltaTime;
+
+      this.onVideoProgress({
+        currentTime: this.playerState.seekPosition,
+        duration: this.getDuration(),
+        seekableDuration: this.playerState.seekableDuration,
+        isLive: this.playerState.isLive,
+      });
+
+      return;
+    }
+
+    if (this.playerState.seekPosition == null) {
+      this.playerState.seekPosition = this.playerState.contentPosition;
+    }
+
+    this.playerState.seekPosition += deltaTime;
+
+    this.delayedSeekTimer && clearTimeout(this.delayedSeekTimer);
+
+    this.delayedSeekTimer = setTimeout(() => {
+      this.delayedSeekTimer = null;
+      this.wrappedPlayer.seekTo(this.playerState.seekPosition);
+
+      this.logState("forward", { deltaTime });
+    }, 3000);
+  };
+
+  rewind = (deltaTime: number) => {
+    if (this.delayedSeek || this.delayedSeekTimer) {
+      if (this.playerState.seekPosition == null) {
+        return;
+      }
+
+      this.playerState.seekPosition -= deltaTime;
+
+      this.onVideoProgress({
+        currentTime: this.playerState.seekPosition,
+        duration: this.getDuration(),
+        seekableDuration: this.playerState.seekableDuration,
+        isLive: this.playerState.isLive,
+      });
+
+      return;
+    }
+
+    this.delayedSeekTimer && clearTimeout(this.delayedSeekTimer);
+
+    if (this.playerState.seekPosition == null) {
+      this.playerState.seekPosition = this.playerState.contentPosition;
+    }
+
+    this.playerState.seekPosition -= deltaTime;
+
+    this.delayedSeekTimer = setTimeout(() => {
+      this.delayedSeekTimer = null;
+      this.wrappedPlayer.seekTo(this.playerState.seekPosition);
+
+      // this.currentPlayerComponent()?.["rewind"]?.(deltaTime);
+      this.logState("rewind", { deltaTime });
+    }, 3000);
+  };
+
+  public enterDelayedSeek() {
+    this.delayedSeekTimer && clearTimeout(this.delayedSeekTimer);
+    this.delayedSeekTimer = null;
+
+    if (this.delayedSeek) {
+      return;
+    }
+
+    this.delayedSeek = true;
+
+    console.log(
+      `Anton enterDelayedSeek wasPlaying: ${this.wasPlaying}`,
+      this.playerState.seekPosition
+    );
+
+    this.playerState.seekPosition = this.playerState.contentPosition;
+
+    if (!this.isPaused()) {
+      this.wasPlaying = true;
+      this.wrappedPlayer.pause();
+    }
+  }
+
+  public exitDelayedSeek() {
+    if (!this.delayedSeek) {
+      return;
+    }
+
+    if (this.delayedSeekTimer) {
+      return;
+    }
+
+    this.delayedSeek = false;
+
+    if (this.playerState.seekPosition != null) {
+      this.wrappedPlayer.seekTo(this.playerState.seekPosition);
+    }
+
+    if (this.wasPlaying) {
+      // Disabled by ticket definition
+      // this.wrappedPlayer.play();
+      this.wasPlaying = true;
+    }
+  }
+}

package/appUtils/playerManager/player.ts

@@ -340,6 +340,7 @@ export class Player {
     const { isLive, seekableDuration, currentTime, duration } = event;
 
     this.setPlaybackState({ currentTime, duration, seekableDuration, isLive });
+
     this.playerState.seekPosition = null;
 
     if (!isLive) {
@@ -727,4 +728,9 @@ export class Player {
   }
 
   public supportsNativeControls = (): boolean => false;
+  public supportNativeCast = (): boolean => false;
+
+  public enterDelayedSeek() {}
+
+  public exitDelayedSeek() {}
 }

package/appUtils/playerManager/playerNative.ts

@@ -295,4 +295,9 @@ export class PlayerNative extends Player {
 
   supportsNativeControls = (): boolean =>
     toBooleanWithDefaultFalse(this.getConfig()?.["supports_native_controls"]);
+
+  supportNativeCast = (): boolean =>
+    toBooleanWithDefaultFalse(
+      this.playerPluginId === "quick-brick-player-brightcove"
+    );
 }

package/appUtils/playerManager/usePlayerControllerSetup.tsx

@@ -4,6 +4,8 @@ import { useEffect } from "react";
 import { playerManager } from "./index";
 import { useValidatePlayerConfig } from "../../playerUtils/useValidatePlayerConfig";
 import { PlayerRole } from "./conts";
+import { isTV } from "../../reactUtils";
+import { DelayedSeekPlayerWrapper } from "./DelayedSeekPlayerWrapper";
 
 // TODO: Rename to ControllerType
 export const usePlayerControllerSetup = ({
@@ -34,7 +36,7 @@ export const usePlayerControllerSetup = ({
   useValidatePlayerConfig(config);
 
   useEffect(() => {
-    const newPlayerController = new ControllerType({
+    const combinedProps = {
       player: ref,
       listener: props as any,
       config,
@@ -42,9 +44,21 @@ export const usePlayerControllerSetup = ({
       entry,
       playerPluginId: pluginId,
       playerRole: PlayerRole.Primary,
+    };
+
+    const newPlayerController = new ControllerType({
+      ...combinedProps,
+      playerRole: PlayerRole.Unspecified,
+      playerId: playerId + "." + "wrapped",
     });
 
-    setPlayerController(newPlayerController);
+    if (isTV()) {
+      setPlayerController(
+        new DelayedSeekPlayerWrapper(combinedProps, newPlayerController)
+      );
+    } else {
+      setPlayerController(newPlayerController);
+    }
   }, [playerId, entry?.id]);
 
   React.useEffect(() => {

package/cellUtils/__tests__/cellUtils.test.ts

@@ -24,7 +24,6 @@ import {
   EMPTY,
   FALLBACK,
   TRANSFORM,
-  defaultColor,
 } from "./fixtures";
 
 describe("getKeyForLabel", () => {
@@ -395,9 +394,7 @@ describe("getColorFromData", () => {
   it("should return value directly if valid color", () => {
     const result = getColorFromData({
       data: entry,
-      key: "background_color",
-      getValue: getValue(componentStyle),
-      defaultColor,
+      valueFromLayout: "#123456",
     });
 
     expect(result).toBe("#123456");
@@ -406,9 +403,7 @@ describe("getColorFromData", () => {
   it("should return valid rgba color name", () => {
     const result = getColorFromData({
       data: entry,
-      key: "component_background_color",
-      getValue: getValue(componentStyle),
-      defaultColor,
+      valueFromLayout: "rgba(255, 255, 255, 0)",
     });
 
     expect(result).toBe("rgba(255, 255, 255, 0)");
@@ -417,33 +412,27 @@ describe("getColorFromData", () => {
   it("should return path value if path value is set and is valid color", () => {
     const result = getColorFromData({
       data: entry,
-      key: VAL.colorKeyPath,
-      getValue: getValue(componentStyle),
-      defaultColor,
+      valueFromLayout: "background_color",
     });
 
     expect(result).toBe("#123456");
   });
 
-  it("should return defaultColor if key value and path value are invalid", () => {
+  it("should return path value if path value is set, nested and is valid color", () => {
     const result = getColorFromData({
       data: entry,
-      key: VAL.invalidColorKey,
-      getValue: getValue(componentStyle),
-      defaultColor,
+      valueFromLayout: "extensions.background_color",
     });
 
-    expect(result).toBe(defaultColor);
+    expect(result).toBe("#123456");
   });
 
-  it("should return defaultColor if path does not exist", () => {
+  it("should return valueFromLayout if path does not exist", () => {
     const result = getColorFromData({
       data: entry,
-      key: VAL.invalidColorKeyPath,
-      getValue: getValue(componentStyle),
-      defaultColor,
+      valueFromLayout: "invalid_color",
     });
 
-    expect(result).toBe(defaultColor);
+    expect(result).toBe("invalid_color");
   });
 });

package/cellUtils/index.ts

@@ -447,30 +447,24 @@ export const toResizeMode = (
 
 type GetColorFromData = {
   data: Record<string, any>;
-  key: string;
-  getValue: Function;
-  defaultColor: string;
+  valueFromLayout: string;
 };
 
 export const getColorFromData = ({
   data,
-  key,
-  getValue,
-  defaultColor,
+  valueFromLayout,
 }: GetColorFromData): string => {
-  const value = getValue(key);
-
   // Temporary hack to fix color validation when alpha is floating point number
   // https://github.com/dreamyguy/validate-color/issues/44
-  if (validateColor(value.replace(".00", ""))) {
-    return value;
+  if (validateColor(valueFromLayout.replace(".00", ""))) {
+    return valueFromLayout;
   }
 
-  const pathValue = R.path(value.split("."), data);
+  const pathValue = R.path(valueFromLayout.split("."), data);
 
   if (pathValue && validateColor(pathValue)) {
     return pathValue;
   }
 
-  return defaultColor;
+  return valueFromLayout;
 };

package/dateUtils/index.ts

@@ -0,0 +1,11 @@
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc";
+import timezone from "dayjs/plugin/timezone";
+import isoWeek from "dayjs/plugin/isoWeek";
+
+// Extend dayjs with plugins
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(isoWeek);
+
+export { dayjs };

package/headersUtils/index.ts

@@ -28,5 +28,6 @@ export const getAppDataHeaders = (screenId: string) => {
     "x-applicaster-signed-device-info-token": appData.signedDeviceInfoToken,
     "x-applicaster-device-make": appData.deviceMake,
     "x-applicaster-device-model": appData.deviceModel,
+    "x-applicaster-uuid": appData?.uuid,
   };
 };

package/inflatedUrlUtils/index.ts

@@ -1,4 +1,4 @@
-import { last, head, isNil, includes, all, pathOr } from "ramda";
+import { last, head, isNil, includes, pathOr } from "ramda";
 
 const stripBrackets = (path) => {
   const withoutPrepened = last(path.split("{{"));
@@ -13,15 +13,15 @@ const hasValue = (context) => (path) => {
   return !isNil(value);
 };
 
-export const isEnoughDataToInflateString = (context, string): boolean => {
+export const getMissingValues = (context, string): string[] => {
   if (!includes("{{", string)) {
-    return true;
+    return [];
   }
 
   const SEARCH_REGEX = new RegExp(/{{.*?}}/g);
   const paths = string.toString().match(SEARCH_REGEX);
 
-  return all(hasValue(context), paths);
+  return paths.filter((path) => !hasValue(context)(path));
 };
 
 export const isNonInflatedUrl = (url: string): boolean =>