local-notification.js

/*
 * Apache 2.0 License
 *
 * Copyright (c) Sebastian Katzer 2017
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apache License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://opensource.org/licenses/Apache-2.0/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 */

var exec    = require('cordova/exec'),
    channel = require('cordova/channel');

// Options for every platform
exports._commonOptions = {
    actions: [],
    attachments: [],
    // Custom data for the notification. Can be used, when the notification
    // is send back to the app, e.g. by clicking on it.
    data: null,
    id: 0,
    launch: true,
    silent: false,
    text: "",
    // In Android 7, this sets the sound uri of a notification.
    // Since Android 8, it sets the sound uri of a notification channel.
    // The string 'default' represents the default notification sound and is not a path.
    sound: 'default',
    // If empty, the app name will be used
    title: "",
    trigger: {type : "calendar"}
}

exports._androidAlarmTypes = {
    'RTC_WAKEUP': 0,
    'RTC': 1,
    'ELAPSED_REALTIME_WAKEUP': 2, // Not supported
    'ELAPSED_REALTIME': 3, // Not supported
}

exports._androidChannelImportanceTypes = {
    'IMPORTANCE_NONE': 0,
    'IMPORTANCE_MIN': 1,
    'IMPORTANCE_LOW': 2,
    'IMPORTANCE_DEFAULT': 3,
    'IMPORTANCE_HIGH': 4,
    'IMPORTANCE_MAX': 5
}

// Options only available on Android
exports._androidSpecificOptions = {
    androidAlarmType: "RTC_WAKEUP",
    // Alarm will be allowed to execute even when the system is in low-power idle (a.k.a. doze) modes.
    androidAllowWhileIdle: false,
    // Make this notification automatically dismissed when the user touches it
    androidAutoCancel : true,
    androidChannelEnableLights: false,
    androidChannelDescription: null,
    androidChannelEnableVibration: false,
    androidChannelId: "default_channel",
    androidChannelImportance: "IMPORTANCE_DEFAULT",
    androidChannelName: "Default channel",
    // soundUsage of a channel. Default is USAGE_NOTIFICATION
    androidChannelSoundUsage: 5,
    // The notification background color for the small icon
    androidColor: null,
    // Android 7 only: Sets the default notification options
    androidDefaults: 0,
    androidGroup: null,
    androidGroupSummary: false,
    androidMessages: null,
    androidLargeIcon : null,
    // Can be square or circle
    androidLargeIconType: "square",
    androidLockscreen: true,
    androidOngoing: false,
    androidOnlyAlertOnce: false,
    androidProgressBar: null,
    // If the Notification should show the when date
    androidShowWhen: true,
    androidSmallIcon: 'res://ic_popup_reminder',
    androidSummary: null,
    // Specifies a duration in milliseconds after which this notification should be canceled,
    // if it is not already canceled.
    androidTimeoutAfter: 0,
    androidTitleCount: "%n%",
    // Show the Notification#when field as a stopwatch. Instead of presenting when as a timestamp,
    // the notification will show an automatically updating display of the minutes and seconds since when
    androidUsesChronometer: false,
    androidWakeUpScreen: true,
    // Overwrites default
    // Increments the badge by the specified number for that notification
    badgeNumber: 1,
    // Only for Android 7
    led: false
}

// Options only available on iOS
exports._iOSSpecificOptions = {
    // Overwrites default
    // Set the badge directly.
    // -1: The badge will not be changed
    // 0: The badge will be cleared
    badgeNumber: -1,
    // Displays notification in foreground, when app is active.
    iOSForeground : true
}

