@use-voltra/android 2.3.2 → 2.4.0

package/build/module/modifiers/index.js

@@ -0,0 +1,169 @@
+"use strict";
+
+import { createAndroidModifier } from './createAndroidModifier.js';
+
+/**
+ * A static color string. Resolves to `never` for an `AndroidDynamicColors` token, so passing one
+ * where Glance needs a concrete color is a compile-time error.
+ */
+
+/** At least one of the two keys is required. */
+
+/**
+ * Adds padding in dp, mirrored in right-to-left layouts. The most specific edge wins (`start` over
+ * `horizontal` over `all`). Glance adds repeated padding together, including `style.padding`.
+ *
+ * @since Android 7.0
+ */
+export const padding = values => {
+  if (typeof values === 'number') {
+    return createAndroidModifier('padding', {
+      all: values
+    });
+  }
+  // Copy only the known edges so extra keys on a caller's object never reach the device.
+  const {
+    all,
+    horizontal,
+    vertical,
+    start,
+    top,
+    end,
+    bottom
+  } = values;
+  return createAndroidModifier('padding', {
+    all,
+    horizontal,
+    vertical,
+    start,
+    top,
+    end,
+    bottom
+  });
+};
+
+/**
+ * Adds padding in dp that ignores the layout direction. Adds up with `padding` and `style.padding`.
+ *
+ * @since Android 7.0
+ */
+export const absolutePadding = values => {
+  if (typeof values === 'number') {
+    return createAndroidModifier('absolutePadding', {
+      all: values
+    });
+  }
+  const {
+    all,
+    horizontal,
+    vertical,
+    left,
+    top,
+    right,
+    bottom
+  } = values;
+  return createAndroidModifier('absolutePadding', {
+    all,
+    horizontal,
+    vertical,
+    left,
+    top,
+    right,
+    bottom
+  });
+};
+
+/**
+ * Sets a fixed width in dp.
+ *
+ * @since Android 7.0
+ */
+export const width = dp => createAndroidModifier('width', {
+  width: dp
+});
+
+/**
+ * Sets a fixed height in dp.
+ *
+ * @since Android 7.0
+ */
+export const height = dp => createAndroidModifier('height', {
+  height: dp
+});
+
+/**
+ * Sets a fixed size in dp. A single number sets both dimensions.
+ *
+ * @since Android 7.0
+ */
+export const size = value => createAndroidModifier('size', typeof value === 'number' ? {
+  width: value,
+  height: value
+} : {
+  width: value.width,
+  height: value.height
+});
+
+/** @since Android 7.0 */
+export const fillMaxWidth = () => createAndroidModifier('fillMaxWidth');
+/** @since Android 7.0 */
+export const fillMaxHeight = () => createAndroidModifier('fillMaxHeight');
+/** @since Android 7.0 */
+export const fillMaxSize = () => createAndroidModifier('fillMaxSize');
+/** @since Android 7.0 */
+export const wrapContentWidth = () => createAndroidModifier('wrapContentWidth');
+/** @since Android 7.0 */
+export const wrapContentHeight = () => createAndroidModifier('wrapContentHeight');
+/** @since Android 7.0 */
+export const wrapContentSize = () => createAndroidModifier('wrapContentSize');
+
+/**
+ * Fills the background with a color: a static color, an `AndroidDynamicColors` token, or a pair of
+ * static colors for light and dark mode.
+ *
+ * @since Android 7.0
+ */
+export const background = color => createAndroidModifier('background', typeof color === 'string' ? {
+  color
+} : {
+  day: color.day,
+  night: color.night
+});
+
+/**
+ * Rounds the corners in dp. Glance ignores it below Android 12 (API 31).
+ *
+ * @since Android 12
+ */
+export const cornerRadius = radius => createAndroidModifier('cornerRadius', {
+  radius
+});
+
+/**
+ * Shows, hides (keeping its space), or removes the component from layout.
+ *
+ * @since Android 7.0
+ */
+export const visibility = value => createAndroidModifier('visibility', {
+  visibility: value
+});
+
+/**
+ * Sets accessibility and test metadata.
+ *
+ * @since Android 7.0
+ */
+export const semantics = values => createAndroidModifier('semantics', {
+  contentDescription: values.contentDescription,
+  testTag: values.testTag
+});
+
+/**
+ * Marks the widget's background view so the launcher can animate it when the widget opens the app.
+ * Use it once per widget, on the outermost component. Only one component keeps it: the first that
+ * appears once in the widget, and none inside a widget with a `Scaffold`, which marks its own.
+ *
+ * @since Android 12
+ */
+export const appWidgetBackground = () => createAndroidModifier('appWidgetBackground');
+//# sourceMappingURL=index.js.map

