Updated Protocol Enums to Match Spec.

SmartDeviceLink/SDLProtocol.m

@@ -108,22 +108,22 @@ - (void)startSecureServiceWithType:(SDLServiceType)serviceType completionHandler
 - (SDLProtocolMessage *)sdl_createStartServiceMessageWithType:(SDLServiceType)serviceType encrypted:(BOOL)encryption {
     SDLProtocolHeader *header = [SDLProtocolHeader headerForVersion:[SDLGlobals sharedGlobals].protocolVersion];
     switch (serviceType) {
-        case SDLServiceType_RPC: {
+        case SDLServiceTypeRPC: {
             // Need a different header for starting the RPC service, we get the session Id from the HU, or its the same as the RPC service's
             header = [SDLProtocolHeader headerForVersion:1];
-            if ([self sdl_retrieveSessionIDforServiceType:SDLServiceType_RPC]) {
-                header.sessionID = [self sdl_retrieveSessionIDforServiceType:SDLServiceType_RPC];
+            if ([self sdl_retrieveSessionIDforServiceType:SDLServiceTypeRPC]) {
+                header.sessionID = [self sdl_retrieveSessionIDforServiceType:SDLServiceTypeRPC];
             } else {
                 header.sessionID = 0;
             }
         } break;
         default: {
-            header.sessionID = [self sdl_retrieveSessionIDforServiceType:SDLServiceType_RPC];
+            header.sessionID = [self sdl_retrieveSessionIDforServiceType:SDLServiceTypeRPC];
         } break;
     }
-    header.frameType = SDLFrameType_Control;
+    header.frameType = SDLFrameTypeControl;
     header.serviceType = serviceType;
-    header.frameData = SDLFrameData_StartSession;
+    header.frameData = SDLFrameInfoStartService;
 
     // Sending a StartSession with the encrypted bit set causes module to initiate SSL Handshake with a ClientHello message, which should be handled by the 'processControlService' method.
     header.encrypted = encryption;
@@ -168,9 +168,9 @@ - (void)sendEndSessionWithType:(SDLServiceType)serviceType {
 
 - (void)endServiceWithType:(SDLServiceType)serviceType {
     SDLProtocolHeader *header = [SDLProtocolHeader headerForVersion:[SDLGlobals sharedGlobals].protocolVersion];
-    header.frameType = SDLFrameType_Control;
+    header.frameType = SDLFrameTypeControl;
     header.serviceType = serviceType;
-    header.frameData = SDLFrameData_EndSession;
+    header.frameData = SDLFrameInfoEndService;
     header.sessionID = [self sdl_retrieveSessionIDforServiceType:serviceType];
 
     SDLProtocolMessage *message = [SDLProtocolMessage messageWithHeader:header andPayload:nil];
@@ -244,10 +244,10 @@ - (BOOL)sendRPC:(SDLRPCMessage *)message encrypted:(BOOL)encryption error:(NSErr
     // Build the protocol level header & message
     SDLProtocolHeader *header = [SDLProtocolHeader headerForVersion:[SDLGlobals sharedGlobals].protocolVersion];
     header.encrypted = encryption;
-    header.frameType = SDLFrameType_Single;
-    header.serviceType = (message.bulkData.length <= 0) ? SDLServiceType_RPC : SDLServiceType_BulkData;
-    header.frameData = SDLFrameData_SingleFrame;
-    header.sessionID = [self sdl_retrieveSessionIDforServiceType:SDLServiceType_RPC];
+    header.frameType = SDLFrameTypeSingle;
+    header.serviceType = (message.bulkData.length <= 0) ? SDLServiceTypeRPC : SDLServiceTypeBulkData;
+    header.frameData = SDLFrameInfoSingleFrame;
+    header.sessionID = [self sdl_retrieveSessionIDforServiceType:SDLServiceTypeRPC];
     header.bytesInPayload = (UInt32)messagePayload.length;
 
     // V2+ messages need to have message ID property set.
@@ -261,12 +261,12 @@ - (BOOL)sendRPC:(SDLRPCMessage *)message encrypted:(BOOL)encryption error:(NSErr
     // See if the message is small enough to send in one transmission. If not, break it up into smaller messages and send.
     if (protocolMessage.size < [SDLGlobals sharedGlobals].maxMTUSize) {
         [self sdl_logRPCSend:protocolMessage];
-        [self sdl_sendDataToTransport:protocolMessage.data onService:SDLServiceType_RPC];
+        [self sdl_sendDataToTransport:protocolMessage.data onService:SDLServiceTypeRPC];
     } else {
         NSArray<SDLProtocolMessage *> *messages = [SDLProtocolMessageDisassembler disassemble:protocolMessage withLimit:[SDLGlobals sharedGlobals].maxMTUSize];
         for (SDLProtocolMessage *smallerMessage in messages) {
             [self sdl_logRPCSend:smallerMessage];
-            [self sdl_sendDataToTransport:smallerMessage.data onService:SDLServiceType_RPC];
+            [self sdl_sendDataToTransport:smallerMessage.data onService:SDLServiceTypeRPC];
         }
     }
 
@@ -307,7 +307,7 @@ - (void)sendEncryptedRawData:(NSData *)data onService:(SDLServiceType)serviceTyp
 - (void)sdl_sendRawData:(NSData *)data onService:(SDLServiceType)service encryption:(BOOL)encryption {
     SDLV2ProtocolHeader *header = [[SDLV2ProtocolHeader alloc] initWithVersion:[SDLGlobals sharedGlobals].protocolVersion];
     header.encrypted = encryption;
-    header.frameType = SDLFrameType_Single;
+    header.frameType = SDLFrameTypeSingle;
     header.serviceType = service;
     header.sessionID = [self sdl_retrieveSessionIDforServiceType:service];
     header.messageID = ++_messageID;
@@ -414,7 +414,7 @@ - (void)processMessages {
 
 - (void)handleProtocolStartSessionACK:(SDLProtocolHeader *)header {
     switch (header.serviceType) {
-        case SDLServiceType_RPC: {
+        case SDLServiceTypeRPC: {
             [SDLGlobals sharedGlobals].maxHeadUnitVersion = header.version;
         } break;
         default:
@@ -471,9 +471,9 @@ - (void)handleProtocolEndSessionNACK:(SDLServiceType)serviceType {
 - (void)handleHeartbeatForSession:(Byte)session {
     // Respond with a heartbeat ACK
     SDLProtocolHeader *header = [SDLProtocolHeader headerForVersion:[SDLGlobals sharedGlobals].protocolVersion];
-    header.frameType = SDLFrameType_Control;
-    header.serviceType = SDLServiceType_Control;
-    header.frameData = SDLFrameData_HeartbeatACK;
+    header.frameType = SDLFrameTypeControl;
+    header.serviceType = SDLServiceTypeControl;
+    header.frameData = SDLFrameInfoHeartbeatAck;
     header.sessionID = session;
     SDLProtocolMessage *message = [SDLProtocolMessage messageWithHeader:header andPayload:nil];
     [self sdl_sendDataToTransport:message.data onService:header.serviceType];
@@ -495,7 +495,7 @@ - (void)handleHeartbeatACK {
 
 - (void)onProtocolMessageReceived:(SDLProtocolMessage *)msg {
     // Control service (but not control frame type) messages are TLS handshake messages
-    if (msg.header.serviceType == SDLServiceType_Control) {
+    if (msg.header.serviceType == SDLServiceTypeControl) {
         [self sdl_processSecurityMessage:msg];
         return;
     }
@@ -568,16 +568,16 @@ - (void)sdl_processSecurityMessage:(SDLProtocolMessage *)clientHandshakeMessage
     }
 
     // Send the response or error message. If it's an error message, the module will ACK the Start Service without encryption. If it's a TLS handshake message, the module will ACK with encryption
-    [self sdl_sendDataToTransport:serverSecurityMessage.data onService:SDLServiceType_Control];
+    [self sdl_sendDataToTransport:serverSecurityMessage.data onService:SDLServiceTypeControl];
 }
 
 + (SDLProtocolMessage *)sdl_serverSecurityHandshakeMessageWithData:(NSData *)data clientMessageHeader:(SDLProtocolHeader *)clientHeader messageId:(UInt32)messageId {
     // This can't possibly be a v1 header because v1 does not have control protocol messages
     SDLV2ProtocolHeader *serverMessageHeader = [SDLProtocolHeader headerForVersion:clientHeader.version];
     serverMessageHeader.encrypted = NO;
-    serverMessageHeader.frameType = SDLFrameType_Single;
-    serverMessageHeader.serviceType = SDLServiceType_Control;
-    serverMessageHeader.frameData = SDLFrameData_SingleFrame;
+    serverMessageHeader.frameType = SDLFrameTypeSingle;
+    serverMessageHeader.serviceType = SDLServiceTypeControl;
+    serverMessageHeader.frameData = SDLFrameInfoSingleFrame;
     serverMessageHeader.sessionID = clientHeader.sessionID;
     serverMessageHeader.messageID = messageId;
 
@@ -598,9 +598,9 @@ + (SDLProtocolMessage *)sdl_serverSecurityFailedMessageWithClientMessageHeader:(
     // This can't possibly be a v1 header because v1 does not have control protocol messages
     SDLV2ProtocolHeader *serverMessageHeader = [SDLProtocolHeader headerForVersion:clientHeader.version];
     serverMessageHeader.encrypted = NO;
-    serverMessageHeader.frameType = SDLFrameType_Single;
-    serverMessageHeader.serviceType = SDLServiceType_Control;
-    serverMessageHeader.frameData = SDLFrameData_SingleFrame;
+    serverMessageHeader.frameType = SDLFrameTypeSingle;
+    serverMessageHeader.serviceType = SDLServiceTypeControl;
+    serverMessageHeader.frameData = SDLFrameInfoSingleFrame;
     serverMessageHeader.sessionID = clientHeader.sessionID;
     serverMessageHeader.messageID = messageId;
 

SmartDeviceLink/SDLProtocolHeader.h

@@ -5,36 +5,36 @@
 
 
 typedef NS_ENUM(UInt8, SDLFrameType) {
-    SDLFrameType_Control = 0x00,
-    SDLFrameType_Single = 0x01,
-    SDLFrameType_First = 0x02,
-    SDLFrameType_Consecutive = 0x03
+    SDLFrameTypeControl = 0x00,
+    SDLFrameTypeSingle = 0x01,
+    SDLFrameTypeFirst = 0x02,
+    SDLFrameTypeConsecutive = 0x03
 };
 
 typedef NS_ENUM(UInt8, SDLServiceType) {
-    SDLServiceType_Control = 0x00,
-    SDLServiceType_RPC = 0x07,
-    SDLServiceType_Audio = 0x0A,
-    SDLServiceType_Video = 0x0B,
-    SDLServiceType_BulkData = 0x0F
+    SDLServiceTypeControl = 0x00,
+    SDLServiceTypeRPC NS_SWIFT_NAME(rpc) = 0x07,
+    SDLServiceTypeAudio = 0x0A,
+    SDLServiceTypeVideo = 0x0B,
+    SDLServiceTypeBulkData = 0x0F
 };
 
-typedef NS_ENUM(UInt8, SDLFrameData) {
-    SDLFrameData_Heartbeat = 0x00,
-    SDLFrameData_StartSession = 0x01,
-    SDLFrameData_StartSessionACK = 0x02,
-    SDLFrameData_StartSessionNACK = 0x03,
-    SDLFrameData_EndSession = 0x04,
-    SDLFrameData_EndSessionACK = 0x05,
-    SDLFrameData_EndSessionNACK = 0x06,
-    SDLFrameData_ServiceDataACK = 0xFE,
-    SDLFrameData_HeartbeatACK = 0xFF,
+typedef NS_ENUM(UInt8, SDLFrameInfo) {
+    SDLFrameInfoHeartbeat = 0x00,
+    SDLFrameInfoStartService = 0x01,
+    SDLFrameInfoStartServiceAck = 0x02,
+    SDLFrameInfoStartServiceNack = 0x03,
+    SDLFrameInfoEndService = 0x04,
+    SDLFrameInfoEndServiceAck = 0x05,
+    SDLFrameInfoEndServiceNack = 0x06,
+    SDLFrameInfoServiceDataAck = 0xFE,
+    SDLFrameInfoHeartbeatAck = 0xFF,
     // If frameType == Single (0x01)
-    SDLFrameData_SingleFrame = 0x00,
+    SDLFrameInfoSingleFrame = 0x00,
     // If frameType == First (0x02)
-    SDLFrameData_FirstFrame = 0x00,
+    SDLFrameInfoFirstFrame = 0x00,
     // If frametype == Consecutive (0x03)
-    SDLFrameData_ConsecutiveLastFrame = 0x00
+    SDLFrameInfoConsecutiveLastFrame = 0x00
 };
 
 NS_ASSUME_NONNULL_BEGIN
@@ -50,7 +50,7 @@ NS_ASSUME_NONNULL_BEGIN
 @property (assign, nonatomic) BOOL encrypted;
 @property (assign, nonatomic) SDLFrameType frameType;
 @property (assign, nonatomic) SDLServiceType serviceType;
-@property (assign, nonatomic) SDLFrameData frameData;
+@property (assign, nonatomic) SDLFrameInfo frameData;
 @property (assign, nonatomic) UInt8 sessionID;
 @property (assign, nonatomic) UInt32 bytesInPayload;
 

SmartDeviceLink/SDLProtocolMessage.m

@@ -52,7 +52,7 @@ - (NSString *)description {
     [description appendString:self.header.description];
 
     // If it's an RPC, provide greater detail
-    if (((self.header.serviceType == SDLServiceType_RPC) || (self.header.serviceType == SDLServiceType_BulkData)) && (self.header.frameType == SDLFrameType_Single)) {
+    if (((self.header.serviceType == SDLServiceTypeRPC) || (self.header.serviceType == SDLServiceTypeBulkData)) && (self.header.frameType == SDLFrameTypeSingle)) {
         // version of RPC Message determines how we access the info.
         if (self.header.version >= 2) {
             SDLRPCPayload *rpcPayload = [SDLRPCPayload rpcPayloadWithData:self.payload];

SmartDeviceLink/SDLProtocolMessageAssembler.m

@@ -39,12 +39,12 @@ - (void)handleMessage:(SDLProtocolMessage *)message withCompletionHandler:(SDLMe
     // Determine which frame it is and save it.
     // Note: frames are numbered 1,2,3, ..., 0
     // Always 0 for last frame.
-    if (message.header.frameType == SDLFrameType_First) {
+    if (message.header.frameType == SDLFrameTypeFirst) {
         // If it's the first-frame, extract the meta-data
         self.expectedBytes = NSSwapBigIntToHost(((UInt32 *)message.payload.bytes)[0]);
         self.frameCount = NSSwapBigIntToHost(((UInt32 *)message.payload.bytes)[1]);
         self.parts[@"firstframe"] = message.payload;
-    } else if (message.header.frameType == SDLFrameType_Consecutive) {
+    } else if (message.header.frameType == SDLFrameTypeConsecutive) {
         // Save the frame w/ frame# as the key
         NSInteger frameNumber = message.header.frameData;
         NSNumber *frameNumberObj = @(frameNumber);
@@ -60,8 +60,8 @@ - (void)handleMessage:(SDLProtocolMessage *)message withCompletionHandler:(SDLMe
 
         // Create the header
         SDLProtocolHeader *header = message.header.copy;
-        header.frameType = SDLFrameType_Single;
-        header.frameData = SDLFrameData_SingleFrame;
+        header.frameType = SDLFrameTypeSingle;
+        header.frameData = SDLFrameInfoSingleFrame;
 
 
         // Create the payload

SmartDeviceLink/SDLProtocolMessageDisassembler.m

@@ -38,7 +38,7 @@ @implementation SDLProtocolMessageDisassembler
 
     // Create the first message
     SDLProtocolHeader *firstFrameHeader = [incomingMessage.header copy];
-    firstFrameHeader.frameType = SDLFrameType_First;
+    firstFrameHeader.frameType = SDLFrameTypeFirst;
 
     UInt32 payloadData[2];
     payloadData[0] = CFSwapInt32HostToBig((UInt32)incomingMessage.payload.length);
@@ -57,7 +57,7 @@ @implementation SDLProtocolMessageDisassembler
         UInt8 frameNumber = (n % 255) + 1;
 
         SDLProtocolHeader *nextFrameHeader = [incomingMessage.header copy];
-        nextFrameHeader.frameType = SDLFrameType_Consecutive;
+        nextFrameHeader.frameType = SDLFrameTypeConsecutive;
         nextFrameHeader.frameData = frameNumber;
 
         NSUInteger offsetOfDataForThisFrame = headerSize + (n * numberOfDataBytesPerMessage);
@@ -71,8 +71,8 @@ @implementation SDLProtocolMessageDisassembler
 
     // Create the last message
     SDLProtocolHeader *lastFrameHeader = [incomingMessage.header copy];
-    lastFrameHeader.frameType = SDLFrameType_Consecutive;
-    lastFrameHeader.frameData = SDLFrameData_ConsecutiveLastFrame;
+    lastFrameHeader.frameType = SDLFrameTypeConsecutive;
+    lastFrameHeader.frameData = SDLFrameInfoConsecutiveLastFrame;
 
     NSUInteger numberOfMessagesCreatedSoFar = numberOfMessagesRequired - 1;
     NSUInteger numberOfDataBytesSentSoFar = numberOfMessagesCreatedSoFar * numberOfDataBytesPerMessage;

SmartDeviceLink/SDLProtocolReceivedMessageRouter.m

@@ -30,14 +30,14 @@ - (void)handleReceivedMessage:(SDLProtocolMessage *)message {
     SDLFrameType frameType = message.header.frameType;
 
     switch (frameType) {
-        case SDLFrameType_Single: {
+        case SDLFrameTypeSingle: {
             [self sdl_dispatchProtocolMessage:message];
         } break;
-        case SDLFrameType_Control: {
+        case SDLFrameTypeControl: {
             [self sdl_dispatchControlMessage:message];
         } break;
-        case SDLFrameType_First: // fallthrough
-        case SDLFrameType_Consecutive: {
+        case SDLFrameTypeFirst: // fallthrough
+        case SDLFrameTypeConsecutive: {
             [self sdl_dispatchMultiPartMessage:message];
         } break;
         default: break;
@@ -52,7 +52,7 @@ - (void)sdl_dispatchProtocolMessage:(SDLProtocolMessage *)message {
 
 - (void)sdl_dispatchControlMessage:(SDLProtocolMessage *)message {
     switch (message.header.frameData) {
-        case SDLFrameData_StartSessionACK: {
+        case SDLFrameInfoStartServiceAck: {
             if ([self.delegate respondsToSelector:@selector(handleProtocolStartSessionACK:sessionID:version:)]) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
@@ -66,27 +66,27 @@ - (void)sdl_dispatchControlMessage:(SDLProtocolMessage *)message {
                 [self.delegate handleProtocolStartSessionACK:message.header];
             }
         } break;
-        case SDLFrameData_StartSessionNACK: {
+        case SDLFrameInfoStartServiceNack: {
             if ([self.delegate respondsToSelector:@selector(handleProtocolStartSessionNACK:)]) {
                 [self.delegate handleProtocolStartSessionNACK:message.header.serviceType];
             }
         } break;
-        case SDLFrameData_EndSessionACK: {
+        case SDLFrameInfoEndServiceAck: {
             if ([self.delegate respondsToSelector:@selector(handleProtocolEndSessionACK:)]) {
                 [self.delegate handleProtocolEndSessionACK:message.header.serviceType];
             }
         } break;
-        case SDLFrameData_EndSessionNACK: {
+        case SDLFrameInfoEndServiceNack: {
             if ([self.delegate respondsToSelector:@selector(handleProtocolStartSessionNACK:)]) {
                 [self.delegate handleProtocolEndSessionNACK:message.header.serviceType];
             }
         } break;
-        case SDLFrameData_Heartbeat: {
+        case SDLFrameInfoHeartbeat: {
             if ([self.delegate respondsToSelector:@selector(handleHeartbeatForSession:)]) {
                 [self.delegate handleHeartbeatForSession:message.header.sessionID];
             }
         } break;
-        case SDLFrameData_HeartbeatACK: {
+        case SDLFrameInfoHeartbeatAck: {
             if ([self.delegate respondsToSelector:@selector(handleHeartbeatACK)]) {
                 [self.delegate handleHeartbeatACK];
             }

SmartDeviceLink/SDLProxy.m

@@ -211,7 +211,7 @@ - (void)onProtocolOpened {
     _isConnected = YES;
     [SDLDebugTool logInfo:@"StartSession (request)" withType:SDLDebugType_RPC toOutput:SDLDebugOutput_All toGroup:self.debugConsoleGroupName];
 
-    [self.protocol startServiceWithType:SDLServiceType_RPC];
+    [self.protocol startServiceWithType:SDLServiceTypeRPC];
 
     if (self.startSessionTimer == nil) {
         self.startSessionTimer = [[SDLTimer alloc] initWithDuration:startSessionTime repeat:NO];
@@ -239,7 +239,7 @@ - (void)handleProtocolStartSessionACK:(SDLProtocolHeader *)header {
     NSString *logMessage = [NSString stringWithFormat:@"StartSession (response)\nSessionId: %d for serviceType %d", header.sessionID, header.serviceType];
     [SDLDebugTool logInfo:logMessage withType:SDLDebugType_RPC toOutput:SDLDebugOutput_All toGroup:self.debugConsoleGroupName];
 
-    if (header.serviceType == SDLServiceType_RPC) {
+    if (header.serviceType == SDLServiceTypeRPC) {
         [self invokeMethodOnDelegates:@selector(onProxyOpened) withObject:nil];
     }
 }