exports._deprecatedProperties = {
    // Changes since version 1.1.0
    autoClear: {newPropertyKey: 'androidAutoCancel', since: "1.1.0"},
    badge: {newPropertyKey: 'badgeNumber', since: "1.1.0"},
    channelDescription: {newPropertyKey: 'androidChannelDescription', since: "1.1.0"},
    channelId: {newPropertyKey: 'androidChannelId', since: "1.1.0"},
    channelImportance: {newPropertyKey: 'androidChannelImportance', since: "1.1.0"},
    channelName: {newPropertyKey: 'androidChannelName', since: "1.1.0"},
    clock: {message: "Use for 'clock: true' = 'androidShowWhen' and clock: 'chronometer' = 'androidUsesChronometer'", since: "1.1.0"},
    color: {newPropertyKey: 'androidColor', since: "1.1.0"},
    description: {newPropertyKey: 'androidChannelDescription', since: "1.1.0"},
    defaults: {newPropertyKey: 'androidDefaults', since: "1.1.0"},
    foreground: {newPropertyKey: 'iOSForeground', since: "1.1.0"},
    group: {newPropertyKey: 'androidGroup', since: "1.1.0"},
    groupSummary: {newPropertyKey: 'androidGroupSummary', since: "1.1.0"},
    icon: {newPropertyKey: 'androidLargeIcon', since: "1.1.0"},
    iconType: {renanewPropertyKeymedTo: 'androidLargeIconType', since: "1.1.0"},
    importance: {newPropertyKey: 'androidChannelImportance', since: "1.1.0"},
    lockscreen: {newPropertyKey: 'androidLockscreen', since: "1.1.0"},
    mediaSession: {removed: true, since: "1.1.0", additionalMessage: "Not supported anymore."},
    onlyAlertOnce: {newPropertyKey: 'androidOnlyAlertOnce', since: "1.1.0"},
    prio: {additionalMessage: 'Use androidChannelImportance, androidAlarmType and androidAllowWhileIdle instead.', since: "1.1.0"},
    priority: {additionalMessage: 'Use androidChannelImportance, androidAlarmType and androidAllowWhileIdle instead.', since: "1.1.0"},
    progressBar: {newPropertyKey: 'androidProgressBar', since: "1.1.0"},
    smallIcon: {newPropertyKey: 'androidSmallIcon', since: "1.1.0"},
    soundUsage: {newPropertyKey: 'androidChannelSoundUsage', since: "1.1.0"},
    sticky: {newPropertyKey: 'androidOngoing', since: "1.1.0"},
    ongoing: {newPropertyKey: 'androidOngoing', since: "1.1.0"},
    summary: {newPropertyKey: 'androidSummary', since: "1.1.0"},
    timeoutAfter: {newPropertyKey: 'androidTimeoutAfter', since: "1.1.0"},
    titleCount: {newPropertyKey: 'androidTitleCount', since: "1.1.0"},
    vibrate: {newPropertyKey: 'androidChannelEnableVibration', since: "1.1.1"},
    wakeup: {newPropertyKey: 'androidWakeUpScreen', since: "1.1.0"},
}

// Defaults
exports._defaults = {
    ...exports._commonOptions,
    meta: {
        plugin:  'cordova-plugin-local-notification',
        version: '1.1.1-dev'
    }
};

/**
 * Setting some things before 'deviceready' event has fired.
 */
channel.onCordovaReady.subscribe(function () {
    channel.onCordovaInfoReady.subscribe(function () {
        console.log("LocalNotification: onCordovaInfoReady");

        // Merge defaults for Android
        if (device.platform == 'Android') {
            exports._defaults = {
                ...exports._defaults,
                ...exports._androidSpecificOptions
            }

            // Merge defaults for iOS
        } else if (device.platform == 'iOS') {
            exports._defaults = {
                ...exports._defaults,
                ...exports._iOSSpecificOptions
            }
        }

        exports._setLaunchDetails();
    });
});

// Called after 'deviceready' event
channel.deviceready.subscribe(function () {
    console.log("LocalNotification: deviceready");
    if (!window.skipLocalNotificationReady) {
        exports.fireQueuedEvents();
    }
});

/**
 * Set the launch details if the app was launched by clicking on a toast.
 */
exports._setLaunchDetails = function () {
    exports._exec('launch', null, function (details) {
        if (details) {
            exports.launchDetails = details;
        }
    });
};

/**
 * ====================
 * Plugin methods
 * ====================
 **/

/**
 * Fire queued events once the device is ready and all listeners are registered.
 */
exports.fireQueuedEvents = function() {
    exports._exec('ready');
};

// Event listeners
// For an event, multiple listeners can be added.
exports._listeners = {};

/**
 * Overwrite default settings.
 * @param {Object} newDefaults
 */
exports.setDefaults = function (newDefaults) {
    Object.assign(this._defaults, newDefaults);
};

/**
 * Android only: Create notification channel
 * @param {Object} options channel options
 * @param {Function} callback The function to be exec as the callback
 * @param {Object} scope The callback function's scope
 */
exports.createChannel = function (options, callback, scope) {
    // Correct renamed properties and set defaults
    exports._correctOptions(options, true);
    exports._exec('createChannel', options, callback, scope);
};

