SDL_Android/SmartDeviceLinkProxyAndroid/src/com/smartdevicelink/trace/Mime.java

   1 package com.smartdevicelink.trace;\r
   2 \r
   3 // Borrowed from Dave Boll's infamous SmartDeviceLinkLinkRelay.java\r
   4 \r
   5 public class Mime {\r
   6         \r
   7         private static String m_base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";\r
   8         \r
   9         public static String base64Encode(String str) {\r
  10                 String b64String = "";\r
  11                 try {\r
  12                         byte[] strBytes = str.getBytes("US-ASCII");\r
  13                         b64String = base64Encode(strBytes);\r
  14                 } catch (Exception ex) {\r
  15                         // Don't care?\r
  16                 } // end-catch\r
  17                 return b64String;\r
  18         } // end-method\r
  19 \r
  20         public static String base64Encode(byte bytesToEncode[]) {\r
  21                 return base64Encode(bytesToEncode, 0, bytesToEncode.length);\r
  22         } // end-method\r
  23 \r
  24         public static String base64Encode(byte bytesToEncode[], int offset, int length) {\r
  25                 StringBuilder sb = new StringBuilder();\r
  26 \r
  27                 int             idxin = 0;\r
  28                 int             b64idx = 0;\r
  29 \r
  30                 for (idxin=offset;idxin < offset + length;idxin++) {\r
  31                         switch ((idxin-offset) % 3) {\r
  32                                 case 0:\r
  33                                         b64idx = (bytesToEncode[idxin] >> 2) & 0x3f;\r
  34                                         break;\r
  35                                 case 1:\r
  36                                         b64idx = (bytesToEncode[idxin] >> 4) & 0x0f;\r
  37                                         b64idx |= ((bytesToEncode[idxin-1] << 4)& 0x30);\r
  38                                         break;\r
  39                                 case 2:\r
  40                                         b64idx = (bytesToEncode[idxin] >> 6) & 0x03;\r
  41                                         b64idx |= ((bytesToEncode[idxin-1] << 2)& 0x3c);\r
  42                                         sb.append(m_base64Chars.charAt(b64idx));\r
  43                                         b64idx = bytesToEncode[idxin] & 0x3f;\r
  44                                         break;\r
  45                         } // end-switch\r
  46                         sb.append(m_base64Chars.charAt(b64idx));\r
  47                 } // end-for\r
  48 \r
  49                 switch ((idxin-offset) % 3) {\r
  50                         case 0:\r
  51                                 break;\r
  52                         case 1:\r
  53                                 b64idx = (bytesToEncode[idxin-1] << 4) & 0x30;\r
  54                                 sb.append(m_base64Chars.charAt(b64idx));\r
  55                                 sb.append("==");\r
  56                                 break;\r
  57                         case 2:\r
  58                                 b64idx = ((bytesToEncode[idxin-1] << 2)& 0x3c);\r
  59                                 sb.append(m_base64Chars.charAt(b64idx));\r
  60                                 sb.append('=');\r
  61                                 break;\r
  62                 } // end-switch\r
  63                 \r
  64                 return sb.toString();\r
  65 \r
  66         } // end-method\r
  67 \r
  68         private byte[] base64Decode(String base64String) {\r
  69                 byte[] outBytes = null;\r
  70                 byte[] base64ASCIIString = null;\r
  71                 final String ASCII_Encoding = "US-ASCII";\r
  72                 \r
  73                 // Convert b64 string to raw bytes\r
  74                 try {\r
  75                         base64ASCIIString = base64String.getBytes(ASCII_Encoding);\r
  76                 } catch (Exception ex) {\r
  77                         return null;\r
  78                 }\r
  79                 \r
  80                 if (!m_decodeInitComplete) {\r
  81                         m_decodeInitComplete = true;\r
  82                         initForDecode();\r
  83                 } // end-if\r
  84 \r
  85                 int     numInChars = base64ASCIIString.length;\r
  86 \r
  87                 if ((numInChars % 4) > 0) {\r
  88                         return null;\r
  89                 } // end-if\r
  90 \r
  91                 int numOutBytes = base64ASCIIString.length / 4;\r
  92                 numOutBytes *= 3;\r
  93                 int     eqpos = base64String.indexOf("=");\r
  94                 if (eqpos >= 0) {\r
  95                         numOutBytes--;\r
  96                         if (base64String.substring(eqpos).indexOf("==") >= 0) {\r
  97                                 numOutBytes--;\r
  98                         } // end-if\r
  99                 } // end-if\r
 100                 outBytes = new byte[numOutBytes];\r
 101 \r
 102                 byte    b64idxbits = 0x00;\r
 103                 int             iidx = 0, oidx = 0;\r
 104                 byte    writeByte = 0x00;\r
 105                 byte    b64ASCIIChar = 0x00;\r
 106                 for (iidx=0, oidx=0;iidx < numInChars;iidx++) {\r
 107                         b64ASCIIChar = base64ASCIIString[iidx];\r
 108                         if (b64ASCIIChar == 0x3d /*'='*/) {\r
 109                                 return outBytes;\r
 110                         } // end-if\r
 111 \r
 112                         if (!isb64char(b64ASCIIChar)) {\r
 113                                 return null;\r
 114                         } // end-if\r
 115 \r
 116                         switch (iidx % 4) {\r
 117                                 case 0:\r
 118                                         break;\r
 119                                 case 1:\r
 120                                         b64idxbits = b64decode[base64ASCIIString[iidx-1]];\r
 121                                         writeByte = (byte)((b64idxbits << 2) | ((b64decode[b64ASCIIChar] >> 4) & 0x03));\r
 122                                         outBytes[oidx++] = writeByte;\r
 123                                         break;\r
 124                                 case 2:\r
 125                                         b64idxbits = b64decode[base64ASCIIString[iidx-1]];\r
 126                                         writeByte = (byte)(((b64idxbits << 4) & 0xf0) | ((b64decode[b64ASCIIChar] >> 2) & 0x0f));\r
 127                                         outBytes[oidx++] = writeByte;\r
 128                                         break;\r
 129                                 case 3:\r
 130                                         b64idxbits = b64decode[base64ASCIIString[iidx-1]];\r
 131                                         writeByte = (byte)(((b64idxbits << 6) & 0xc0) | ((b64decode[b64ASCIIChar]) & 0x3f));\r
 132                                         outBytes[oidx++] = writeByte;\r
 133                                         break;\r
 134                         } // end-switch\r
 135                 } // end-for\r
 136 \r
 137                 return outBytes;\r
 138 \r
 139         } // end-method\r
 140 \r
 141 \r
 142         private static  byte[]  b64decode = new byte[256];\r
 143         // A-Z is 0x41-0x5a\r
 144         // a-z is 0x61-0x7a\r
 145         // 0-9 is 0x30-0x39\r
 146         // + is 0x2b\r
 147         // / is 0x2f\r
 148 \r
 149         private static  boolean m_decodeInitComplete = false;\r
 150 \r
 151         private void initForDecode() {\r
 152                 int aidx = 0;\r
 153                 int lidx = 0;\r
 154                 // Set A-Z\r
 155                 for (aidx=0x41, lidx=0;aidx <= 0x5a;aidx++, lidx++) {\r
 156                         b64decode[aidx] = (byte)lidx;\r
 157                 } // end-for\r
 158                 // Set a-z\r
 159                 for (aidx=0x61;aidx <= 0x7a;aidx++, lidx++) {\r
 160                         b64decode[aidx] = (byte)lidx;\r
 161                 } // end-for\r
 162                 // Set 0-9\r
 163                 for (aidx=0x30;aidx <= 0x39;aidx++, lidx++) {\r
 164                         b64decode[aidx] = (byte)lidx;\r
 165                 } // end-for\r
 166                 // Set '+'\r
 167                 b64decode[0x2b] = (byte)lidx++;\r
 168                 // Set '/'\r
 169                 b64decode[0x2f] = (byte)lidx++;\r
 170         } // end-method\r
 171 \r
 172         private boolean isb64char(byte b) {\r
 173                 // A-Z is 0x41-0x5a\r
 174                 // a-z is 0x61-0x7a\r
 175                 // 0-9 is 0x30-0x39\r
 176                 // + is 0x2b\r
 177                 // / is 0x2f\r
 178                 return (   (b >= 0x41 && b <= 0x5a)\r
 179                         || (b >= 0x61 && b <= 0x7a)\r
 180                         || (b >= 0x30 && b <= 0x39)\r
 181                         || (b == 0x2b)\r
 182                         || (b == 0x2f)\r
 183                         );\r
 184         } // end-method\r
 185 } // end-class