community-cordova-plugin-dbmeter 2.2.0

package/.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true

package/.eslintrc

@@ -0,0 +1,15 @@
+{
+  "rules": {
+    "array-bracket-spacing": [ 2, "always" ],
+    "comma-dangle": [ 2, "never" ],
+    "eol-last": 2,
+    "indent": [ 2, 2, { "SwitchCase": 1 } ],
+    "no-multiple-empty-lines": 2,
+    "no-unused-vars": 2,
+    "object-curly-spacing": [ 2, "always" ],
+    "quotes": [ 2, "single", "avoid-escape" ],
+    "semi": 2,
+    "strict": 0,
+    "space-before-blocks": [ 2, "always" ]
+  }
+}

package/.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: eyalin

package/.travis.yml

@@ -0,0 +1,4 @@
+language: node_js
+sudo: false
+node_js:
+  - "4.2"

package/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work
+(an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including
+the original version of the Work and any modifications or additions
+to that Work or Derivative Works thereof, that is intentionally
+submitted to Licensor for inclusion in the Work by the copyright owner
+or by an individual or Legal Entity authorized to submit on behalf of
+the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems,
+and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the
+Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable
+by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You
+institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work
+or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate
+as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or
+Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+that You distribute, all copyright, patent, trademark, and
+attribution notices from the Source form of the Work,
+excluding those notices that do not pertain to any part of
+the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+distribution, then any Derivative Works that You distribute must
+include a readable copy of the attribution notices contained
+within such NOTICE file, excluding those notices that do not
+pertain to any part of the Derivative Works, in at least one
+of the following places: within a NOTICE text file distributed
+as part of the Derivative Works; within the Source form or
+documentation, if provided along with the Derivative Works; or,
+within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and
+do not modify the License. You may add Your own attribution
+notices within Derivative Works that You distribute, alongside
+or as an addendum to the NOTICE text from the Work, provided
+that such additional attribution notices cannot be construed
+as modifying the License.
+
+You may add Your own copyright statement to Your modifications and
+may provide additional or different license terms and conditions
+for use, reproduction, or distribution of Your modifications, or
+for any such Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work
+by You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses), even if such Contributor
+has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer,
+and charge a fee for, acceptance of support, warranty, indemnity,
+or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf
+of any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason
+of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following
+boilerplate notice, with the fields enclosed by brackets "{}"
+replaced with your own identifying information. (Don't include
+the brackets!)  The text should be enclosed in the appropriate
+comment syntax for the file format. We also recommend that a
+file or class name and description of purpose be included on the
+same "printed page" as the copyright notice for easier
+identification within third-party archives.
+
+Copyright {yyyy} {name of copyright owner}
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,109 @@
+[![NPM version](https://img.shields.io/npm/v/community-cordova-plugin-dbmeter)](https://www.npmjs.com/package/community-cordova-plugin-dbmeter)
+[![Downloads](https://img.shields.io/npm/dm/community-cordova-plugin-dbmeter)](https://www.npmjs.com/package/community-cordova-plugin-dbmeter)
+
+#### This is a fork of the original plugin cordova-plugin-dbmeter
+
+# community-cordova-plugin-dbmeter
+
+This plugin defines a global DBMeter object, which permits to get the decibel values from the microphone.
+Although the object is in the global scope, it is not available until after the deviceready event.
+
+```
+document.addEventListener("deviceready", onDeviceReady, false);
+function onDeviceReady() {
+    DBMeter.start(function(dB){
+        console.log(dB);
+    });
+}
+```
+
+## Installation
+
+```
+cordova plugin add cordova-plugin-add-swift-support
+cordova plugin add community-cordova-plugin-dbmeter
+```
+The iOS part is written in Swift so the [Swift support plugin](https://github.com/akofman/cordova-plugin-add-swift-support) is needed.
+
+## Supported Platforms
+
+ - iOS
+ - Android
+
+## iOS Quirks
+
+ Since iOS 10 it's mandatory to provide an usage description in the info.plist if trying to access privacy-sensitive data. When the system prompts the user to allow access, this usage description string will displayed as part of the permission dialog box, but if you didn't provide the usage description, the app will crash before showing the dialog. Also, Apple will reject apps that access private data but don't provide an usage description.
+
+ This plugins requires the following usage description:
+
+ - NSMicrophoneUsageDescription describes the reason the app accesses the user's microphone.
+
+ To add this entry into the info.plist, you can use the `edit-config` tag in the platform section of your `config.xml` like this:
+
+```
+<edit-config target="NSMicrophoneUsageDescription" file="*-Info.plist" mode="merge">
+    <string>need microphone access to record sounds</string>
+</edit-config>
+```
+
+## Methods
+
+## `DBMeter.start(success, error)`
+start listening.
+
+```
+DBMeter.start(function(dB){
+  console.log(dB);
+}, function(e){
+  console.log('code: ' + e.code + ', message: ' + e.message);
+});
+```
+
+## `DBMeter.stop(success, error)`
+stop listening.
+
+```
+DBMeter.stop(function(){
+  console.log("DBMeter well stopped");
+}, function(e){
+  console.log('code: ' + e.code + ', message: ' + e.message);  
+});
+```
+
+:warning: If the DBMeter is stopped while is not listening, an error will be
+triggered and can be handle from the second callback argument.
+
+## `DBMeter.isListening(success, error)`
+retrieve from the success callback whether
+the DBMeter is listening.
+
+```
+DBMeter.isListening(function(isListening){
+  console.log(isListening);
+});
+```
+
+## `DBMeter.delete(success, error)`
+delete the DBMeter instance.
+
+```
+DBMeter.delete(function(){
+  console.log("Well done !");
+}, function(e){
+  console.log('code: ' + e.code + ', message: ' + e.message);  
+});
+```
+:warning: If the DBMeter has not been started once before deleting, an error will be
+triggered and can be handle from the second callback argument.
+
+## App
+
+An app is available in the app folder and is generated from the [Cordova Plugin Test Framework](https://github.com/apache/cordova-plugin-test-framework).
+It permits to launch auto tests and manual tests.
+
+To install it, please follow these steps :
+
+```
+cd app && cordova platform add android|ios
+cordova run android|ios --device
+```

package/dbmeter.js

@@ -0,0 +1,68 @@
+var DBMeter = {
+
+  /**
+  * Delete the plugin.
+  * Remove its native instance from the memory.
+  *
+  * @param  {success} callback in case of success
+  * @param  {error} callback in case of error
+  */
+  delete: function(success, error) {
+    cordova.exec(
+      success,
+      error,
+      'DBMeter', 'destroy', []
+    );
+  },
+
+  /**
+  * Starts listening the audio signal.
+  *
+  * Returns the current decibel value from the success callback parameter
+  * as a float value.
+  * @param  {success} callback in case of success
+  * @param  {error} callback in case of error
+  */
+  start: function(success, error) {
+    cordova.exec(
+      success,
+      error,
+      'DBMeter', 'start', []
+    );
+  },
+
+  /**
+  * Stops listening any audio signal.
+  *
+  * @param  {success} callback in case of success
+  * @param  {error} callback in case of error
+  */
+  stop: function(success, error) {
+    cordova.exec(
+      success,
+      error,
+      'DBMeter', 'stop', []
+    );
+  },
+
+  /**
+  * Returns whether the DBMeter is listening.
+  *
+  * @param  {success} callback in case of success
+  * @param  {error} callback in case of error
+  */
+  isListening: function(success, error) {
+    cordova.exec(
+      success,
+      error,
+      'DBMeter', 'isListening', []
+    );
+  }
+};
+
+DBMeter.ERROR_CODES = {
+  '0':'DBMETER_NOT_INITIALIZED',
+  '1':'DBMETER_NOT_LISTENING'
+};
+
+module.exports = DBMeter;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "community-cordova-plugin-dbmeter",
+  "version": "2.2.0",
+  "description": "Cordova DBMeter plugin",
+  "author": {
+    "name": "Alexis Kofman"
+  },
+  "license": "Apache-2.0",
+  "cordova": {
+    "id": "community-cordova-plugin-dbmeter",
+    "platforms": [
+      "ios",
+      "android"
+    ]
+  },
+  "repository": "EYALIN/community-cordova-plugin-dbmeter/tree/master",
+  "homepage": "https://github.com/EYALIN/community-cordova-plugin-dbmeter/tree/master",
+  "funding": "https://github.com/sponsors/EYALIN",
+  "keywords": [
+    "cordova",
+    "ios",
+    "android",
+    "dbmeter",
+    "audio",
+    "volume",
+    "sound",
+    "decibel",
+    "ecosystem:cordova",
+    "cordova-ios",
+    "cordova-android",
+    "cordova:plugin"
+  ]
+}

package/plugin.xml

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0" id="community-cordova-plugin-dbmeter" version="2.2.0">
+
+  <name>DBMeter</name>
+  <license>Apache 2.0</license>
+  <description>Cordova DBMeter plugin</description>
+  <keywords>cordova,phonegap,volume,sound,audio,decibel</keywords>
+
+  <platform name="android">
+    <config-file target="AndroidManifest.xml" parent="/*">
+      <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    </config-file>
+
+    <config-file target="res/xml/config.xml" parent="/*">
+      <feature name="DBMeter">
+        <param name="android-package" value="org.apache.cordova.dbmeter.DBMeter"/>
+      </feature>
+    </config-file>
+
+    <source-file src="src/android/DBMeter.java" target-dir="src/org/apache/cordova/dbmeter" />
+    <source-file src="src/android/PermissionHelper.java" target-dir="src/org/apache/cordova/dbmeter" />
+  </platform>
+
+  <platform name="ios">
+    <config-file target="config.xml" parent="/*">
+      <feature name="DBMeter">
+        <param name="ios-package" value="DBMeter" />
+      </feature>
+    </config-file>
+
+    <source-file src="src/ios/DBMeter.swift" />
+  </platform>
+
+  <js-module src="dbmeter.js" name="DBMeter">
+    <clobbers target="DBMeter" />
+  </js-module>
+</plugin>

package/src/android/DBMeter.java

@@ -0,0 +1,200 @@
+package org.apache.cordova.dbmeter;
+
+import android.Manifest;
+import android.media.AudioFormat;
+import android.media.AudioManager;
+import android.media.AudioRecord;
+import android.media.AudioTrack;
+import android.media.MediaRecorder;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.LOG;
+import org.apache.cordova.PluginResult;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+/**
+ * This plugin provides the decibel level from the microphone.
+ */
+public class DBMeter extends CordovaPlugin {
+
+    private static final String LOG_TAG = "DBMeter";
+    private static final int REQ_CODE = 0;
+    private AudioRecord audioRecord;
+    private short[] buffer;
+    private Timer timer;
+    private boolean isListening = false;
+
+
+    @Override
+    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+        //LOG.setLogLevel(LOG.DEBUG);
+
+        if (!PermissionHelper.hasPermission(this, Manifest.permission.RECORD_AUDIO)) {
+            PermissionHelper.requestPermission(this, REQ_CODE, Manifest.permission.RECORD_AUDIO);
+        } else {
+            if (action.equals("start")) {
+                this.start(callbackContext);
+            } else if (action.equals("stop")) {
+                this.stop(callbackContext);
+            } else if (action.equals("isListening")) {
+                this.isListening(callbackContext);
+            } else if (action.equals("destroy")) {
+                this.destroy(callbackContext);
+            } else {
+                LOG.e(LOG_TAG, "Not a valid action: " + action);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Permits to free the memory from the audioRecord instance
+     *
+     * @param callbackContext The callback context used when calling back into JavaScript.
+     */
+    public void destroy(CallbackContext callbackContext) {
+        if (this.audioRecord != null) {
+            this.isListening = false;
+            this.audioRecord.stop();
+            this.audioRecord = null;
+            if (this.timer != null) {
+                this.timer.cancel();
+                this.timer = null;
+            }
+            callbackContext.success();
+        } else {
+            sendPluginError(callbackContext, PluginError.DBMETER_NOT_INITIALIZED, "DBMeter is not initialized");
+        }
+    }
+
+    /**
+     * Starts listening the audio signal and sends dB values as a
+     * {@link org.apache.cordova.PluginResult PluginResult} using a
+     * {@link java.util.TimerTask TimerTask}.
+     *
+     * @param callbackContext The callback context used when calling back into JavaScript.
+     */
+    public void start(final CallbackContext callbackContext) {
+        final DBMeter that = this;
+        cordova.getThreadPool().execute(new Runnable() {
+            public void run() {
+                if (that.audioRecord == null) {
+                    that.isListening = false;
+                    int rate = AudioTrack.getNativeOutputSampleRate(AudioManager.STREAM_SYSTEM);
+                    int bufferSize = AudioRecord.getMinBufferSize(rate, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT);
+
+                    that.audioRecord = new AudioRecord(
+                            MediaRecorder.AudioSource.MIC,
+                            rate,
+                            AudioFormat.CHANNEL_IN_MONO,
+                            AudioFormat.ENCODING_PCM_16BIT,
+                            bufferSize);
+
+                    that.buffer = new short[bufferSize];
+                }
+                if (!that.isListening) {
+                    that.isListening = true;
+                    that.audioRecord.startRecording();
+
+                    that.timer = new Timer(LOG_TAG, true);
+
+                    //start calling run in a timertask
+                    TimerTask timerTask = new TimerTask() {
+                        public void run() {
+                            int readSize = that.audioRecord.read(that.buffer, 0, that.buffer.length);
+                            double db = 0;
+                            double maxAmplitude = 0;
+                            for (int i = 0; i < readSize; i++) {
+                                if (Math.abs(that.buffer[i]) > maxAmplitude) {
+                                    maxAmplitude = Math.abs(that.buffer[i]);
+                                }
+                            }
+
+                            if (maxAmplitude != 0) {
+                                db = 20.0 * Math.log10(maxAmplitude / 32767.0) + 90;
+                            }
+
+                            LOG.d(LOG_TAG, Double.toString(db));
+
+                            PluginResult result = new PluginResult(PluginResult.Status.OK, (float) db);
+                            result.setKeepCallback(true);
+                            callbackContext.sendPluginResult(result);
+                        }
+                    };
+                    that.timer.scheduleAtFixedRate(timerTask, 0, 100);
+                }
+            }
+        });
+    }
+
+    /**
+     * Stops listening the audio signal.
+     * Even if stopped, the {@link android.media.AudioRecord AudioRecord} instance still exist.
+     * To destroy this instance, please use the {@link #destroy(CallbackContext) destroy} method.
+     *
+     * @param callbackContext The callback context used when calling back into JavaScript.
+     */
+    public void stop(final CallbackContext callbackContext) {
+        final DBMeter that = this;
+        cordova.getThreadPool().execute(new Runnable() {
+            public void run() {
+                if (that.isListening) {
+                    that.isListening = false;
+
+
+                    if (that.timer != null) {
+                        that.timer.cancel();
+                    }
+                    if (that.audioRecord != null) {
+                        that.audioRecord.stop();
+                    }
+                    callbackContext.success();
+
+                } else {
+                    sendPluginError(callbackContext, PluginError.DBMETER_NOT_LISTENING, "DBMeter is not listening");
+                }
+            }
+        });
+    }
+
+    /**
+     * Returns whether the DBMeter is listening.
+     *
+     * @param callbackContext The callback context used when calling back into JavaScript.
+     */
+    public void isListening(final CallbackContext callbackContext) {
+        PluginResult result = new PluginResult(PluginResult.Status.OK, this.isListening);
+        callbackContext.sendPluginResult(result);
+    }
+
+    /**
+     * Convenient method to send plugin errors.
+     *
+     * @param callbackContext The callback context used when calling back into JavaScript.
+     * @param error           The error code to return
+     * @param message         The error message to return
+     */
+    private void sendPluginError(CallbackContext callbackContext, PluginError error, String message) {
+        JSONObject jsonObject = new JSONObject();
+        try {
+            jsonObject.put("code", error.ordinal());
+            jsonObject.put("message", message);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        callbackContext.error(jsonObject);
+    }
+
+    public enum PluginError {
+        DBMETER_NOT_INITIALIZED,
+        DBMETER_NOT_LISTENING
+    }
+}

package/src/android/PermissionHelper.java

@@ -0,0 +1,138 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.apache.cordova.dbmeter;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.LOG;
+
+import android.content.pm.PackageManager;
+
+/**
+ * This class provides reflective methods for permission requesting and checking so that plugins
+ * written for cordova-android 5.0.0+ can still compile with earlier cordova-android versions.
+ */
+public class PermissionHelper {
+    private static final String LOG_TAG = "CordovaPermissionHelper";
+
+    /**
+     * Requests a "dangerous" permission for the application at runtime. This is a helper method
+     * alternative to cordovaInterface.requestPermission() that does not require the project to be
+     * built with cordova-android 5.0.0+
+     *
+     * @param plugin        The plugin the permission is being requested for
+     * @param requestCode   A requestCode to be passed to the plugin's onRequestPermissionResult()
+     *                      along with the result of the permission request
+     * @param permission    The permission to be requested
+     */
+    public static void requestPermission(CordovaPlugin plugin, int requestCode, String permission) {
+        PermissionHelper.requestPermissions(plugin, requestCode, new String[] {permission});
+    }
+
+    /**
+     * Requests "dangerous" permissions for the application at runtime. This is a helper method
+     * alternative to cordovaInterface.requestPermissions() that does not require the project to be
+     * built with cordova-android 5.0.0+
+     *
+     * @param plugin        The plugin the permissions are being requested for
+     * @param requestCode   A requestCode to be passed to the plugin's onRequestPermissionResult()
+     *                      along with the result of the permissions request
+     * @param permissions   The permissions to be requested
+     */
+    public static void requestPermissions(CordovaPlugin plugin, int requestCode, String[] permissions) {
+        try {
+            Method requestPermission = CordovaInterface.class.getDeclaredMethod(
+                    "requestPermissions", CordovaPlugin.class, int.class, String[].class);
+
+            // If there is no exception, then this is cordova-android 5.0.0+
+            requestPermission.invoke(plugin.cordova, plugin, requestCode, permissions);
+        } catch (NoSuchMethodException noSuchMethodException) {
+            // cordova-android version is less than 5.0.0, so permission is implicitly granted
+            LOG.d(LOG_TAG, "No need to request permissions " + Arrays.toString(permissions));
+
+            // Notify the plugin that all were granted by using more reflection
+            deliverPermissionResult(plugin, requestCode, permissions);
+        } catch (IllegalAccessException illegalAccessException) {
+            // Should never be caught; this is a public method
+            LOG.e(LOG_TAG, "IllegalAccessException when requesting permissions " + Arrays.toString(permissions), illegalAccessException);
+        } catch(InvocationTargetException invocationTargetException) {
+            // This method does not throw any exceptions, so this should never be caught
+            LOG.e(LOG_TAG, "invocationTargetException when requesting permissions " + Arrays.toString(permissions), invocationTargetException);
+        }
+    }
+
+    /**
+     * Checks at runtime to see if the application has been granted a permission. This is a helper
+     * method alternative to cordovaInterface.hasPermission() that does not require the project to
+     * be built with cordova-android 5.0.0+
+     *
+     * @param plugin        The plugin the permission is being checked against
+     * @param permission    The permission to be checked
+     *
+     * @return              True if the permission has already been granted and false otherwise
+     */
+    public static boolean hasPermission(CordovaPlugin plugin, String permission) {
+        try {
+            Method hasPermission = CordovaInterface.class.getDeclaredMethod("hasPermission", String.class);
+
+            // If there is no exception, then this is cordova-android 5.0.0+
+            return (Boolean) hasPermission.invoke(plugin.cordova, permission);
+        } catch (NoSuchMethodException noSuchMethodException) {
+            // cordova-android version is less than 5.0.0, so permission is implicitly granted
+            LOG.d(LOG_TAG, "No need to check for permission " + permission);
+            return true;
+        } catch (IllegalAccessException illegalAccessException) {
+            // Should never be caught; this is a public method
+            LOG.e(LOG_TAG, "IllegalAccessException when checking permission " + permission, illegalAccessException);
+        } catch(InvocationTargetException invocationTargetException) {
+            // This method does not throw any exceptions, so this should never be caught
+            LOG.e(LOG_TAG, "invocationTargetException when checking permission " + permission, invocationTargetException);
+        }
+        return false;
+    }
+
+    private static void deliverPermissionResult(CordovaPlugin plugin, int requestCode, String[] permissions) {
+        // Generate the request results
+        int[] requestResults = new int[permissions.length];
+        Arrays.fill(requestResults, PackageManager.PERMISSION_GRANTED);
+
+        try {
+            Method onRequestPermissionResult = CordovaPlugin.class.getDeclaredMethod(
+                    "onRequestPermissionResult", int.class, String[].class, int[].class);
+
+            onRequestPermissionResult.invoke(plugin, requestCode, permissions, requestResults);
+        } catch (NoSuchMethodException noSuchMethodException) {
+            // Should never be caught since the plugin must be written for cordova-android 5.0.0+ if it
+            // made it to this point
+            LOG.e(LOG_TAG, "NoSuchMethodException when delivering permissions results", noSuchMethodException);
+        } catch (IllegalAccessException illegalAccessException) {
+            // Should never be caught; this is a public method
+            LOG.e(LOG_TAG, "IllegalAccessException when delivering permissions results", illegalAccessException);
+        } catch(InvocationTargetException invocationTargetException) {
+            // This method may throw a JSONException. We are just duplicating cordova-android's
+            // exception handling behavior here; all it does is log the exception in CordovaActivity,
+            // print the stacktrace, and ignore it
+            LOG.e(LOG_TAG, "InvocationTargetException when delivering permissions results", invocationTargetException);
+        }
+    }
+}

package/src/ios/DBMeter.swift

@@ -0,0 +1,158 @@
+import Foundation
+import AVFoundation
+
+@objc(DBMeter) class DBMeter : CDVPlugin {
+
+    private let LOG_TAG = "DBMeter"
+    private let REQ_CODE = 0
+    private var isListening: Bool = false
+    private var audioRecorder: AVAudioRecorder!
+    private var command: CDVInvokedUrlCommand!
+    private var timer: DispatchSourceTimer!
+    private var isTimerExists: Bool = false
+
+    /**
+     This plugin provides the decibel level from the microphone.
+     */
+    init(commandDelegate: CDVCommandDelegate) {
+        super.init()
+        self.commandDelegate = commandDelegate
+    }
+
+    override init() {
+    }
+  
+    /**
+     Permits to free the memory from the audioRecord instance
+     */
+    @objc(destroy:)
+    func destroy(command: CDVInvokedUrlCommand) {
+        if (self.isListening) {
+            self.timer.suspend()
+            self.isListening = false
+        }
+
+        self.command = nil
+
+        if (self.audioRecorder != nil) {
+
+            self.audioRecorder.stop()
+            self.audioRecorder = nil
+
+            let pluginResult = CDVPluginResult(status: CDVCommandStatus_OK)
+            self.commandDelegate!.send(pluginResult, callbackId: command.callbackId)
+        } else {
+            self.sendPluginError(callbackId: command.callbackId, errorCode: PluginError.DBMETER_NOT_INITIALIZED, errorMessage: "DBMeter is not initialized")
+        }
+    }
+
+    /**
+     Starts listening the audio signal and sends dB values as a
+     CDVPluginResult keeping the same calback alive.
+     */
+    @objc(start:)
+    func start(command: CDVInvokedUrlCommand) {
+        self.commandDelegate!.run(inBackground:{
+            self.command = command
+
+            if (!self.isTimerExists) {
+                self.timer = DispatchSource.makeTimerSource(queue: DispatchQueue.main)
+                self.timer.scheduleRepeating(deadline: .now(), interval: DispatchTimeInterval.milliseconds(300))
+                self.timer.setEventHandler(handler: self.timerCallBack)
+                self.isTimerExists = true
+            }
+
+            if (self.audioRecorder == nil) {
+                let url: URL = URL.init(fileURLWithPath: "/dev/null")
+
+                let settings : [String:Any] = [
+                    AVFormatIDKey: Int(kAudioFormatAppleLossless),
+                    AVSampleRateKey: 44100.0,
+                    AVNumberOfChannelsKey: 1 as NSNumber,
+                    AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
+                ]
+
+                do {
+                    let audioSession: AVAudioSession = AVAudioSession.sharedInstance()
+                    try audioSession.setCategory(AVAudioSession.Category.playAndRecord)
+                    try audioSession.setActive(true)
+
+                    self.audioRecorder = try AVAudioRecorder(url: url, settings: settings)
+                    self.audioRecorder.isMeteringEnabled = true
+                } catch {
+                    self.sendPluginError(callbackId: command.callbackId, errorCode: PluginError.DBMETER_NOT_INITIALIZED, errorMessage: "Error while initializing DBMeter")
+                }
+            }
+            if (!self.isListening) {
+                self.isListening = true
+                self.audioRecorder.record()
+
+                self.timer.resume()
+            }
+        })
+    }
+
+    /**
+     Stops listening the audio signal.
+     Even if stopped, the AVAudioRecorder instance still exist.
+     To destroy this instance, please use the destroy method.
+     */
+    @objc(stop:)
+    public func stop(command: CDVInvokedUrlCommand) {
+        self.commandDelegate!.run(inBackground: {
+            if (self.isListening) {
+                self.isListening = false
+
+                if (self.audioRecorder != nil && self.audioRecorder.isRecording) {
+                    self.timer.suspend()
+                    self.audioRecorder.stop()
+                }
+
+                let pluginResult = CDVPluginResult(status: CDVCommandStatus_OK)
+                self.commandDelegate!.send(pluginResult, callbackId: command.callbackId)
+            } else {
+                self.sendPluginError(callbackId: command.callbackId, errorCode: PluginError.DBMETER_NOT_LISTENING, errorMessage: "DBMeter is not listening")
+            }
+        })
+    }
+
+    /**
+     Returns whether the DBMeter is listening.
+     */
+    @objc(isListening:)
+    func isListening(command: CDVInvokedUrlCommand?) -> Bool {
+        if (command != nil) {
+            let pluginResult = CDVPluginResult(status: CDVCommandStatus_OK, messageAs: self.isListening)
+            self.commandDelegate!.send(pluginResult, callbackId: command!.callbackId)
+        }
+        return self.isListening;
+    }
+
+    private func timerCallBack() {
+        autoreleasepool {
+            if (self.isListening && self.audioRecorder != nil) {
+                self.audioRecorder.updateMeters()
+
+                let peakPowerForChannel = pow(10, (self.audioRecorder.averagePower(forChannel: 0) / 20))
+                let db = Int32(round(20 * log10(peakPowerForChannel) + 90))
+
+                let pluginResult = CDVPluginResult(status: CDVCommandStatus_OK, messageAs: db)
+                pluginResult!.setKeepCallbackAs(true)
+                self.commandDelegate!.send(pluginResult, callbackId: self.command.callbackId)
+            }
+        }
+    }
+
+    /**
+     Convenient method to send plugin errors.
+     */
+    private func sendPluginError(callbackId: String, errorCode: PluginError, errorMessage: String) {
+        let pluginResult = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: ["code": errorCode.hashValue, "message": errorMessage])
+        self.commandDelegate!.send(pluginResult, callbackId: callbackId)
+    }
+
+    enum PluginError: String {
+        case DBMETER_NOT_INITIALIZED = "0"
+        case DBMETER_NOT_LISTENING = "1"
+    }
+}

package/tests/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "cordova-plugin-dbmeter-tests",
+  "version": "1.0.0-dev"
+}

package/tests/plugin.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
+  id="cordova-plugin-dbmeter-tests"
+  version="1.0.0-dev">
+  <name>Cordova DBMeter Plugin Tests</name>
+  <license>Apache 2.0</license>
+
+  <js-module src="tests.js" name="tests">
+  </js-module>
+</plugin>

package/tests/tests.js

@@ -0,0 +1,212 @@
+exports.defineAutoTests = function() {
+  var fail = function (done) {
+    expect(false).toBe(true);
+    done();
+  };
+
+  describe('DBMeter (window.DBMeter)', function () {
+    it('should exist', function() {
+      expect(window.DBMeter).toBeDefined();
+    });
+
+    it('should contain a start function', function () {
+      expect(typeof window.DBMeter.start).toBeDefined();
+      expect(typeof window.DBMeter.start === 'function').toBe(true);
+    });
+
+    it('should contain a stop function', function () {
+      expect(typeof window.DBMeter.stop).toBeDefined();
+      expect(typeof window.DBMeter.stop === 'function').toBe(true);
+    });
+
+    it('should contain a isListening function', function () {
+      expect(typeof window.DBMeter.isListening).toBeDefined();
+      expect(typeof window.DBMeter.isListening === 'function').toBe(true);
+    });
+
+    it('should contain a delete function', function () {
+      expect(typeof window.DBMeter.delete).toBeDefined();
+      expect(typeof window.DBMeter.delete === 'function').toBe(true);
+    });
+  });
+
+  describe('start method', function () {
+
+    it('should start the DBMeter', function (done) {
+      var started = false;
+
+      window.DBMeter.start(function() {
+        if(!started) {
+          started = true;
+          window.DBMeter.isListening(function(result) {
+            expect(result).toBe(true);
+            done();
+          }, fail.bind(null, done));
+        }
+      }, fail.bind(null, done));
+    });
+
+    it('should return dB if we start the DBMeter', function (done) {
+      var started = false;
+
+      window.DBMeter.delete(function() {
+        window.DBMeter.start(function(dB) {
+          if(!started) {
+            started = true;
+            window.DBMeter.stop(function() {
+              expect(dB).not.toBe(null);
+              done();
+            });
+          }
+        }, fail.bind(null, done));
+      }, fail.bind(null, done));
+    });
+  });
+
+  describe('stop method', function () {
+
+    it('should stop the DBMeter', function (done) {
+      var started = false;
+
+      window.DBMeter.delete(function() {
+        window.DBMeter.start(function() {
+          if(!started) {
+            started = true;
+            window.DBMeter.stop(function() {
+              window.DBMeter.isListening(function(result) {
+                expect(result).toBe(false);
+                done();
+              }, fail.bind(null, done));
+            }, fail.bind(null, done));
+          }
+        }, fail.bind(null, done));
+      }, fail.bind(null, done));
+    });
+
+    describe('error callback', function () {
+
+      it('should be called if we stop the DBMeter while it is not started, the expected error should have the code 1', function (done) {
+        window.DBMeter.delete(function() {
+          window.DBMeter.stop(fail.bind(null, done), function(e) {
+            expect(e.code).toBe(1);
+            done();
+          }, fail.bind(null, done));
+        });
+      });
+    });
+  });
+
+  describe('delete method', function () {
+
+    it('should delete the DBMeter instance', function (done) {
+      var started = false;
+
+      window.DBMeter.start(function() {
+        if(!started) {
+          started = true;
+          window.DBMeter.isListening(function(result) {
+            expect(result).toBe(true);
+            window.DBMeter.delete(function() {
+              window.DBMeter.isListening(function(result) {
+                expect(result).toBe(false);
+                done();
+              }, fail.bind(null, done));
+            }, fail.bind(null, done));
+          }, fail.bind(null, done));
+        }
+      }, fail.bind(null, done));
+    });
+
+    describe('error callback', function () {
+      it('should be called if we delete the DBMeter while it is not initialized, the expected error should have the code 0', function (done) {
+        window.DBMeter.delete(fail.bind(null, done), function(e) {
+          expect(e.code).toBe(0);
+          done();
+        }, fail.bind(null, done));
+      });
+    });
+  });
+
+  describe('isListening method', function () {
+
+    it('should return false if the DBMeter is not initialized', function (done) {
+      window.DBMeter.isListening(function(result) {
+        expect(result).toBe(false);
+        done();
+      }, fail.bind(null, done));
+    });
+
+    it('should return true if the DBMeter is listening', function (done) {
+      var started = false;
+
+      window.DBMeter.start(function() {
+        if(!started) {
+          started = true;
+          window.DBMeter.isListening(function(result) {
+            expect(result).toBe(true);
+            done();
+          });
+          window.DBMeter.stop();
+          window.DBMeter.delete();
+        }
+      }, fail.bind(null, done));
+    });
+  });
+};
+
+exports.defineManualTests = function(contentEl, createActionButton) {
+
+  contentEl.innerHTML = '<div class="decibelBarContainer">'
+  + '<div class="decibelBar"></div>'
+  + '</div>'
+  + '<div class="decibel">0dB</div>';
+
+  var decibelBarContainer = document.querySelector('.decibelBarContainer');
+  var decibelBar = document.querySelector('.decibelBar');
+  var decibel = document.querySelector('.decibel');
+
+
+  decibelBarContainer.style.display = '-webkit-flex';
+  decibelBarContainer.style.display = 'flex';
+  decibelBarContainer.style.width = '50px';
+  decibelBarContainer.style.WebkitTransform = 'translateX(-50%)';
+  decibelBarContainer.style.marginLeft = '50%';
+  decibelBarContainer.style.position = 'absolute';
+  decibelBarContainer.style.top = '140px';
+  decibelBarContainer.style.height = '200px';
+
+  decibel.style.padding = '50px';
+  decibel.style.fontSize = '100px';
+  decibel.style.WebkitTransform = 'translateX(-50%)';
+  decibel.style.marginLeft = '50%';
+  decibel.style.position= 'absolute';
+  decibel.style.top = '300px';
+  decibel.style.textTransform = 'none';
+
+  decibelBar.style.background ='linear-gradient(to top, #009bca 0px, #009bca 25px, #009182 50px, #009182 100px, #009182 200px)';
+  decibelBar.style.flex = '0 1 auto';
+  decibelBar.style.alignSelf = 'flex-end';
+  decibelBar.style.WebkitFlex = '0 1 auto';
+  decibelBar.style.WebkitAlignSelf = 'flex-end';
+  decibelBar.style.width = '100%';
+  decibelBar.style.height = '2px';
+
+  createActionButton('Start DBMeter', function() {
+    DBMeter.start(function(dB) {
+      decibelBar.style.height = parseFloat(dB, 10) + '%';
+      decibel.innerHTML = parseInt(dB, 10) + 'dB';
+    }, function(e) {
+      console.log('code: ' + e.code + ', message: ' + e.message);
+    });
+  });
+
+  createActionButton('Stop DBMeter', function() {
+    DBMeter.stop(function() {
+      decibelBar.style.height = '0';
+      decibel.innerHTML = '0dB';
+    }, function(e) {
+      console.log('code: ' + e.code + ', message: ' + e.message);
+    });
+  });
+
+};