/**
 * Android only: Deletes a notification channel.
 * If you create a new channel with this same id, the deleted channel will be un-deleted
 * with all of the same settings it had before it was deleted
 * See: https://developer.android.com/reference/androidx/core/app/NotificationManagerCompat#deleteNotificationChannel(java.lang.String)
 *
 * @param {string} channelId Channel ID to delete. Has to be a string like "my_channel_id"
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope  The callback function's scope.
 */
exports.deleteChannel = function (channelId, callback, scope) {
    exports._exec('deleteChannel', channelId, callback, scope);
};

/**
 * Check permission to show notifications.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.hasPermission = function (callback, scope) {
    exports._exec('hasPermission', null, callback, scope);
};

/**
 * Request permission to show notifications.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.requestPermission = function (callback, scope) {
    console.log("Requesting permission");
    exports._exec('requestPermission', null, callback, scope);
};

/**
 * Android only: Check permission to schedule exact alarms.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.canScheduleExactAlarms = function (callback, scope) {
    exports._exec('canScheduleExactAlarms', null, callback, scope);
};

/**
 * Schedule notifications
 * @param {Object|Array} options The notifications to schedule
 * @param {Function} callback
 * @param {Object} scope The callback function's scope.
 * @param {Object} args Optional, can be {skipPermission: true} to skip the permission check
 */
exports.schedule = function (options, callback, scope, args) {
    const optionsList = exports._toArray(options);

    for (const options of optionsList) {
        // Correct renamed properties and set defaults
        exports._correctOptions(options, true);
    }

    // Skip permission check if requested and schedule directly
    if (args && args.skipPermission) {
        console.log("Skip permission check");
        exports._exec('schedule', optionsList, callback, scope);

        // Ask for permission
    } else {
        exports.requestPermission((granted) => {
            console.log("Permission granted=" + granted);

            if (!granted) {
                if (callback) callback.call(scope || this, false);
                return;
            }

            exports._exec('schedule', optionsList, callback, scope);
        }, this);
    }
};

/**
 * Update notifications
 * @param {Object|Array} options The notifications to update
 * @param {Function} callback
 * @param {Object} scope The callback function's scope.
 * @param {Object} args Optional, can be {skipPermission: true} to skip the permission check
 */
exports.update = function (options, callback, scope, args) {
    const optionsList = exports._toArray(options);

    for (const options of optionsList) {
        // Correct renamed properties and don't merge defaults
        // The defaults are not merged, because otherwise, some values
        // could be set back to a default value
        exports._correctOptions(options, false);
    }

    // Skip permission check if requested and update directly
    if (args && args.skipPermission) {
        exports._exec('update', optionsList, callback, scope);

        // Ask for permission
    } else {
        exports.requestPermission((granted) => {
            if (!granted) {
                if (callback) callback.call(scope || this, false);
                return;
            }
    
            exports._exec('update', optionsList, callback, scope);
        }, this);
    }
};

