@applicaster/zapp-react-native-utils 16.0.0-alpha.5652127751 → 16.0.0-alpha.6001988150

package/analyticsUtils/PlayerAnalyticsManager.ts

@@ -23,6 +23,15 @@ class PlayerAnalyticsTrackerFactory {
         return new PlayerAnalyticsTracker();
     }
   }
+
+  onPlayerRegistered(tracker: PlayerAnalyticsTrackerI, player: Player) {
+    tracker.setPlayer(player);
+    tracker.onPlayerPresented();
+  }
+
+  onPlayerUnRegistered(tracker?: PlayerAnalyticsTrackerI) {
+    tracker?.onPlayerClosed();
+  }
 }
 
 export class PlayerAnalyticsManager implements PlayerLifecycleListener {
@@ -70,7 +79,7 @@ export class PlayerAnalyticsManager implements PlayerLifecycleListener {
     }
 
     const tracker = this.getTracker(player.playerId);
-    tracker.setPlayer(player);
+    this.trackerFactory.onPlayerRegistered(tracker, player);
 
     const analyticsListener = new AnalyticPlayerListener({
       analyticsTracker: tracker,
@@ -84,6 +93,7 @@ export class PlayerAnalyticsManager implements PlayerLifecycleListener {
   };
 
   onUnRegistered = (player: Player) => {
+    this.trackerFactory.onPlayerUnRegistered(this.trackers[player.playerId]);
     player.removeListener(AnalyticPlayerListener.analyticsListenerID);
     delete this.trackers[player.playerId];
   };

package/analyticsUtils/playerAnalyticsTracker.ts

@@ -4,8 +4,14 @@ import { isTrue } from "@applicaster/zapp-react-native-utils/booleanUtils";
 import { postAnalyticEvent } from "./manager";
 import { isLive } from "../playerUtils";
 import { extensionsEvents } from "./AnalyticsEvents/helper";
-import { AD_EVENT, EVENT_TYPES, PLAYER_DISPLAY_STATES } from "./events";
+import {
+  AD_EVENT,
+  EVENT_TYPES,
+  GENERAL_EVENT,
+  PLAYER_DISPLAY_STATES,
+} from "./events";
 import { Player } from "../appUtils/playerManager/player";
+import { isNil } from "@applicaster/zapp-react-native-utils/utils";
 
 export interface PlayerAnalyticsTrackerI {
   handleAnalyticEvent(
@@ -13,6 +19,8 @@ export interface PlayerAnalyticsTrackerI {
     eventData?: QuickBrickPlayer.EventData
   ): void;
   setPlayer(player: Player): void;
+  onPlayerPresented(): void;
+  onPlayerClosed(): void;
 }
 
 export class PlayerAnalyticsTracker implements PlayerAnalyticsTrackerI {
@@ -26,6 +34,15 @@ export class PlayerAnalyticsTracker implements PlayerAnalyticsTrackerI {
     this.player = player;
   }
 
+  onPlayerPresented() {
+    this.handleAnalyticEvent(GENERAL_EVENT.player_presented);
+  }
+
+  onPlayerClosed() {
+    this.handleAnalyticEvent(GENERAL_EVENT.session_end);
+    this.handleAnalyticEvent(GENERAL_EVENT.player_closed);
+  }
+
   isAdBreak(event: string): boolean {
     const adBreakEvents = [
       AD_EVENT.ad_break_start,
@@ -180,7 +197,8 @@ export class PlayerAnalyticsTracker implements PlayerAnalyticsTrackerI {
       this.entry?.extensions?.free || this.entry?.extensions?.isFree;
 
     const title = this.entry?.title;
-    const streamType = isLive(this.entry) ? "live" : "vod"; // Todo: determine other types, channel, podcast, aod
+    const isStreamLive = isLive(this.entry);
+    const streamType = isStreamLive ? "live" : "vod"; // Todo: determine other types, channel, podcast, aod
 
     const currentPosition = this.getCurrentPosition(
       event,
@@ -201,6 +219,7 @@ export class PlayerAnalyticsTracker implements PlayerAnalyticsTrackerI {
     );
 
     const playerState = this.getPlayerState();
+    const playerType = this.player?.playerPluginId;
 
     const analyticsCustomProperties = extensionsEvents(this.entry?.extensions);
 
@@ -210,7 +229,11 @@ export class PlayerAnalyticsTracker implements PlayerAnalyticsTrackerI {
       name: title,
       media_type: mediaType,
       stream_type: streamType,
-      duration: mediaDuration,
+      player_type: playerType,
+      // We do not pass duration for live streams anymore (it's now seekableDuration),
+      //  but we can't mark it as optional in Analytics Mapper yet,
+      //  so we set it to -1 for live streams
+      duration: isStreamLive && isNil(mediaDuration) ? -1 : mediaDuration,
       current_position: currentPosition,
       player_state: playerState,
       stream_format: contentType,

package/appUtils/HooksManager/index.ts

@@ -87,7 +87,7 @@ export function HooksManager({
 }: HookManagerArgs): HookManager {
   hooksManagerLogger.addContext({ targetScreenId: targetScreen.id });
 
-  function logHookEvent(func, message, data) {
+  function logHookEvent(func, message, data = {}) {
     func({
       message,
       data: __DEV__ ? data : null,
@@ -344,7 +344,6 @@ export function HooksManager({
             `hookCallback: send app to background, cancelled flow blocker hook  ${hookPlugin.identifier} on home screen`,
             {
               payload,
-              hook: hookPlugin,
             }
           );
 
@@ -356,17 +355,13 @@ export function HooksManager({
           `hookCallback: hook successfully finished: ${hookPlugin.identifier}`,
           {
             payload,
-            hook: hookPlugin,
           }
         );
 
         if (!callback) {
           logHookEvent(
-            hooksManagerLogger.warn,
-            `hookCallback: ${hookPlugin.identifier} is missing \`callback\`, using hookCallback(default one)`,
-            {
-              hookPlugin,
-            }
+            hooksManagerLogger.debug,
+            `hookCallback: ${hookPlugin.identifier} is missing \`callback\`, using hookCallback(default one)`
           );
 
           callback = hookCallback;

package/appUtils/contextKeysManager/utils/index.ts

@@ -1,40 +1,53 @@
-import * as R from "ramda";
 import { DEFAULT_NAMESPACE } from "../consts";
 import { KeyName, KeyNameObj } from "../index";
 
-const lastDotRegex = /\.([^.]+)$/;
-const splitByLastDot = R.compose(R.init, R.split(lastDotRegex));
-
 export function getNamespaceAndKey(namespacedKey: KeyName): KeyNameObj {
   if (typeof namespacedKey !== "string") return namespacedKey;
 
-  const namespacedKeyProps = namespacedKey.includes(".")
-    ? splitByLastDot(namespacedKey)
-    : [DEFAULT_NAMESPACE, namespacedKey];
+  if (!namespacedKey.includes(".")) {
+    return { namespace: DEFAULT_NAMESPACE, key: namespacedKey };
+  }
+
+  // split on the last dot - the namespace itself may contain dots
+  const lastDotIndex = namespacedKey.lastIndexOf(".");
 
-  return R.zipObj(["namespace", "key"], namespacedKeyProps);
+  return {
+    namespace: namespacedKey.slice(0, lastDotIndex),
+    key: namespacedKey.slice(lastDotIndex + 1),
+  };
 }
 
-const propIsNotNullOrUndefined = (prop) =>
-  R.compose(R.not, R.isNil, R.prop(prop));
+const hasOwn = (obj: object, prop: string): boolean =>
+  Object.prototype.hasOwnProperty.call(obj, prop);
+
+const isEmpty = (value: unknown): boolean => {
+  if (typeof value === "string" || Array.isArray(value)) {
+    return value.length === 0;
+  }
+
+  if (value !== null && typeof value === "object") {
+    return Object.keys(value).length === 0;
+  }
+
+  return false;
+};
+
+export const keyIsValid = (parsedKey: unknown): boolean => {
+  if (parsedKey == null) return false;
+  if (typeof parsedKey === "string") return false;
+  if (Array.isArray(parsedKey)) return false;
 
-const propIsNotEmpty = (prop) => R.compose(R.not, R.isEmpty, R.prop(prop));
+  const obj = parsedKey as Record<string, unknown>;
 
-export const keyIsValid = R.allPass([
-  R.compose(R.not, R.isNil),
-  R.compose(R.not, R.is(String)),
-  R.compose(R.not, R.is(Array)),
-  R.has("key"),
-  R.has("namespace"),
-  propIsNotNullOrUndefined("key"),
-  propIsNotNullOrUndefined("namespace"),
-  propIsNotEmpty("key"),
-  propIsNotEmpty("namespace"),
-]);
+  if (!hasOwn(obj, "key") || !hasOwn(obj, "namespace")) return false;
+  if (obj.key == null || obj.namespace == null) return false;
+  if (isEmpty(obj.key) || isEmpty(obj.namespace)) return false;
+
+  return true;
+};
 
 export const buildNamespaceKey = (key: string, namespace: string) =>
   `${namespace}.${key}`;
 
-export const savingResultIsSuccess = (result: unknown): boolean => {
-  return R.is(Boolean, result) && !!result;
-};
+export const savingResultIsSuccess = (result: unknown): boolean =>
+  typeof result === "boolean" && result === true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "16.0.0-alpha.5652127751",
+  "version": "16.0.0-alpha.6001988150",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "16.0.0-alpha.5652127751",
+    "@applicaster/applicaster-types": "16.0.0-alpha.6001988150",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

package/playerUtils/index.ts

@@ -9,6 +9,16 @@ import { Dimensions } from "react-native";
 
 export { getPlayerActionButtons } from "./getPlayerActionButtons";
 
+export const HLS_MIME_TYPES = [
+  "application/x-mpegURL",
+  "application/vnd.apple.mpegurl",
+];
+
+export const STREAMING_VIDEO_MIME_TYPES = [
+  ...HLS_MIME_TYPES,
+  "application/dash+xml",
+];
+
 /**
  * Gets duration value from player manager, and from extensions
  * then checks whether the value from either is a not a valid number
@@ -27,7 +37,7 @@ export function isLiveLegacy(content) {
   ]);
 
   const durationFromExt = R.path(["extensions", "duration"], content);
-  const durationFromMgr = playerManager.getDuration();
+  const durationFromMgr = playerManager.getInstanceController()?.getDuration();
   const duration = Math.floor(durationFromExt || durationFromMgr);
 
   const isLive = R.anyPass([isNotaValidNumber, R.lte(R.__, 0)])(duration);
@@ -71,7 +81,9 @@ function isLiveByManager(): boolean {
     return true;
   }
 
-  const durationFromPlayerManager = playerManager.getDuration();
+  const durationFromPlayerManager = playerManager
+    .getInstanceController()
+    ?.getDuration();
 
   return isLiveByDuration(durationFromPlayerManager);
 }
@@ -80,6 +92,16 @@ export function isLive(entry: ZappEntry): boolean {
   return isEntryLive(entry) || isLiveByManager();
 }
 
+export const isVideoItem = (item: Option<ZappEntry>) => {
+  const contentType = item?.content?.type;
+
+  return (
+    isString(contentType) &&
+    (contentType.includes("video") ||
+      STREAMING_VIDEO_MIME_TYPES.includes(contentType))
+  );
+};
+
 export const isAudioItem = (item: Option<ZappEntry>) => {
   if (
     isString(item?.content?.type) &&

package/reactHooks/videoModal/hooks/useVideoModalScreenData.tsx

@@ -2,6 +2,12 @@ import React from "react";
 import { useContentTypes } from "@applicaster/zapp-react-native-redux/hooks";
 import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
 import { useRivers } from "../../state";
+import { createLogger } from "../../../logger";
+
+const { log_warning } = createLogger({
+  subsystem: "zapp-react-native-utils/reactHooks/videoModal",
+  category: "useVideoModalScreenData",
+});
 
 export const useVideoModalScreenData = ():
   | (ZappEntry & { targetScreen: any }) // TODO: fix ZappEntry type ( was ZappRiver but conflict )
@@ -14,10 +20,22 @@ export const useVideoModalScreenData = ():
   const rivers = useRivers();
 
   return React.useMemo(() => {
-    if (item?.type?.value) {
-      const screenId = contentTypes[item?.type?.value].screen_id;
+    const itemType = item?.type?.value;
+
+    if (!itemType) {
+      return;
+    }
 
-      return { ...item, targetScreen: rivers?.[screenId] };
+    const screenId = contentTypes[itemType]?.screen_id;
+
+    if (!screenId) {
+      log_warning(
+        `Type mapping is missing for item type: ${itemType}, title: ${item.title}`
+      );
+
+      return;
     }
-  }, [item]);
+
+    return { ...item, targetScreen: rivers?.[screenId] };
+  }, [contentTypes, item, rivers]);
 };