Adding new Version class and updating WiProProtocol to use it

3 files changed, 136 insertions, 34 deletions

diff --git a/sdl_android/src/androidTest/java/com/smartdevicelink/test/util/VersionTest.java b/sdl_android/src/androidTest/java/com/smartdevicelink/test/util/VersionTest.java
new file mode 100644
index 000000000..44d25ffe0
--- /dev/null
+++ b/sdl_android/src/androidTest/java/com/smartdevicelink/test/util/VersionTest.java
@@ -0,0 +1,31 @@
+package com.smartdevicelink.test.util;
+
+import android.test.AndroidTestCase;
+
+import com.smartdevicelink.util.Version;
+
+public class VersionTest extends AndroidTestCase {
+
+    private static final String TEST_VERSION = "1.2.3";
+
+    public void testConstructorCorrect(){
+        Version version = new Version(TEST_VERSION);
+        assertEquals(1, version.getMajor());
+        assertEquals(2, version.getMinor());
+        assertEquals(3, version.getPatch());
+    }
+
+    public void testConstructorIncorrect(){
+        try{
+            Version version = new Version("1.2");
+        }catch (Exception e){
+            assert true;
+        }
+        assert false;
+    }
+
+    public void testToString(){
+        Version version = new Version(TEST_VERSION);
+        assertEquals(version.toString(), TEST_VERSION);
+    }
+}
diff --git a/sdl_android/src/main/java/com/smartdevicelink/protocol/WiProProtocol.java b/sdl_android/src/main/java/com/smartdevicelink/protocol/WiProProtocol.java
index b510067b8..00e86b058 100644
--- a/sdl_android/src/main/java/com/smartdevicelink/protocol/WiProProtocol.java
+++ b/sdl_android/src/main/java/com/smartdevicelink/protocol/WiProProtocol.java
@@ -15,6 +15,7 @@ import com.smartdevicelink.protocol.enums.SessionType;
 import com.smartdevicelink.security.SdlSecurityBase;

 import com.smartdevicelink.util.BitConverter;

 import com.smartdevicelink.util.DebugTool;

+import com.smartdevicelink.util.Version;

 

 import java.io.ByteArrayOutputStream;

 import java.util.HashMap;

@@ -22,9 +23,11 @@ import java.util.Hashtable;
 import java.util.List;

 

 public class WiProProtocol extends AbstractProtocol {

-	byte _version = 1;

+	//byte _version = 1;

 	private final static String FailurePropagating_Msg = "Failure propagating ";

-	public static String MAX_PROTOCOL_VERSION = "5.0.0";

+	private static final Version MAX_PROTOCOL_VERSION = new Version("5.0.0");

+	private Version protocolVersion = new Version("1.0.0");

+	byte _version = 1;

 

 	public static final int V1_V2_MTU_SIZE = 1500;

 	public static final int V3_V4_MTU_SIZE = 131072;

@@ -77,9 +80,26 @@ public class WiProProtocol extends AbstractProtocol {
 		}

 		return mtu;

 	}

-	

+

+

+	/**

+	 * Use getProtocolVersion() or getMajorVersionByte instead.<br>

+	 * Returns the Major version of the currently used protocol version

+	 */

+	@Deprecated

 	public byte getVersion() {

-		return this._version;

+		return getMajorVersionByte();

+	}

+

+	public Version getProtocolVersion(){

+		return this.protocolVersion;

+	}