/**
 * Clear one or multiple notifications by id/ids
 * @param {Array<number>|number} ids One Id or an array of Ids
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.clear = function (ids, callback, scope) {
    exports._exec('clear', exports._convertIdsToNumbers(ids), callback, scope);
};

/**
 * Clear all triggered notifications.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.clearAll = function (callback, scope) {
    exports._exec('clearAll', null, callback, scope);
};

/**
 * Clear one or multiple notifications by id/ids
 * @param {Array<number>|number} ids One Id or an array of Ids
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.cancel = function (ids, callback, scope) {
    exports._exec('cancel', exports._convertIdsToNumbers(ids), callback, scope);
};

/**
 * Cancel all scheduled notifications.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.cancelAll = function (callback, scope) {
    exports._exec('cancelAll', null, callback, scope);
};

/**
 * Check if a notification is present.
 * @param {number} id The ID of the notification.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.isPresent = function (id, callback, scope) {
    exports.getType(id, function (type) {
        exports._callbackWithScope(callback, scope)(type != 'unknown');
    });
};

/**
 * Check if a notification is scheduled.
 * @param {Int} id The ID of the notification.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.isScheduled = function (id, callback, scope) {
    exports.hasType(id, 'scheduled', callback, scope);
};

/**
 * Check if a notification was triggered.
 * @param {Int} id The ID of the notification.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.isTriggered = function (id, callback, scope) {
    exports.hasType(id, 'triggered', callback, scope);
};

/**
 * Check if a notification has a given type.
 * @param {number} id The ID of the notification.
 * @param {string} type The type of the notification.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.hasType = function (id, type, callback, scope) {
    exports.getType(id, function (type2) {
        exports._callbackWithScope(callback, scope)(type == type2);
    });
};

/**
 * Get the type (triggered, scheduled) for the notification.
 * @param {number} id The ID of the notification.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.getType = function (id, callback, scope) {
    exports._exec('type', id, callback, scope);
};

/**
 * List of all notification ids.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.getIds = function (callback, scope) {
    exports._exec('ids', 0, callback, scope);
};

/**
 * List of all scheduled notification IDs.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.getScheduledIds = function (callback, scope) {
    exports._exec('ids', 1, callback, scope);
};

/**
 * List of all triggered notification IDs.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.getTriggeredIds = function (callback, scope) {
    exports._exec('ids', 2, callback, scope);
};

/**
 * List of local notifications specified by id.
 * If called without IDs, all notification will be returned.
 *
 * @param [ Array<Int> ] ids      The IDs of the notifications.
 * @param [ Function ]   callback The function to be exec as the callback.
 * @param [ Object ]     scope    The callback function's scope.
 *
 * @return [ Void ]
 */
exports.get = function () {
    var args = Array.apply(null, arguments);

    if (typeof args[0] == 'function') {
        args.unshift([]);
    }

    var ids = args[0], callback = args[1], scope = args[2];

    if (!Array.isArray(ids)) {
        this._exec('notification', Number(ids), callback, scope);
        return;
    }

    this._exec('notifications', [3, exports._convertIdsToNumbers(ids)], callback, scope);
};

/**
 * List for all notifications.
 *
 * @param [ Function ] callback The function to be exec as the callback.
 * @param [ Object ]   scope    The callback function's scope.
 *
 * @return [ Void ]
 */
exports.getAll = function (callback, scope) {
    this._exec('notifications', 0, callback, scope);
};

/**
 * List of all scheduled notifications.
 *
 * @param [ Function ]   callback The function to be exec as the callback.
 * @param [ Object ]     scope    The callback function's scope.
 */
exports.getScheduled = function (callback, scope) {
    this._exec('notifications', 1, callback, scope);
};

/**
 * List of all triggered notifications.
 *
 * @param [ Function ]   callback The function to be exec as the callback.
 * @param [ Object ]     scope    The callback function's scope.
 */
exports.getTriggered = function (callback, scope) {
    this._exec('notifications', 2, callback, scope);
};

/**
 * Add an group of actions by id.
 *
 * @param [ String ]   id       The Id of the group.
 * @param [ Array]     actions  The action config settings.
 * @param [ Function ] callback The function to be exec as the callback.
 * @param [ Object ]   scope    The callback function's scope.
 *
 * @return [ Void ]
 */
exports.addActions = function (id, actions, callback, scope) {
    this._exec('actions', [0, id, actions], callback, scope);
};

/**
 * Remove an group of actions by id.
 *
 * @param [ String ]   id       The Id of the group.
 * @param [ Function ] callback The function to be exec as the callback.
 * @param [ Object ]   scope    The callback function's scope.
 *
 * @return [ Void ]
 */
exports.removeActions = function (id, callback, scope) {
    this._exec('actions', [1, id], callback, scope);
};

/**
 * Check if a group of actions is defined.
 *
 * @param [ String ]   id       The Id of the group.
 * @param [ Function ] callback The function to be exec as the callback.
 * @param [ Object ]   scope    The callback function's scope.
 *
 * @return [ Void ]
 */
exports.hasActions = function (id, callback, scope) {
    this._exec('actions', [2, id], callback, scope);
};

/**
 * Open native settings to enable notifications.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.openNotificationSettings = function (callback, scope) {
    this._exec('openNotificationSettings', null, callback, scope);
};

/**
 * Android only: Open native settings to enable alarms & reminders.
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 */
exports.openAlarmSettings = function (callback, scope) {
    this._exec('openAlarmSettings', null, callback, scope);
};

/**
 * iOS only: Clear the badge of the app icon.
 * @param {Function} callback 
 * @param {Object} scope 
 */
exports.iOSClearBadge = function (callback, scope) {
    this._exec('clearBadge', null, callback, scope);
}

