text: ﻿cordova.define("de.appplant.cordova.plugin.local-notification.LocalNotification.Core", function(require, exports, module) { /*
   * Copyright (c) 2013-2015 by appPlant UG. All rights reserved.
   *
   * @APPPLANT_LICENSE_HEADER_START@
   *
   * 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.
   *
   * @APPPLANT_LICENSE_HEADER_END@
   */
  
  var exec = require('cordova/exec');
  
  
  /********
   * CORE *
   ********/
  
  /**
   * Returns the default settings.
   *
   * @return {Object}
   */
  exports.getDefaults = function () {
      return this._defaults;
  };
  
  /**
   * Overwrite default settings.
   *
   * @param {Object} defaults
   */
  exports.setDefaults = function (newDefaults) {
      var defaults = this.getDefaults();
  
      for (var key in defaults) {
          if (newDefaults.hasOwnProperty(key)) {
              defaults[key] = newDefaults[key];
          }
      }
  };
  
  /**
   * Schedule a new local notification.
   *
   * @param {Object} opts
   *      The notification properties
   * @param {Function} callback
   *      A function to be called after the notification has been canceled
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.schedule = function (opts, callback, scope) {
      this.registerPermission(function(granted) {
  
          if (!granted)
              return;
  
          var notifications = Array.isArray(opts) ? opts : [opts];
  
          for (var i = 0; i < notifications.length; i++) {
              var properties = notifications[i];
  
              this.mergeWithDefaults(properties);
              this.convertProperties(properties);
          }
  
          this.exec('schedule', notifications, callback, scope);
      }, this);
  };
  
  /**
   * Update existing notifications specified by IDs in options.
   *
   * @param {Object} options
   *      The notification properties to update
   * @param {Function} callback
   *      A function to be called after the notification has been updated
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.update = function (opts, callback, scope) {
      var notifications = Array.isArray(opts) ? opts : [opts];
  
      for (var i = 0; i < notifications.length; i++) {
          var properties = notifications[i];
  
          this.convertProperties(properties);
      }
  
      this.exec('update', notifications, callback, scope);
  };
  
  /**
   * Clear the specified notification.
   *
   * @param {String} id
   *      The ID of the notification
   * @param {Function} callback
   *      A function to be called after the notification has been cleared
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.clear = function (ids, callback, scope) {
      ids = Array.isArray(ids) ? ids : [ids];
      ids = this.convertIds(ids);
  
      this.exec('clear', ids, callback, scope);
  };
  
  /**
   * Clear all previously sheduled notifications.
   *
   * @param {Function} callback
   *      A function to be called after all notifications have been cleared
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.clearAll = function (callback, scope) {
      this.exec('clearAll', null, callback, scope);
  };
  
  /**
   * Cancel the specified notifications.
   *
   * @param {String[]} ids
   *      The IDs of the notifications
   * @param {Function} callback
   *      A function to be called after the notifications has been canceled
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.cancel = function (ids, callback, scope) {
      ids = Array.isArray(ids) ? ids : [ids];
      ids = this.convertIds(ids);
  
      this.exec('cancel', ids, callback, scope);
  };
  
  /**
   * Remove all previously registered notifications.
   *
   * @param {Function} callback
   *      A function to be called after all notifications have been canceled
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.cancelAll = function (callback, scope) {
      this.exec('cancelAll', null, callback, scope);
  };
  
  /**
   * Check if a notification with an ID is present.
   *
   * @param {String} id
   *      The ID of the notification
   * @param {Function} callback
   *      A callback function to be called with the list
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.isPresent = function (id, callback, scope) {
      this.exec('isPresent', id || 0, callback, scope);
  };
  
  /**
   * Check if a notification with an ID is scheduled.
   *
   * @param {String} id
   *      The ID of the notification
   * @param {Function} callback
   *      A callback function to be called with the list
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.isScheduled = function (id, callback, scope) {
      this.exec('isScheduled', id || 0, callback, scope);
  };
  
  /**
   * Check if a notification with an ID was triggered.
   *
   * @param {String} id
   *      The ID of the notification
   * @param {Function} callback
   *      A callback function to be called with the list
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.isTriggered = function (id, callback, scope) {
      this.exec('isTriggered', id || 0, callback, scope);
  };
  
  /**
   * List all local notification IDs.
   *
   * @param {Function} callback
   *      A callback function to be called with the list
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.getAllIds = function (callback, scope) {
      this.exec('getAllIds', null, callback, scope);
  };
  
  /**
   * Alias for `getAllIds`.
   */
  exports.getIds = function () {
      this.getAllIds.apply(this, arguments);
  };
  
  /**
   * List all scheduled notification IDs.
   *
   * @param {Function} callback
   *      A callback function to be called with the list
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.getScheduledIds = function (callback, scope) {
      this.exec('getScheduledIds', null, callback, scope);
  };
  
  /**
   * List all triggered notification IDs.
   *
   * @param {Function} callback
   *      A callback function to be called with the list
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.getTriggeredIds = function (callback, scope) {
      this.exec('getTriggeredIds', null, callback, scope);
  };
  
  /**
   * Property list for given local notifications.
   * If called without IDs, all notification will be returned.
   *
   * @param {Number[]?} ids
   *      Set of notification IDs
   * @param {Function} callback
   *      A callback function to be called with the list
   * @param {Object?} scope
   *      The scope for the callback function
   */
  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('getSingle', Number(ids), callback, scope);
          return;
      }
  
      ids = this.convertIds(ids);
  
      this.exec('getAll', ids, callback, scope);
  };
  
  /**
   * Property list for all local notifications.
   *
   * @param {Function} callback
   *      A callback function to be called with the list
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.getAll = function (callback, scope) {
      this.exec('getAll', null, callback, scope);
  };
  
  /**
   * Property list for given scheduled notifications.
   * If called without IDs, all notification will be returned.
   *
   * @param {Number[]?} ids
   *      Set of notification IDs
   * @param {Function} callback
   *      A callback function to be called with the list
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.getScheduled = 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)) {
          ids = [ids];
      }
  
      if (!Array.isArray(ids)) {
          this.exec('getSingleScheduled', Number(ids), callback, scope);
          return;
      }
  
      ids = this.convertIds(ids);
  
      this.exec('getScheduled', ids, callback, scope);
  };
  
  /**
   * Property list for all scheduled notifications.
   *
   * @param {Function} callback
   *      A callback function to be called with the list
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.getAllScheduled = function (callback, scope) {
      this.exec('getScheduled', null, callback, scope);
  };
  
  /**
   * Property list for given triggered notifications.
   * If called without IDs, all notification will be returned.
   *
   * @param {Number[]?} ids
   *      Set of notification IDs
   * @param {Function} callback
   *      A callback function to be called with the list
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.getTriggered = 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)) {
          ids = [ids];
      }
  
      if (!Array.isArray(ids)) {
          this.exec('getSingleTriggered', Number(ids), callback, scope);
          return;
      }
  
      ids = this.convertIds(ids);
  
      this.exec('getTriggered', ids, callback, scope);
  };
  
  /**
   * Property list for all triggered notifications.
   *
   * @param {Function} callback
   *      A callback function to be called with the list
   * @param {Object?} scope
   *      The scope for the callback function
   */
  exports.getAllTriggered = function (callback, scope) {
      this.exec('getTriggered', null, callback, scope);
  };
  
  /**
   * Informs if the app has the 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) {
      var fn = this.createCallbackFn(callback, scope);
  
      if (device.platform != 'iOS') {
          fn(true);
          return;
      }
  
      exec(fn, null, 'LocalNotification', 'hasPermission', []);
  };
  
  /**
   * Register permission to show notifications if not already granted.
   *
   * @param {Function} callback
   *      The function to be exec as the callback
   * @param {Object?} scope
   *      The callback function's scope
   */
  exports.registerPermission = function (callback, scope) {
      var fn = this.createCallbackFn(callback, scope);
  
      if (device.platform != 'iOS') {
          fn(true);
          return;
      }
  
      exec(fn, null, 'LocalNotification', 'registerPermission', []);
  };
  
  
  /**********
   * EVENTS *
   **********/
  
  /**
   * Register callback for given event.
   *
   * @param {String} event
   *      The event's name
   * @param {Function} callback
   *      The function to be exec as callback
   * @param {Object?} scope
   *      The callback function's scope
   */
  exports.on = function (event, callback, scope) {
  
      if (!this._listener[event]) {
          this._listener[event] = [];
      }
  
      var item = [callback, scope || window];
  
      this._listener[event].push(item);
  };
  
  /**
   * Unregister callback for given event.
   *
   * @param {String} event
   *      The event's name
   * @param {Function} callback
   *      The function to be exec as callback
   */
  exports.un = function (event, callback) {
      var listener = this._listener[event];
  
      if (!listener)
          return;
  
      for (var i = 0; i < listener.length; i++) {
          var fn = listener[i][0];
  
          if (fn == callback) {
              listener.splice(i, 1);
              break;
          }
      }
  };
  
  });
  