applied some code review comments

13 files changed, 78 insertions, 72 deletions

diff --git a/Example Apps/Example ObjC/RPCPermissionsManager.m b/Example Apps/Example ObjC/RPCPermissionsManager.m
index da00253fd..634f6239d 100644
--- a/Example Apps/Example ObjC/RPCPermissionsManager.m
+++ b/Example Apps/Example ObjC/RPCPermissionsManager.m
@@ -28,19 +28,19 @@ NS_ASSUME_NONNULL_BEGIN
     SDLPermissionElement *createInteractionPermissionElement = [[SDLPermissionElement alloc] initWithRPCName:SDLRPCFunctionNameCreateInteractionChoiceSet parameterPermissions:nil];
     SDLPermissionElement *performInteractionPermissionElement = [[SDLPermissionElement alloc] initWithRPCName:SDLRPCFunctionNamePerformInteraction parameterPermissions:nil];
     NSArray<SDLPermissionElement *> *menuRPCPermissions = @[addCommandPermissionElement, createInteractionPermissionElement, performInteractionPermissionElement];
-    [self sdlex_checkCurrentGroupPermissionsWithManager:manager rpcNames:menuRPCNames];
+    [self sdlex_checkCurrentGroupPermissionsWithManager:manager rpcNames:menuRPCPermissions];
 
     // Set up an observer for permissions changes to media template releated RPCs. Since the `groupType` is set to all allowed, this block is called when the group permissions changes from all allowed. This block is called immediately when created.
     SDLPermissionElement *setMediaClockPermissionElement = [[SDLPermissionElement alloc] initWithRPCName:SDLRPCFunctionNameSetMediaClockTimer parameterPermissions:nil];
     SDLPermissionElement *subscribeButtonPermissionElement = [[SDLPermissionElement alloc] initWithRPCName:SDLRPCFunctionNameSubscribeButton parameterPermissions:nil];
     NSArray<SDLPermissionElement *> *mediaTemplateRPCPermissions = @[setMediaClockPermissionElement, subscribeButtonPermissionElement];
-    SDLPermissionObserverIdentifier allAllowedObserverId = [self sdlex_subscribeGroupPermissionsWithManager:manager rpcNames:mediaTemplateRPCs groupType:SDLPermissionGroupTypeAllAllowed];
+    SDLPermissionObserverIdentifier allAllowedObserverId = [self sdlex_subscribeGroupPermissionsWithManager:manager rpcNames:mediaTemplateRPCPermissions groupType:SDLPermissionGroupTypeAllAllowed];
 
     // Stop observing permissions changes for the media template releated RPCs
     [self sdlex_unsubscribeGroupPermissionsWithManager:manager observerId:allAllowedObserverId];
 
     // Set up an observer for permissions changes to media template releated RPCs. Since the `groupType` is set to any, this block is called when the permission status changes for any of the RPCs being observed. This block is called immediately when created.
-    [self sdlex_subscribeGroupPermissionsWithManager:manager rpcNames:mediaTemplateRPCs groupType:SDLPermissionGroupTypeAny];
+    [self sdlex_subscribeGroupPermissionsWithManager:manager rpcNames:mediaTemplateRPCPermissions groupType:SDLPermissionGroupTypeAny];
 }
 
 /**
@@ -80,7 +80,7 @@ NS_ASSUME_NONNULL_BEGIN
  */
 + (SDLPermissionGroupStatus)sdlex_checkCurrentGroupPermissionsWithManager:(SDLManager *)manager rpcNames:(NSArray<SDLPermissionElement *> *)rpcNames {
     SDLPermissionGroupStatus groupPermissionStatus = [manager.permissionManager groupStatusOfRPCNames:rpcNames];
-    NSDictionary<NSString *, SDLRPCPermissionStatus *> *individualPermissionStatuses = [manager.permissionManager statusesOfRPCNames:rpcNames];
+    NSDictionary<NSString *, SDLRPCPermissionStatus *> *individualPermissionStatuses = [manager.permissionManager statusesOfRPCPermissions:rpcNames];
     [self sdlex_logRPCGroupPermissions:rpcNames groupPermissionStatus:groupPermissionStatus individualPermissionStatuses:individualPermissionStatuses];
     return groupPermissionStatus;
 }