package/build/module/modifiers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAndroidModifier","padding","values","all","horizontal","vertical","start","top","end","bottom","absolutePadding","left","right","width","dp","height","size","value","fillMaxWidth","fillMaxHeight","fillMaxSize","wrapContentWidth","wrapContentHeight","wrapContentSize","background","color","day","night","cornerRadius","radius","visibility","semantics","contentDescription","testTag","appWidgetBackground"],"sourceRoot":"../../../src","sources":["modifiers/index.ts"],"mappings":"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","ignoreList":[]}

package/build/module/ongoing-notification/components.js

@@ -9,10 +9,16 @@ const createAndroidOngoingNotificationComponent = (displayName, kind) => {
 };
 export const Progress = createAndroidOngoingNotificationComponent('AndroidOngoingNotification.Progress', 'progress');
 export const BigText = createAndroidOngoingNotificationComponent('AndroidOngoingNotification.BigText', 'bigText');
+export const BigPicture = createAndroidOngoingNotificationComponent('AndroidOngoingNotification.BigPicture', 'bigPicture');
+export const Inbox = createAndroidOngoingNotificationComponent('AndroidOngoingNotification.Inbox', 'inbox');
+export const Metric = createAndroidOngoingNotificationComponent('AndroidOngoingNotification.Metric', 'metric');
 export const Action = createAndroidOngoingNotificationComponent('AndroidOngoingNotification.Action', 'action');
 export const AndroidOngoingNotification = {
   Progress,
   BigText,
+  BigPicture,
+  Inbox,
+  Metric,
   Action
 };
 //# sourceMappingURL=components.js.map

package/build/module/ongoing-notification/components.js.map