/**
 * Register callback for a given event.
 * @param {string} event The name of the event.
 * @param {Function|string} callback The function to be exec as callback or the
 * method name on the scope, which should be called.
 * @param {Object} scope The callback function's scope.
 */
exports.on = function (event, callback, scope) {
    // If callback is a string, a method on the scope schould be called
    if (typeof callback !== 'function' && typeof callback !== 'string') return;

    // Create empty array, if there are no listeners already
    if (!this._listeners[event]) this._listeners[event] = [];

    this._listeners[event].push([callback, scope || window]);
};

/**
 * Unregister callback for given event
 * @param {string} event The name of the event
 * @param {Function|string} callback Callback or method name for the scope, which should be unregistered
 */
exports.un = function (event, callback) {
    // No listeners added to this event
    if (!this._listeners[event]) return;
    // Remove all listeners by callback or method name
    this._listeners[event] = this._listeners[event].filter((listener) => listener[0] != callback);
};

/**
 * Fire the event with given arguments.
 * @param {string} event The event's name.
 * @param {...Object} args The callback's arguments. The first element, can be the options of a notification.
 */
exports.fireEvent = function (event, ...args) {
    // No listeners added for this event
    if (!this._listeners[event]) return;

    // Convert custom notification data to object
    if (args[0] && typeof args[0].data === 'string') {
        args[0].data = JSON.parse(args[0].data);
    }

    for (const listener of this._listeners[event]) {
        const callback = listener[0];
        const scope = listener[1];

        // If callback is a string, a method on the scope schould be called
        if (typeof callback === 'string') callback = scope[callback];

        callback.apply(scope, args);
    }
};

/**
 * ====================
 * Internal JS Methods for handling options etc.
 * ====================
 **/

/**
 * Correct renamed propertie and merge defaults optionally, also do the following:
 * - correct options to their required type
 * - warn about wrong smallIcon uri
 * - log unknown and deprecated properties
 * - Remove null values, because of a Android bug
 * @param {Object} options The options to convert
 */
exports._correctOptions = function (options, mergeDefaults = false) {
    exports._handleDeprecatedProperties(options)

    // Warn about wrong androidSmallIcon uri
    if (options.androidSmallIcon && !options.androidSmallIcon.match(/^res:/)) {
        console.warn('Property "androidSmallIcon" must be of kind res://...')
    }

    // Convert custom data to string
    options.data = JSON.stringify(options.data)

    // No auto cancelling, if the notification is ongoing
    if (options.androidOngoing) options.androidAutoCancel = false

    exports._convertTrigger(options);
    exports._convertActions(options);
    exports._convertAndroidProgressBar(options);

    if (mergeDefaults) {
        for (const key in this._defaults) {
            if (options[key] === undefined) options[key] = exports._defaults[key];
        }
    }

    // Convert Enums
    // Android: alarmType string to integer
    if (typeof options.androidAlarmType === 'string') {
        options.androidAlarmType = exports._androidAlarmTypes[options.androidAlarmType]
    }

    // Android: channelImportance string to integer
    if (typeof options.androidChannelImportance === 'string') {
        options.androidChannelImportance = exports._androidChannelImportanceTypes[options.androidChannelImportance]
    }

    // Due to a Android bug, null values have to be removed
    exports._removeNullValues(options);
    exports._logUnknownProperties(options);
};

/**
 * Corrects renamed properties since Plugin version 1.1.0
 * @param {Oject} options 
 */
