@applicaster/quick-brick-core 16.0.0-rc.99 → 17.0.0-alpha.1984136194

package/App/ActionSetters/index.ts

@@ -4,8 +4,8 @@ import { allSettled } from "promise";
 import { useActions } from "@applicaster/zapp-react-native-utils/reactHooks/actions";
 
 import * as React from "react";
-import { coreAppLogger } from "../logger";
-const logger = coreAppLogger.addSubsystem("AppLifeCycleManager");
+import { subsystemLogger } from "@applicaster/zapp-react-native-utils/logger";
+const logger = subsystemLogger("app/lifecycle", "AppLifeCycleManager");
 
 const debugActions = (actions) =>
   logger.debug({

package/App/ActionsProvider/ActionsProvider.tsx

@@ -8,7 +8,7 @@ import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
 import { LegacyActionsRegistryAdapter } from "./LegacyActionsRegistryAdapter";
 
 const { log_debug } = createLogger({
-  subsystem: "ActionsProvider",
+  subsystem: "core/actions",
   category: "ActionRegistration",
 });
 

package/App/ActionsProvider/LegacyActionsRegistryAdapter.tsx

@@ -5,7 +5,7 @@ import { uiActionsRegistry } from "@applicaster/zapp-react-native-utils/uiAction
 import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
 
 const { log_debug, log_warning } = createLogger({
-  subsystem: "LegacyActionsRegistryAdapter",
+  subsystem: "core/actions/legacy_registry",
   category: "ActionRegistration",
 });
 
@@ -66,6 +66,22 @@ function LegacyActionBridge({ plugin }: { plugin: LegacyActionPlugin }) {
     };
   }, [plugin.identifier]);
 
+  // Consumers resolve a snapshot of `value`; when the plugin publishes a new
+  // one (e.g. cast devices found), make them re-resolve so availability
+  // predicates are not read from a stale value. Registration already
+  // notifies, so the first render is skipped.
+  const isFirstValueRef = React.useRef(true);
+
+  React.useEffect(() => {
+    if (isFirstValueRef.current) {
+      isFirstValueRef.current = false;
+
+      return;
+    }
+
+    uiActionsRegistry.notifyProviderChanged(plugin.identifier);
+  }, [value, plugin.identifier]);
+
   return null;
 }
 

package/App/ActionsProvider/__tests__/LegacyActionsRegistryAdapter.test.tsx

@@ -0,0 +1,64 @@
+import React from "react";
+import { render } from "@testing-library/react-native";
+import { uiActionsRegistry } from "@applicaster/zapp-react-native-utils/uiActionsRegistrator";
+import { LegacyActionsRegistryAdapter } from "../LegacyActionsRegistryAdapter";
+
+const CastContext = React.createContext<any>(null);
+
+const plugin = {
+  identifier: "cast-action-test",
+  module: { context: CastContext },
+};
+
+const renderWithValue = (value) => (
+  <CastContext.Provider value={value}>
+    <LegacyActionsRegistryAdapter actionPlugins={{ cast: plugin } as any} />
+  </CastContext.Provider>
+);
+
+describe("LegacyActionsRegistryAdapter", () => {
+  it("makes consumers re-resolve when the plugin publishes a new value", () => {
+    const noDevices = { isActionAvailable: () => false };
+    const devicesFound = { isActionAvailable: () => true };
+
+    const { rerender, unmount } = render(renderWithValue(noDevices));
+
+    // what a consumer resolved at first paint
+    expect(
+      uiActionsRegistry
+        .getAction("cast-action-test")
+        ?.isActionAvailable?.({} as any)
+    ).toBe(false);
+
+    const listener = jest.fn();
+    const unsubscribe = uiActionsRegistry.subscribe(listener);
+
+    rerender(renderWithValue(devicesFound));
+
+    expect(listener).toHaveBeenCalledTimes(1);
+
+    expect(
+      uiActionsRegistry
+        .getAction("cast-action-test")
+        ?.isActionAvailable?.({} as any)
+    ).toBe(true);
+
+    unsubscribe();
+    unmount();
+  });
+
+  it("does not notify again when the value is unchanged", () => {
+    const stable = { isActionAvailable: () => true };
+    const { rerender, unmount } = render(renderWithValue(stable));
+
+    const listener = jest.fn();
+    const unsubscribe = uiActionsRegistry.subscribe(listener);
+
+    rerender(renderWithValue(stable));
+
+    expect(listener).not.toHaveBeenCalled();
+
+    unsubscribe();
+    unmount();
+  });
+});

