feat: split camera and mic permission requests into two fns (#3)

Author: Geoff Lawson

README.md

@@ -120,32 +120,62 @@ const { askForFullDiskAccess } = require('node-mac-permissions')
 askForFullDiskAccess()
 ```
 
-## `permissions.askForMediaAccess(type)`
+## `permissions.askForCameraAccess()`
 
-* `type` String - The type of media to which you are requesting access. Can be `microphone` or `camera`.
+Returns `Promise<String>` - Current permission status; can be `authorized`, `denied`, or `restricted`.
 
-Returns `Promise<String>` - Whether or not the request succeeded or failed; can be `authorized` or `denied`.
+Checks the authorization status for camera access. If the status check returns:
+
+- `not determined`, the camera access authorization will prompt the user to authorize or deny. The Promise is resolved after the user selection with either `authorized` or `denied`.
+- `denied`, the `Security & Privacy` System Preferences window is opened with the Camera privacy key highlighted. On open of the `Security & Privacy` window, the Promise is resolved as `denied`.
+- `restricted`, the Promise is resolved as `restricted`.
 
-Your app must provide an explanation for its use of capture devices using the `NSCameraUsageDescription` or `NSMicrophoneUsageDescription` `Info.plist` keys; Calling this method or attempting to start a capture session without a usage description raises an exception.
+Your app must provide an explanation for its use of capture devices using the `NSCameraUsageDescription` `Info.plist` key; Calling this method or attempting to start a capture session without a usage description raises an exception.
 
 ```
-<key>`NSCameraUsageDescription</key>
+<key>NSCameraUsageDescription</key>
 <string>Your reason for wanting to access the Camera</string>
-<key>`NSMicrophoneUsageDescription</key>
+```
+
+**Note:**
+
+- `status` will be resolved back as `authorized` prior to macOS 10.14 High Sierra, as access to the camera and microphone was unilaterally allowed until that version.
+
+Example:
+
+```js
+const { askForCameraAccess } = require("node-mac-permissions");
+
+const status = await askForCameraAccess();
+```
+
+## `permissions.askForMicrophoneAccess()`
+
+Returns `Promise<String>` - Current permission status; can be `authorized`, `denied`, or `restricted`.
+
+Checks the authorization status for microphone access. If the status check returns:
+
+- `not determined`, the microphone access authorization will prompt the user to authorize or deny. The Promise is resolved after the user selection with either `authorized` or `denied`.
+- `denied`, the `Security & Privacy` System Preferences window is opened with the Microphone privacy key highlighted. On open of the `Security & Privacy` window, the Promise is resolved as `denied`.
+- `restricted`, the Promise is resolved as `restricted`.
+
+Your app must provide an explanation for its use of capture devices using the `NSMicrophoneUsageDescription` `Info.plist` key; Calling this method or attempting to start a capture session without a usage description raises an exception.
+
+```
+<key>NSMicrophoneUsageDescription</key>
 <string>Your reason for wanting to access the Microphone</string>
 ```
 
-**Note:** `status` will be resolved back as `authorized` prior to macOS 10.14 High Sierra, as access to the camera and microphone was unilaterally allowed until that version.
+**Note:**
+
+- `status` will be resolved back as `authorized` prior to macOS 10.14 High Sierra, as access to the camera and microphone was unilaterally allowed until that version.
 
 Example:
+
 ```js
-const { askForMediaAccess } = require('node-mac-permissions')
+const { askForMicrophoneAccess } = require("node-mac-permissions");
 
-for (const type of ['microphone', 'camera']) {
-  askForMediaAccess(type).then(status => {
-    console.log(`Access to media type ${type} is ${status}`)
-  })
-}
+const status = await askForMicrophoneAccess();
 ```
 
 ## `permissions.askForScreenCaptureAccess()`

index.js

@@ -1,4 +1,4 @@
-const permissions = require('bindings')('permissions.node')
+const permissions = require('bindings')('permissions.node');
 
 function getAuthStatus(type) {
   const validTypes = [
@@ -10,31 +10,24 @@ function getAuthStatus(type) {
     'microphone',
     'accessibility',
     'location',
-    'screen'
-  ]
+    'screen',
+  ];
 
   if (!validTypes.includes(type)) {
-    throw new TypeError(`${type} is not a valid type`)
+    throw new TypeError(`${type} is not a valid type`);
   }
 
-  return permissions.getAuthStatus.call(this, type)
-}
-
-function askForMediaAccess(type) {
-  if (!['microphone', 'camera'].includes(type)) {
-    throw new TypeError(`${type} must be either 'camera' or 'microphone'`)
-  }
-
-  return permissions.askForMediaAccess.call(this, type)
+  return permissions.getAuthStatus.call(this, type);
 }
 
 module.exports = {
   askForCalendarAccess: permissions.askForCalendarAccess,
   askForContactsAccess: permissions.askForContactsAccess,
   askForFullDiskAccess: permissions.askForFullDiskAccess,
   askForRemindersAccess: permissions.askForRemindersAccess,
+  askForCameraAccess: permissions.askForCameraAccess,
+  askForMicrophoneAccess: permissions.askForMicrophoneAccess,
   askForScreenCaptureAccess: permissions.askForScreenCaptureAccess,
   askForAccessibilityAccess: permissions.askForAccessibilityAccess,
-  askForMediaAccess,
-  getAuthStatus
-}
+  getAuthStatus,
+};

package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-mac-permissions",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "A native node module to manage system permissions on macOS",
   "main": "index.js",
   "scripts": {

permissions.mm

@@ -283,28 +283,69 @@ void AskForFullDiskAccess(const Napi::CallbackInfo &info) {
   [workspace openURL:[NSURL URLWithString:pref_string]];
 }
 
-// Request access to either the Camera or the Microphone.
-Napi::Promise AskForMediaAccess(const Napi::CallbackInfo &info) {
+// Request Camera Access.
+Napi::Promise AskForCameraAccess(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
-  const std::string type = info[0].As<Napi::String>().Utf8Value();
   Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
-  Napi::ThreadSafeFunction ts_fn = Napi::ThreadSafeFunction::New(
-      env, Napi::Function::New(env, NoOp), "mediaAccessCallback", 0, 1,
-      [](Napi::Env) {});
+  Napi::ThreadSafeFunction ts_fn = Napi::ThreadSafeFunction::New(env, Napi::Function::New(env, NoOp), "cameraAccessCallback", 0, 1, [](Napi::Env) {});
 
   if (@available(macOS 10.14, *)) {
-    AVMediaType media_type =
-        (type == "microphone") ? AVMediaTypeAudio : AVMediaTypeVideo;
-    [AVCaptureDevice
-        requestAccessForMediaType:media_type
-                completionHandler:^(BOOL granted) {
-                  auto callback = [=](Napi::Env env, Napi::Function js_cb,
-                                      const char *granted) {
-                    deferred.Resolve(Napi::String::New(env, granted));
-                  };
-                  ts_fn.BlockingCall(granted ? "authorized" : "denied",
-                                     callback);
-                }];
+    std::string auth_status = MediaAuthStatus("camera");
+
+    if (auth_status == "not determined") {
+        [AVCaptureDevice requestAccessForMediaType:AVMediaTypeVideo completionHandler:^(BOOL granted) {
+          auto callback = [=](Napi::Env env, Napi::Function js_cb, const char *granted) {
+            deferred.Resolve(Napi::String::New(env, granted));
+          };
+
+          ts_fn.BlockingCall(granted ? "authorized" : "denied", callback);
+        }];  
+    } else if (auth_status == "denied"){
+      NSWorkspace *workspace = [[NSWorkspace alloc] init];
+      NSString *pref_string = @"x-apple.systempreferences:com.apple.preference.security?Privacy_Camera";
+  
+      [workspace openURL:[NSURL URLWithString:pref_string]];
+
+      deferred.Resolve(Napi::String::New(env, "denied"));
+    } else {
+      deferred.Resolve(Napi::String::New(env, auth_status));
+    }    
+  } else {
+    deferred.Resolve(Napi::String::New(env, "authorized"));
+  }
+
+  return deferred.Promise();
+}
+
+
+
+// Request Microphone Access.
+Napi::Promise AskForMicrophoneAccess(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+  Napi::ThreadSafeFunction ts_fn = Napi::ThreadSafeFunction::New(env, Napi::Function::New(env, NoOp), "microphoneAccessCallback", 0, 1, [](Napi::Env) {});
+
+  if (@available(macOS 10.14, *)) {
+    std::string auth_status = MediaAuthStatus("microphone");
+
+    if (auth_status == "not determined") {
+        [AVCaptureDevice requestAccessForMediaType:AVMediaTypeAudio completionHandler:^(BOOL granted) {
+          auto callback = [=](Napi::Env env, Napi::Function js_cb, const char *granted) {
+            deferred.Resolve(Napi::String::New(env, granted));
+          };
+
+          ts_fn.BlockingCall(granted ? "authorized" : "denied", callback);
+        }];  
+    } else if (auth_status == "denied") {
+      NSWorkspace *workspace = [[NSWorkspace alloc] init];
+      NSString *pref_string = @"x-apple.systempreferences:com.apple.preference.security?Privacy_Microphone";
+  
+      [workspace openURL:[NSURL URLWithString:pref_string]];
+
+      deferred.Resolve(Napi::String::New(env, "denied"));
+    } else {
+      deferred.Resolve(Napi::String::New(env, auth_status));
+    }
   } else {
     deferred.Resolve(Napi::String::New(env, "authorized"));
   }
@@ -347,8 +388,10 @@ void AskForAccessibilityAccess(const Napi::CallbackInfo &info) {
               Napi::Function::New(env, AskForRemindersAccess));
   exports.Set(Napi::String::New(env, "askForFullDiskAccess"),
               Napi::Function::New(env, AskForFullDiskAccess));
-  exports.Set(Napi::String::New(env, "askForMediaAccess"),
-              Napi::Function::New(env, AskForMediaAccess));
+  exports.Set(Napi::String::New(env, "askForCameraAccess"),  
+              Napi::Function::New(env, AskForCameraAccess));
+  exports.Set(Napi::String::New(env, "askForMicrophoneAccess"),  
+              Napi::Function::New(env, AskForMicrophoneAccess));
   exports.Set(Napi::String::New(env, "askForScreenCaptureAccess"),
               Napi::Function::New(env, AskForScreenCaptureAccess));
   exports.Set(Napi::String::New(env, "askForAccessibilityAccess"),

test/module.spec.js

@@ -1,7 +1,6 @@
 const { expect } = require('chai')
 const { 
   getAuthStatus,
-  askForMediaAccess
 } = require('../index')
 
 describe('node-mac-permissions', () => {
@@ -32,14 +31,4 @@ describe('node-mac-permissions', () => {
       }
     })
   })
-
-  describe('askForMediaAccess(type, callback)', () => {
-    it ('throws on invalid media types', () => {
-      expect(() => {
-        askForMediaAccess('bad-type').then(status =>{
-          console.log(status)
-        })
-      }).to.throw(/bad-type must be either 'camera' or 'microphone'/)
-    })
-  })
 })