@psync/notifee 9.2.0

package/src/validators/validateAndroidNotification.ts

@@ -0,0 +1,734 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+import { Image } from 'react-native';
+
+import {
+  objectHasProperty,
+  isArray,
+  isArrayOfStrings,
+  isBoolean,
+  isNumber,
+  isObject,
+  isString,
+  isUndefined,
+  isIOS,
+} from '../utils';
+
+import { AndroidImportance } from '../types/NotificationAndroid';
+import {
+  AndroidBadgeIconType,
+  AndroidCategory,
+  AndroidDefaults,
+  AndroidForegroundServiceType,
+  AndroidFlags,
+  AndroidGroupAlertBehavior,
+  AndroidProgress,
+  AndroidStyle,
+  AndroidVisibility,
+  NotificationAndroid,
+} from '../types/NotificationAndroid';
+
+import {
+  isValidColor,
+  isValidLightPattern,
+  isValidTimestamp,
+  isValidVibratePattern,
+} from './validate';
+
+import {
+  validateAndroidBigPictureStyle,
+  validateAndroidBigTextStyle,
+  validateAndroidInboxStyle,
+  validateAndroidMessagingStyle,
+} from './validateAndroidStyle';
+import validateAndroidPressAction from './validateAndroidPressAction';
+import validateAndroidFullScreenAction from './validateAndroidFullScreenAction';
+import validateAndroidAction from './validateAndroidAction';
+
+export default function validateAndroidNotification(
+  android?: NotificationAndroid,
+): NotificationAndroid {
+  // Notification default values
+  const out: NotificationAndroid = {
+    autoCancel: true,
+    asForegroundService: false,
+    lightUpScreen: false,
+    badgeIconType: AndroidBadgeIconType.LARGE,
+    colorized: false,
+    chronometerDirection: 'up',
+    defaults: [AndroidDefaults.ALL],
+    groupAlertBehavior: AndroidGroupAlertBehavior.ALL,
+    groupSummary: false,
+    localOnly: false,
+    ongoing: false,
+    loopSound: false,
+    onlyAlertOnce: false,
+    importance: AndroidImportance.DEFAULT,
+    showTimestamp: false,
+    smallIcon: 'ic_launcher',
+    showChronometer: false,
+    visibility: AndroidVisibility.PRIVATE,
+    circularLargeIcon: false,
+  };
+
+  /* Skip validating if iOS in release */
+  if (isIOS && !__DEV__) return out;
+
+  if (isUndefined(android)) {
+    return out;
+  }
+
+  if (!isUndefined(android) && !isObject(android)) {
+    throw new Error("'notification.android' expected an object value.");
+  }
+
+  /**
+   * actions
+   */
+  if (objectHasProperty(android, 'actions') && android.actions !== undefined) {
+    if (!isArray(android.actions)) {
+      throw new Error("'notification.android.actions' expected an array of AndroidAction types.");
+    }
+
+    const actions = [];
+    try {
+      for (let i = 0; i < android.actions.length; i++) {
+        actions.push(validateAndroidAction(android.actions[i]));
+      }
+    } catch (e: any) {
+      throw new Error(`'notification.android.actions' invalid AndroidAction. ${e.message}.`);
+    }
+
+    if (actions.length) {
+      out.actions = actions;
+    }
+  }
+
+  /**
+   * asForegroundService
+   */
+  if (objectHasProperty(android, 'asForegroundService')) {
+    if (!isBoolean(android.asForegroundService)) {
+      throw new Error("'notification.android.asForegroundService' expected a boolean value.");
+    }
+
+    out.asForegroundService = android.asForegroundService;
+  }
+
+  /**
+   * lightUpScreen
+   */
+  if (objectHasProperty(android, 'lightUpScreen')) {
+    if (!isBoolean(android.lightUpScreen)) {
+      throw new Error("'notification.android.lightUpScreen' expected a boolean value.");
+    }
+
+    out.lightUpScreen = android.lightUpScreen;
+  }
+
+  /**
+   * autoCancel
+   */
+  if (objectHasProperty(android, 'autoCancel')) {
+    if (!isBoolean(android.autoCancel)) {
+      throw new Error("'notification.android.autoCancel' expected a boolean value.");
+    }
+
+    out.autoCancel = android.autoCancel;
+  }
+
+  /**
+   * badgeCount
+   */
+  if (objectHasProperty(android, 'badgeCount')) {
+    if (!isNumber(android.badgeCount)) {
+      throw new Error("'notification.android.badgeCount' expected a number value.");
+    }
+
+    out.badgeCount = android.badgeCount;
+  }
+
+  /**
+   * badgeIconType
+   */
+  if (objectHasProperty(android, 'badgeIconType') && !isUndefined(android.badgeIconType)) {
+    if (!Object.values(AndroidBadgeIconType).includes(android.badgeIconType)) {
+      throw new Error(
+        "'notification.android.badgeIconType' expected a valid AndroidBadgeIconType.",
+      );
+    }
+
+    out.badgeIconType = android.badgeIconType;
+  }
+
+  /**
+   * category
+   */
+  if (objectHasProperty(android, 'category') && !isUndefined(android.category)) {
+    if (!Object.values(AndroidCategory).includes(android.category)) {
+      throw new Error("'notification.android.category' expected a valid AndroidCategory.");
+    }
+
+    out.category = android.category;
+  }
+
+  /**
+   * channelId
+   */
+  if (!isString(android.channelId)) {
+    throw new Error("'notification.android.channelId' expected a string value.");
+  }
+
+  out.channelId = android.channelId;
+
+  /**
+   * color
+   */
+  if (objectHasProperty(android, 'color') && !isUndefined(android.color)) {
+    if (!isString(android.color)) {
+      throw new Error("'notification.android.color' expected a string value.");
+    }
+
+    if (!isValidColor(android.color)) {
+      throw new Error(
+        "'notification.android.color' invalid color. Expected an AndroidColor or hexadecimal string value.",
+      );
+    }
+
+    out.color = android.color;
+  }
+
+  /**
+   * colorized
+   */
+  if (objectHasProperty(android, 'colorized')) {
+    if (!isBoolean(android.colorized)) {
+      throw new Error("'notification.android.colorized' expected a boolean value.");
+    }
+
+    out.colorized = android.colorized;
+  }
+
+  /**
+   * chronometerDirection
+   */
+  if (objectHasProperty(android, 'chronometerDirection')) {
+    if (!isString(android.chronometerDirection)) {
+      throw new Error("'notification.android.chronometerDirection' expected a string value.");
+    }
+
+    if (android.chronometerDirection !== 'up' && android.chronometerDirection !== 'down') {
+      throw new Error(`'notification.android.chronometerDirection' must be one of "up" or "down".`);
+    }
+
+    out.chronometerDirection = android.chronometerDirection;
+  }
+
+  /**
+   * defaults
+   */
+  if (objectHasProperty(android, 'defaults') && !isUndefined(android.defaults)) {
+    if (!isArray(android.defaults)) {
+      throw new Error("'notification.android.defaults' expected an array.");
+    }
+
+    if (android.defaults.length === 0) {
+      throw new Error(
+        "'notification.android.defaults' expected an array containing AndroidDefaults.",
+      );
+    }
+
+    const defaults = Object.values(AndroidDefaults);
+
+    for (let i = 0; i < android.defaults.length; i++) {
+      if (!defaults.includes(android.defaults[i])) {
+        throw new Error(
+          "'notification.android.defaults' invalid array value, expected an AndroidDefaults value.",
+        );
+      }
+    }
+
+    out.defaults = android.defaults;
+  }
+
+  /**
+   * groupId
+   */
+  if (objectHasProperty(android, 'groupId')) {
+    if (!isString(android.groupId)) {
+      throw new Error("'notification.android.groupId' expected a string value.");
+    }
+
+    out.groupId = android.groupId;
+  }
+
+  /**
+   * groupAlertBehavior
+   */
+  if (
+    objectHasProperty(android, 'groupAlertBehavior') &&
+    !isUndefined(android.groupAlertBehavior)
+  ) {
+    if (!Object.values(AndroidGroupAlertBehavior).includes(android.groupAlertBehavior)) {
+      throw new Error(
+        "'notification.android.groupAlertBehavior' expected a valid AndroidGroupAlertBehavior.",
+      );
+    }
+
+    out.groupAlertBehavior = android.groupAlertBehavior;
+  }
+
+  /**
+   * groupSummary
+   */
+  if (objectHasProperty(android, 'groupSummary')) {
+    if (!isBoolean(android.groupSummary)) {
+      throw new Error("'notification.android.groupSummary' expected a boolean value.");
+    }
+
+    out.groupSummary = android.groupSummary;
+  }
+
+  if (objectHasProperty(android, 'inputHistory')) {
+    if (!isArrayOfStrings(android.inputHistory)) {
+      throw new Error("'notification.android.inputHistory' expected an array of string values.");
+    }
+
+    out.inputHistory = android.inputHistory;
+  }
+
+  /**
+   * largeIcon
+   */
+  if (objectHasProperty(android, 'largeIcon')) {
+    if (
+      (!isNumber(android.largeIcon) &&
+        !isString(android.largeIcon) &&
+        !isObject(android.largeIcon)) ||
+      (isString(android.largeIcon) && !android.largeIcon.length)
+    ) {
+      throw new Error(
+        "'notification.android.largeIcon' expected a React Native ImageResource value or a valid string URL.",
+      );
+    }
+
+    if (isNumber(android.largeIcon) || isObject(android.largeIcon)) {
+      const image = Image.resolveAssetSource(android.largeIcon);
+      out.largeIcon = image.uri;
+    } else {
+      out.largeIcon = android.largeIcon;
+    }
+
+    if (isBoolean(android.circularLargeIcon)) {
+      out.circularLargeIcon = android.circularLargeIcon;
+    }
+  }
+
+  /**
+   * lights
+   */
+  if (objectHasProperty(android, 'lights') && !isUndefined(android.lights)) {
+    if (!isArray(android.lights)) {
+      throw new Error(
+        "'notification.android.lights' expected an array value containing the color, on ms and off ms.",
+      );
+    }
+
+    const [valid, property] = isValidLightPattern(android.lights);
+
+    if (!valid) {
+      switch (property) {
+        case 'color':
+          throw new Error(
+            "'notification.android.lights' invalid color. Expected an AndroidColor or hexadecimal string value.",
+          );
+        case 'onMs':
+          throw new Error(
+            `'notification.android.lights' invalid "on" millisecond value, expected a number greater than 0.`,
+          );
+        case 'offMs':
+          throw new Error(
+            `'notification.android.lights' invalid "off" millisecond value, expected a number greater than 0.`,
+          );
+      }
+    }
+
+    out.lights = android.lights;
+  }
+
+  /**
+   * localOnly
+   */
+  if (objectHasProperty(android, 'localOnly')) {
+    if (!isBoolean(android.localOnly)) {
+      throw new Error("'notification.android.localOnly' expected a boolean value.");
+    }
+
+    out.localOnly = android.localOnly;
+  }
+
+  /**
+   * ongoing
+   */
+  if (objectHasProperty(android, 'ongoing')) {
+    if (!isBoolean(android.ongoing)) {
+      throw new Error("'notification.android.ongoing' expected a boolean value.");
+    }
+
+    out.ongoing = android.ongoing;
+  }
+
+  /**
+   * loopSound
+   */
+  if (objectHasProperty(android, 'loopSound')) {
+    if (!isBoolean(android.loopSound)) {
+      throw new Error("'notification.android.loopSound' expected a boolean value.");
+    }
+
+    out.loopSound = android.loopSound;
+  }
+
+  /**
+   * foregroundServiceTypes
+   */
+  if (
+    objectHasProperty(android, 'foregroundServiceTypes') &&
+    !isUndefined(android.foregroundServiceTypes)
+  ) {
+    if (!isArray(android.foregroundServiceTypes)) {
+      throw new Error("'notification.android.foregroundServiceTypes' expected an array.");
+    }
+
+    if (android.foregroundServiceTypes.length === 0) {
+      throw new Error(
+        "'notification.android.foregroundServiceTypes' expected a non empty array containing AndroidForegroundServiceType.",
+      );
+    }
+
+    const defaults = Object.values(AndroidForegroundServiceType);
+
+    for (let i = 0; i < android.foregroundServiceTypes.length; i++) {
+      if (!defaults.includes(android.foregroundServiceTypes[i])) {
+        throw new Error(
+          "'notification.android.foregroundServiceTypes' invalid array value, expected an AndroidForegroundServiceType value.",
+        );
+      }
+    }
+
+    out.foregroundServiceTypes = android.foregroundServiceTypes;
+  }
+
+  /**
+   * flags
+   */
+  if (objectHasProperty(android, 'flags') && !isUndefined(android.flags)) {
+    if (!isArray(android.flags)) {
+      throw new Error("'notification.android.flags' expected an array.");
+    }
+
+    if (android.flags.length === 0) {
+      throw new Error("'notification.android.flags' expected an array containing AndroidDefaults.");
+    }
+
+    const defaults = Object.values(AndroidFlags);
+
+    for (let i = 0; i < android.flags.length; i++) {
+      if (!defaults.includes(android.flags[i])) {
+        throw new Error(
+          "'notification.android.flags' invalid array value, expected an AndroidFlags value.",
+        );
+      }
+    }
+
+    out.flags = android.flags;
+  }
+
+  /**
+   * onlyAlertOnce
+   */
+  if (objectHasProperty(android, 'onlyAlertOnce')) {
+    if (!isBoolean(android.onlyAlertOnce)) {
+      throw new Error("'notification.android.onlyAlertOnce' expected a boolean value.");
+    }
+
+    out.onlyAlertOnce = android.onlyAlertOnce;
+  }
+
+  /**
+   * pressAction
+   */
+  if (objectHasProperty(android, 'pressAction') && !isUndefined(android.pressAction)) {
+    try {
+      out.pressAction = validateAndroidPressAction(android.pressAction);
+    } catch (e: any) {
+      throw new Error(`'notification.android.pressAction' ${e.message}`);
+    }
+  }
+
+  /**
+   * fullScreenAction
+   */
+  if (objectHasProperty(android, 'fullScreenAction') && !isUndefined(android.fullScreenAction)) {
+    try {
+      out.fullScreenAction = validateAndroidFullScreenAction(android.fullScreenAction);
+    } catch (e: any) {
+      throw new Error(`'notification.android.fullScreenAction' ${e.message}`);
+    }
+  }
+
+  /**
+   * importance
+   */
+  if (objectHasProperty(android, 'importance') && !isUndefined(android.importance)) {
+    if (!Object.values(AndroidImportance).includes(android.importance)) {
+      throw new Error("'notification.android.importance' expected a valid Importance.");
+    }
+
+    out.importance = android.importance;
+  }
+
+  /**
+   * progress
+   */
+  if (objectHasProperty(android, 'progress') && !isUndefined(android.progress)) {
+    if (!isObject(android.progress)) {
+      throw new Error("'notification.android.progress' expected an object value.");
+    }
+
+    const progress: AndroidProgress = {
+      indeterminate: false,
+    };
+
+    if (objectHasProperty(android.progress, 'indeterminate')) {
+      if (!isBoolean(android.progress.indeterminate)) {
+        throw new Error("'notification.android.progress.indeterminate' expected a boolean value.");
+      }
+
+      progress.indeterminate = android.progress.indeterminate;
+    }
+
+    if (!isUndefined(android.progress.max)) {
+      if (!isNumber(android.progress.max) || android.progress.max < 0) {
+        throw new Error("'notification.android.progress.max' expected a positive number value.");
+      }
+
+      if (isUndefined(android.progress.current)) {
+        throw new Error(
+          "'notification.android.progress.max' when providing a max value, you must also specify a current value.",
+        );
+      }
+
+      progress.max = android.progress.max;
+    }
+
+    if (!isUndefined(android.progress.current)) {
+      if (!isNumber(android.progress.current) || android.progress.current < 0) {
+        throw new Error(
+          "'notification.android.progress.current' expected a positive number value.",
+        );
+      }
+
+      if (isUndefined(android.progress.max)) {
+        throw new Error(
+          "'notification.android.progress.current' when providing a current value, you must also specify a `max` value.",
+        );
+      }
+
+      progress.current = android.progress.current;
+    }
+
+    // We have a max/current value
+    if (!isUndefined(progress.max) && !isUndefined(progress.current)) {
+      if (progress.current > progress.max) {
+        throw new Error(
+          "'notification.android.progress' the current value cannot be greater than the max value.",
+        );
+      }
+    }
+
+    out.progress = progress;
+  }
+
+  /**
+   * showTimestamp
+   */
+  if (objectHasProperty(android, 'showTimestamp')) {
+    if (!isBoolean(android.showTimestamp)) {
+      throw new Error("'notification.android.showTimestamp' expected a boolean value.");
+    }
+
+    out.showTimestamp = android.showTimestamp;
+  }
+
+  /**
+   * smallIcon
+   */
+  if (objectHasProperty(android, 'smallIcon') && !isUndefined(android.smallIcon)) {
+    if (!isString(android.smallIcon)) {
+      throw new Error("'notification.android.smallIcon' expected value to be a string.");
+    }
+
+    out.smallIcon = android.smallIcon;
+  }
+
+  /**
+   * smallIconLevel
+   */
+  if (objectHasProperty(android, 'smallIconLevel') && !isUndefined(android.smallIcon)) {
+    if (!isNumber(android.smallIconLevel)) {
+      throw new Error("'notification.android.smallIconLevel' expected value to be a number.");
+    }
+
+    out.smallIconLevel = android.smallIconLevel;
+  }
+
+  /**
+   * sortKey
+   */
+  if (objectHasProperty(android, 'sortKey')) {
+    if (!isString(android.sortKey)) {
+      throw new Error("'notification.android.sortKey' expected a string value.");
+    }
+
+    out.sortKey = android.sortKey;
+  }
+
+  /**
+   * style
+   */
+
+  if (objectHasProperty(android, 'style') && !isUndefined(android.style)) {
+    if (!isObject(android.style)) {
+      throw new Error("'notification.android.style' expected an object value.");
+    }
+
+    switch (android.style.type) {
+      case AndroidStyle.BIGPICTURE:
+        out.style = validateAndroidBigPictureStyle(android.style);
+        break;
+      case AndroidStyle.BIGTEXT:
+        out.style = validateAndroidBigTextStyle(android.style);
+        break;
+      case AndroidStyle.INBOX:
+        out.style = validateAndroidInboxStyle(android.style);
+        break;
+      case AndroidStyle.MESSAGING:
+        out.style = validateAndroidMessagingStyle(android.style);
+        break;
+      default:
+        throw new Error(
+          "'notification.android.style' style type must be one of AndroidStyle.BIGPICTURE, AndroidStyle.BIGTEXT, AndroidStyle.INBOX or AndroidStyle.MESSAGING.",
+        );
+    }
+  }
+
+  /**
+   * tag
+   */
+  if (objectHasProperty(android, 'tag') && android.tag !== undefined) {
+    if (!isString(android.tag)) {
+      throw new Error("'notification.android.tag' expected a string value.");
+    }
+
+    if (android.tag.includes('|')) {
+      throw new Error(`'notification.android.tag' tag cannot contain the "|" (pipe) character.`);
+    }
+
+    out.tag = android.tag;
+  }
+
+  /**
+   * ticker
+   */
+  if (objectHasProperty(android, 'ticker')) {
+    if (!isString(android.ticker)) {
+      throw new Error("'notification.android.ticker' expected a string value.");
+    }
+
+    out.ticker = android.ticker;
+  }
+
+  /**
+   * timeoutAfter
+   */
+  if (objectHasProperty(android, 'timeoutAfter') && android.timeoutAfter !== undefined) {
+    if (!isNumber(android.timeoutAfter)) {
+      throw new Error("'notification.android.timeoutAfter' expected a number value.");
+    }
+
+    if (!isValidTimestamp(android.timeoutAfter)) {
+      throw new Error("'notification.android.timeoutAfter' invalid millisecond timestamp.");
+    }
+
+    out.timeoutAfter = android.timeoutAfter;
+  }
+
+  /**
+   * showChronometer
+   */
+  if (objectHasProperty(android, 'showChronometer')) {
+    if (!isBoolean(android.showChronometer)) {
+      throw new Error("'notification.android.showChronometer' expected a boolean value.");
+    }
+
+    out.showChronometer = android.showChronometer;
+  }
+
+  /**
+   * vibrationPattern
+   */
+  if (objectHasProperty(android, 'vibrationPattern') && android.vibrationPattern !== undefined) {
+    if (!isArray(android.vibrationPattern) || !isValidVibratePattern(android.vibrationPattern)) {
+      throw new Error(
+        "'notification.android.vibrationPattern' expected an array containing an even number of positive values.",
+      );
+    }
+
+    out.vibrationPattern = android.vibrationPattern;
+  }
+
+  /**
+   * visibility
+   */
+  if (objectHasProperty(android, 'visibility') && android.visibility !== undefined) {
+    if (!Object.values(AndroidVisibility).includes(android.visibility)) {
+      throw new Error(
+        "'notification.android.visibility' expected a valid AndroidVisibility value.",
+      );
+    }
+
+    out.visibility = android.visibility;
+  }
+
+  /**
+   * timestamp
+   */
+  if (objectHasProperty(android, 'timestamp') && android.timestamp !== undefined) {
+    if (!isNumber(android.timestamp)) {
+      throw new Error("'notification.android.timestamp' expected a number value.");
+    }
+
+    if (!isValidTimestamp(android.timestamp)) {
+      throw new Error(
+        "'notification.android.timestamp' invalid millisecond timestamp, date must be a positive number",
+      );
+    }
+
+    out.timestamp = android.timestamp;
+  }
+
+  /**
+   * sound
+   */
+  if (objectHasProperty(android, 'sound') && android.sound !== undefined) {
+    if (!isString(android.sound)) {
+      throw new Error("'notification.sound' expected a valid sound string.");
+    }
+
+    out.sound = android.sound;
+  }
+
+  return out;
+}