package/App/AssetCache/logger.ts

@@ -5,6 +5,6 @@ import { coreAppLogger } from "../logger";
 export const { log_verbose, log_debug, log_warning, log_info, log_error } =
   createLogger({
     category: "AssetCache",
-    subsystem: "quick-brick-core",
+    subsystem: "storage/asset_cache",
     parent: coreAppLogger,
   });

package/App/DeepLinking/SamsungAppControl/__tests__/samsungAppControl.test.ts

@@ -0,0 +1,255 @@
+import {
+  actionDataToUrl,
+  addSamsungAppControlListener,
+  getSamsungAppControlUrl,
+  resetSamsungAppControlState,
+} from "..";
+
+jest.mock("@applicaster/zapp-react-native-utils/appDataUtils", () => ({
+  getAppUrlScheme: () => "self",
+}));
+
+const QUERY =
+  "feed_locator=https%3A%2F%2Fzapp-pf-axnm.web.app%2Faxinom%2Fmovies%2F488059942906&id=488059942906";
+
+const DEEP_LINK = `pureflix://open?${QUERY}`;
+
+const mockTizen = (data?: { key: string; value: string[] }[]) => {
+  const getRequestedAppControl = jest.fn(() =>
+    data
+      ? {
+          appControl: {
+            operation: "http://tizen.org/appcontrol/operation/default",
+            data,
+          },
+        }
+      : null
+  );
+
+  // @ts-ignore
+  window.tizen = {
+    application: { getCurrentApplication: () => ({ getRequestedAppControl }) },
+  };
+
+  return getRequestedAppControl;
+};
+
+const payload = (values: unknown) => [
+  { key: "PAYLOAD", value: [JSON.stringify({ values })] },
+];
+
+// The RN jest environment has no DOM events on window
+const target = new EventTarget();
+// @ts-ignore
+window.addEventListener = target.addEventListener.bind(target);
+// @ts-ignore
+window.removeEventListener = target.removeEventListener.bind(target);
+// @ts-ignore
+window.dispatchEvent = target.dispatchEvent.bind(target);
+
+const documentTarget = new EventTarget();
+let documentHidden = false;
+
+// @ts-ignore
+global.document = {
+  get hidden() {
+    return documentHidden;
+  },
+  addEventListener: documentTarget.addEventListener.bind(documentTarget),
+  removeEventListener: documentTarget.removeEventListener.bind(documentTarget),
+  dispatchEvent: documentTarget.dispatchEvent.bind(documentTarget),
+};
+
+const setVisibility = (hidden: boolean) => {
+  documentHidden = hidden;
+  document.dispatchEvent(new Event("visibilitychange"));
+};
+
+afterEach(() => {
+  // @ts-ignore
+  delete window.tizen;
+  documentHidden = false;
+  resetSamsungAppControlState();
+});
+
+describe("actionDataToUrl", () => {
+  it("keeps a full deep link", () => {
+    expect(actionDataToUrl(DEEP_LINK)).toBe(DEEP_LINK);
+  });
+
+  it("builds an open deep link from a query string", () => {
+    expect(actionDataToUrl(QUERY)).toBe(`self://open?${QUERY}`);
+    expect(actionDataToUrl(`?${QUERY}`)).toBe(`self://open?${QUERY}`);
+  });
+
+  it("reads url / deep_link / values from JSON", () => {
+    expect(actionDataToUrl(JSON.stringify({ url: DEEP_LINK }))).toBe(DEEP_LINK);
+    expect(actionDataToUrl({ deep_link: DEEP_LINK })).toBe(DEEP_LINK);
+
+    expect(actionDataToUrl(JSON.stringify({ values: DEEP_LINK }))).toBe(
+      DEEP_LINK
+    );
+
+    expect(
+      actionDataToUrl(
+        JSON.stringify({ values: JSON.stringify({ url: DEEP_LINK }) })
+      )
+    ).toBe(DEEP_LINK);
+  });
+
+  it("returns null for non deep link data", () => {
+    expect(actionDataToUrl("")).toBeNull();
+    expect(actionDataToUrl("hello")).toBeNull();
+    expect(actionDataToUrl(undefined)).toBeNull();
+    expect(actionDataToUrl("{not json")).toBeNull();
+  });
+});
+
+describe("getSamsungAppControlUrl", () => {
+  it("returns null outside Tizen", () => {
+    expect(getSamsungAppControlUrl()).toBeNull();
+  });
+
+  it("returns null when the app was launched without PAYLOAD", () => {
+    mockTizen([]);
+    expect(getSamsungAppControlUrl()).toBeNull();
+  });
+
+  it("returns null when there is no requested app control", () => {
+    mockTizen();
+    expect(getSamsungAppControlUrl()).toBeNull();
+  });
+
+  it("returns the deep link from PAYLOAD", () => {
+    mockTizen(payload(DEEP_LINK));
+    expect(getSamsungAppControlUrl()).toBe(DEEP_LINK);
+  });
+
+  it("does not throw when getRequestedAppControl throws", () => {
+    // @ts-ignore
+    window.tizen = {
+      application: {
+        getCurrentApplication: () => ({
+          getRequestedAppControl: () => {
+            throw new Error("NotFoundError");
+          },
+        }),
+      },
+    };
+
+    expect(getSamsungAppControlUrl()).toBeNull();
+  });
+});
+
+describe("addSamsungAppControlListener", () => {
+  it("is a no-op outside Tizen", () => {
+    const onUrl = jest.fn();
+    const remove = addSamsungAppControlListener(onUrl);
+    window.dispatchEvent(new Event("appcontrol"));
+    expect(onUrl).not.toHaveBeenCalled();
+    remove();
+  });
+
+  it("calls onUrl with the deep link on appcontrol event and unsubscribes", () => {
+    mockTizen(payload(DEEP_LINK));
+    const onUrl = jest.fn();
+    const remove = addSamsungAppControlListener(onUrl);
+
+    window.dispatchEvent(new Event("appcontrol"));
+    expect(onUrl).toHaveBeenCalledWith(DEEP_LINK);
+
+    remove();
+    window.dispatchEvent(new Event("appcontrol"));
+    expect(onUrl).toHaveBeenCalledTimes(1);
+  });
+
+  it("ignores appcontrol events without a deep link", () => {
+    mockTizen([]);
+    const onUrl = jest.fn();
+    const remove = addSamsungAppControlListener(onUrl);
+    window.dispatchEvent(new Event("appcontrol"));
+    expect(onUrl).not.toHaveBeenCalled();
+    remove();
+  });
+});
+
+describe("deduplication", () => {
+  it("returns the same PAYLOAD only once until a launch without PAYLOAD", () => {
+    const tizenData = payload(DEEP_LINK);
+    const getRequested = mockTizen(tizenData);
+
+    expect(getSamsungAppControlUrl()).toBe(DEEP_LINK);
+    expect(getSamsungAppControlUrl()).toBeNull();
+
+    // App opened from the icon: app control without PAYLOAD
+    getRequested.mockReturnValueOnce({
+      appControl: { operation: "default", data: [] },
+    });
+
+    expect(getSamsungAppControlUrl()).toBeNull();
+    expect(getSamsungAppControlUrl()).toBe(DEEP_LINK);
+  });
+
+  it("handles a different PAYLOAD right away", () => {
+    const getRequested = mockTizen(payload(DEEP_LINK));
+    expect(getSamsungAppControlUrl()).toBe(DEEP_LINK);
+
+    const other = DEEP_LINK.replace(/488059942906/g, "111");
+
+    getRequested.mockReturnValue({
+      appControl: { operation: "default", data: payload(other) },
+    });
+
+    expect(getSamsungAppControlUrl()).toBe(other);
+  });
+});
+
+describe("visibilitychange (app brought back to foreground)", () => {
+  it("calls onUrl when the page becomes visible with a new PAYLOAD", () => {
+    mockTizen(payload(DEEP_LINK));
+    const onUrl = jest.fn();
+    const remove = addSamsungAppControlListener(onUrl);
+
+    setVisibility(true);
+    expect(onUrl).not.toHaveBeenCalled();
+
+    setVisibility(false);
+    expect(onUrl).toHaveBeenCalledWith(DEEP_LINK);
+
+    remove();
+  });
+
+  it("does not reopen the same deep link on a plain return to the app", () => {
+    mockTizen(payload(DEEP_LINK));
+    const onUrl = jest.fn();
+    const remove = addSamsungAppControlListener(onUrl);
+
+    setVisibility(false);
+    setVisibility(true);
+    setVisibility(false);
+    expect(onUrl).toHaveBeenCalledTimes(1);
+
+    remove();
+  });
+
+  it("handles appcontrol + visibilitychange for one launch only once", () => {
+    mockTizen(payload(DEEP_LINK));
+    const onUrl = jest.fn();
+    const remove = addSamsungAppControlListener(onUrl);
+
+    window.dispatchEvent(new Event("appcontrol"));
+    setVisibility(false);
+    expect(onUrl).toHaveBeenCalledTimes(1);
+
+    remove();
+  });
+
+  it("does not react after unsubscribe", () => {
+    mockTizen(payload(DEEP_LINK));
+    const onUrl = jest.fn();
+    addSamsungAppControlListener(onUrl)();
+
+    setVisibility(false);
+    expect(onUrl).not.toHaveBeenCalled();
+  });
+});