@@ -96,7 +96,7 @@ NS_ASSUME_NONNULL_BEGIN
  *  @return             A unique identifier for the subscription. This can be used to later to unsubscribe from the notifications.
  */
 + (SDLPermissionObserverIdentifier)sdlex_subscribeGroupPermissionsWithManager:(SDLManager *)manager rpcNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType {
-    SDLPermissionObserverIdentifier observerId = [manager.permissionManager subscribeToRPCNames:rpcNames groupType:groupType withHandler:^(NSDictionary<SDLPermissionRPCName,SDLRPCPermissionStatus *> * _Nonnull change, SDLPermissionGroupStatus status) {
+    SDLPermissionObserverIdentifier observerId = [manager.permissionManager subscribeToRPCPermissions:rpcNames groupType:groupType withHandler:^(NSDictionary<SDLPermissionRPCName,SDLRPCPermissionStatus *> * _Nonnull change, SDLPermissionGroupStatus status) {
         [self sdlex_logRPCGroupPermissions:rpcNames groupPermissionStatus:status individualPermissionStatuses:change];
     }];
     return observerId;
diff --git a/SmartDeviceLink-iOS.xcodeproj/project.pbxproj b/SmartDeviceLink-iOS.xcodeproj/project.pbxproj
index d0a5385d4..a03306fda 100644
--- a/SmartDeviceLink-iOS.xcodeproj/project.pbxproj
+++ b/SmartDeviceLink-iOS.xcodeproj/project.pbxproj
@@ -773,7 +773,7 @@
 		5D61FCF91A84238C00846EE7 /* SDLMenuParams.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D61FB0C1A84238A00846EE7 /* SDLMenuParams.m */; };
 		5D61FCFA1A84238C00846EE7 /* SDLMyKey.h in Headers */ = {isa = PBXBuildFile; fileRef = 5D61FB0D1A84238A00846EE7 /* SDLMyKey.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		5D61FCFB1A84238C00846EE7 /* SDLMyKey.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D61FB0E1A84238A00846EE7 /* SDLMyKey.m */; };
-		5D61FCFC1A84238C00846EE7 /* SDLRPCParameterNames.h in Headers */ = {isa = PBXBuildFile; fileRef = 5D61FB0F1A84238A00846EE7 /* SDLRPCParameterNames.h */; settings = {ATTRIBUTES = (Private, ); }; };
+		5D61FCFC1A84238C00846EE7 /* SDLRPCParameterNames.h in Headers */ = {isa = PBXBuildFile; fileRef = 5D61FB0F1A84238A00846EE7 /* SDLRPCParameterNames.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		5D61FCFD1A84238C00846EE7 /* SDLObjectWithPriority.h in Headers */ = {isa = PBXBuildFile; fileRef = 5D61FB101A84238A00846EE7 /* SDLObjectWithPriority.h */; };
 		5D61FCFE1A84238C00846EE7 /* SDLObjectWithPriority.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D61FB111A84238A00846EE7 /* SDLObjectWithPriority.m */; };
 		5D61FCFF1A84238C00846EE7 /* SDLOnAppInterfaceUnregistered.h in Headers */ = {isa = PBXBuildFile; fileRef = 5D61FB121A84238B00846EE7 /* SDLOnAppInterfaceUnregistered.h */; settings = {ATTRIBUTES = (Public, ); }; };
@@ -6601,7 +6601,6 @@
 			isa = PBXHeadersBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				106187BA24AA76550045C4EC /* SDLRPCPermissionStatus.h in Headers */,
 				106412C824A13F160069A97A /* SDLPermissionManager.h in Headers */,
 				106412C6249FB80B0069A97A /* SDLPermissionElement.h in Headers */,
 				9F425AD222DD980200BE3245 /* SDLWindowCapability.h in Headers */,
@@ -7036,6 +7035,7 @@
 				1E5AD04C1F1F79640029B8AF /* SDLDefrostZone.h in Headers */,
 				1E5AD0601F207AB10029B8AF /* SDLRadioState.h in Headers */,
 				1E5AD0801F20B73E0029B8AF /* SDLButtonPress.h in Headers */,
+				106187BA24AA76550045C4EC /* SDLRPCPermissionStatus.h in Headers */,
 				884554AC222453A800BAFB6C /* SDLNavigationServiceManifest.h in Headers */,
 				8816772C222097C3001FACFF /* SDLNavigationServiceData.h in Headers */,
 				1E5AD05C1F2064A80029B8AF /* SDLRDSData.h in Headers */,
diff --git a/SmartDeviceLink/SDLPermissionElement.m b/SmartDeviceLink/SDLPermissionElement.m
index 47425f18f..034cae343 100644
--- a/SmartDeviceLink/SDLPermissionElement.m
+++ b/SmartDeviceLink/SDLPermissionElement.m
@@ -28,4 +28,10 @@
     return newElement;
 }
 
+#pragma mark - Description
+
+- (NSString *)description {
+    return [NSString stringWithFormat:@"rpc name: %@, parameter permissions: %@", self.rpcName, self.parameterPermissions];
+}
+
 @end
diff --git a/SmartDeviceLink/SDLPermissionFilter.h b/SmartDeviceLink/SDLPermissionFilter.h
index 8bd82736e..ca9bfdc9f 100644
--- a/SmartDeviceLink/SDLPermissionFilter.h
+++ b/SmartDeviceLink/SDLPermissionFilter.h
@@ -50,10 +50,10 @@ NS_ASSUME_NONNULL_BEGIN
  *
  *  @return An instance of `SDLPermissionFilter`.
  */
-- (instancetype)initWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType permissionsHandler:(nullable SDLPermissionsChangedHandler)handler rpcPermissionStatusHandler:(nullable SDLRPCPermissionStatusChangedHandler)permissionStatusHandler NS_DESIGNATED_INITIALIZER;
+- (instancetype)initWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType permissionsHandler:(nullable SDLPermissionsChangedHandler)handler;
 
 /**
- *  Create a new permission filter group.
+ *  Create a new permission filter group with a SDLPermissionsChangedHandler.
  *
  *  @param rpcNames  The names of the RPCs to watch permissions of.
  *  @param groupType The type of notifications to be sent for this filter group.
@@ -61,7 +61,18 @@ NS_ASSUME_NONNULL_BEGIN
  *
  *  @return An instance of `SDLPermissionFilter`.
  */
-+ (instancetype)filterWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType permissionsHandler:(nullable SDLPermissionsChangedHandler)handler rpcPermissionStatusHandler:(nullable SDLRPCPermissionStatusChangedHandler)permissionStatusHandler NS_SWIFT_UNAVAILABLE("Use the initializer");
++ (instancetype)filterWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType permissionsHandler:(nullable SDLPermissionsChangedHandler)handler NS_SWIFT_UNAVAILABLE("Use the initializer");
+
+/**
+ *  Create a new permission filter group with a SDLRPCPermissionStatusChangedHandler.
+ *
+ *  @param rpcNames  The names of the RPCs to watch permissions of.
+ *  @param groupType The type of notifications to be sent for this filter group.
+ *  @param permissionStatusHandler  The block observer to be called when changes occur.
+ *
+ *  @return An instance of `SDLPermissionFilter`.
+ */
++ (instancetype)filterWithRPCPermissions:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType permissionStatusHandler:(SDLRPCPermissionStatusChangedHandler)permissionStatusHandler; 
 
 /**
  *  Whether the current filter is equivalent with another filter or not.
diff --git a/SmartDeviceLink/SDLPermissionFilter.m b/SmartDeviceLink/SDLPermissionFilter.m
index 650478876..558f3910d 100644
--- a/SmartDeviceLink/SDLPermissionFilter.m
+++ b/SmartDeviceLink/SDLPermissionFilter.m
@@ -19,10 +19,10 @@ NS_ASSUME_NONNULL_BEGIN
 - (instancetype)init {
     return [self initWithRPCNames:@[]
                         groupType:SDLPermissionGroupTypeAny
-                         permissionsHandler:^(NSDictionary<SDLPermissionElement *, NSNumber<SDLBool> *> *_Nonnull change, SDLPermissionGroupStatus status){ } rpcPermissionStatusHandler:^(NSDictionary<SDLPermissionRPCName, SDLRPCPermissionStatus *> * _Nonnull change, SDLPermissionGroupStatus status) { }];
+                         permissionsHandler:^(NSDictionary<SDLPermissionElement *, NSNumber<SDLBool> *> *_Nonnull change, SDLPermissionGroupStatus status){ }];
 }
 
-- (instancetype)initWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType permissionsHandler:(nullable SDLPermissionsChangedHandler)observer rpcPermissionStatusHandler:(nullable SDLRPCPermissionStatusChangedHandler)permissionStatusHandler {
+- (instancetype)initWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType permissionsHandler:(nullable SDLPermissionsChangedHandler)observer {
     self = [super init];
     if (!self) {
         return nil;
@@ -32,20 +32,32 @@ NS_ASSUME_NONNULL_BEGIN
     _permissionElements = rpcNames;
     _groupType = groupType;
     _handler = observer;
-    _rpcPermissionStatusHandler = permissionStatusHandler;
+//    _rpcPermissionStatusHandler = permissionStatusHandler;
 
     return self;
 }
 
-+ (instancetype)filterWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType permissionsHandler:(nullable SDLPermissionsChangedHandler)observer rpcPermissionStatusHandler:(nullable SDLRPCPermissionStatusChangedHandler)permissionStatusHandler {
-    return [[self alloc] initWithRPCNames:rpcNames groupType:groupType permissionsHandler:observer rpcPermissionStatusHandler:permissionStatusHandler];
++ (instancetype)filterWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType permissionsHandler:(nullable SDLPermissionsChangedHandler)observer {
+    return [[self alloc] initWithRPCNames:rpcNames groupType:groupType permissionsHandler:observer];
+}
+
+
+#pragma mark - Helpers
+
+- (NSArray<SDLPermissionRPCName> *)rpcNamesFromPermissionElements:(NSArray<SDLPermissionElement *> *)permissionElements {
+    NSMutableArray *rpcNames = [[NSMutableArray alloc] init];
+    for (SDLPermissionElement *element in permissionElements) {
+        [rpcNames addObject:element.rpcName];
+    }
+
+    return rpcNames;
 }
 
 
 #pragma mark - NSCopying
 
 - (id)copyWithZone:(nullable NSZone *)zone {
-    SDLPermissionFilter *newFilter = [[self.class allocWithZone:zone] initWithRPCNames:[_permissionElements copyWithZone:zone] groupType:_groupType permissionsHandler:[_handler copyWithZone:zone] rpcPermissionStatusHandler:[_rpcPermissionStatusHandler copyWithZone:zone]];
+    SDLPermissionFilter *newFilter = [[self.class allocWithZone:zone] initWithRPCNames:[_permissionElements copyWithZone:zone] groupType:_groupType permissionsHandler:[_handler copyWithZone:zone]];
     newFilter->_identifier = _identifier;
 
     return newFilter;
@@ -77,17 +89,6 @@ NS_ASSUME_NONNULL_BEGIN
     return [NSString stringWithFormat:@"identifier: %@, group type: %@, rpcs: %@", self.identifier, @(self.groupType), self.permissionElements];
 }
 
-#pragma mark - Helpers
-
-- (NSArray<SDLPermissionRPCName> *)getRPCNamesFromPermissionElements:(NSArray<SDLPermissionElement *> *)permissionElements {
-    NSMutableArray *rpcNames = [[NSMutableArray alloc] init];
-    for (SDLPermissionElement *element in permissionElements) {
-        [rpcNames addObject:element.rpcName];
-    }
-
-    return rpcNames;
-}
-
 @end
 
 NS_ASSUME_NONNULL_END
diff --git a/SmartDeviceLink/SDLPermissionManager.h b/SmartDeviceLink/SDLPermissionManager.h
index f9806a7d4..284970030 100644
--- a/SmartDeviceLink/SDLPermissionManager.h
+++ b/SmartDeviceLink/SDLPermissionManager.h
@@ -90,7 +90,7 @@ NS_ASSUME_NONNULL_BEGIN
  *
  * @return A dictionary with specific RPC info contained in a SDLRPCPermissionStatus
 */
-- (NSDictionary<SDLRPCFunctionName, SDLRPCPermissionStatus *> *)statusesOfRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames;
+- (NSDictionary<SDLRPCFunctionName, SDLRPCPermissionStatus *> *)statusesOfRPCPermissions:(NSArray<SDLPermissionElement *> *)rpcNames;
 
 /**
  *  Add an observer for specified RPC names, with a callback that will be called whenever the value changes, as well as immediately with the current status.
@@ -112,7 +112,7 @@ NS_ASSUME_NONNULL_BEGIN
  *
  *  @warning The observer may be called before this method returns, do not attempt to remove the observer from within the observer. That could send `nil` to removeObserverForIdentifier:. If you want functionality like that, call groupStatusOfRPCs: instead.
  *
- *  @param rpcNames The RPCs to be observed
+ *  @param permissionElements The permission elements to be observed
  *  @param groupType Affects the times that the observer block will be called. If Any, any change to any RPC in rpcNames will cause the observer block to be called. If AllAllowed, the block will be called when: 1. Every RPC in rpcNames becomes allowed 2. The group of rpcNames goes from all being allowed to some or all being disallowed.
  *  @param handler The block that will be called whenever permissions change.
  *
@@ -148,7 +148,7 @@ NS_ASSUME_NONNULL_BEGIN
  *
  * @param rpcName The name of the RPC to be tested, for example, SDLRPCFunctionNameGetVehicleData
  *
- * @param parameter The name of the parameter to be tested, for example, rpm
+ * @param parameterName The name of the parameter to be tested, for example, rpm
  */
 - (BOOL)isPermissionParameterAllowed:(SDLRPCFunctionName)rpcName parameter:(NSString *)parameterName;
 
diff --git a/SmartDeviceLink/SDLPermissionManager.m b/SmartDeviceLink/SDLPermissionManager.m
index 9fa8343d7..81169f206 100644
--- a/SmartDeviceLink/SDLPermissionManager.m
+++ b/SmartDeviceLink/SDLPermissionManager.m
@@ -80,7 +80,7 @@ NS_ASSUME_NONNULL_BEGIN
 }
 
 - (SDLPermissionGroupStatus)groupStatusOfRPCs:(NSArray<SDLPermissionRPCName> *)rpcNames {
-    return [self groupStatusOfRPCNames:[self sdl_createPermissionElementFromRPCNames:rpcNames]];
+    return [self groupStatusOfRPCNames:[self sdl_createPermissionElementsFromRPCNames:rpcNames]];
 }
 
 - (SDLPermissionGroupStatus)groupStatusOfRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames {
@@ -88,10 +88,10 @@ NS_ASSUME_NONNULL_BEGIN
         return SDLPermissionGroupStatusUnknown;
     }
 