exports._handleDeprecatedProperties = function (options) {
    if (device.platform == "Android") {

        // text as Array to androidMessages, since 1.1.0
        if (Array.isArray(options.text)) {
            options.androidMessages = options.text
            console.log("Property 'text' as array is deprecated since version 1.1.0. Use 'androidMessages' instead.")
        }

        // "clock: true" to androidShowWhen, since 1.1.0
        if (options.clock === true) {
            options.androidShowWhen = true
            console.log("Property 'clock: true' is deprecated since version 1.1.0. Use 'androidShowWhen: true' instead.")
        }

        // "clock: 'chronometer'" to androidUsesChronometer, since 1.1.0
        if (options.clock == "chronometer") {
            options.androidUsesChronometer = true
            console.log("Property 'clock: 'chronometer'' is deprecated since version 1.1.0. Use 'androidUsesChronometer: true' instead.")
        }

        // led replaced by androidChannelEnableLights, since Android 8
        if (options.led) options.androidChannelEnableLights = true

        // priority changed to androidChannelImportance, androidAlarmType and androidAllowWhileIdle
        this._androidHandleOldPropertyPriority(options)
    }

    // sound: true changed to sound: "default", since 1.1.0
    if (options.sound === true) {
        options.sound = "default"
        console.log(`Property "sound: true" is deprecated since version 1.1.0. Use "sound: 'default'" instead.`)
    }

    // Handle renamed and removed properties
    // Log deprecated properties
    for (const key in options) {

        // Check if the property is deprecated
        const deprecatedProperty = this._deprecatedProperties[key];

        // Property not deprecated
        if (!deprecatedProperty) continue

        let message;

        // Check if propert is renamed
        if (deprecatedProperty.newPropertyKey) {
            message = `Use "${deprecatedProperty.newPropertyKey}" instead.`
            // Set deprecated property value to new property
            options[deprecatedProperty.newPropertyKey] = options[key]

            // Property was removed
        } else if (deprecatedProperty.removed) {
            message = `Property removed`
        }

        if (deprecatedProperty.additionalMessage) {
            message += ` ${deprecatedProperty.additionalMessage}`
        }

        console.warn(`Property "${key}" is deprecated since version ${deprecatedProperty.since}. ${message}`)
    }
}

/**
 * Android: Backward compatibility for property priority.
 * Replaced by androidChannelImportance, androidAlarmType and androidAllowWhileIdle
 * Removed in plugin version 1.1.0
 * If priority is present, it will set androidAlarmType and androidAllowWhileIdle, but not androidChannelImportance.
 * @param {Object} options
 */
exports._androidHandleOldPropertyPriority = function (options) {
    let priority = options.priority || options.prio;

    // Old property not found
    if (priority === undefined) return

    if (typeof priority === 'string') {
        priority = { min: -2, low: -1, high: 1, max: 2 }[priority] || 0;
    }

    if (options.foreground === true) {
        priority = Math.max(priority, 1);
    }

    if (options.foreground === false) {
        priority = Math.min(priority, 0);
    }

    // PRIORITY_MIN and PRIORITY_LOW
    if (priority < 0) {
        options.androidAlarmType = "RTC"
        options.androidAllowWhileIdle = false

        // PRIORITY_DEFAULT and PRIORITY_HIGH
    } else if (priority < 2) {
        options.androidAlarmType = "RTC_WAKEUP"
        options.androidAllowWhileIdle = false

        // PRIORITY_MAX
    } else {
        options.androidAlarmType = "RTC_WAKEUP"
        options.androidAllowWhileIdle = true
    }

    options.priority = priority;
};

/**
 * Convert the passed values to their required type, modifying them
 * directly for Android and passing the converted list back for iOS.
 *
 * @param [ Map ] options Set of custom values.
 *
 * @return [ Map ] Interaction object with category & actions.
 */
exports._convertActions = function (options) {
    var actions = [];

    if (!options.actions || typeof options.actions === 'string')
        return options;

    for (var i = 0, len = options.actions.length; i < len; i++) {
        var action = options.actions[i];

        if (!action.id) {
            console.warn('Action with title ' + action.title + ' ' +
                         'has no id and will not be added.');
            continue;
        }

        action.id = action.id.toString();

        actions.push(action);
    }

    options.actions = actions;

    return options;
};

/**
 * Convert the passed values for the trigger to their required type.
 * @param {Object} options
 * @return {Object} Converted options
 */