package/App/DeepLinking/SamsungAppControl/index.ts

@@ -0,0 +1,223 @@
+/**
+ * Samsung (Tizen) deep links.
+ *
+ * Samsung delivers deep links (Smart Hub Preview, Universal Guide, search, voice,
+ * partner launchers) as an app control with a `PAYLOAD` data key:
+ *   PAYLOAD = '{"values":"<action data>"}'
+ *
+ * - Cold start: the app control that launched the app is available through
+ *   tizen.application.getCurrentApplication().getRequestedAppControl().
+ * - App already running (multitasking): the platform fires a window "appcontrol"
+ *   event and getRequestedAppControl() returns the new app control.
+ *
+ * The action data may be a full deep link (`<scheme>://open?feed_locator=...&id=...`),
+ * a bare query string (`feed_locator=...&id=...`) or a JSON object with a `url`,
+ * `deep_link` or `deeplink` field. It is normalized to a URL handled by
+ * URLSchemeListener (routing is by host, e.g. "open" / "present").
+ */
+import { getAppUrlScheme } from "@applicaster/zapp-react-native-utils/appDataUtils";
+
+import { log_debug, log_error, log_info } from "../logger";
+
+export const PAYLOAD_KEY = "PAYLOAD";
+
+export const APP_CONTROL_EVENT = "appcontrol";
+
+type AppControlData = { key: string; value?: string[] };
+
+const SCHEME_REGEX = /^[a-z][a-z0-9+.-]*:\/\//i;
+
+const getTizenApplication = () => {
+  try {
+    // @ts-ignore tizen is a global injected by the Tizen web runtime
+    const tizenApi = typeof window !== "undefined" ? window.tizen : undefined;
+
+    return tizenApi?.application?.getCurrentApplication?.() ?? null;
+  } catch (error) {
+    log_debug("SamsungAppControl: Tizen application API is not available", {
+      error,
+    });
+
+    return null;
+  }
+};
+
+const parseJSON = (value: string): unknown => {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Converts Samsung action data into a deep link URL, or null if it is not one.
+ */
+export const actionDataToUrl = (raw: unknown, depth = 0): string | null => {
+  if (depth > 6 || raw === null || raw === undefined) return null;
+
+  if (typeof raw === "object") {
+    const data = raw as Record<string, unknown>;
+
+    return actionDataToUrl(
+      data.url ?? data.deep_link ?? data.deeplink ?? data.values,
+      depth + 1
+    );
+  }
+
+  if (typeof raw !== "string") return null;
+
+  const value = raw.trim();
+
+  if (!value) return null;
+
+  if (value.startsWith("{")) {
+    const parsed = parseJSON(value);
+
+    if (parsed) return actionDataToUrl(parsed, depth + 1);
+  }
+
+  if (SCHEME_REGEX.test(value)) {
+    // Already a deep link (<scheme>://<host>?...). http(s) links are not deep
+    // links: only their query string is used below.
+    if (!/^https?:\/\//i.test(value)) return value;
+  }
+
+  const queryIndex = value.indexOf("?");
+  const query = queryIndex >= 0 ? value.slice(queryIndex + 1) : value;
+
+  if (!query.includes("=")) return null;
+
+  return `${getAppUrlScheme()}://open?${query}`;
+};
+
+/**
+ * Key of the last app control whose PAYLOAD was handed to the app. Used to avoid
+ * opening the same deep link again when the app is merely brought back to the
+ * foreground. A launch without PAYLOAD (e.g. from the app icon) replaces the
+ * requested app control and resets this key, so the same link can be sent again.
+ */
+let lastHandledPayloadKey: string | null = null;
+
+/** Test helper */
+export const resetSamsungAppControlState = () => {
+  lastHandledPayloadKey = null;
+};
+
+/**
+ * Returns the deep link carried by the app control that launched / resumed the
+ * app, or null if there is none or it was already handled.
+ */
+export const getSamsungAppControlUrl = (source = "launch"): string | null => {
+  const application = getTizenApplication();
+
+  if (!application) return null;
+
+  try {
+    const requested = application.getRequestedAppControl?.();
+    const data: AppControlData[] = requested?.appControl?.data ?? [];
+    const payload = data.find((item) => item?.key === PAYLOAD_KEY);
+
+    if (!payload) {
+      lastHandledPayloadKey = null;
+
+      log_debug(
+        `SamsungAppControl[${source}]: no PAYLOAD in requested app control`,
+        {
+          operation: requested?.appControl?.operation,
+          keys: data.map((item) => item?.key),
+        }
+      );
+
+      return null;
+    }
+
+    const payloadKey = JSON.stringify(payload.value ?? null);
+
+    if (payloadKey === lastHandledPayloadKey) {
+      log_debug(
+        `SamsungAppControl[${source}]: PAYLOAD already handled, skipping`,
+        {
+          payload: payload.value,
+        }
+      );
+
+      return null;
+    }
+
+    lastHandledPayloadKey = payloadKey;
+
+    const url = actionDataToUrl(payload.value?.[0]);
+
+    if (!url) {
+      log_error(`SamsungAppControl[${source}]: PAYLOAD is not a deep link`, {
+        payload: payload.value,
+      });
+
+      return null;
+    }
+
+    log_info(
+      `SamsungAppControl[${source}]: deep link from app control: ${url}`,
+      {
+        payload: payload.value,
+      }
+    );
+
+    return url;
+  } catch (error) {
+    log_error(
+      `SamsungAppControl[${source}]: failed to read requested app control`,
+      {
+        error,
+      }
+    );
+
+    return null;
+  }
+};
+
+/**
+ * Listens for deep links sent while the app is already running.
+ *
+ * On Samsung TVs (verified on a 2023 Tizen 7 model) a running app relaunched with
+ * an app control is only brought to the foreground: the new app control is
+ * available through getRequestedAppControl(), but no "appcontrol" event is fired.
+ * So the app control is checked both on "appcontrol" (fired by some runtimes /
+ * configurations) and when the page becomes visible again.
+ *
+ * Returns an unsubscribe function.
+ */
+export const addSamsungAppControlListener = (
+  onUrl: (url: string) => void
+): (() => void) => {
+  if (
+    typeof window === "undefined" ||
+    typeof document === "undefined" ||
+    typeof window.addEventListener !== "function" ||
+    typeof document.addEventListener !== "function" ||
+    !getTizenApplication()
+  ) {
+    return () => {};
+  }
+
+  const check = (source: string) => {
+    const url = getSamsungAppControlUrl(source);
+
+    if (url) onUrl(url);
+  };
+
+  const onAppControl = () => check("appcontrol");
+
+  const onVisibilityChange = () => {
+    if (!document.hidden) check("visibilitychange");
+  };
+
+  window.addEventListener(APP_CONTROL_EVENT, onAppControl);
+  document.addEventListener("visibilitychange", onVisibilityChange);
+
+  return () => {
+    window.removeEventListener(APP_CONTROL_EVENT, onAppControl);
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+  };
+};

package/App/DeepLinking/URLSchemeHandler/SchemeHandlerHooks/usePresentSchemeHandler.ts

@@ -28,6 +28,7 @@ import {
 
 import { log_error, log_info } from "../../logger";
 import { useRivers } from "@applicaster/zapp-react-native-utils/reactHooks/state";
+import { rememberLayoutPreview } from "../../../layoutPreview/persistence";
 
 const getFeed = (query) => ({
   content: { src: query.data_source },
@@ -155,6 +156,8 @@ export function usePresentSchemeHandler({
           rivers_configuration_id
         );
 
+        await rememberLayoutPreview(rivers_configuration_id);
+
         onFinish((done) => {
           actions?.setAppReady();
           navigator.replace(homeRiver);

package/App/DeepLinking/URLSchemeListener/URLSchemeContextProvider.tsx

@@ -3,6 +3,7 @@ import React, {
   createContext,
   useEffect,
   useCallback,
+  useMemo,
   ComponentType,
   ReactChild,
 } from "react";
@@ -11,6 +12,10 @@ import * as ReactNative from "react-native";
 import { isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { log_debug, log_error, log_info } from "../logger";
 import { parseUrl } from "../helpers";
+import {
+  addSamsungAppControlListener,
+  getSamsungAppControlUrl,
+} from "../SamsungAppControl";
 import { getAppUrlScheme } from "@applicaster/zapp-react-native-utils/appDataUtils";
 import {
   getZappPlatform,
@@ -86,6 +91,17 @@ function URLSchemeContextProvider(props: Props) {
       const url = await Linking.getInitialURL();
 
       if (isWeb()) {
+        // Samsung: deep link from the app control that launched the app
+        const samsungDeepLink = getSamsungAppControlUrl();
+
+        if (samsungDeepLink) {
+          log_info(
+            `URLSchemeContextProvider: Retrieved initial Samsung deep link: ${samsungDeepLink}`
+          );
+
+          return setState(samsungDeepLink);
+        }
+
         const presentDeepLink = getPresentDeepLink(url);
 
         if (presentDeepLink) {
@@ -179,10 +195,22 @@ function URLSchemeContextProvider(props: Props) {
         handleOpenURL
       );
 
+      // Samsung: deep links sent while the app is running ("appcontrol" event)
+      const removeSamsungAppControlListener = addSamsungAppControlListener(
+        (appControlUrl) => {
+          log_info(
+            `URLSchemeContextProvider: Samsung appcontrol deep link received — url=${appControlUrl}`
+          );
+
+          setState(appControlUrl);
+        }
+      );
+
       return () => {
         log_debug("URLSchemeContextProvider: Remove URL event listeners");
         listener.remove();
         linkingListener.remove();
+        removeSamsungAppControlListener();
       };
     }
 
@@ -196,9 +224,11 @@ function URLSchemeContextProvider(props: Props) {
     };
   }, []);
 
+  const contextValue = useMemo(() => ({ url: state, done }), [state, done]);
+
   return (
     <View style={fillStyles.container}>
-      <URLSchemeContext.Provider value={{ url: state, done }}>
+      <URLSchemeContext.Provider value={contextValue}>
         {props.children}
       </URLSchemeContext.Provider>
     </View>

package/App/DeepLinking/logger.ts

@@ -5,6 +5,6 @@ import { coreAppLogger } from "../logger";
 export const { log_verbose, log_debug, log_warning, log_info, log_error } =
   createLogger({
     category: "DeepLinking",
-    subsystem: "General",
+    subsystem: "app/deep_linking",
     parent: coreAppLogger,
   });