-    return [self.class sdl_groupStatusOfRPCs:rpcNames withPermissions:[self.permissions copy] hmiLevel:self.currentHMILevel];
+    return [self.class sdl_groupStatusOfRPCPermissions:rpcNames withPermissions:[self.permissions copy] hmiLevel:self.currentHMILevel];
 }
 
-+ (SDLPermissionGroupStatus)sdl_groupStatusOfRPCs:(NSArray<SDLPermissionElement *> *)rpcNames withPermissions:(NSDictionary<SDLPermissionRPCName, SDLPermissionItem *> *)permissions hmiLevel:(SDLHMILevel)hmiLevel {
++ (SDLPermissionGroupStatus)sdl_groupStatusOfRPCPermissions:(NSArray<SDLPermissionElement *> *)rpcNames withPermissions:(NSDictionary<SDLPermissionRPCName, SDLPermissionItem *> *)permissions hmiLevel:(SDLHMILevel)hmiLevel {
     // If we don't have an HMI level, then just say everything is disallowed
     if (hmiLevel == nil) {
         return SDLPermissionGroupStatusUnknown;
@@ -133,13 +133,13 @@ NS_ASSUME_NONNULL_BEGIN
 }
 
 - (NSDictionary<SDLPermissionRPCName, NSNumber *> *)statusOfRPCs:(NSArray<SDLPermissionRPCName> *)rpcNames {
-    NSArray *permissionElementsArray = [self sdl_createPermissionElementFromRPCNames:rpcNames];
+    NSArray *permissionElementsArray = [self sdl_createPermissionElementsFromRPCNames:rpcNames];
 
     // Convert the dictionary returned from statusesOfRPCNames: to the correct return type
-    return [self sdl_convertPermissionsDictionary:[self statusesOfRPCNames:permissionElementsArray]];
+    return [self sdl_convertPermissionsStatusDictionaryToPermissionsBoolDictionary:[self statusesOfRPCPermissions:permissionElementsArray]];
 }
 
-- (NSDictionary<SDLRPCFunctionName, SDLRPCPermissionStatus *> *)statusesOfRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames {
+- (NSDictionary<SDLRPCFunctionName, SDLRPCPermissionStatus *> *)statusesOfRPCPermissions:(NSArray<SDLPermissionElement *> *)rpcNames {
     NSMutableDictionary<SDLRPCFunctionName, SDLRPCPermissionStatus *> *permissionAllowedDict = [NSMutableDictionary dictionary];
 
     for (SDLPermissionElement *permissionElement in rpcNames) {
@@ -166,7 +166,7 @@ NS_ASSUME_NONNULL_BEGIN
 #pragma mark Add Observers
 
 - (SDLPermissionObserverIdentifier)addObserverForRPCs:(NSArray<SDLPermissionRPCName> *)rpcNames groupType:(SDLPermissionGroupType)groupType withHandler:(nonnull SDLPermissionsChangedHandler)handler {
-    SDLPermissionFilter *filter = [SDLPermissionFilter filterWithRPCNames:[self sdl_createPermissionElementFromRPCNames:rpcNames] groupType:groupType permissionsHandler:handler rpcPermissionStatusHandler:nil];
+    SDLPermissionFilter *filter = [SDLPermissionFilter filterWithRPCNames:[self sdl_createPermissionElementsFromRPCNames:rpcNames] groupType:groupType permissionsHandler:handler];
 
     // Store the filter for later use
     [self.filters addObject:filter];
@@ -177,8 +177,8 @@ NS_ASSUME_NONNULL_BEGIN
     return filter.identifier;
 }
 
-- (SDLPermissionObserverIdentifier)subscribeToRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType withHandler:(SDLRPCPermissionStatusChangedHandler)handler {
-    SDLPermissionFilter *filter = [SDLPermissionFilter filterWithRPCNames:rpcNames groupType:groupType permissionsHandler:nil rpcPermissionStatusHandler:handler];
+- (SDLPermissionObserverIdentifier)subscribeToRPCPermissions:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType withHandler:(SDLRPCPermissionStatusChangedHandler)handler {
+    SDLPermissionFilter *filter = [SDLPermissionFilter filterWithRPCPermissions:rpcNames groupType:groupType permissionStatusHandler:handler];
 
     // Store the filter for later use
     [self.filters addObject:filter];
@@ -193,16 +193,15 @@ NS_ASSUME_NONNULL_BEGIN
 }
 
 - (void)sdl_callFilterObserver:(SDLPermissionFilter *)filter {
-
     if (filter.rpcPermissionStatusHandler != nil) {
         SDLPermissionGroupStatus permissionStatus = [self groupStatusOfRPCNames:filter.permissionElements];
-        NSDictionary<SDLRPCFunctionName, SDLRPCPermissionStatus *> *allowedDict = [self statusesOfRPCNames:filter.permissionElements];
+        NSDictionary<SDLRPCFunctionName, SDLRPCPermissionStatus *> *allowedDict = [self statusesOfRPCPermissions:filter.permissionElements];
         filter.rpcPermissionStatusHandler(allowedDict, permissionStatus);
     }
 
     if (filter.handler != nil) {
         SDLPermissionGroupStatus permissionStatus = [self groupStatusOfRPCNames:filter.permissionElements];
-        NSDictionary<SDLRPCFunctionName, NSNumber *> *allowedDict = [self sdl_convertPermissionsDictionary:[self statusesOfRPCNames:filter.permissionElements]];
+        NSDictionary<SDLRPCFunctionName, NSNumber *> *allowedDict = [self sdl_convertPermissionsStatusDictionaryToPermissionsBoolDictionary:[self statusesOfRPCPermissions:filter.permissionElements]];
         filter.handler(allowedDict, permissionStatus);
     }
 }
@@ -334,7 +333,7 @@ NS_ASSUME_NONNULL_BEGIN
  *
  *  @return An array of permission elements.
  */
-- (NSArray<SDLPermissionElement *> *)sdl_createPermissionElementFromRPCNames:(NSArray<NSString *> *)rpcNames {
+- (NSArray<SDLPermissionElement *> *)sdl_createPermissionElementsFromRPCNames:(NSArray<SDLRPCFunctionName> *)rpcNames {
     NSMutableArray *permissionElements = [[NSMutableArray alloc] init];
     for (NSString *rpcName in rpcNames) {
         SDLPermissionElement *permissionElement = [[SDLPermissionElement alloc] initWithRPCName:rpcName parameterPermissions:nil];
@@ -355,7 +354,7 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (BOOL)sdl_didFilterChange:(SDLPermissionFilter *)filter fromHMILevel:(SDLHMILevel)oldHMILevel toHMILevel:(SDLHMILevel)newHMILevel {
     BOOL changed = NO;
-    for (NSString *rpcName in [filter getRPCNamesFromPermissionElements:filter.permissionElements]) {
+    for (NSString *rpcName in [filter rpcNamesFromPermissionElements:filter.permissionElements]) {
         SDLPermissionItem *item = self.permissions[rpcName];
         BOOL newAllowed = [item.hmiPermissions.allowed containsObject:self.currentHMILevel];
         BOOL oldAllowed = [item.hmiPermissions.allowed containsObject:oldHMILevel];
@@ -373,8 +372,8 @@ NS_ASSUME_NONNULL_BEGIN
 
     // This is only for the All Allowed group type. Unlike with the Any group type, we need to know if the group status has changed
     if (changed) {
-        SDLPermissionGroupStatus oldStatus = [self.class sdl_groupStatusOfRPCs:filter.permissionElements withPermissions:self.permissions hmiLevel:oldHMILevel];
-        SDLPermissionGroupStatus newStatus = [self.class sdl_groupStatusOfRPCs:filter.permissionElements withPermissions:self.permissions hmiLevel:newHMILevel];
+        SDLPermissionGroupStatus oldStatus = [self.class sdl_groupStatusOfRPCPermissions:filter.permissionElements withPermissions:self.permissions hmiLevel:oldHMILevel];
+        SDLPermissionGroupStatus newStatus = [self.class sdl_groupStatusOfRPCPermissions:filter.permissionElements withPermissions:self.permissions hmiLevel:newHMILevel];
 
         // We've already eliminated the case where the permissions could stay the same, so if the permissions changed *to* allowed or *away* from allowed, we need to call the observer.
         if (newStatus == SDLPermissionGroupStatusAllowed || oldStatus == SDLPermissionGroupStatusAllowed) {
@@ -419,7 +418,7 @@ NS_ASSUME_NONNULL_BEGIN
     for (SDLPermissionFilter *filter in filters) {
         NSArray<SDLPermissionItem *> *modifiedPermissionItems = [self sdl_modifiedUpdatedPermissions:updatedPermissions comparedToCurrentPermissions:currentPermissions];
         for (SDLPermissionItem *item in modifiedPermissionItems) {
-            if ([[filter getRPCNamesFromPermissionElements:filter.permissionElements] containsObject:item.rpcName]) {
+            if ([[filter rpcNamesFromPermissionElements:filter.permissionElements] containsObject:item.rpcName]) {
                 [modifiedFilters addObject:filter];
                 break;
             }
diff --git a/SmartDeviceLink/SDLRPCPermissionStatus.h b/SmartDeviceLink/SDLRPCPermissionStatus.h
index 827c57872..d672f5207 100644
--- a/SmartDeviceLink/SDLRPCPermissionStatus.h
+++ b/SmartDeviceLink/SDLRPCPermissionStatus.h
@@ -9,6 +9,7 @@
 #import <Foundation/Foundation.h>
 
 #import "SDLRPCFunctionNames.h"
+#import "SDLRPCParameterNames.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -27,7 +28,7 @@ NS_ASSUME_NONNULL_BEGIN
 @property (assign, nonatomic, readonly, getter=isRPCAllowed) BOOL rpcAllowed;
 
 /**
- * Holds a dictionary of RPC parameters and their permission status
+ * Holds a dictionary of RPC parameters and objects of an NSNumber<BOOL> specifying if that RPC parameter is currently allowed
  */
 @property (strong, nonatomic, nullable, readonly) NSDictionary<SDLRPCParameterName, NSNumber *> *rpcParameters;
 
diff --git a/SmartDeviceLink/SDLRPCPermissionStatus.m b/SmartDeviceLink/SDLRPCPermissionStatus.m
index edc64dc89..5115e238e 100644
--- a/SmartDeviceLink/SDLRPCPermissionStatus.m
+++ b/SmartDeviceLink/SDLRPCPermissionStatus.m
@@ -11,6 +11,9 @@
 @implementation SDLRPCPermissionStatus
 
 - (instancetype)initWithRPCName:(SDLRPCFunctionName)rpcName isRPCAllowed:(BOOL)isRPCAllowed rpcParameters:(nullable NSMutableDictionary<NSString *,NSNumber *> *)rpcParameters {
+    self = [super init];
+    if (!self) { return nil; }
+    
     _rpcName = rpcName;
     _rpcAllowed = isRPCAllowed;
     _rpcParameters = rpcParameters;
diff --git a/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionFilterSpec.m b/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionFilterSpec.m
index d93005337..769f86675 100644
--- a/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionFilterSpec.m
+++ b/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionFilterSpec.m
@@ -36,7 +36,7 @@ describe(@"A filter", ^{
         context(@"using initWithRPCNames:changeType:permissionsHandler:rpcPermissionStatusHandler", ^{
             context(@"and the rpcPermissionStatusHandler is nil", ^{
                 beforeEach(^{
-                    testFilter = [[SDLPermissionFilter alloc] initWithRPCNames:testPermissionElements groupType:testGroupType permissionsHandler:^(NSDictionary<SDLPermissionRPCName,NSNumber *> * _Nonnull change, SDLPermissionGroupStatus status) { testObserverReturnChangedDict = change; } rpcPermissionStatusHandler:nil];
+                    testFilter = [[SDLPermissionFilter alloc] initWithRPCNames:testPermissionElements groupType:testGroupType permissionsHandler:^(NSDictionary<SDLPermissionRPCName,NSNumber *> * _Nonnull change, SDLPermissionGroupStatus status) { testObserverReturnChangedDict = change; } :nil];
                 });
 
                 it(@"should set the rpcNames array correctly", ^{
@@ -71,7 +71,7 @@ describe(@"A filter", ^{
 
             context(@"and the permissionsHandler is nil", ^{
                 beforeEach(^{
-                    testFilter = [[SDLPermissionFilter alloc] initWithRPCNames:testPermissionElements groupType:testGroupType permissionsHandler:nil rpcPermissionStatusHandler:^(NSDictionary<SDLPermissionRPCName,SDLRPCPermissionStatus *> * _Nonnull change, SDLPermissionGroupStatus status) {
+                    testFilter = [[SDLPermissionFilter alloc] initWithRPCNames:testPermissionElements groupType:testGroupType permissionsHandler:nil :^(NSDictionary<SDLPermissionRPCName,SDLRPCPermissionStatus *> * _Nonnull change, SDLPermissionGroupStatus status) {
                         testRPCPermissionStatusReturnChangedDict = change;
                     }];
                 });
diff --git a/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionsManagerSpec.m b/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionsManagerSpec.m
index d7c994dc7..0fe78fa55 100644
--- a/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionsManagerSpec.m
+++ b/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionsManagerSpec.m
@@ -435,7 +435,7 @@ describe(@"SDLPermissionsManager", ^{
 
             context(@"statusesOfRPCNames: method", ^{
                 beforeEach(^{
-                    testResultRPCPermissionStatusDict = [testPermissionsManager statusesOfRPCNames:@[testPermissionElementAllAllowed, testPermissionElementDisallowed]];
+                    testResultRPCPermissionStatusDict = [testPermissionsManager statusesOfRPCPermissions:@[testPermissionElementAllAllowed, testPermissionElementDisallowed]];
                     allowedResultStatus = testResultRPCPermissionStatusDict[testPermissionElementAllAllowed.rpcName];
                     disallowedResultStatus = testResultRPCPermissionStatusDict[testPermissionElementDisallowed.rpcName];
 
@@ -479,7 +479,7 @@ describe(@"SDLPermissionsManager", ^{
                     [[NSNotificationCenter defaultCenter] postNotification:limitedHMINotification];
                     [[NSNotificationCenter defaultCenter] postNotification:testPermissionsNotification];
 
-                    testResultRPCPermissionStatusDict = [testPermissionsManager statusesOfRPCNames:@[testPermissionElementAllAllowed, testPermissionElementDisallowed]];
+                    testResultRPCPermissionStatusDict = [testPermissionsManager statusesOfRPCPermissions:@[testPermissionElementAllAllowed, testPermissionElementDisallowed]];
 
                     allowedResultStatus = testResultRPCPermissionStatusDict[testPermissionElementAllAllowed.rpcName];
                     disallowedResultStatus = testResultRPCPermissionStatusDict[testPermissionElementDisallowed.rpcName];
@@ -632,7 +632,7 @@ describe(@"SDLPermissionsManager", ^{
 
                 beforeEach(^{
                     testObserverCalled = NO;
-                    [testPermissionsManager subscribeToRPCNames:@[testPermissionElementAllAllowed, testPermissionElementDisallowed] groupType:SDLPermissionGroupTypeAny withHandler:^(NSDictionary<SDLPermissionRPCName,NSNumber *> * _Nonnull change, SDLPermissionGroupStatus status) {
+                    [testPermissionsManager subscribeToRPCPermissions:@[testPermissionElementAllAllowed, testPermissionElementDisallowed] groupType:SDLPermissionGroupTypeAny withHandler:^(NSDictionary<SDLPermissionRPCName,NSNumber *> * _Nonnull change, SDLPermissionGroupStatus status) {
                         testObserverCalled = YES;
                     }];
                 });
@@ -654,7 +654,7 @@ describe(@"SDLPermissionsManager", ^{
                     [[NSNotificationCenter defaultCenter] postNotification:testPermissionsNotification];
 
                     // This should not be called even with data currently present, the handler will only be called when an permissions update occurs after the RPC is subscribed to
-                    [testPermissionsManager subscribeToRPCNames:@[testPermissionElementAllAllowed, testPermissionElementDisallowed] groupType:SDLPermissionGroupTypeAny withHandler:^(NSDictionary<SDLPermissionRPCName,NSNumber *> * _Nonnull change, SDLPermissionGroupStatus status) {
+                    [testPermissionsManager subscribeToRPCPermissions:@[testPermissionElementAllAllowed, testPermissionElementDisallowed] groupType:SDLPermissionGroupTypeAny withHandler:^(NSDictionary<SDLPermissionRPCName,NSNumber *> * _Nonnull change, SDLPermissionGroupStatus status) {
                         testObserverCalled = YES;
                     }];
                 });
diff --git a/SmartDeviceLinkTests/SDLPermissionElementSpec.m b/SmartDeviceLinkTests/SDLPermissionElementSpec.m
index 7f710bb93..2fac3a7c2 100644
--- a/SmartDeviceLinkTests/SDLPermissionElementSpec.m
+++ b/SmartDeviceLinkTests/SDLPermissionElementSpec.m
@@ -32,11 +32,8 @@ describe(@"A permission element", ^{
             testPermissionElement = [[SDLPermissionElement alloc] initWithRPCName:testRPCName1 parameterPermissions:parameterPermissions];
         });
 
-        it(@"should set the rpcName correctly", ^{
+        it(@"should set the rpcName and parameterPermissions correctly", ^{
             expect(testPermissionElement.rpcName).to(equal(testRPCName1));
-        });
-
-        it(@"should set the parameterPermissions correctly", ^{
             expect(testPermissionElement.parameterPermissions).to(equal(parameterPermissions));
         });
     });
@@ -50,15 +47,9 @@ describe(@"A permission element", ^{
             testPermissionElementCopy = [testPermissionElement copy];
         });
 
-        it(@"should say copied filters are not the same instance", ^{
+        it(@"should copy correctly", ^{
             expect(testPermissionElementCopy).toNot(beIdenticalTo(testPermissionElement));
-        });
-
-        it(@"should copy the rpc name correctly", ^{
             expect(testPermissionElementCopy.rpcName).to(equal(testPermissionElement.rpcName));
-        });
-
-        it(@"should copy the parameter permissions correctly", ^{
             expect(testPermissionElementCopy.parameterPermissions).to(equal(testPermissionElement.parameterPermissions));
         });
     });
diff --git a/SmartDeviceLinkTests/SDLRPCPermissionStatusSpec.m b/SmartDeviceLinkTests/SDLRPCPermissionStatusSpec.m
index 1e2d6e668..d6bbb1c78 100644
--- a/SmartDeviceLinkTests/SDLRPCPermissionStatusSpec.m
+++ b/SmartDeviceLinkTests/SDLRPCPermissionStatusSpec.m
@@ -32,15 +32,9 @@ describe(@"A rpc permission status", ^{
             testSDLRPCPermissionStatusSpec = [[SDLRPCPermissionStatus alloc] initWithRPCName:testRPCName isRPCAllowed:isRPCAllowed rpcParameters:allowedParameters];
         });
 
-        it(@"should set the rpcName correctly", ^{
+        it(@"should set rpcName, isRPCAllowed, rpcPArameters correctly", ^{
             expect(testSDLRPCPermissionStatusSpec.rpcName).to(equal(testRPCName));
-        });
-
-        it(@"should set isRPCAllowed correctly", ^{
             expect(testSDLRPCPermissionStatusSpec.isRPCAllowed).to(equal(isRPCAllowed));
-        });
-
-        it(@"should set the parameter permissions correctly", ^{
             expect(testSDLRPCPermissionStatusSpec.rpcParameters[testParameterName]).to(equal(@NO));
         });
     });