+	public byte getMajorVersionByte(){

+		if(_version == 1){

+			_version = new Integer(this.protocolVersion.getMajor()).byteValue();

+		}

+		return _version;

+

 	}

 

 	/**

@@ -88,48 +108,48 @@ public class WiProProtocol extends AbstractProtocol {
 	 */

 	public void setVersion(byte version) {

         if (version > 5) {

-            this._version = 5; //protect for future, proxy only supports v5 or lower

+            this.protocolVersion = new Version("5.0.0"); //protect for future, proxy only supports v5 or lower

             HEADER_SIZE = 12;

 			mtus.put(SessionType.RPC,new Long(V3_V4_MTU_SIZE) );

         } else if (version == 5) {

-	        this._version = version;

+			this.protocolVersion = new Version("5.0.0");

 	        HEADER_SIZE = 12;

 			mtus.put(SessionType.RPC,new Long(V3_V4_MTU_SIZE) );

         }else if (version == 4) {

-            this._version = version;

+			this.protocolVersion = new Version("4.0.0");

             HEADER_SIZE = 12;

 			mtus.put(SessionType.RPC,new Long(V3_V4_MTU_SIZE) ); //versions 4 supports 128k MTU

         } else if (version == 3) {

-            this._version = version;

+			this.protocolVersion = new Version("3.0.0");

             HEADER_SIZE = 12;

 			mtus.put(SessionType.RPC,new Long(V3_V4_MTU_SIZE) ); //versions 3 supports 128k MTU

         } else if (version == 2) {

-            this._version = version;

+			this.protocolVersion = new Version("2.0.0");

             HEADER_SIZE = 12;

 			mtus.put(SessionType.RPC,new Long(V1_V2_MTU_SIZE - HEADER_SIZE) );

         } else if (version == 1){

-            this._version = version;

+			this.protocolVersion = new Version("1.0.0");

             HEADER_SIZE = 8;

 			mtus.put(SessionType.RPC,new Long(V1_V2_MTU_SIZE - HEADER_SIZE) );

         }

     }

 

 	public void StartProtocolSession(SessionType sessionType) {

-		SdlPacket header = SdlPacketFactory.createStartSession(sessionType, 0x00, _version, (byte) 0x00, false);

+		SdlPacket header = SdlPacketFactory.createStartSession(sessionType, 0x00, getMajorVersionByte(), (byte) 0x00, false);

 		if(sessionType.equals(SessionType.RPC)){ // check for RPC session

-			header.putTag(BsonTags.PROTOCOL_VERSION, MAX_PROTOCOL_VERSION);

-			Log.i(sessionType.getName(), "Sending PROTOCOL_VERSION: "+MAX_PROTOCOL_VERSION);

+			header.putTag(BsonTags.PROTOCOL_VERSION, protocolVersion);

+			Log.i(sessionType.getName(), "Sending PROTOCOL_VERSION: "+ protocolVersion);

 		}

 		handlePacketToSend(header);

 	} // end-method

 

 	private void sendStartProtocolSessionACK(SessionType sessionType, byte sessionID) {

-		SdlPacket header = SdlPacketFactory.createStartSessionACK(sessionType, sessionID, 0x00, _version);

+		SdlPacket header = SdlPacketFactory.createStartSessionACK(sessionType, sessionID, 0x00, getMajorVersionByte());

 		handlePacketToSend(header);

 	} // end-method

 	

 	public void EndProtocolSession(SessionType sessionType, byte sessionID, int hashId) {

-		SdlPacket header = SdlPacketFactory.createEndSession(sessionType, sessionID, hashID, _version, BitConverter.intToByteArray(hashId));

+		SdlPacket header = SdlPacketFactory.createEndSession(sessionType, sessionID, hashID, getMajorVersionByte(), BitConverter.intToByteArray(hashId));

 		if(sessionType.equals(SessionType.RPC)){ // check for RPC session

 			header.putTag(BsonTags.HASH_ID, hashID);

 			Log.i(sessionType.getName(), "Sending " + BsonTags.HASH_ID + " : "+hashID);

@@ -144,7 +164,7 @@ public class WiProProtocol extends AbstractProtocol {
 		byte sessionID = protocolMsg.getSessionID();

 		

 		byte[] data = null;

-		if (_version > 1 && sessionType != SessionType.NAV && sessionType != SessionType.PCM) {

+		if (protocolVersion.getMajor() > 1 && sessionType != SessionType.NAV && sessionType != SessionType.PCM) {

             if (sessionType.eq(SessionType.CONTROL)) {

                 final byte[] secureData = protocolMsg.getData().clone();

                 data = new byte[HEADER_SIZE + secureData.length];

@@ -221,7 +241,7 @@ public class WiProProtocol extends AbstractProtocol {
 				// Second four bytes are frame count.

 				System.arraycopy(BitConverter.intToByteArray(frameCount), 0, firstFrameData, 4, 4);

 

-				SdlPacket firstHeader = SdlPacketFactory.createMultiSendDataFirst(sessionType, sessionID, messageID, _version,firstFrameData,protocolMsg.getPayloadProtected());

+				SdlPacket firstHeader = SdlPacketFactory.createMultiSendDataFirst(sessionType, sessionID, messageID, getMajorVersionByte(),firstFrameData,protocolMsg.getPayloadProtected());

 				firstHeader.setPriorityCoefficient(1+protocolMsg.priorityCoefficient);

 				//Send the first frame

 				handlePacketToSend(firstHeader);

@@ -246,14 +266,14 @@ public class WiProProtocol extends AbstractProtocol {
 					if (bytesToWrite > mtu) {

 						bytesToWrite = mtu.intValue();

 					}

-					SdlPacket consecHeader = SdlPacketFactory.createMultiSendDataRest(sessionType, sessionID, bytesToWrite, frameSequenceNumber , messageID, _version,data, currentOffset, bytesToWrite, protocolMsg.getPayloadProtected());

+					SdlPacket consecHeader = SdlPacketFactory.createMultiSendDataRest(sessionType, sessionID, bytesToWrite, frameSequenceNumber , messageID, getMajorVersionByte(),data, currentOffset, bytesToWrite, protocolMsg.getPayloadProtected());

 					consecHeader.setPriorityCoefficient(i+2+protocolMsg.priorityCoefficient);

 					handlePacketToSend(consecHeader);

 					currentOffset += bytesToWrite;

 				}

 			} else {

 				messageID++;

-				SdlPacket header = SdlPacketFactory.createSingleSendData(sessionType, sessionID, data.length, messageID, _version,data, protocolMsg.getPayloadProtected());

+				SdlPacket header = SdlPacketFactory.createSingleSendData(sessionType, sessionID, data.length, messageID, getMajorVersionByte(),data, protocolMsg.getPayloadProtected());

 				header.setPriorityCoefficient(protocolMsg.priorityCoefficient);

 				handlePacketToSend(header);

 			}

@@ -262,7 +282,7 @@ public class WiProProtocol extends AbstractProtocol {
 

 	public void handlePacketReceived(SdlPacket packet){

 		//Check for a version difference

-		if (_version == 1) {

+		if (getMajorVersionByte() == 1) {

 			setVersion((byte)packet.version);	

 		}

 		

@@ -327,13 +347,13 @@ public class WiProProtocol extends AbstractProtocol {
 				message.setSessionType(SessionType.valueOf((byte)packet.getServiceType()));

 				message.setSessionID((byte)packet.getSessionId());

 				//If it is WiPro 2.0 it must have binary header

-				if (_version > 1) {

+				if (protocolVersion.getMajor() > 1) {

 					BinaryFrameHeader binFrameHeader = BinaryFrameHeader.

 							parseBinaryHeader(accumulator.toByteArray());

 					if(binFrameHeader == null) {

 						return;

 					}

-					message.setVersion(_version);

+					message.setVersion(getMajorVersionByte());

 					message.setRPCType(binFrameHeader.getRPCType());

 					message.setFunctionID(binFrameHeader.getFunctionID());

 					message.setCorrID(binFrameHeader.getCorrID());

@@ -440,11 +460,15 @@ public class WiProProtocol extends AbstractProtocol {
 					}

 					if(serviceType.equals(SessionType.RPC)){

 						hashID = (Integer) packet.getTag(BsonTags.HASH_ID);

-						MAX_PROTOCOL_VERSION = (String) packet.getTag(BsonTags.PROTOCOL_VERSION);

+						Object version = packet.getTag(BsonTags.PROTOCOL_VERSION);

+						if(version!=null){

+							//At this point we have confirmed the negotiated version between the module and the proxy

+							protocolVersion = new Version((String)version);

+						}

 

 						Log.i(serviceType.getName(), "Receiving hashID: "+hashID);

 						Log.i(serviceType.getName(), "Receiving mtu: "+packet.getTag(BsonTags.MTU));

-						Log.i(serviceType.getName(), "Receiving MAX_PROTOCOL_VERSION: "+MAX_PROTOCOL_VERSION);

+						Log.i(serviceType.getName(), "Receiving MAX_PROTOCOL_VERSION: "+ protocolVersion);

 					}else if(serviceType.equals(SessionType.PCM)){

 						hashID = (Integer) packet.getTag(BsonTags.HASH_ID);

 

@@ -458,13 +482,13 @@ public class WiProProtocol extends AbstractProtocol {
 						// TODO: Implement remaining bson tags for video

 					}

 				}else{

-					if (_version > 1){

+					if (protocolVersion.getMajor() > 1){

 						if (packet.payload!= null && packet.dataSize == 4){ //hashid will be 4 bytes in length

 							hashID = BitConverter.intFromByteArray(packet.payload, 0);

 						}

 					}

 				}

-				handleProtocolSessionStarted(serviceType,(byte) packet.getSessionId(), _version, "", hashID, packet.isEncrypted());

+				handleProtocolSessionStarted(serviceType,(byte) packet.getSessionId(), getMajorVersionByte(), "", hashID, packet.isEncrypted());

 			} else if (frameInfo == FrameDataControlFrameType.StartSessionNACK.getValue()) {

 				if(packet.version >= 5){

 					if(serviceType.equals(SessionType.RPC) || serviceType.equals(SessionType.PCM) ||

@@ -474,12 +498,12 @@ public class WiProProtocol extends AbstractProtocol {
 					}

 				}

 				if (serviceType.eq(SessionType.NAV) || serviceType.eq(SessionType.PCM)) {

-					handleProtocolSessionNACKed(serviceType, (byte)packet.getSessionId(), _version, "");

+					handleProtocolSessionNACKed(serviceType, (byte)packet.getSessionId(), getMajorVersionByte(), "");

 				} else {

 					handleProtocolError("Got StartSessionNACK for protocol sessionID=" + packet.getSessionId(), null);

 				}

 			} else if (frameInfo == FrameDataControlFrameType.EndSession.getValue()) {

-				if (_version > 1) {

+				if (protocolVersion.getMajor() > 1) {

 					handleProtocolSessionEnded(serviceType, (byte)packet.getSessionId(), "");

 				} else {

 					handleProtocolSessionEnded(serviceType, (byte)packet.getSessionId(), "");

@@ -518,13 +542,13 @@ public class WiProProtocol extends AbstractProtocol {
 			message.setSessionID((byte)packet.getSessionId());

 			//If it is WiPro 2.0 it must have binary header

 			boolean isControlService = message.getSessionType().equals(SessionType.CONTROL);

-			if (_version > 1&& !isControlService) {

+			if (protocolVersion.getMajor() > 1 && !isControlService) {

 				BinaryFrameHeader binFrameHeader = BinaryFrameHeader.

 						parseBinaryHeader(packet.payload);

 				if(binFrameHeader == null) {

 					return;

 				}

-				message.setVersion(_version);

+				message.setVersion(getMajorVersionByte());

 				message.setRPCType(binFrameHeader.getRPCType());

 				message.setFunctionID(binFrameHeader.getFunctionID());

 				message.setCorrID(binFrameHeader.getCorrID());

@@ -551,7 +575,7 @@ public class WiProProtocol extends AbstractProtocol {
 

 	@Override

 	public void StartProtocolService(SessionType sessionType, byte sessionID, boolean isEncrypted) {

-		SdlPacket header = SdlPacketFactory.createStartSession(sessionType, 0x00, _version, sessionID, isEncrypted);

+		SdlPacket header = SdlPacketFactory.createStartSession(sessionType, 0x00, getMajorVersionByte(), sessionID, isEncrypted);

 		if(sessionType.equals(SessionType.NAV)){

 			// TODO: Add bson tags for video service

 		}

@@ -572,19 +596,19 @@ public class WiProProtocol extends AbstractProtocol {
 

 	@Override

 	public void SendHeartBeat(byte sessionID) {

-        final SdlPacket heartbeat = SdlPacketFactory.createHeartbeat(SessionType.CONTROL, sessionID, _version);        

+        final SdlPacket heartbeat = SdlPacketFactory.createHeartbeat(SessionType.CONTROL, sessionID, getMajorVersionByte());

         handlePacketToSend(heartbeat);		

 	}

 

 	@Override

 	public void SendHeartBeatACK(byte sessionID) {

-        final SdlPacket heartbeat = SdlPacketFactory.createHeartbeatACK(SessionType.CONTROL, sessionID, _version);        

+        final SdlPacket heartbeat = SdlPacketFactory.createHeartbeatACK(SessionType.CONTROL, sessionID, getMajorVersionByte());

         handlePacketToSend(heartbeat);		

 	}

 

 	@Override

 	public void EndProtocolService(SessionType serviceType, byte sessionID) {

- 		SdlPacket header = SdlPacketFactory.createEndSession(serviceType, sessionID, hashID, _version, new byte[4]);

+ 		SdlPacket header = SdlPacketFactory.createEndSession(serviceType, sessionID, hashID, getMajorVersionByte(), new byte[4]);

 		handlePacketToSend(header);

 		if(serviceType.equals(SessionType.PCM) || serviceType.equals(SessionType.NAV)){ // check for RPC session

 			header.putTag(BsonTags.HASH_ID, hashID);

diff --git a/sdl_android/src/main/java/com/smartdevicelink/util/Version.java b/sdl_android/src/main/java/com/smartdevicelink/util/Version.java
new file mode 100644
index 000000000..49fcfa9e8
--- /dev/null
+++ b/sdl_android/src/main/java/com/smartdevicelink/util/Version.java
@@ -0,0 +1,47 @@
+package com.smartdevicelink.util;
+
+
+public class Version {
+
+    Integer major,minor,patch;
+
+    public Version(){
+        major = 0;
+        minor = 0;
+        patch = 0;
+    }
+
+    public Version(String versionString){
+        String[] versions = versionString.split("\\.");
+        if(versions.length!=3){
+            throw new IllegalArgumentException("Incorrect version string format");
+        }
+        major = Integer.valueOf(versions[0]);
+        minor = Integer.valueOf(versions[1]);
+        patch = Integer.valueOf(versions[2]);
+
+    }
+
+    public Integer getMajor() {
+        return major;
+    }
+
+    public Integer getMinor() {
+        return minor;
+    }
+
+    public Integer getPatch() {
+        return patch;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        builder.append(major);
+        builder.append(".");
+        builder.append(minor);
+        builder.append(".");
+        builder.append(patch);
+        return builder.toString();
+    }
+}