@@ -1 +1 @@
-{"version":3,"names":["ANDROID_ONGOING_NOTIFICATION_COMPONENT_TAG","Symbol","for","createAndroidOngoingNotificationComponent","displayName","kind","Component","_props","Progress","BigText","Action","AndroidOngoingNotification"],"sourceRoot":"../../../src","sources":["ongoing-notification/components.tsx"],"mappings":";;AAQA,OAAO,MAAMA,0CAA0C,GAAGC,MAAM,CAACC,GAAG,CAAC,+CAA+C,CAAC;AASrH,MAAMC,yCAAyC,GAAGA,CAChDC,WAAmB,EACnBC,IAA6C,KACG;EAChD,MAAMC,SAAS,GAAIC,MAAc,IAAK,IAAI;EAE1CD,SAAS,CAACF,WAAW,GAAGA,WAAW;EACjCE,SAAS,CAAiDN,0CAA0C,CAAC,GAAGK,IAAI;EAE9G,OAAOC,SAAS;AAClB,CAAC;AAED,OAAO,MAAME,QAAQ,GAAGL,yCAAyC,CAC/D,qCAAqC,EACrC,UACF,CAAC;AAED,OAAO,MAAMM,OAAO,GAAGN,yCAAyC,CAC9D,oCAAoC,EACpC,SACF,CAAC;AAED,OAAO,MAAMO,MAAM,GAAGP,yCAAyC,CAC7D,mCAAmC,EACnC,QACF,CAAC;AAED,OAAO,MAAMQ,0BAA0B,GAAG;EACxCH,QAAQ;EACRC,OAAO;EACPC;AACF,CAAU","ignoreList":[]}
+{"version":3,"names":["ANDROID_ONGOING_NOTIFICATION_COMPONENT_TAG","Symbol","for","createAndroidOngoingNotificationComponent","displayName","kind","Component","_props","Progress","BigText","BigPicture","Inbox","Metric","Action","AndroidOngoingNotification"],"sourceRoot":"../../../src","sources":["ongoing-notification/components.tsx"],"mappings":";;AAWA,OAAO,MAAMA,0CAA0C,GAAGC,MAAM,CAACC,GAAG,CAAC,+CAA+C,CAAC;AASrH,MAAMC,yCAAyC,GAAGA,CAChDC,WAAmB,EACnBC,IAA6C,KACG;EAChD,MAAMC,SAAS,GAAIC,MAAc,IAAK,IAAI;EAE1CD,SAAS,CAACF,WAAW,GAAGA,WAAW;EACjCE,SAAS,CAAiDN,0CAA0C,CAAC,GAAGK,IAAI;EAE9G,OAAOC,SAAS;AAClB,CAAC;AAED,OAAO,MAAME,QAAQ,GAAGL,yCAAyC,CAC/D,qCAAqC,EACrC,UACF,CAAC;AAED,OAAO,MAAMM,OAAO,GAAGN,yCAAyC,CAC9D,oCAAoC,EACpC,SACF,CAAC;AAED,OAAO,MAAMO,UAAU,GAAGP,yCAAyC,CACjE,uCAAuC,EACvC,YACF,CAAC;AAED,OAAO,MAAMQ,KAAK,GAAGR,yCAAyC,CAC5D,kCAAkC,EAClC,OACF,CAAC;AAED,OAAO,MAAMS,MAAM,GAAGT,yCAAyC,CAC7D,mCAAmC,EACnC,QACF,CAAC;AAED,OAAO,MAAMU,MAAM,GAAGV,yCAAyC,CAC7D,mCAAmC,EACnC,QACF,CAAC;AAED,OAAO,MAAMW,0BAA0B,GAAG;EACxCN,QAAQ;EACRC,OAAO;EACPC,UAAU;EACVC,KAAK;EACLC,MAAM;EACNC;AACF,CAAU","ignoreList":[]}

package/build/module/ongoing-notification/renderer.js

@@ -5,6 +5,24 @@ import { getAndroidComponentId } from '../payload/component-ids.js';
 import { ANDROID_ONGOING_NOTIFICATION_COMPONENT_TAG } from './components.js';
 void getAndroidComponentId;
 const PAYLOAD_VERSION = 1;
+
+/**
+ * InboxStyle only renders six lines, so more than that is rejected at render time instead of being
+ * silently truncated. Kept in sync with MAX_INBOX_LINES in the Android client.
+ */
+const MAX_INBOX_LINES = 6;
+
+/**
+ * Size of an inline picture that is still reasonable to hand to a native post. Push providers cap
+ * data payloads at a few kilobytes (FCM allows 4096 bytes), so no inline picture travels through a
+ * push message. Warns instead of failing: local starts and self-hosted transports can legitimately
+ * carry more. Compared against the decoded size, because a base64 string is four characters per
+ * three bytes and its length flatters the image.
+ */
+const MAX_INLINE_PICTURE_BYTES = 256 * 1024;
+
+/** Bytes a base64 string holds once decoded. Padding leaves this at most two bytes high. */
+const decodedBase64Bytes = base64 => Math.ceil(base64.length * 3 / 4);
 const flattenChildren = node => {
   if (node === null || node === undefined || typeof node === 'boolean') {
     return [];
@@ -77,6 +95,13 @@ const assertOptionalImageSource = (value, propName) => {
   }
   return value;
 };
+const assertRequiredImageSource = (value, propName) => {
+  const source = assertOptionalImageSource(value, propName);
+  if (source === undefined) {
+    throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}" is required.`);
+  }
+  return source;
+};
 const assertBoolean = (value, propName) => {
   if (value === undefined) {
     return undefined;
@@ -143,21 +168,91 @@ const normalizeProgressPoints = value => {
     };
   });
 };