exports._convertTrigger = function (options) {
    if (!options.trigger) return;

    let trigger = options.trigger;

    trigger.type = trigger.type || trigger.center ? 'location' : 'calendar';
    var isCal = trigger.type == 'calendar';

    // Get trigger date from trigger
    var date = exports._getValueFor(trigger, 'at', 'firstAt', 'date');

    // Fallback: Get trigger date from options, if not defined in trigger
    if (isCal && !date) {
        date = exports._getValueFor(options, 'at', 'firstAt', 'date');
    }

    // Fallback: Transfer every option to trigger
    if (isCal && !trigger.every && options.every) {
        trigger.every = options.every;
    }

    if (isCal && (trigger.in || trigger.every)) {
        date = null;
    }

    var dateToNum = function (date) {
        var num = typeof date == 'object' ? date.getTime() : date;
        return Math.round(num);
    };

    if (isCal && date) {
        trigger.at = dateToNum(date);
    }

    if (isCal && trigger.firstAt) {
        trigger.firstAt = dateToNum(trigger.firstAt);
    }

    if (isCal && trigger.before) {
        trigger.before = dateToNum(trigger.before);
    }

    if (isCal && trigger.after) {
        trigger.after = dateToNum(trigger.after);
    }

    if (trigger.count && device.platform == 'iOS') {
        console.warn('trigger: { count: } is not supported on iOS.');
    }

    if (!isCal) {
        trigger.notifyOnEntry = !!trigger.notifyOnEntry;
        trigger.notifyOnExit  = trigger.notifyOnExit === true;
        trigger.radius        = trigger.radius || 5;
        trigger.single        = !!trigger.single;
    }

    if (!isCal || trigger.at) {
        delete trigger.every;
    }

    delete options.every;
    delete options.at;
    delete options.firstAt;
    delete options.date;

    options.trigger = trigger;

    return options;
};

/**
 * Convert the passed values for the progressBar to their required type.
 * @param {Object} options
 */
exports._convertAndroidProgressBar = function (options) {
    if (options.androidProgressBar === undefined) return
    let progressBar = options.androidProgressBar

    progressBar.value = progressBar.value || 0;
    progressBar.maxValue = progressBar.maxValue || 100;
    progressBar.indeterminate = progressBar.indeterminate || false;

    // Show the Notification#when field as a stopwatch
    if (options.androidShowWhen) options.androidUsesChronometer = true;
};

/**
 * On Android exists the bug, that when using JSONObject.optString("key", null),
 * it will return "NULL" as string and not plain null. This function removes
 * all null values, to workaround this. If this is also a problem on iOS, is not known.
 * 
 * See: https://stackoverflow.com/questions/18226288/json-jsonobject-optstring-returns-string-null
 * @param {Object} options 
 */
exports._removeNullValues = function (options) {
    for (const key in options) {
        if (options[key] === null) delete options[key];
    }
}

/**
 * Warns about unknown properties in options
 * @param {Object} options
 */
exports._logUnknownProperties = function (options) {
    for (const key in options) {
        // Check if property is missing in defaults and is not a deprecated property
        if (this._defaults[key] === undefined &&  this._deprecatedProperties[key] === undefined) {
            console.warn('Unknown property: ' + key);
        }
    }
}

/**
 * Create a callback function to get executed within a specific scope.
 *
 * @param {Function} callback The function to be exec as the callback.
 * @param {Object} scope The callback function's scope.
 * @return {Function} The callback function.
 */
exports._callbackWithScope = function (callback, scope) {
    if (typeof callback != 'function') return;

    return function () {
        callback.apply(scope || this, arguments);
    };
};

/**
 * Convert the IDs to numbers.
 * @param {Array|Object} ids Will be turned into an array, if it's not already.
 * @return {Array<Number>}
 */
exports._convertIdsToNumbers = function (ids) {
    return exports._toArray(ids).map((id) => Number(id))
};

/**
 * Execute the native counterpart.
 *
 * @param [ String ]  action   The name of the action.
 * @param [ Array ]   args     Array of arguments.
 * @param [ Function] callback The callback function.
 * @param [ Object ] scope     The scope for the function.
 *
 * @return [ Void ]
 */
exports._exec = function (action, options, callback, scope) {
    exec(
        exports._callbackWithScope(callback, scope),
        null,
        'LocalNotification',
        action,
        // Convert options to array, if not already
        options === null ? [] : this._toArray(options)
    );
};

/**
 * First found value for the given keys.
 * @param {Object} options
 * @param {...string} findkeys Keys to find
 * @returns {*|void} The first found value or undefined
 */
exports._getValueFor = function (options, ...findKeys) {
    for (const findKey of findKeys) {
        if (options.hasOwnProperty(findKey)) return options[findKey];
    }

    return undefined;
};

/**
 * Convert a value to an array, if it is not already an array.
 *
 * @param {Object|Array} object Any kind of object, or an array.
 * @return {Array} An array with the object as first item or the object itself, if it's already an array.
 */
exports._toArray = function (object) {
    return Array.isArray(object) ? object : [object];
};

exports._deepCopy = function (object) {
    return JSON.parse(JSON.stringify(object));
};