SDL_Android/SmartDeviceLinkAndroidProxy - added the correct version of the proxy
[profile/ivi/smartdevicelink.git] / SDL_Android / SmartDeviceLinkProxyAndroid / src / com / smartdevicelink / trace / Mime.java
index d2b28df..059d642 100755 (executable)
-//
-// Copyright (c) 2013 Ford Motor Company
-//
-package com.smartdevicelink.trace;
-
-public class Mime {
-       
-       private static String m_base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-       
-       public static String base64Encode(String str) {
-               String b64String = "";
-               try {
-                       byte[] strBytes = str.getBytes("US-ASCII");
-                       b64String = base64Encode(strBytes);
-               } catch (Exception ex) {
-                       // Don't care?
-               } // end-catch
-               return b64String;
-       } // end-method
-
-       public static String base64Encode(byte bytesToEncode[]) {
-               return base64Encode(bytesToEncode, 0, bytesToEncode.length);
-       } // end-method
-
-       public static String base64Encode(byte bytesToEncode[], int offset, int length) {
-               StringBuilder sb = new StringBuilder();
-
-               int             idxin = 0;
-               int             b64idx = 0;
-
-               for (idxin=offset;idxin < offset + length;idxin++) {
-                       switch ((idxin-offset) % 3) {
-                               case 0:
-                                       b64idx = (bytesToEncode[idxin] >> 2) & 0x3f;
-                                       break;
-                               case 1:
-                                       b64idx = (bytesToEncode[idxin] >> 4) & 0x0f;
-                                       b64idx |= ((bytesToEncode[idxin-1] << 4)& 0x30);
-                                       break;
-                               case 2:
-                                       b64idx = (bytesToEncode[idxin] >> 6) & 0x03;
-                                       b64idx |= ((bytesToEncode[idxin-1] << 2)& 0x3c);
-                                       sb.append(m_base64Chars.charAt(b64idx));
-                                       b64idx = bytesToEncode[idxin] & 0x3f;
-                                       break;
-                       } // end-switch
-                       sb.append(m_base64Chars.charAt(b64idx));
-               } // end-for
-
-               switch ((idxin-offset) % 3) {
-                       case 0:
-                               break;
-                       case 1:
-                               b64idx = (bytesToEncode[idxin-1] << 4) & 0x30;
-                               sb.append(m_base64Chars.charAt(b64idx));
-                               sb.append("==");
-                               break;
-                       case 2:
-                               b64idx = ((bytesToEncode[idxin-1] << 2)& 0x3c);
-                               sb.append(m_base64Chars.charAt(b64idx));
-                               sb.append('=');
-                               break;
-               } // end-switch
-               
-               return sb.toString();
-
-       } // end-method
-
-       private byte[] base64Decode(String base64String) {
-               byte[] outBytes = null;
-               byte[] base64ASCIIString = null;
-               final String ASCII_Encoding = "US-ASCII";
-               
-               // Convert b64 string to raw bytes
-               try {
-                       base64ASCIIString = base64String.getBytes(ASCII_Encoding);
-               } catch (Exception ex) {
-                       return null;
-               }
-               
-               if (!m_decodeInitComplete) {
-                       m_decodeInitComplete = true;
-                       initForDecode();
-               } // end-if
-
-               int     numInChars = base64ASCIIString.length;
-
-               if ((numInChars % 4) > 0) {
-                       return null;
-               } // end-if
-
-               int numOutBytes = base64ASCIIString.length / 4;
-               numOutBytes *= 3;
-               int     eqpos = base64String.indexOf("=");
-               if (eqpos >= 0) {
-                       numOutBytes--;
-                       if (base64String.substring(eqpos).indexOf("==") >= 0) {
-                               numOutBytes--;
-                       } // end-if
-               } // end-if
-               outBytes = new byte[numOutBytes];
-
-               byte    b64idxbits = 0x00;
-               int             iidx = 0, oidx = 0;
-               byte    writeByte = 0x00;
-               byte    b64ASCIIChar = 0x00;
-               for (iidx=0, oidx=0;iidx < numInChars;iidx++) {
-                       b64ASCIIChar = base64ASCIIString[iidx];
-                       if (b64ASCIIChar == 0x3d /*'='*/) {
-                               return outBytes;
-                       } // end-if
-
-                       if (!isb64char(b64ASCIIChar)) {
-                               return null;
-                       } // end-if
-
-                       switch (iidx % 4) {
-                               case 0:
-                                       break;
-                               case 1:
-                                       b64idxbits = b64decode[base64ASCIIString[iidx-1]];
-                                       writeByte = (byte)((b64idxbits << 2) | ((b64decode[b64ASCIIChar] >> 4) & 0x03));
-                                       outBytes[oidx++] = writeByte;
-                                       break;
-                               case 2:
-                                       b64idxbits = b64decode[base64ASCIIString[iidx-1]];
-                                       writeByte = (byte)(((b64idxbits << 4) & 0xf0) | ((b64decode[b64ASCIIChar] >> 2) & 0x0f));
-                                       outBytes[oidx++] = writeByte;
-                                       break;
-                               case 3:
-                                       b64idxbits = b64decode[base64ASCIIString[iidx-1]];
-                                       writeByte = (byte)(((b64idxbits << 6) & 0xc0) | ((b64decode[b64ASCIIChar]) & 0x3f));
-                                       outBytes[oidx++] = writeByte;
-                                       break;
-                       } // end-switch
-               } // end-for
-
-               return outBytes;
-
-       } // end-method
-
-
-       private static  byte[]  b64decode = new byte[256];
-       // A-Z is 0x41-0x5a
-       // a-z is 0x61-0x7a
-       // 0-9 is 0x30-0x39
-       // + is 0x2b
-       // / is 0x2f
-
-       private static  boolean m_decodeInitComplete = false;
-
-       private void initForDecode() {
-               int aidx = 0;
-               int lidx = 0;
-               // Set A-Z
-               for (aidx=0x41, lidx=0;aidx <= 0x5a;aidx++, lidx++) {
-                       b64decode[aidx] = (byte)lidx;
-               } // end-for
-               // Set a-z
-               for (aidx=0x61;aidx <= 0x7a;aidx++, lidx++) {
-                       b64decode[aidx] = (byte)lidx;
-               } // end-for
-               // Set 0-9
-               for (aidx=0x30;aidx <= 0x39;aidx++, lidx++) {
-                       b64decode[aidx] = (byte)lidx;
-               } // end-for
-               // Set '+'
-               b64decode[0x2b] = (byte)lidx++;
-               // Set '/'
-               b64decode[0x2f] = (byte)lidx++;
-       } // end-method
-
-       private boolean isb64char(byte b) {
-               // A-Z is 0x41-0x5a
-               // a-z is 0x61-0x7a
-               // 0-9 is 0x30-0x39
-               // + is 0x2b
-               // / is 0x2f
-               return (   (b >= 0x41 && b <= 0x5a)
-                       || (b >= 0x61 && b <= 0x7a)
-                       || (b >= 0x30 && b <= 0x39)
-                       || (b == 0x2b)
-                       || (b == 0x2f)
-                       );
-       } // end-method
-} // end-class
+package com.smartdevicelink.trace;\r
+\r
+// Borrowed from Dave Boll's infamous SmartDeviceLinkLinkRelay.java\r
+\r
+public class Mime {\r
+       \r
+       private static String m_base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";\r
+       \r
+       public static String base64Encode(String str) {\r
+               String b64String = "";\r
+               try {\r
+                       byte[] strBytes = str.getBytes("US-ASCII");\r
+                       b64String = base64Encode(strBytes);\r
+               } catch (Exception ex) {\r
+                       // Don't care?\r
+               } // end-catch\r
+               return b64String;\r
+       } // end-method\r
+\r
+       public static String base64Encode(byte bytesToEncode[]) {\r
+               return base64Encode(bytesToEncode, 0, bytesToEncode.length);\r
+       } // end-method\r
+\r
+       public static String base64Encode(byte bytesToEncode[], int offset, int length) {\r
+               StringBuilder sb = new StringBuilder();\r
+\r
+               int             idxin = 0;\r
+               int             b64idx = 0;\r
+\r
+               for (idxin=offset;idxin < offset + length;idxin++) {\r
+                       switch ((idxin-offset) % 3) {\r
+                               case 0:\r
+                                       b64idx = (bytesToEncode[idxin] >> 2) & 0x3f;\r
+                                       break;\r
+                               case 1:\r
+                                       b64idx = (bytesToEncode[idxin] >> 4) & 0x0f;\r
+                                       b64idx |= ((bytesToEncode[idxin-1] << 4)& 0x30);\r
+                                       break;\r
+                               case 2:\r
+                                       b64idx = (bytesToEncode[idxin] >> 6) & 0x03;\r
+                                       b64idx |= ((bytesToEncode[idxin-1] << 2)& 0x3c);\r
+                                       sb.append(m_base64Chars.charAt(b64idx));\r
+                                       b64idx = bytesToEncode[idxin] & 0x3f;\r
+                                       break;\r
+                       } // end-switch\r
+                       sb.append(m_base64Chars.charAt(b64idx));\r
+               } // end-for\r
+\r
+               switch ((idxin-offset) % 3) {\r
+                       case 0:\r
+                               break;\r
+                       case 1:\r
+                               b64idx = (bytesToEncode[idxin-1] << 4) & 0x30;\r
+                               sb.append(m_base64Chars.charAt(b64idx));\r
+                               sb.append("==");\r
+                               break;\r
+                       case 2:\r
+                               b64idx = ((bytesToEncode[idxin-1] << 2)& 0x3c);\r
+                               sb.append(m_base64Chars.charAt(b64idx));\r
+                               sb.append('=');\r
+                               break;\r
+               } // end-switch\r
+               \r
+               return sb.toString();\r
+\r
+       } // end-method\r
+\r
+       private byte[] base64Decode(String base64String) {\r
+               byte[] outBytes = null;\r
+               byte[] base64ASCIIString = null;\r
+               final String ASCII_Encoding = "US-ASCII";\r
+               \r
+               // Convert b64 string to raw bytes\r
+               try {\r
+                       base64ASCIIString = base64String.getBytes(ASCII_Encoding);\r
+               } catch (Exception ex) {\r
+                       return null;\r
+               }\r
+               \r
+               if (!m_decodeInitComplete) {\r
+                       m_decodeInitComplete = true;\r
+                       initForDecode();\r
+               } // end-if\r
+\r
+               int     numInChars = base64ASCIIString.length;\r
+\r
+               if ((numInChars % 4) > 0) {\r
+                       return null;\r
+               } // end-if\r
+\r
+               int numOutBytes = base64ASCIIString.length / 4;\r
+               numOutBytes *= 3;\r
+               int     eqpos = base64String.indexOf("=");\r
+               if (eqpos >= 0) {\r
+                       numOutBytes--;\r
+                       if (base64String.substring(eqpos).indexOf("==") >= 0) {\r
+                               numOutBytes--;\r
+                       } // end-if\r
+               } // end-if\r
+               outBytes = new byte[numOutBytes];\r
+\r
+               byte    b64idxbits = 0x00;\r
+               int             iidx = 0, oidx = 0;\r
+               byte    writeByte = 0x00;\r
+               byte    b64ASCIIChar = 0x00;\r
+               for (iidx=0, oidx=0;iidx < numInChars;iidx++) {\r
+                       b64ASCIIChar = base64ASCIIString[iidx];\r
+                       if (b64ASCIIChar == 0x3d /*'='*/) {\r
+                               return outBytes;\r
+                       } // end-if\r
+\r
+                       if (!isb64char(b64ASCIIChar)) {\r
+                               return null;\r
+                       } // end-if\r
+\r
+                       switch (iidx % 4) {\r
+                               case 0:\r
+                                       break;\r
+                               case 1:\r
+                                       b64idxbits = b64decode[base64ASCIIString[iidx-1]];\r
+                                       writeByte = (byte)((b64idxbits << 2) | ((b64decode[b64ASCIIChar] >> 4) & 0x03));\r
+                                       outBytes[oidx++] = writeByte;\r
+                                       break;\r
+                               case 2:\r
+                                       b64idxbits = b64decode[base64ASCIIString[iidx-1]];\r
+                                       writeByte = (byte)(((b64idxbits << 4) & 0xf0) | ((b64decode[b64ASCIIChar] >> 2) & 0x0f));\r
+                                       outBytes[oidx++] = writeByte;\r
+                                       break;\r
+                               case 3:\r
+                                       b64idxbits = b64decode[base64ASCIIString[iidx-1]];\r
+                                       writeByte = (byte)(((b64idxbits << 6) & 0xc0) | ((b64decode[b64ASCIIChar]) & 0x3f));\r
+                                       outBytes[oidx++] = writeByte;\r
+                                       break;\r
+                       } // end-switch\r
+               } // end-for\r
+\r
+               return outBytes;\r
+\r
+       } // end-method\r
+\r
+\r
+       private static  byte[]  b64decode = new byte[256];\r
+       // A-Z is 0x41-0x5a\r
+       // a-z is 0x61-0x7a\r
+       // 0-9 is 0x30-0x39\r
+       // + is 0x2b\r
+       // / is 0x2f\r
+\r
+       private static  boolean m_decodeInitComplete = false;\r
+\r
+       private void initForDecode() {\r
+               int aidx = 0;\r
+               int lidx = 0;\r
+               // Set A-Z\r
+               for (aidx=0x41, lidx=0;aidx <= 0x5a;aidx++, lidx++) {\r
+                       b64decode[aidx] = (byte)lidx;\r
+               } // end-for\r
+               // Set a-z\r
+               for (aidx=0x61;aidx <= 0x7a;aidx++, lidx++) {\r
+                       b64decode[aidx] = (byte)lidx;\r
+               } // end-for\r
+               // Set 0-9\r
+               for (aidx=0x30;aidx <= 0x39;aidx++, lidx++) {\r
+                       b64decode[aidx] = (byte)lidx;\r
+               } // end-for\r
+               // Set '+'\r
+               b64decode[0x2b] = (byte)lidx++;\r
+               // Set '/'\r
+               b64decode[0x2f] = (byte)lidx++;\r
+       } // end-method\r
+\r
+       private boolean isb64char(byte b) {\r
+               // A-Z is 0x41-0x5a\r
+               // a-z is 0x61-0x7a\r
+               // 0-9 is 0x30-0x39\r
+               // + is 0x2b\r
+               // / is 0x2f\r
+               return (   (b >= 0x41 && b <= 0x5a)\r
+                       || (b >= 0x61 && b <= 0x7a)\r
+                       || (b >= 0x30 && b <= 0x39)\r
+                       || (b == 0x2b)\r
+                       || (b == 0x2f)\r
+                       );\r
+       } // end-method\r
+} // end-class
\ No newline at end of file