-const normalizeWhen = value => {
-  if (value === undefined) {
-    return undefined;
+const normalizeInboxLines = value => {
+  if (!Array.isArray(value)) {
+    throw new Error('[Voltra] [Android] Ongoing notification prop "lines" must be an array of non-empty strings.');
+  }
+  if (value.length === 0) {
+    throw new Error('[Voltra] [Android] Ongoing notification prop "lines" must contain at least one line.');
   }
+  if (value.length > MAX_INBOX_LINES) {
+    throw new Error(`[Voltra] [Android] Ongoing notification prop "lines" must contain at most ${MAX_INBOX_LINES} lines, got ${value.length}.`);
+  }
+  return value.map((line, index) => assertString(line, `lines[${index}]`));
+};
+const warnInlinePicture = picture => {
+  const base64 = 'base64' in picture ? picture.base64 : undefined;
+  if (base64 === undefined) {
+    return;
+  }
+  const pictureBytes = decodedBase64Bytes(base64);
+  if (pictureBytes > MAX_INLINE_PICTURE_BYTES) {
+    console.warn(`[Voltra] [Android] Ongoing notification prop "picture" carries a ${pictureBytes}-byte image, which exceeds ${MAX_INLINE_PICTURE_BYTES} bytes. Inline pictures cannot travel through push messages: preload the image and reference it with assetName instead.`);
+  }
+};
+const normalizeEpoch = (value, propName) => {
   if (value instanceof Date) {
     const timestamp = value.getTime();
     if (!Number.isFinite(timestamp)) {
-      throw new Error('[Voltra] [Android] Ongoing notification prop "when" must be a valid Date or timestamp.');
+      throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}" must be a valid Date or timestamp.`);
     }
     return timestamp;
   }
   if (typeof value === 'number' && Number.isFinite(value)) {
     return value;
   }
-  throw new Error('[Voltra] [Android] Ongoing notification prop "when" must be a valid Date or timestamp.');
+  throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}" must be a valid Date or timestamp.`);
+};
+const normalizeWhen = value => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return normalizeEpoch(value, 'when');
+};
+
+// `true` keeps meaning "count up" for payloads and props written before the
+// chip gained a direction; only 'countDown' sets chronometerCountDown, and a
+// countdown without `when` has nothing to count down to.
+const normalizeChronometer = (value, when) => {
+  if (value === undefined) {
+    return {};
+  }
+  if (typeof value === 'boolean') {
+    return {
+      chronometer: value
+    };
+  }
+  if (value === 'countUp') {
+    return {
+      chronometer: true
+    };
+  }
+  if (value === 'countDown') {
+    if (when === undefined) {
+      throw new Error('[Voltra] [Android] Ongoing notification prop "chronometer" set to "countDown" requires the "when" prop.');
+    }
+    return {
+      chronometer: true,
+      chronometerCountDown: true
+    };
+  }
+  throw new Error('[Voltra] [Android] Ongoing notification prop "chronometer" must be a boolean, "countUp" or "countDown".');
+};
+const normalizePublicVersion = value => {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('[Voltra] [Android] Ongoing notification prop "publicVersion" must be an object with a title.');
+  }
+  const {
+    title,
+    text
+  } = value;
+  return {
+    title: assertString(title, 'publicVersion.title'),
+    text: assertOptionalString(text, 'publicVersion.text')
+  };
 };
 const getElementKind = element => {
   const elementType = element.type;
@@ -170,6 +265,19 @@ const normalizeActionPayload = props => {
     icon: assertOptionalImageSource(props.icon, 'icon')
   };
 };
+const normalizeCommonDisplayFields = props => {
+  const when = normalizeWhen(props.when);
+  return {
+    title: assertOptionalNonEmptyString(props.title, 'title'),
+    subText: assertOptionalString(props.subText, 'subText'),
+    shortCriticalText: assertOptionalString(props.shortCriticalText, 'shortCriticalText'),
+    when,
+    ...normalizeChronometer(props.chronometer, when),
+    showWhen: assertBoolean(props.showWhen, 'showWhen'),
+    largeIcon: assertOptionalImageSource(props.largeIcon, 'largeIcon'),
+    publicVersion: normalizePublicVersion(props.publicVersion)
+  };
+};
 const normalizeActions = value => {
   const actions = [];
   Children.forEach(value, child => {
@@ -202,16 +310,11 @@ const normalizeProgressPayload = props => {
   return {
     v: PAYLOAD_VERSION,
     kind: 'progress',
-    title: assertOptionalNonEmptyString(props.title, 'title'),
-    subText: assertOptionalString(props.subText, 'subText'),
+    ...normalizeCommonDisplayFields(props),
     text: assertOptionalString(props.text, 'text'),
     value,
     max,
     indeterminate: assertBoolean(props.indeterminate, 'indeterminate'),
-    shortCriticalText: assertOptionalString(props.shortCriticalText, 'shortCriticalText'),
-    when: normalizeWhen(props.when),
-    chronometer: assertBoolean(props.chronometer, 'chronometer'),
-    largeIcon: assertOptionalImageSource(props.largeIcon, 'largeIcon'),
     progressTrackerIcon: assertOptionalImageSource(props.progressTrackerIcon, 'progressTrackerIcon'),
     progressStartIcon: assertOptionalImageSource(props.progressStartIcon, 'progressStartIcon'),
     progressEndIcon: assertOptionalImageSource(props.progressEndIcon, 'progressEndIcon'),
@@ -225,14 +328,238 @@ const normalizeBigTextPayload = props => {
   return {
     v: PAYLOAD_VERSION,
     kind: 'bigText',
-    title: assertOptionalNonEmptyString(props.title, 'title'),
-    subText: assertOptionalString(props.subText, 'subText'),
+    ...normalizeCommonDisplayFields(props),
     text,
     bigText: assertOptionalString(props.bigText, 'bigText') ?? text,
-    shortCriticalText: assertOptionalString(props.shortCriticalText, 'shortCriticalText'),
-    when: normalizeWhen(props.when),
-    chronometer: assertBoolean(props.chronometer, 'chronometer'),
-    largeIcon: assertOptionalImageSource(props.largeIcon, 'largeIcon'),
+    actions: normalizeActions(props.children)
+  };
+};
+const METRIC_TIME_PATTERN = /^(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d)?$/;
+const METRIC_SEMANTIC_STYLES = ['unspecified', 'info', 'safe', 'caution', 'danger'];
+const METRIC_TIME_FORMATS = ['adaptive', 'chronometer'];
+const assertMetricNonEmptyString = (value, propName) => {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}" must be a non-empty string.`);
+  }
+  return value;
+};
+const normalizeMetricTimeFormat = (value, propName) => {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (!METRIC_TIME_FORMATS.includes(value)) {
+    throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}" must be "adaptive" or "chronometer".`);
+  }
+  return value;
+};
+const normalizeMetricValue = (value, unit, propName) => {
+  const topLevelUnit = assertOptionalString(unit, `${propName}.unit`);
+  const rejectTopLevelUnit = () => {
+    if (topLevelUnit !== undefined) {
+      throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}.unit" only applies to "int", "float" and "text" values.`);
+    }
+  };
+
+  // Shorthands: an integer reads as int, any other number as float, a string as text.
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) {
+      throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}.value" must be a finite number.`);
+    }
+    return Number.isInteger(value) ? {
+      type: 'int',
+      value,
+      unit: topLevelUnit
+    } : {
+      type: 'float',
+      value,
+      unit: topLevelUnit
+    };
+  }
+  if (typeof value === 'string') {
+    return {
+      type: 'text',
+      value: assertMetricNonEmptyString(value, `${propName}.value`),
+      unit: topLevelUnit
+    };
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}.value" must be a number, a string, or a metric value object.`);
+  }
+  const source = value;
+  const type = source.type;
+  switch (type) {
+    case 'int':
+      {
+        const numberValue = assertFiniteNumber(source.value, `${propName}.value`);
+        if (!Number.isInteger(numberValue)) {
+          throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}.value" must be an integer.`);
+        }
+        return {
+          type: 'int',
+          value: numberValue,
+          unit: assertOptionalString(source.unit, `${propName}.unit`) ?? topLevelUnit
+        };
+      }
+    case 'float':
+      {
+        const numberValue = assertFiniteNumber(source.value, `${propName}.value`);
+        const min = source.min === undefined ? undefined : assertFiniteNumber(source.min, `${propName}.min`);
+        const max = source.max === undefined ? undefined : assertFiniteNumber(source.max, `${propName}.max`);
+        if (min !== undefined && min < 0) {
+          throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}.min" must be greater than or equal to 0.`);
+        }
+        if (max !== undefined && max < 0) {
+          throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}.max" must be greater than or equal to 0.`);
+        }
+        if (min !== undefined && max !== undefined && min > max) {
+          throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}.min" must not exceed "${propName}.max".`);
+        }
+        let fractionDigits;
+        if (source.fractionDigits !== undefined) {
+          fractionDigits = assertFiniteNumber(source.fractionDigits, `${propName}.fractionDigits`);
+          if (!Number.isInteger(fractionDigits) || fractionDigits < 0) {
+            throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}.fractionDigits" must be an integer greater than or equal to 0.`);
+          }
+        }
+        return {
+          type: 'float',
+          value: numberValue,
+          unit: assertOptionalString(source.unit, `${propName}.unit`) ?? topLevelUnit,
+          min,
+          max,
+          fractionDigits
+        };
+      }
+    case 'text':
+      return {
+        type: 'text',
+        value: assertMetricNonEmptyString(source.value, `${propName}.value`),
+        unit: assertOptionalString(source.unit, `${propName}.unit`) ?? topLevelUnit
+      };
+    case 'time':
+      {
+        rejectTopLevelUnit();
+        const timeValue = assertMetricNonEmptyString(source.value, `${propName}.value`);
+        if (!METRIC_TIME_PATTERN.test(timeValue)) {
+          throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}.value" must be a time in "HH:mm" or "HH:mm:ss" form.`);
+        }
+        return {
+          type: 'time',
+          value: timeValue
+        };
+      }
+    case 'timer':
+      rejectTopLevelUnit();
+      return {
+        type: 'timer',
+        endsAt: normalizeEpoch(source.endsAt, `${propName}.endsAt`),
+        format: normalizeMetricTimeFormat(source.format, `${propName}.format`)
+      };
+    case 'stopwatch':
+      rejectTopLevelUnit();
+      return {
+        type: 'stopwatch',
+        startedAt: normalizeEpoch(source.startedAt, `${propName}.startedAt`),
+        format: normalizeMetricTimeFormat(source.format, `${propName}.format`)
+      };
+    case 'pausedTimer':
+      {
+        rejectTopLevelUnit();
+        const remainingMillis = assertFiniteNumber(source.remainingMillis, `${propName}.remainingMillis`);
+        if (remainingMillis < 0) {
+          throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}.remainingMillis" must be greater than or equal to 0.`);
+        }
+        return {
+          type: 'pausedTimer',
+          remainingMillis
+        };
+      }
+    case 'pausedStopwatch':
+      {
+        rejectTopLevelUnit();
+        const elapsedMillis = assertFiniteNumber(source.elapsedMillis, `${propName}.elapsedMillis`);
+        if (elapsedMillis < 0) {
+          throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}.elapsedMillis" must be greater than or equal to 0.`);
+        }
+        return {
+          type: 'pausedStopwatch',
+          elapsedMillis
+        };
+      }
+    default:
+      throw new Error(`[Voltra] [Android] Ongoing notification prop "${propName}.type" must be "int", "float", "text", "time", "timer", "stopwatch", "pausedTimer", or "pausedStopwatch".`);
+  }
+};
+const normalizeMetricPayload = props => {
+  if (!Array.isArray(props.metrics)) {
+    throw new Error('[Voltra] [Android] Ongoing notification prop "metrics" must be an array.');
+  }
+  if (props.metrics.length < 1 || props.metrics.length > 3) {
+    throw new Error('[Voltra] [Android] Ongoing notification prop "metrics" must contain between 1 and 3 metrics.');
+  }
+  const metrics = props.metrics.map((descriptor, index) => {
+    if (!descriptor || typeof descriptor !== 'object' || Array.isArray(descriptor)) {
+      throw new Error(`[Voltra] [Android] Ongoing notification prop "metrics[${index}]" must be an object.`);
+    }
+    const label = assertMetricNonEmptyString(descriptor.label, `metrics[${index}].label`);
+    if (label.length > 10) {
+      throw new Error(`[Voltra] [Android] Ongoing notification prop "metrics[${index}].label" must be at most 10 characters long.`);
+    }
+    return {
+      label,
+      value: normalizeMetricValue(descriptor.value, descriptor.unit, `metrics[${index}]`)
+    };
+  });
+  let criticalMetric;
+  if (props.criticalMetric !== undefined) {
+    criticalMetric = assertFiniteNumber(props.criticalMetric, 'criticalMetric');
+    if (!Number.isInteger(criticalMetric) || criticalMetric < 0 || criticalMetric >= metrics.length) {
+      throw new Error(`[Voltra] [Android] Ongoing notification prop "criticalMetric" must be an index between 0 and ${metrics.length - 1}.`);
+    }
+  }
+  let semanticStyle;
+  if (props.semanticStyle !== undefined) {
+    if (!METRIC_SEMANTIC_STYLES.includes(props.semanticStyle)) {
+      throw new Error('[Voltra] [Android] Ongoing notification prop "semanticStyle" must be "unspecified", "info", "safe", "caution", or "danger".');
+    }
+    semanticStyle = props.semanticStyle;
+  }
+  return {
+    v: PAYLOAD_VERSION,
+    kind: 'metric',
+    ...normalizeCommonDisplayFields(props),
+    metrics,
+    criticalMetric,
+    semanticStyle,
+    actions: normalizeActions(props.children)
+  };
+};
+const normalizeBigPicturePayload = props => {
+  const picture = assertRequiredImageSource(props.picture, 'picture');
+  warnInlinePicture(picture);
+  return {
+    v: PAYLOAD_VERSION,
+    kind: 'bigPicture',
+    ...normalizeCommonDisplayFields(props),
+    text: assertOptionalString(props.text, 'text'),
+    picture,
+    summaryText: assertOptionalNonEmptyString(props.summaryText, 'summaryText'),
+    pictureContentDescription: assertOptionalNonEmptyString(props.pictureContentDescription, 'pictureContentDescription'),
+    showPictureWhenCollapsed: assertBoolean(props.showPictureWhenCollapsed, 'showPictureWhenCollapsed'),
+    bigLargeIcon: assertOptionalImageSource(props.bigLargeIcon, 'bigLargeIcon'),
+    hideLargeIconWhenExpanded: assertBoolean(props.hideLargeIconWhenExpanded, 'hideLargeIconWhenExpanded'),
+    actions: normalizeActions(props.children)
+  };
+};
+const normalizeInboxPayload = props => {
+  const lines = normalizeInboxLines(props.lines);
+  return {
+    v: PAYLOAD_VERSION,
+    kind: 'inbox',
+    ...normalizeCommonDisplayFields(props),
+    text: props.text === undefined ? lines[0] : assertString(props.text, 'text'),
+    lines,
+    summaryText: assertOptionalNonEmptyString(props.summaryText, 'summaryText'),
     actions: normalizeActions(props.children)
   };
 };
@@ -245,7 +572,16 @@ export const renderAndroidOngoingNotificationPayloadToJson = content => {
   if (kind === 'bigText') {
     return normalizeBigTextPayload(element.props);
   }
-  throw new Error('[Voltra] [Android] Ongoing notification content must use AndroidOngoingNotification.Progress or AndroidOngoingNotification.BigText.');
+  if (kind === 'bigPicture') {
+    return normalizeBigPicturePayload(element.props);
+  }
+  if (kind === 'inbox') {
+    return normalizeInboxPayload(element.props);
+  }
+  if (kind === 'metric') {
+    return normalizeMetricPayload(element.props);
+  }
+  throw new Error('[Voltra] [Android] Ongoing notification content must use AndroidOngoingNotification.Progress, AndroidOngoingNotification.BigText, AndroidOngoingNotification.BigPicture, AndroidOngoingNotification.Inbox, or AndroidOngoingNotification.Metric.');
 };
 export const renderAndroidOngoingNotificationPayload = content => {
   return JSON.stringify(renderAndroidOngoingNotificationPayloadToJson(content));