22 | * MVP模式 23 | *
24 | * Created by LiQi on 2017/12/6. 25 | */ 26 | 27 | public class TestDataBaseOperateActivity extends AppCompatActivity implements View.OnClickListener, TestDataBaseOperateP.OnTestDataBaseOperateListener41 | * 样例：要转换的值：1.0。转换之后的值：10 42 | *
43 | * @param doubleData double类型数据 44 | * @return 转换成功后的值 45 | */ 46 | public static int doubleToInt(double doubleData) { 47 | int doubleDataTag = 0; 48 | if (doubleData > 0.0) { 49 | String verString = String.valueOf(doubleData); 50 | String[] split = verString.split("\\."); 51 | if (split.length > 1) { 52 | int intTwo = Integer.parseInt(split[1]); 53 | if (intTwo >= 0) { 54 | doubleDataTag = Integer.parseInt(split[0] + split[1]); 55 | }else { 56 | doubleDataTag = Integer.parseInt(split[0]); 57 | } 58 | } else { 59 | doubleDataTag = Integer.parseInt(split[0]); 60 | } 61 | } 62 | return doubleDataTag; 63 | } 64 | 65 | /** 66 | * 正则验证方法 67 | * 68 | * @param regexstr 正则规则 69 | * @param str 验证内容 70 | * @return true正确，false错误。 71 | */ 72 | public static boolean match(String regexstr, String str) { 73 | Pattern regex = Pattern.compile(regexstr, Pattern.CASE_INSENSITIVE 74 | | Pattern.DOTALL); 75 | Matcher matcher = regex.matcher(str); 76 | return matcher.matches(); 77 | } 78 | 79 | /** 80 | * 解析短信推送内容 81 | * 82 | * @param data 短信推送内容 83 | * @return 解析后的数据 84 | */ 85 | public static Map17 | * 只适合android系统加密 18 | *
19 | * 20 | * @author LiQi 21 | */ 22 | public class AndroidAESEncryptor { 23 | private final static String HEX = "0123456789ABCDEF"; 24 | private static String CODING = "UTF-8"; 25 | 26 | /** 27 | * 128-加密 28 | * 29 | * @param seed 加密钥匙 30 | * @param cleartext 要加密内容 31 | * @param coding 编码 32 | * @return 加密之后的内容 33 | * @throws Exception 加密失败异常 34 | */ 35 | public static String encrypt128(String seed, String cleartext, String coding) 36 | throws Exception { 37 | byte[] rawKey = getRawKey(128, seed.getBytes()); 38 | byte[] result = encrypt(rawKey, cleartext.getBytes(TextUtils.isEmpty(coding) ? CODING : coding)); 39 | return toHex(result); 40 | } 41 | 42 | /** 43 | * 192-加密 44 | * 45 | * @param seed 加密钥匙 46 | * @param cleartext 要加密内容 47 | * @param coding 编码 48 | * @return 加密之后的内容 49 | * @throws Exception 加密失败异常 50 | */ 51 | public static String encrypt192(String seed, String cleartext, String coding) 52 | throws Exception { 53 | byte[] rawKey = getRawKey(192, seed.getBytes()); 54 | byte[] result = encrypt(rawKey, cleartext.getBytes(TextUtils.isEmpty(coding) ? CODING : coding)); 55 | return toHex(result); 56 | } 57 | 58 | /** 59 | * 256-加密 60 | * 61 | * @param seed 加密钥匙 62 | * @param cleartext 要加密内容 63 | * @param coding 编码 64 | * @return 加密之后的内容 65 | * @throws Exception 加密失败异常 66 | */ 67 | public static String encrypt256(String seed, String cleartext, String coding) 68 | throws Exception { 69 | byte[] rawKey = getRawKey(256, seed.getBytes()); 70 | byte[] result = encrypt(rawKey, cleartext.getBytes(TextUtils.isEmpty(coding) ? CODING : coding)); 71 | return toHex(result); 72 | } 73 | 74 | /** 75 | * 128-加密 76 | * 77 | * @param seed 加密钥匙 78 | * @param cleartext 要加密内容 79 | * @return 加密之后的内容 80 | * @throws Exception 加密失败异常 81 | */ 82 | public static String encrypt128(String seed, String cleartext) 83 | throws Exception { 84 | byte[] rawKey = getRawKey(128, seed.getBytes()); 85 | byte[] result = encrypt(rawKey, cleartext.getBytes(CODING)); 86 | return toHex(result); 87 | } 88 | 89 | /** 90 | * 192-加密 91 | * 92 | * @param seed 加密钥匙 93 | * @param cleartext 要加密内容 94 | * @return 加密之后的内容 95 | * @throws Exception 加密失败异常 96 | */ 97 | public static String encrypt192(String seed, String cleartext) 98 | throws Exception { 99 | byte[] rawKey = getRawKey(192, seed.getBytes()); 100 | byte[] result = encrypt(rawKey, cleartext.getBytes()); 101 | return toHex(result); 102 | } 103 | 104 | /** 105 | * 256-加密 106 | * 107 | * @param seed 加密钥匙 108 | * @param cleartext 要加密内容 109 | * @return 加密之后的内容 110 | * @throws Exception 加密失败异常 111 | */ 112 | public static String encrypt256(String seed, String cleartext) 113 | throws Exception { 114 | byte[] rawKey = getRawKey(256, seed.getBytes()); 115 | byte[] result = encrypt(rawKey, cleartext.getBytes()); 116 | return toHex(result); 117 | } 118 | 119 | /** 120 | * 128-解密 121 | * 122 | * @param seed 解密钥匙 123 | * @param encrypted 加密内容 124 | * @param coding 编码 125 | * @return 126 | * @throws Exception 127 | */ 128 | public static String decrypt128(String seed, String encrypted, String coding) 129 | throws Exception { 130 | byte[] rawKey = getRawKey(128, seed.getBytes()); 131 | byte[] enc = toByte(encrypted); 132 | byte[] result = decrypt(rawKey, enc); 133 | return new String(result, TextUtils.isEmpty(coding) ? CODING : coding); 134 | } 135 | 136 | /** 137 | * 192-解密 138 | * 139 | * @param seed 解密钥匙 140 | * @param encrypted 加密内容 141 | * @param coding 编码 142 | * @return 143 | * @throws Exception 144 | */ 145 | public static String decrypt192(String seed, String encrypted, String coding) 146 | throws Exception { 147 | byte[] rawKey = getRawKey(192, seed.getBytes()); 148 | byte[] enc = toByte(encrypted); 149 | byte[] result = decrypt(rawKey, enc); 150 | return new String(result, TextUtils.isEmpty(coding) ? CODING : coding); 151 | } 152 | 153 | /** 154 | * 256-解密 155 | * 156 | * @param seed 解密钥匙 157 | * @param encrypted 加密内容 158 | * @param coding 编码 159 | * @return 160 | * @throws Exception 161 | */ 162 | public static String decrypt256(String seed, String encrypted, String coding) 163 | throws Exception { 164 | byte[] rawKey = getRawKey(256, seed.getBytes()); 165 | byte[] enc = toByte(encrypted); 166 | byte[] result = decrypt(rawKey, enc); 167 | return new String(result, TextUtils.isEmpty(coding) ? CODING : coding); 168 | } 169 | 170 | /** 171 | * 128-解密 172 | * 173 | * @param seed 解密钥匙 174 | * @param encrypted 加密内容 175 | * @return 176 | * @throws Exception 177 | */ 178 | public static String decrypt128(String seed, String encrypted) 179 | throws Exception { 180 | byte[] rawKey = getRawKey(128, seed.getBytes()); 181 | byte[] enc = toByte(encrypted); 182 | byte[] result = decrypt(rawKey, enc); 183 | return new String(result, "utf-8"); 184 | } 185 | 186 | /** 187 | * 192-解密 188 | * 189 | * @param seed 解密钥匙 190 | * @param encrypted 加密内容 191 | * @return 192 | * @throws Exception 193 | */ 194 | public static String decrypt192(String seed, String encrypted) 195 | throws Exception { 196 | byte[] rawKey = getRawKey(192, seed.getBytes()); 197 | byte[] enc = toByte(encrypted); 198 | byte[] result = decrypt(rawKey, enc); 199 | return new String(result); 200 | } 201 | 202 | /** 203 | * 256-解密 204 | * 205 | * @param seed 解密钥匙 206 | * @param encrypted 加密内容 207 | * @return 208 | * @throws Exception 209 | */ 210 | public static String decrypt256(String seed, String encrypted) 211 | throws Exception { 212 | byte[] rawKey = getRawKey(256, seed.getBytes()); 213 | byte[] enc = toByte(encrypted); 214 | byte[] result = decrypt(rawKey, enc); 215 | return new String(result, "utf-8"); 216 | } 217 | 218 | @SuppressLint("TrulyRandom") 219 | private static byte[] getRawKey(int pattern, byte[] seed) throws Exception { 220 | KeyGenerator kgen = KeyGenerator.getInstance("AES"); 221 | // SHA1PRNG 强随机种子算法, 要区别4.2以上版本的调用方法 222 | SecureRandom sr; 223 | if (android.os.Build.VERSION.SDK_INT > 23) { // Android 6.0 以上 224 | sr = SecureRandom.getInstance("SHA1PRNG", new CryptoProvider()); 225 | } else if (android.os.Build.VERSION.SDK_INT >= 17) { 226 | sr = SecureRandom.getInstance("SHA1PRNG", "Crypto"); 227 | } else { 228 | sr = SecureRandom.getInstance("SHA1PRNG"); 229 | } 230 | sr.setSeed(seed); 231 | kgen.init(pattern, sr); // 192 and 256 bits may not be available 232 | SecretKey skey = kgen.generateKey(); 233 | return skey.getEncoded(); 234 | } 235 | 236 | private static byte[] encrypt(byte[] raw, byte[] clear) throws Exception { 237 | SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES"); 238 | Cipher cipher = Cipher.getInstance("AES"); 239 | 240 | cipher.init(Cipher.ENCRYPT_MODE, skeySpec); 241 | return cipher.doFinal(clear); 242 | } 243 | 244 | private static byte[] decrypt(byte[] raw, byte[] encrypted) 245 | throws Exception { 246 | SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES"); 247 | Cipher cipher = Cipher.getInstance("AES"); 248 | cipher.init(Cipher.DECRYPT_MODE, skeySpec); 249 | return cipher.doFinal(encrypted); 250 | } 251 | 252 | /** 253 | * 把字符串内容转换成十六进制内容 254 | * 255 | * @param txt 内容 256 | * @return 十六进制内容 257 | */ 258 | public static String toHex(String txt) { 259 | return toHex(txt.getBytes()); 260 | } 261 | 262 | /** 263 | * 十六进制内容转换成字符串内容 264 | * 265 | * @param hex 十六进制内容 266 | * @return 字符串内容 267 | */ 268 | public static String fromHex(String hex) { 269 | return new String(toByte(hex)); 270 | } 271 | 272 | /** 273 | * 把十六进制内容转换成字节数组 274 | * 275 | * @param hexString 十六进制内容 276 | * @return 字节数组 277 | */ 278 | public static byte[] toByte(String hexString) { 279 | int len = hexString.length() / 2; 280 | byte[] result = new byte[len]; 281 | for (int i = 0; i < len; i++) 282 | result[i] = Integer.valueOf(hexString.substring(2 * i, 2 * i + 2), 283 | 16).byteValue(); 284 | return result; 285 | } 286 | 287 | /** 288 | * 把字节数组转换成十六进制内容 289 | * 290 | * @param buf 字节数组 291 | * @return 十六进制内容 292 | */ 293 | public static String toHex(byte[] buf) { 294 | if (buf == null) 295 | return ""; 296 | StringBuffer result = new StringBuffer(2 * buf.length); 297 | for (int i = 0; i < buf.length; i++) { 298 | appendHex(result, buf[i]); 299 | } 300 | return result.toString(); 301 | } 302 | 303 | private static void appendHex(StringBuffer sb, byte b) { 304 | sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f)); 305 | } 306 | // 增加 CryptoProvider 类 307 | 308 | private static class CryptoProvider extends Provider { 309 | /** 310 | * Creates a Provider and puts parameters 311 | */ 312 | private CryptoProvider() { 313 | super("Crypto", 1.0, "HARMONY (SHA1 digest; SecureRandom; SHA1withDSA signature)"); 314 | put("SecureRandom.SHA1PRNG", 315 | "org.apache.harmony.security.provider.crypto.SHA1PRNG_SecureRandomImpl"); 316 | put("SecureRandom.SHA1PRNG ImplementedIn", "Software"); 317 | } 318 | } 319 | } 320 | -------------------------------------------------------------------------------- /utils/src/main/java/com/liqi/utils/encoding/Base64.java: -------------------------------------------------------------------------------- 1 | package com.liqi.utils.encoding; 2 | 3 | import java.io.UnsupportedEncodingException; 4 | 5 | /** 6 | * Base64编码和解码对象。 7 | * 8 | * @author LiQi 9 | */ 10 | public class Base64 { 11 | 12 | private static final char[] base64Map = // base64 character table 13 | 14 | {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 15 | 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 16 | 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 17 | 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', 18 | '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'}; 19 | 20 | /** 21 | * convert the platform dependent string characters to UTF8 which can also 22 | * be done by calling the java String method getBytes("UTF-8"),but I hope to 23 | * do it from the ground up. 24 | */ 25 | 26 | private static byte[] toUTF8ByteArray(String s) { 27 | int ichar; 28 | byte buffer[] = new byte[3 * (s.length())]; 29 | byte hold[]; 30 | int index = 0; 31 | int count = 0; // count the actual bytes in the 32 | // buffer array 33 | 34 | for (int i = 0; i < s.length(); i++) { 35 | ichar = (int) s.charAt(i); 36 | 37 | // determine the bytes for a specific character 38 | if ((ichar >= 0x0080) & (ichar <= 0x07FF)) { 39 | buffer[index++] = (byte) ((6 << 5) | ((ichar >> 6) & 31)); 40 | buffer[index++] = (byte) ((2 << 6) | (ichar & 63)); 41 | count += 2; 42 | } 43 | 44 | // determine the bytes for a specific character 45 | else if ((ichar >= 0x0800) & (ichar <= 0x0FFFF)) { 46 | buffer[index++] = (byte) ((14 << 4) | ((ichar >> 12) & 15)); 47 | buffer[index++] = (byte) ((2 << 6) | ((ichar >> 6) & 63)); 48 | buffer[index++] = (byte) ((2 << 6) | (ichar & 63)); 49 | count += 3; 50 | } 51 | 52 | // determine the bytes for a specific character 53 | else if ((ichar >= 0x0000) & (ichar <= 0x007F)) { 54 | buffer[index++] = (byte) ((0 << 7) | (ichar & 127)); 55 | count += 1; 56 | } 57 | 58 | // longer than 16 bit Unicode is not supported 59 | else 60 | throw new RuntimeException( 61 | "Unsupported encoding character length!\n"); 62 | } 63 | hold = new byte[count]; 64 | System.arraycopy(buffer, 0, hold, 0, count); // trim to size 65 | return hold; 66 | } 67 | 68 | /** 69 | * 编码 70 | * 71 | * @param encodeContent 要编码内容 72 | * @return Base64编码之后的内容 73 | */ 74 | public static String encode(String encodeContent) { 75 | byte buf[] = toUTF8ByteArray(encodeContent); 76 | return encode(buf); 77 | } 78 | 79 | /** 80 | * 编码 81 | * 82 | * @param encodeContentBuf 编码内容字节数组 83 | * @return Base64编码之后的内容 84 | */ 85 | public static String encode(byte encodeContentBuf[]) { 86 | StringBuffer sb = new StringBuffer(); 87 | String padder = ""; 88 | 89 | if (encodeContentBuf.length == 0) 90 | return ""; 91 | 92 | // cope with less than 3 bytes conditions at the end of encodeContentBuf 93 | 94 | switch (encodeContentBuf.length % 3) { 95 | case 1: { 96 | padder += base64Map[((encodeContentBuf[encodeContentBuf.length - 1] >>> 2) & 63)]; 97 | padder += base64Map[((encodeContentBuf[encodeContentBuf.length - 1] << 4) & 63)]; 98 | padder += "=="; 99 | break; 100 | } 101 | case 2: { 102 | padder += base64Map[(encodeContentBuf[encodeContentBuf.length - 2] >>> 2) & 63]; 103 | padder += base64Map[(((encodeContentBuf[encodeContentBuf.length - 2] << 4) & 63)) 104 | | (((encodeContentBuf[encodeContentBuf.length - 1] >>> 4) & 63))]; 105 | padder += base64Map[(encodeContentBuf[encodeContentBuf.length - 1] << 2) & 63]; 106 | padder += "="; 107 | break; 108 | } 109 | default: 110 | break; 111 | } 112 | 113 | int temp = 0; 114 | int index = 0; 115 | 116 | // encode encodeContentBuf.length-encodeContentBuf.length%3 bytes which must be a multiply of 3 117 | 118 | for (int i = 0; i < (encodeContentBuf.length - (encodeContentBuf.length % 3)); ) { 119 | // get three bytes and encode them to four base64 characters 120 | temp = ((encodeContentBuf[i++] << 16) & 0xFF0000) | ((encodeContentBuf[i++] << 8) & 0xFF00) 121 | | (encodeContentBuf[i++] & 0xFF); 122 | index = (temp >> 18) & 63; 123 | sb.append(base64Map[index]); 124 | if (sb.length() % 76 == 0)// a Base64 encoded line is no longer than 125 | // 76 characters 126 | sb.append('\n'); 127 | 128 | index = (temp >> 12) & 63; 129 | sb.append(base64Map[index]); 130 | if (sb.length() % 76 == 0) 131 | sb.append('\n'); 132 | 133 | index = (temp >> 6) & 63; 134 | sb.append(base64Map[index]); 135 | if (sb.length() % 76 == 0) 136 | sb.append('\n'); 137 | 138 | index = temp & 63; 139 | sb.append(base64Map[index]); 140 | if (sb.length() % 76 == 0) 141 | sb.append('\n'); 142 | } 143 | 144 | sb.append(padder); // add the remaining one or two bytes 145 | return sb.toString(); 146 | } 147 | 148 | /** 149 | * 解码 150 | * 151 | * @param decodeContent 要解码的内容 152 | * @return Base64解码之后的内容 153 | */ 154 | public static String decode(String decodeContent) { 155 | 156 | byte buf[]; 157 | try { 158 | buf = decodeToByteArray(decodeContent); 159 | 160 | decodeContent = new String(buf, "UTF-8"); 161 | decodeContent = decodeContent.replaceAll("[\\n|\\r]", ""); 162 | } catch (Exception e) { 163 | // TODO Auto-generated catch block 164 | return ""; 165 | } 166 | return decodeContent; 167 | } 168 | 169 | /** 170 | * 解码 171 | * 172 | * @param decodeContent 要解码的内容 173 | * @return Base64解码之后的字节数组 174 | */ 175 | public static byte[] decodeToByteArray(String decodeContent) throws UnsupportedEncodingException { 176 | byte hold[]; 177 | 178 | if (decodeContent.length() == 0) 179 | return null; 180 | byte buf[] = decodeContent.getBytes("iso-8859-1"); 181 | byte debuf[] = new byte[buf.length * 3 / 4]; 182 | byte tempBuf[] = new byte[4]; 183 | int index = 0; 184 | int index1 = 0; 185 | int temp; 186 | int count = 0; 187 | int count1 = 0; 188 | 189 | // decode to byte array 190 | for (int i = 0; i < buf.length; i++) { 191 | if (buf[i] >= 65 && buf[i] < 91) 192 | tempBuf[index++] = (byte) (buf[i] - 65); 193 | else if (buf[i] >= 97 && buf[i] < 123) 194 | tempBuf[index++] = (byte) (buf[i] - 71); 195 | else if (buf[i] >= 48 && buf[i] < 58) 196 | tempBuf[index++] = (byte) (buf[i] + 4); 197 | else if (buf[i] == '+') 198 | tempBuf[index++] = 62; 199 | else if (buf[i] == '/') 200 | tempBuf[index++] = 63; 201 | else if (buf[i] == '=') { 202 | tempBuf[index++] = 0; 203 | count1++; 204 | } 205 | 206 | // Discard line breaks and other nonsignificant characters 207 | else { 208 | if (buf[i] == '\n' || buf[i] == '\r' || buf[i] == ' ' 209 | || buf[i] == '\t') 210 | continue; 211 | else 212 | throw new RuntimeException( 213 | "Illegal character found in encoded string!"); 214 | } 215 | if (index == 4) { 216 | temp = ((tempBuf[0] << 18)) | ((tempBuf[1] << 12)) 217 | | ((tempBuf[2] << 6)) | (tempBuf[3]); 218 | debuf[index1++] = (byte) (temp >> 16); 219 | debuf[index1++] = (byte) ((temp >> 8) & 255); 220 | debuf[index1++] = (byte) (temp & 255); 221 | count += 3; 222 | index = 0; 223 | } 224 | } 225 | hold = new byte[count - count1]; 226 | System.arraycopy(debuf, 0, hold, 0, count - count1); // trim to size 227 | return hold; 228 | } 229 | 230 | // public static void main(String[] args) { 231 | // String url = "u=00ca21b3ad4342ce9a28ab96f5bb2514&c=00ca21b3ad4342ce9a28ab96f5bb2514"; 232 | // 233 | // System.out.println(Base64.encode(url)); 234 | // 235 | // System.out.println(Base64.encode(url).replaceAll("\n", "")); 236 | // } 237 | } -------------------------------------------------------------------------------- /utils/src/main/java/com/liqi/utils/encoding/JToAAesEncryptor.java: -------------------------------------------------------------------------------- 1 | package com.liqi.utils.encoding; 2 | 3 | import android.text.TextUtils; 4 | 5 | import javax.crypto.Cipher; 6 | import javax.crypto.spec.IvParameterSpec; 7 | import javax.crypto.spec.SecretKeySpec; 8 | 9 | /** 10 | * Java端-android系统平台互通加密AES算术加密 11 | */ 12 | public class JToAAesEncryptor { 13 | private final static String HEX = "0123456789ABCDEF"; 14 | private final static String CODING = "UTF-8"; 15 | private static final String VIPARA = "1269571569321021"; 16 | 17 | /** 18 | * 加密 19 | * 20 | * @param seed 加密钥匙（length==16） 21 | * @param cleartext 要加密内容 22 | * @param coding 编码 23 | * @return 加密之后的内容 24 | * @throws Exception 加密失败异常 25 | */ 26 | public static String encrypt(String seed, String cleartext, String coding) 27 | throws Exception { 28 | byte[] result = encrypt(seed.getBytes(), cleartext.getBytes(TextUtils.isEmpty(coding) ? CODING : coding)); 29 | return toHex(result); 30 | } 31 | 32 | /** 33 | * 加密 34 | * 35 | * @param seed 加密钥匙（length==16） 36 | * @param cleartext 要加密内容 37 | * @return 加密之后的内容 38 | * @throws Exception 加密失败异常 39 | */ 40 | public static String encrypt(String seed, String cleartext) 41 | throws Exception { 42 | byte[] result = encrypt(seed.getBytes(), cleartext.getBytes(CODING)); 43 | return toHex(result); 44 | } 45 | 46 | /** 47 | * 解密 48 | * 49 | * @param seed 解密钥匙（length==16） 50 | * @param encrypted 加密内容 51 | * @param coding 编码 52 | * @return 53 | * @throws Exception 54 | */ 55 | public static String decrypt(String seed, String encrypted, String coding) 56 | throws Exception { 57 | byte[] enc = toByte(encrypted); 58 | byte[] result = decrypt(seed.getBytes(), enc); 59 | return new String(result, TextUtils.isEmpty(coding) ? CODING : coding); 60 | } 61 | 62 | /** 63 | * 解密 64 | * 65 | * @param seed 解密钥匙（length>=16） 66 | * @param encrypted 加密内容 67 | * @return 68 | * @throws Exception 69 | */ 70 | public static String decrypt(String seed, String encrypted) 71 | throws Exception { 72 | byte[] enc = toByte(encrypted); 73 | byte[] result = decrypt(seed.getBytes(), enc); 74 | return new String(result, "utf-8"); 75 | } 76 | 77 | private static byte[] encrypt(byte[] raw, byte[] clear) throws Exception { 78 | IvParameterSpec zeroIv = new IvParameterSpec(VIPARA.getBytes()); 79 | SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES"); 80 | Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); 81 | 82 | cipher.init(Cipher.ENCRYPT_MODE, skeySpec, zeroIv); 83 | return cipher.doFinal(clear); 84 | } 85 | 86 | private static byte[] decrypt(byte[] raw, byte[] encrypted) 87 | throws Exception { 88 | IvParameterSpec zeroIv = new IvParameterSpec(VIPARA.getBytes()); 89 | SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES"); 90 | Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); 91 | cipher.init(Cipher.DECRYPT_MODE, skeySpec, zeroIv); 92 | return cipher.doFinal(encrypted); 93 | } 94 | 95 | /** 96 | * 把字符串内容转换成十六进制内容 97 | * 98 | * @param txt 内容 99 | * @return 十六进制内容 100 | */ 101 | public static String toHex(String txt) { 102 | return toHex(txt.getBytes()); 103 | } 104 | 105 | /** 106 | * 十六进制内容转换成字符串内容 107 | * 108 | * @param hex 十六进制内容 109 | * @return 字符串内容 110 | */ 111 | public static String fromHex(String hex) { 112 | return new String(toByte(hex)); 113 | } 114 | 115 | /** 116 | * 把十六进制内容转换成字节数组 117 | * 118 | * @param hexString 十六进制内容 119 | * @return 字节数组 120 | */ 121 | public static byte[] toByte(String hexString) { 122 | int len = hexString.length() / 2; 123 | byte[] result = new byte[len]; 124 | for (int i = 0; i < len; i++) 125 | result[i] = Integer.valueOf(hexString.substring(2 * i, 2 * i + 2), 126 | 16).byteValue(); 127 | return result; 128 | } 129 | 130 | /** 131 | * 把字节数组转换成十六进制内容 132 | * 133 | * @param buf 字节数组 134 | * @return 十六进制内容 135 | */ 136 | public static String toHex(byte[] buf) { 137 | if (buf == null) 138 | return ""; 139 | StringBuffer result = new StringBuffer(2 * buf.length); 140 | for (int i = 0; i < buf.length; i++) { 141 | appendHex(result, buf[i]); 142 | } 143 | return result.toString(); 144 | } 145 | 146 | private static void appendHex(StringBuffer sb, byte b) { 147 | sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f)); 148 | } 149 | } 150 | -------------------------------------------------------------------------------- /utils/src/main/java/com/liqi/utils/encoding/MD5Util.java: -------------------------------------------------------------------------------- 1 | package com.liqi.utils.encoding; 2 | 3 | import java.security.MessageDigest; 4 | 5 | /** 6 | * MD5编码对象。 7 | * 8 | * @author LiQi 9 | */ 10 | public class MD5Util { 11 | private static final String HEX_DIGITS[] = {"0", "1", "2", "3", "4", "5", 12 | "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"}; 13 | 14 | /** 15 | * MD5编码 16 | * 17 | * @param codingContent 要编码的内容 18 | * @return MD5编码之后的内容 19 | */ 20 | public static String md5(String codingContent) { 21 | try { 22 | byte[] btInput = codingContent.getBytes(); 23 | // 获得MD5摘要算法的 MessageDigest 对象 24 | MessageDigest mdInst = MessageDigest.getInstance("MD5"); 25 | // 使用指定的字节更新摘要 26 | mdInst.update(btInput); 27 | // 获得密文 28 | byte[] md = mdInst.digest(); 29 | // 把密文转换成十六进制的字符串形式 30 | int j = md.length; 31 | String str = ""; 32 | for (int i = 0; i < j; i++) { 33 | byte byte0 = md[i]; 34 | str += HEX_DIGITS[byte0 >>> 4 & 0xf] + HEX_DIGITS[byte0 & 0xf]; 35 | } 36 | return str; 37 | } catch (Exception e) { 38 | e.printStackTrace(); 39 | return null; 40 | } 41 | } 42 | 43 | private static String byteArrayToHexString(byte b[]) { 44 | StringBuffer resultSb = new StringBuffer(); 45 | for (int i = 0; i < b.length; i++) 46 | resultSb.append(byteToHexString(b[i])); 47 | 48 | return resultSb.toString(); 49 | } 50 | 51 | private static String byteToHexString(byte b) { 52 | int n = b; 53 | if (n < 0) 54 | n += 256; 55 | int d1 = n / 16; 56 | int d2 = n % 16; 57 | return HEX_DIGITS[d1] + HEX_DIGITS[d2]; 58 | } 59 | 60 | /**MD5编码 61 | * 62 | * @param codingContent 要编码的内容 63 | * @param coding 编码 64 | * @return MD5编码之后的内容 65 | */ 66 | public static String md5Encode(String codingContent, String coding) { 67 | String resultString = null; 68 | try { 69 | resultString = new String(codingContent); 70 | MessageDigest md = MessageDigest.getInstance("MD5"); 71 | if (coding == null || "".equals(coding)) 72 | resultString = byteArrayToHexString(md.digest(resultString 73 | .getBytes())); 74 | else 75 | resultString = byteArrayToHexString(md.digest(resultString 76 | .getBytes(coding))); 77 | } catch (Exception exception) { 78 | } 79 | return resultString; 80 | } 81 | 82 | } 83 | -------------------------------------------------------------------------------- /utils/src/main/java/com/liqi/utils/file/FileSizeFormattingUtil.java: -------------------------------------------------------------------------------- 1 | package com.liqi.utils.file; 2 | 3 | import java.text.DecimalFormat; 4 | 5 | /** 6 | * 文件大小格式化工具 7 | * Created by LiQi on 2018/10/19. 8 | */ 9 | 10 | public class FileSizeFormattingUtil { 11 | /** 12 | * 转换文件大小 13 | * 14 | * @param fileSize 文件大小 15 | * @param isInteger 是否返回取整的单位 16 | * @return 返回格式化的单位值。逢单位最大值进阶 17 | *18 | * 单位：B,KB,MG,G 19 | *
20 | */ 21 | public static String formetFileSize(long fileSize, boolean isInteger) { 22 | String fileSizeString; 23 | String wrongSize = "0B"; 24 | if (fileSize <= 0) { 25 | return wrongSize; 26 | } 27 | DecimalFormat df = isInteger ? new DecimalFormat("#0") : new DecimalFormat("#0.##"); 28 | if (fileSize < 1024) { 29 | fileSizeString = df.format((double) fileSize) + "B"; 30 | } else if (fileSize < 1048576) { 31 | fileSizeString = df.format((double) fileSize / 1024) + "KB"; 32 | } else if (fileSize < 1073741824) { 33 | fileSizeString = df.format((double) fileSize / 1048576) + "MB"; 34 | } else { 35 | fileSizeString = df.format((double) fileSize / 1073741824) + "G"; 36 | } 37 | return fileSizeString; 38 | } 39 | 40 | /** 41 | * 转换文件大小 42 | * 43 | * @param fileSize 文件大小 44 | * @param df 格式化对象 45 | * @return 返回格式化的单位值。逢单位最大值进阶 46 | *47 | * 单位：B,KB,MG,G 48 | *
49 | */ 50 | public static String formetFileSize(long fileSize, DecimalFormat df) { 51 | String fileSizeString; 52 | String wrongSize = "0B"; 53 | if (fileSize <= 0) { 54 | return wrongSize; 55 | } 56 | df = null == df ? new DecimalFormat("#0") : df; 57 | if (fileSize < 1024) { 58 | fileSizeString = df.format((double) fileSize) + "B"; 59 | } else if (fileSize < 1048576) { 60 | fileSizeString = df.format((double) fileSize / 1024) + "KB"; 61 | } else if (fileSize < 1073741824) { 62 | fileSizeString = df.format((double) fileSize / 1048576) + "MB"; 63 | } else { 64 | fileSizeString = df.format((double) fileSize / 1073741824) + "G"; 65 | } 66 | return fileSizeString; 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /utils/src/main/java/com/liqi/utils/file/StaticFileUtils.java: -------------------------------------------------------------------------------- 1 | package com.liqi.utils.file; 2 | 3 | import android.content.Context; 4 | import android.content.pm.PackageInfo; 5 | import android.content.pm.PackageManager; 6 | import android.os.Environment; 7 | 8 | import com.liqi.Logger; 9 | import com.liqi.utils.encoding.AndroidAESEncryptor; 10 | 11 | import java.io.BufferedOutputStream; 12 | import java.io.File; 13 | import java.io.FileInputStream; 14 | import java.io.FileOutputStream; 15 | import java.io.IOException; 16 | import java.io.InputStream; 17 | import java.text.DecimalFormat; 18 | import java.util.ArrayList; 19 | import java.util.List; 20 | 21 | /** 22 | * 文件操作工具 23 | * 24 | * @author LiQi 25 | */ 26 | public class StaticFileUtils { 27 | private static final String TAG = StaticFileUtils.class.getName(); 28 | 29 | /** 30 | * 根据路径删除指定的目录或文件，无论存在与否 31 | * 32 | * @param deletePath 要删除的目录或文件 33 | * @return 删除成功返回 true，否则返回 false。 34 | */ 35 | public static boolean deleteFolder(String deletePath) { 36 | File file = new File(deletePath); 37 | // 判断目录或文件是否存在 38 | if (!file.exists()) { // 不存在返回 false 39 | return false; 40 | } else { 41 | // 判断是否为文件 42 | if (file.isFile()) { // 为文件时调用删除文件方法 43 | return deleteFile(file); 44 | } else { // 为目录时调用删除目录方法 45 | return deleteDirectory(deletePath); 46 | } 47 | } 48 | } 49 | 50 | /** 51 | * 删除单个文件 52 | * 53 | * @param file 被删除文件的文件File对象 54 | * @return 单个文件删除成功返回true，否则返回false 55 | */ 56 | private static boolean deleteFile(File file) { 57 | boolean flag = false; 58 | // 路径为文件且不为空则进行删除 59 | if (file.isFile() && file.exists()) { 60 | file.delete(); 61 | flag = true; 62 | } 63 | return flag; 64 | } 65 | 66 | /** 67 | * 删除目录（文件夹）以及目录下的文件 68 | * 69 | * @param deletePath 被删除目录的文件路径 70 | * @return 目录删除成功返回true，否则返回false 71 | */ 72 | private static boolean deleteDirectory(String deletePath) { 73 | // 如果sPath不以文件分隔符结尾，自动添加文件分隔符 74 | if (!deletePath.endsWith(File.separator)) { 75 | deletePath = deletePath + File.separator; 76 | } 77 | File dirFile = new File(deletePath); 78 | // 如果dir对应的文件不存在，或者不是一个目录，则退出 79 | if (!dirFile.exists() || !dirFile.isDirectory()) { 80 | return false; 81 | } 82 | boolean flag = true; 83 | // 删除文件夹下的所有文件(包括子目录) 84 | File[] files = dirFile.listFiles(); 85 | for (int i = 0; i < files.length; i++) { 86 | // 删除子文件 87 | if (files[i].isFile()) { 88 | flag = deleteFile(files[i]); 89 | if (!flag) 90 | break; 91 | } // 删除子目录 92 | else { 93 | flag = deleteDirectory(files[i].getAbsolutePath()); 94 | if (!flag) 95 | break; 96 | } 97 | } 98 | if (!flag) 99 | return false; 100 | // 删除当前目录 101 | if (dirFile.delete()) { 102 | return true; 103 | } else { 104 | return false; 105 | } 106 | } 107 | 108 | /** 109 | * 获取保存路径 110 | * 111 | * @param context 上下文 112 | * @param filePath 路径名字 113 | * @return 保存路径 114 | */ 115 | public static String getPath(Context context, String filePath) { 116 | String path; 117 | // 判断是否安装有SD卡 118 | if (Environment.getExternalStorageState().equals( 119 | Environment.MEDIA_MOUNTED)) { 120 | path = Environment.getExternalStorageDirectory() + "/" + filePath; 121 | } else { 122 | path = context.getCacheDir() + "/" + filePath; 123 | } 124 | return path; 125 | } 126 | 127 | /** 128 | * 通过切割URL获取路径文件名，然后拼接完整的存储路径。（原理是切割URL最后的文件名作为保存在本地的文件名） 129 | * 130 | * @param url URL 131 | * @param context 上下文 132 | * @param folderPathName 保存的文件夹路径。样例:xxx/xxx。 133 | *134 | * 如果本地没有，本方法会为你创建一个 135 | *
136 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 137 | *
138 | * @return 拼接完整的存储路径 139 | */ 140 | public static File putFilePath(String url, Context context, String folderPathName) { 141 | File file; 142 | String[] split = url.split("/"); 143 | String name = split[split.length - 1]; 144 | // String name = "SampleVideo_1080x720_10mb~4.mp4"; 145 | String path = getPath(context, folderPathName); 146 | // 先创建文件夹file 147 | file = new File(path); 148 | if (!file.exists() || !file.isDirectory()) { 149 | file.mkdirs(); 150 | } 151 | file = new File(path, name); 152 | return file; 153 | } 154 | 155 | /** 156 | * 切割URl最尾部的内容，按“/”切割 157 | * 158 | * @param url url 159 | * @return URl最尾部的内容 160 | */ 161 | public static String httpGetName(String url) { 162 | if (null != url) { 163 | String[] split = url.split("/"); 164 | String name = split[split.length - 1]; 165 | return name; 166 | } else 167 | return null; 168 | } 169 | 170 | /** 171 | * 判断路径是否存在并且是一个文件 172 | * 173 | * @param file 文件 174 | * @return true是存在并是一个文件，false不是。 175 | */ 176 | public static boolean isFilePath(File file) { 177 | boolean isFile; 178 | if (file.exists() && file.isFile()) { 179 | isFile = true; 180 | } else { 181 | isFile = false; 182 | } 183 | return isFile; 184 | 185 | } 186 | 187 | /** 188 | * 创建一个目录路径，并且返回目录路径 189 | *190 | * 没有创建，有直接返回。 191 | *
193 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 194 | * 195 | * 196 | * @param context 上下文 197 | * @param cataloguePath 目录路径。样例:xxx/xxx 198 | * @return 目录路径 199 | */ 200 | public static String foundFilePathString(Context context, String cataloguePath) { 201 | File file = new File(getPath(context, cataloguePath)); 202 | if (!file.exists() || !file.isDirectory()) { 203 | file.mkdirs(); 204 | } 205 | return file.getAbsolutePath(); 206 | } 207 | 208 | /** 209 | * 创建一个目录路径，并且返回目录路径File对象 210 | *211 | * 没有创建，有直接返回。 212 | *
214 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 215 | * 216 | * 217 | * @param context 上下文 218 | * @param cataloguePath 目录路径。样例:xxx/xxx 219 | * @return 目录路径File对象 220 | */ 221 | public static File foundFilePathFile(Context context, String cataloguePath) { 222 | File file = new File(getPath(context, cataloguePath)); 223 | if (!file.exists() || !file.isDirectory()) { 224 | file.mkdirs(); 225 | } 226 | return file; 227 | } 228 | 229 | /** 230 | * 根据传过来的文件目录路径和文件名来创建路径，并且返回路径File对象。 231 | *232 | * 没有创建，有直接返回。 233 | *
235 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 236 | * 237 | * 238 | * @param context 上下文 239 | * @param cataloguePath 目录路径。样例:xxx/xxx 240 | * @param fileName 文件名称，记得带扩展名 -->如果没有传值，就只返回目录路径File 241 | * @return 目录路径File对象 242 | */ 243 | public static File nonentityFoundFile(Context context, String cataloguePath, String fileName) { 244 | String path = getPath(context, cataloguePath); 245 | // 先创建文件夹file 246 | File file = new File(path); 247 | if (!file.exists() || !file.isDirectory()) { 248 | file.mkdirs(); 249 | } 250 | if (null != fileName && !"".equals(fileName)) { 251 | file = new File(path, fileName); 252 | } 253 | return file; 254 | } 255 | 256 | /** 257 | * 根据传过来的文件目录路径和文件名来创建路径，并且返回路径 258 | *259 | * 没有创建，有直接返回。 260 | *
262 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 263 | * 264 | * 265 | * @param context 上下文 266 | * @param cataloguePath 目录路径。样例:xxx/xxx 267 | * @param fileName 文件名称，记得带扩展名 -->如果没有传值，就只返回目录路径File 268 | * @return 目录路径 269 | */ 270 | public static String nonentityFoundString(Context context, String cataloguePath, String fileName) { 271 | String path = getPath(context, cataloguePath); 272 | // 先创建文件夹file 273 | File file = new File(path); 274 | if (!file.exists() || !file.isDirectory()) { 275 | file.mkdirs(); 276 | } 277 | if (null != fileName && !"".equals(fileName)) { 278 | file = new File(path, fileName); 279 | } 280 | return file.getAbsolutePath(); 281 | } 282 | 283 | /** 284 | * 通过包名去判断程序是不是已经安装 285 | * 286 | * @param context 上下文 287 | * @param packageName 包名 288 | * @return true是已经安装，false没有。 289 | */ 290 | public static boolean isAppInstalled(Context context, String packageName) { 291 | final PackageManager packageManager = context.getPackageManager(); 292 | List355 | * 加密方式采用：AndroidAESEncryptor.encrypt128(key,content),解密请使用：AndroidAESEncryptor.decrypt128(key, content) 356 | *
357 | * 358 | * @param password 密码 359 | * @param content 内容 360 | * @param file 路径 361 | * @return true是写入成功，false失败。 362 | */ 363 | public static boolean putFileOutputStreamContent(String password, 364 | String content, File file) { 365 | 366 | boolean sign = false; 367 | FileOutputStream fileOutputStream = null; 368 | BufferedOutputStream bufferedOutputStream = null; 369 | try { 370 | fileOutputStream = new FileOutputStream(file); 371 | bufferedOutputStream = new BufferedOutputStream(fileOutputStream); 372 | bufferedOutputStream.write(AndroidAESEncryptor.encrypt128(password, content) 373 | .getBytes()); 374 | bufferedOutputStream.flush(); 375 | if (file.exists()) 376 | sign = true; 377 | else 378 | sign = false; 379 | } catch (Exception e) { 380 | sign = false; 381 | e.printStackTrace(); 382 | } finally { 383 | try { 384 | if (null != bufferedOutputStream) { 385 | bufferedOutputStream.close(); 386 | } 387 | if (null != fileOutputStream) { 388 | fileOutputStream.close(); 389 | } 390 | } catch (IOException e) { 391 | e.printStackTrace(); 392 | } 393 | } 394 | 395 | return sign; 396 | } 397 | 398 | /** 399 | * 通过递归得到某一路径下所有的目录及其文件 400 | * 401 | * @param filePath 目录路径 402 | * @return 目录路径里面的所有文件集合 403 | */ 404 | public static List84 | * 此方法里面ImageLoaderConfiguration已经配置对应的设置。可以直接使用，也可以重新配置。 85 | *
86 | * 87 | * @param context 上下文 88 | * @param path 存储路径 89 | * @return ImageLoaderConfiguration对象 90 | */ 91 | public static ImageLoaderConfiguration.Builder getImageLoaderConfiguration( 92 | Context context, String path) { 93 | // 缓存文件的目录 94 | File cacheDir = StorageUtils.getOwnCacheDirectory(context, path); 95 | return new ImageLoaderConfiguration.Builder( 96 | context) 97 | // default = device screen dimensions 内存缓存文件的最大长宽 98 | .memoryCacheExtraOptions(480, 800) 99 | // default 线程池内加载的数量 100 | .threadPoolSize(5) 101 | // default 设置当前线程的优先级 102 | .threadPriority(Thread.NORM_PRIORITY - 2) 103 | // default 104 | .tasksProcessingOrder(QueueProcessingType.FIFO) 105 | .denyCacheImageMultipleSizesInMemory() 106 | .memoryCache(new UsingFreqLimitedMemoryCache(2 * 1024 * 1024)) // 你可以通过自己的内存缓存实现 107 | // 内存缓存的最大值 108 | .memoryCacheSize(2 * 1024 * 1024) 109 | // default 110 | .memoryCacheSizePercentage(13) 111 | // default 可以自定义缓存路径 112 | .diskCache(new UnlimitedDiskCache(cacheDir)) 113 | // 50 Mb sd卡(本地)缓存的最大值 114 | .diskCacheSize(50 * 1024 * 1024) 115 | // 可以缓存的文件数量 116 | .diskCacheFileCount(100) 117 | // default为使用Md5FileNameGenerator对UIL进行加密命名，用MD5(new 118 | // Md5FileNameGenerator())加密 119 | .diskCacheFileNameGenerator(new Md5FileNameGenerator()) 120 | .defaultDisplayImageOptions(DisplayImageOptions.createSimple()) // default 121 | .writeDebugLogs(); // 打印debug log 122 | } 123 | 124 | /** 125 | * 获取ImageLoader配置DisplayImageOptions对象 126 | *127 | * 此方法里面DisplayImageOptions已经配置对应的设置。可以直接使用，也可以重新配置。 128 | *
129 | * 130 | * @param drawableStub 图片下载期间显示的图片ID 131 | * @param drawableError 错误的时候显示的图片ID 132 | * @param cacheTarget false是存储在缓存进内存中，true缓存到SD中 133 | * @param rounded 圆角角度 134 | * @return DisplayImageOptions对象 135 | */ 136 | public static DisplayImageOptions getDisplayImageOptions(int drawableStub, 137 | int drawableError, boolean cacheTarget, int rounded) { 138 | DisplayImageOptions.Builder builder = new DisplayImageOptions.Builder() 139 | .showImageOnLoading(drawableStub) // 设置图片下载期间显示的图片 140 | .showImageForEmptyUri(drawableError) // 设置图片Uri为空或是错误的时候显示的图片 141 | .showImageOnFail(drawableError) // 设置图片加载或解码过程中发生错误显示的图片 142 | .resetViewBeforeLoading(true) // default 设置图片在加载前是否重置、复位 143 | .delayBeforeLoading(100) // 下载前的延迟时间 144 | .cacheInMemory(!cacheTarget) // default 设置下载的图片是否缓存在内存中 145 | .cacheOnDisk(cacheTarget) // default 设置下载的图片是否缓存在SD卡中 146 | .considerExifParams(true) // default 保留Exif信息 147 | .imageScaleType(ImageScaleType.EXACTLY) // default设置图片以如何的编码方式显示 148 | .bitmapConfig(Config.RGB_565) // default 设置图片的解码类型 149 | .displayer(new FadeInBitmapDisplayer(100));// default设置淡入动画 150 | DisplayImageOptions options; 151 | //是否设置圆角 152 | if (rounded > 0) { 153 | options = builder.displayer(new RoundedBitmapDisplayer(rounded))//设置圆角图片 154 | .build(); 155 | } else { 156 | options = builder.build(); 157 | } 158 | return options; 159 | } 160 | } 161 | -------------------------------------------------------------------------------- /utils/src/main/java/com/liqi/utils/imageloader/ImageStaticDispose.java: -------------------------------------------------------------------------------- 1 | package com.liqi.utils.imageloader; 2 | 3 | import android.content.Context; 4 | import android.graphics.Bitmap; 5 | import android.graphics.Bitmap.Config; 6 | import android.graphics.BitmapFactory; 7 | import android.graphics.Canvas; 8 | import android.graphics.Color; 9 | import android.graphics.Matrix; 10 | import android.graphics.Paint; 11 | import android.graphics.PixelFormat; 12 | import android.graphics.drawable.BitmapDrawable; 13 | import android.graphics.drawable.Drawable; 14 | 15 | import com.liqi.Logger; 16 | 17 | import java.io.BufferedOutputStream; 18 | import java.io.ByteArrayOutputStream; 19 | import java.io.File; 20 | import java.io.FileInputStream; 21 | import java.io.FileNotFoundException; 22 | import java.io.FileOutputStream; 23 | import java.io.IOException; 24 | import java.io.InputStream; 25 | import java.net.HttpURLConnection; 26 | import java.net.URL; 27 | 28 | /** 29 | * 图片处理工具对象 30 | * 31 | * @author LiQi 32 | */ 33 | public class ImageStaticDispose { 34 | /** 35 | * 通过Ulr路径获取byte[] 36 | * 37 | * @param urlStr ：图片的Url 38 | * @return ：byte[] 39 | */ 40 | public static byte[] getImageFromBuffer(String urlStr) throws Exception { 41 | // 从网络获取，在返回 42 | URL url = new URL(urlStr); 43 | HttpURLConnection conn = (HttpURLConnection) url.openConnection(); 44 | conn.setRequestMethod("GET"); 45 | conn.setUseCaches(false); 46 | conn.setConnectTimeout(10 * 1000); 47 | // 开辟输出流，用于写图片到缓存 48 | Logger.e("ImageStaticDispose.getImageFromBuffer()", "从网络获取图片"); 49 | if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) { 50 | Logger.e("ImageStaticDispose.getImageFromBuffer()", "从网络获取图片++++++"); 51 | return readStream(conn.getInputStream());// 获取图片的输入流 52 | } else { 53 | Logger.e("ImageStaticDispose.getImageFromBuffer()", "网络错误：" + conn.getErrorStream().toString()); 54 | return null; 55 | } 56 | } 57 | 58 | /** 59 | * 通过输入流转换成字节数组 60 | * 61 | * @param inStream 输入流 62 | * @return 字节数组 63 | * @throws Exception 输入流转换异常 64 | */ 65 | public static byte[] readStream(InputStream inStream) throws Exception { 66 | byte[] buffer = new byte[1024]; 67 | int len = -1; 68 | ByteArrayOutputStream outStream = new ByteArrayOutputStream(); 69 | while ((len = inStream.read(buffer)) != -1) { 70 | outStream.write(buffer, 0, len); 71 | } 72 | byte[] data = outStream.toByteArray(); 73 | outStream.close(); 74 | inStream.close(); 75 | Logger.e("ImageStaticDispose.readStream()", "data转换" + (data == null)); 76 | return data; 77 | 78 | } 79 | 80 | /** 81 | * 通过字节数组和BitmapFactory转换成Bitmap 82 | * 83 | * @param bytes 字节数组 84 | * @param opts BitmapFactory 85 | * @return Bitmap 86 | */ 87 | public static Bitmap getPicFromBytes(byte[] bytes, 88 | BitmapFactory.Options opts) { 89 | if (bytes != null) { 90 | if (opts != null) { 91 | opts.inJustDecodeBounds = false; 92 | return BitmapFactory.decodeByteArray(bytes, 0, bytes.length, 93 | opts); 94 | } else { 95 | return BitmapFactory.decodeByteArray(bytes, 0, bytes.length); 96 | } 97 | } 98 | return null; 99 | } 100 | 101 | /** 102 | * 转换成指定大小的Bitmap 103 | * 104 | * @param bitmap Bitmap 105 | * @param w 宽度 106 | * @param h 高度 107 | * @return 转换好的Bitmap 108 | */ 109 | public static Bitmap zoomBitmap(Bitmap bitmap, int w, int h) { 110 | int width = bitmap.getWidth(); 111 | int height = bitmap.getHeight(); 112 | Matrix matrix = new Matrix(); 113 | float scaleWidth = ((float) w / width); 114 | float scaleHeight = ((float) h / height); 115 | matrix.postScale(scaleWidth, scaleHeight); 116 | Bitmap newBmp = Bitmap.createBitmap(bitmap, 0, 0, width, height, 117 | matrix, true); 118 | return newBmp; 119 | } 120 | 121 | /** 122 | * 把bitmap转换成字节数组 123 | * 124 | * @param bm bitmap 125 | * @param quality 压缩质量百分比 126 | * @return 字节数组 127 | */ 128 | public static byte[] Bitmap2Bytes(Bitmap bm, int quality) { 129 | ByteArrayOutputStream baos = new ByteArrayOutputStream(); 130 | bm.compress(Bitmap.CompressFormat.PNG, quality, baos); 131 | return baos.toByteArray(); 132 | } 133 | 134 | /** 135 | * 把file写入到字节数组中 136 | * 137 | * @param b 写入的字节数组 138 | * @param file 要写入的file 139 | */ 140 | public static void getFileFromBytes(byte[] b, File file) { 141 | BufferedOutputStream stream = null; 142 | try { 143 | FileOutputStream fstream = new FileOutputStream(file); 144 | stream = new BufferedOutputStream(fstream); 145 | stream.write(b); 146 | } catch (Exception e) { 147 | e.printStackTrace(); 148 | } finally { 149 | if (stream != null) { 150 | try { 151 | stream.close(); 152 | } catch (IOException e1) { 153 | e1.printStackTrace(); 154 | } 155 | } 156 | } 157 | } 158 | 159 | /** 160 | * 切割指定大小的Bitmap对象 161 | * 162 | * @param srcBitmap Bitmap 163 | * @param limitWidth 限制宽度 164 | * @param limitHeight 限制高度 165 | * @return 切割之后的Bitmap 166 | */ 167 | public static Bitmap cutterBitmap(Bitmap srcBitmap, int limitWidth, 168 | int limitHeight) { 169 | float width = srcBitmap.getWidth(); 170 | float height = srcBitmap.getHeight(); 171 | 172 | float limitScale = limitWidth / limitHeight; 173 | float srcScale = width / height; 174 | 175 | if (limitScale > srcScale) { 176 | // 高小了，所以要去掉多余的高度 177 | height = limitHeight / ((float) limitWidth / width); 178 | } else { 179 | // 宽度小了，所以要去掉多余的宽度 180 | width = limitWidth / ((float) limitHeight / height); 181 | } 182 | 183 | Bitmap bitmap = Bitmap.createBitmap((int) width, (int) height, 184 | Config.ARGB_8888); 185 | Canvas canvas = new Canvas(bitmap); 186 | canvas.drawBitmap(srcBitmap, 0, 0, new Paint()); 187 | return bitmap; 188 | } 189 | 190 | /** 191 | * 图片压缩->返回bitmap字节数组 192 | * 193 | * @param bitmap Bitmap 194 | * @param maxsize 指定多大 195 | * @return 字节数组 196 | */ 197 | public static byte[] compressBmpFromByte(Bitmap bitmap, long maxsize) { 198 | ByteArrayOutputStream baos = new ByteArrayOutputStream(); 199 | int compress = 100; 200 | bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos); 201 | Logger.e("ImageStaticDispose.compressBmpFromByte()", "没有压缩前>>>>" + baos.toByteArray().length); 202 | while (baos.toByteArray().length > maxsize) { 203 | baos.reset(); 204 | compress -= 10; 205 | bitmap.compress(Bitmap.CompressFormat.JPEG, compress, baos); 206 | } 207 | Logger.e("ImageStaticDispose.compressBmpFromByte()", "压缩之后>>>>" + baos.toByteArray().length); 208 | return baos.toByteArray(); 209 | } 210 | 211 | /** 212 | * 图片压缩->返回压缩的bitmap 213 | * 214 | * @param bitmap Bitmap 215 | * @param maxsize 指定多大 216 | * @return 压缩之后的bitmap 217 | */ 218 | public static Bitmap compressBmpGetBmp(Bitmap bitmap, long maxsize) { 219 | if (null != bitmap) { 220 | ByteArrayOutputStream baos = new ByteArrayOutputStream(); 221 | int compress = 100; 222 | bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos); 223 | while (baos.toByteArray().length > maxsize) { 224 | baos.reset(); 225 | compress -= 10; 226 | bitmap.compress(Bitmap.CompressFormat.JPEG, compress, baos); 227 | } 228 | } 229 | return bitmap; 230 | } 231 | 232 | /** 233 | * 通过地址获取指定宽度和高度的Bitmap 234 | * 235 | * @param path 地址 236 | * @param reqWidth 限制宽度 237 | * @param reqHeight 限制高度 238 | * @return 处理好的Bitmap 239 | */ 240 | public static Bitmap acquireBitmap(String path, int reqWidth, int reqHeight) { 241 | final BitmapFactory.Options options = new BitmapFactory.Options(); 242 | options.inDither = false; // 不进行图片抖动处理 243 | options.inPreferredConfig = null; // 设置让解码器以最佳方式解码 244 | if (reqWidth > 0 || reqHeight > 0) { 245 | options.inJustDecodeBounds = true; 246 | options.inSampleSize = calculateInSampleSize(options, reqWidth, 247 | reqHeight); 248 | } 249 | options.inJustDecodeBounds = false; 250 | 251 | return BitmapFactory.decodeFile(path, options); 252 | } 253 | 254 | /** 255 | * 通过地址获取指定大小的Bitmap(质量压缩) 256 | * 257 | * @param path 本地路径 258 | * @param compressSize 设置位图缩放比例 width，hight设为原来的四分一（该参数请使用2的整数倍）,这也减小了位图占用的内存大小； 259 | * 例如，一张 260 | * 分辨率为2048*1536px的图像使用inSampleSize值为4的设置来解码，产生的Bitmap大小约为512 261 | * *384px。 相较于完整图片占用12M的内存，这种方式只需0.75M内存(假设Bitmap配置为//ARGB_8888)。 262 | * @return 压缩之后的bitmap 263 | */ 264 | public static Bitmap acquireBitmap(String path, int compressSize) { 265 | FileInputStream is = null; 266 | try { 267 | is = new FileInputStream(path); 268 | } catch (FileNotFoundException e) { 269 | e.printStackTrace(); 270 | } 271 | // 2.为位图设置100K的缓存 272 | BitmapFactory.Options opts = new BitmapFactory.Options(); 273 | opts.inTempStorage = new byte[100 * 1024]; 274 | // 3.设置位图颜色显示优化方式 275 | // ALPHA_8：每个像素占用1byte内存（8位） 276 | // ARGB_4444:每个像素占用2byte内存（16位） 277 | // ARGB_8888:每个像素占用4byte内存（32位） 278 | // RGB_565:每个像素占用2byte内存（16位） 279 | // Android默认的颜色模式为ARGB_8888，这个颜色模式色彩最细腻，显示质量最高。但同样的，占用的内存//也最大。也就意味着一个像素点占用4个字节的内存。我们来做一个简单的计算题：3200*2400*4 280 | // bytes //=30M。如此惊人的数字！哪怕生命周期超不过10s，Android也不会答应的。 281 | opts.inPreferredConfig = Config.RGB_565; 282 | // 4.设置图片可以被回收，创建Bitmap用于存储Pixel的内存空间在系统内存不足时可以被回收 283 | opts.inPurgeable = true; 284 | // 5.设置位图缩放比例 285 | // width，hight设为原来的四分一（该参数请使用2的整数倍）,这也减小了位图占用的内存大小；例如，一张//分辨率为2048*1536px的图像使用inSampleSize值为4的设置来解码，产生的Bitmap大小约为//512*384px。相较于完整图片占用12M的内存，这种方式只需0.75M内存(假设Bitmap配置为//ARGB_8888)。 286 | opts.inSampleSize = compressSize; 287 | // 6.设置解码位图的尺寸信息 288 | opts.inInputShareable = true; 289 | // 7.解码位图 290 | Bitmap btp = BitmapFactory.decodeStream(is, null, opts); 291 | try { 292 | if (is != null) { 293 | is.close(); 294 | is = null; 295 | } 296 | } catch (IOException e) { 297 | e.printStackTrace(); 298 | } 299 | return btp; 300 | } 301 | 302 | // 计算图片的缩放值 303 | private static int calculateInSampleSize(BitmapFactory.Options options, 304 | int reqWidth, int reqHeight) { 305 | final int height = options.outHeight; 306 | final int width = options.outWidth; 307 | int inSampleSize = 1; 308 | 309 | if (height > reqHeight || width > reqWidth) { 310 | final double heightRatio = Math.ceil((float) height 311 | / (float) reqHeight); 312 | final double widthRatio = Math.ceil((float) width 313 | / (float) reqWidth); 314 | inSampleSize = (int) Math.ceil(Math.max(heightRatio, widthRatio)); 315 | } 316 | return inSampleSize; 317 | } 318 | 319 | /** 320 | * Drawable转Bitmap 321 | * 322 | * @param drawable Drawable 323 | * @return Bitmap 324 | */ 325 | public static Bitmap drawableToBitmap(Drawable drawable) { 326 | // 取 drawable 的长宽 327 | int w = drawable.getIntrinsicWidth(); 328 | int h = drawable.getIntrinsicHeight(); 329 | 330 | // 取 drawable 的颜色格式 331 | Config config = drawable.getOpacity() != PixelFormat.OPAQUE ? Config.ARGB_8888 332 | : Config.RGB_565; 333 | // 建立对应 bitmap 334 | Bitmap bitmap = Bitmap.createBitmap(w, h, config); 335 | // 建立对应 bitmap 的画布 336 | Canvas canvas = new Canvas(bitmap); 337 | drawable.setBounds(0, 0, w, h); 338 | // 把 drawable 内容画到画布中 339 | drawable.draw(canvas); 340 | return bitmap; 341 | } 342 | 343 | /** 344 | * Drawable 指定大小的缩放 345 | * 346 | * @param drawable Drawable 347 | * @param w 限制宽度 348 | * @param h 限制高度 349 | * @return 处理好的Drawable 350 | */ 351 | public static Drawable zoomDrawable(Drawable drawable, int w, int h) { 352 | int width = drawable.getIntrinsicWidth(); 353 | int height = drawable.getIntrinsicHeight(); 354 | // drawable转换成bitmap 355 | Bitmap oldbmp = drawableToBitmap(drawable); 356 | // 创建操作图片用的Matrix对象 357 | Matrix matrix = new Matrix(); 358 | // 计算缩放比例 359 | float sx = ((float) w / width); 360 | float sy = ((float) h / height); 361 | // 设置缩放比例 362 | matrix.postScale(sx, sy); 363 | // 建立新的bitmap，其内容是对原bitmap的缩放后的图 364 | Bitmap newbmp = Bitmap.createBitmap(oldbmp, 0, 0, width, height, 365 | matrix, true); 366 | return new BitmapDrawable(newbmp); 367 | } 368 | 369 | /** 370 | * 字节数组转换File对象 371 | * 372 | * @param byteOne 字节数组 373 | * @param filePath 写入路径 374 | * @return 转换的File对象 375 | * @throws Exception 转换失败异常 376 | */ 377 | public static File acquireByteFile(byte[] byteOne, String filePath) { 378 | File file = null; 379 | FileOutputStream fos = null; 380 | BufferedOutputStream bos = null; 381 | try { 382 | file = new File(filePath); 383 | fos = new FileOutputStream(file); 384 | bos = new BufferedOutputStream(fos); 385 | bos.write(byteOne); 386 | } catch (Exception e) { 387 | e.printStackTrace(); 388 | } finally { 389 | if (fos != null) { 390 | try { 391 | fos.close(); 392 | } catch (IOException e) { 393 | e.printStackTrace(); 394 | } 395 | } 396 | if (bos != null) { 397 | try { 398 | bos.close(); 399 | } catch (IOException e) { 400 | e.printStackTrace(); 401 | } 402 | } 403 | } 404 | 405 | return file; 406 | } 407 | 408 | /** 409 | * 获取指定图片Y轴0，X轴中间的颜色值 410 | * 411 | * @param context 上下文 412 | * @param imageId 图片ID 413 | * @return 颜色值 414 | */ 415 | public static int getPixColorXCentre(Context context, int imageId) { 416 | Bitmap src = BitmapFactory.decodeResource(context.getResources(), imageId); 417 | if (null != src) { 418 | int A, R, G, B; 419 | //获取图片高度 420 | int height = src.getHeight(); 421 | //获取图片宽度 422 | int width = src.getWidth(); 423 | //获取像素点对应的颜色值 424 | int pixelColor = src.getPixel(height / 2, 0); 425 | //获取透明度 426 | //A = Color.alpha(pixelColor); 427 | //获取红色值 428 | R = Color.red(pixelColor); 429 | //获取绿色值 430 | G = Color.green(pixelColor); 431 | //获取蓝色值 432 | B = Color.blue(pixelColor); 433 | 434 | //循环获取图片中所有的颜色值 435 | // for (int y = 0; y < height; y++) { 436 | // for (int x = 0; x < width; x++) { 437 | // pixelColor = src.getPixel(x, y); 438 | // A = Color.alpha(pixelColor); 439 | // R = Color.red(pixelColor); 440 | // G = Color.green(pixelColor); 441 | // B = Color.blue(pixelColor); 442 | // 443 | // Logger.e("A:", A+""); 444 | // Logger.e("R:", R+""); 445 | // Logger.e("G:", G+""); 446 | // Logger.e("B:", B+""); 447 | // } 448 | // } 449 | return Color.rgb(R, G, B); 450 | } else { 451 | return 0; 452 | } 453 | } 454 | } 455 | -------------------------------------------------------------------------------- /utils/src/main/java/com/liqi/utils/spf/BaseSharePreference.java: -------------------------------------------------------------------------------- 1 | package com.liqi.utils.spf; 2 | 3 | import android.content.Context; 4 | import android.content.SharedPreferences; 5 | 6 | import com.liqi.Logger; 7 | 8 | import java.lang.ref.Reference; 9 | import java.lang.ref.SoftReference; 10 | 11 | /** 12 | * SharePreference偏好设置的工具 13 | * 14 | * @author LiQi 15 | */ 16 | public class BaseSharePreference { 17 | private static final String TAG=BaseSharePreference.class.getName(); 18 | private static Reference38 | * 返回“当”就代表时间轴为当前 39 | *
40 | * @param millisecond 毫秒值 41 | * @return 加单位格式化好的数值 42 | */ 43 | public static String millisecondTurnValue(long millisecond) { 44 | String timeTurnValue; 45 | //转换秒 46 | millisecond /= 1000; 47 | //大于60秒 48 | if (millisecond > 60) { 49 | //转换分 50 | millisecond /= 60; 51 | //大于60分 52 | if (millisecond > 60) { 53 | //转换时 54 | millisecond /= 60; 55 | //大于24小时 56 | if (millisecond > 24) { 57 | millisecond /= 24; 58 | timeTurnValue = millisecond + "天"; 59 | } else { 60 | timeTurnValue = millisecond + "小时"; 61 | } 62 | } else { 63 | timeTurnValue = millisecond + "分钟"; 64 | } 65 | } else { 66 | if (millisecond <= 0) { 67 | timeTurnValue = "当"; 68 | } else { 69 | timeTurnValue = millisecond + "秒"; 70 | } 71 | } 72 | return timeTurnValue; 73 | } 74 | 75 | /** 76 | * 根据年月日计算年龄 77 | *78 | * 时间格式必须为：yyyy-MM-dd 79 | *
80 | * 81 | * @param birthTimeString 时间值 82 | */ 83 | public static int getAgeFromBirthTime(String birthTimeString) { 84 | if (!TextUtils.isEmpty(birthTimeString)) { 85 | // 先截取到字符串中的年、月、日 86 | String strs[] = birthTimeString.trim().split("-"); 87 | int selectYear = Integer.parseInt(strs[0]); 88 | int selectMonth = Integer.parseInt(strs[1]); 89 | int selectDay = Integer.parseInt(strs[2]); 90 | // 得到当前时间的年、月、日 91 | Calendar cal = Calendar.getInstance(); 92 | int yearNow = cal.get(Calendar.YEAR); 93 | int monthNow = cal.get(Calendar.MONTH) + 1; 94 | int dayNow = cal.get(Calendar.DATE); 95 | 96 | // 用当前年月日减去生日年月日 97 | int yearMinus = yearNow - selectYear; 98 | int monthMinus = monthNow - selectMonth; 99 | int dayMinus = dayNow - selectDay; 100 | 101 | int age = yearMinus; // 先大致赋值 102 | if (yearMinus < 0) { // 选了未来的年份 103 | age = 0; 104 | } else { 105 | if ((monthMinus > 0) || (monthMinus == 0 && dayMinus >= 0)) { 106 | age += 1; 107 | } 108 | } 109 | return age > 0 ? age - 1 : age; 110 | } 111 | return 0; 112 | } 113 | 114 | /** 115 | * 根据时间戳计算年龄 116 | * 117 | * @param birthTimeLong 时间戳 118 | */ 119 | public static int getAgeFromBirthTime(long birthTimeLong) { 120 | String birthTimeString = TimeUtil.longgetStringDate(birthTimeLong, "yyyy-MM-dd"); 121 | return getAgeFromBirthTime(birthTimeString); 122 | } 123 | } 124 | -------------------------------------------------------------------------------- /utils/src/main/java/com/liqi/utils/time/TimeHMSTransitionEnum.java: -------------------------------------------------------------------------------- 1 | package com.liqi.utils.time; 2 | 3 | /**时间时分秒转换类型枚举 4 | * Created by LiQi on 2018/1/26. 5 | */ 6 | 7 | public enum TimeHMSTransitionEnum { 8 | /** 9 | * 单位天类型 10 | */ 11 | DAY_TYPE, 12 | /** 13 | * 单位时类型 14 | */ 15 | TIME_TYPE, 16 | /** 17 | * 单位分钟类型 18 | */ 19 | MINUTE_TYPE, 20 | /** 21 | * 单位秒钟类型 22 | */ 23 | SECOND_TYPE, 24 | /** 25 | * 单位毫秒类型 26 | */ 27 | MILLISECOND_TYPE 28 | } 29 | -------------------------------------------------------------------------------- /utils/src/main/java/com/liqi/utils/wifi/OnWifiControllerListener.java: -------------------------------------------------------------------------------- 1 | package com.liqi.utils.wifi; 2 | 3 | import android.net.wifi.ScanResult; 4 | import android.net.wifi.WifiConfiguration; 5 | 6 | import java.util.List; 7 | 8 | /**wifi操作对象扫描之后操作方法接口 9 | * Created by LiQi on 2017/12/15. 10 | */ 11 | 12 | public interface OnWifiControllerListener { 13 | /** 14 | * 得到配置好的网络. 15 | */ 16 | List17 | * 由于XML解析的格式有限。 18 | * 在使用前，请参看解析方法对应的XML格式。 19 | *
20 | * 21 | * @author LiQi 22 | */ 23 | public class XmlUtils { 24 | public static final String TAG = "tag"; 25 | 26 | private XmlUtils() { 27 | 28 | } 29 | 30 | /** 31 | * 根据XML来获取指定节点（单个节点），判断是否符合OK来返回 32 | * 33 | * @param xmlName xmlName[0] XML文件，xmlName[1] XML子节点，xmlName[2] 要对比的值 34 | * @return true 是和对比的一致，false 和对比的值不一致 35 | */ 36 | public static boolean xmlPull(String... xmlName) { 37 | boolean wxSign = false; 38 | try { 39 | // 准备解析器 40 | XmlPullParser parser = Xml.newPullParser(); 41 | parser.setInput(new StringReader(xmlName[0]));// 设置要解析的输入流 42 | boolean isdone = false;// 是否结束解析 43 | // 取得当前节点的事件类型 44 | int eventType = parser.getEventType(); 45 | // 当事件不是文档结尾时，一直解析内容 46 | while (eventType != XmlPullParser.END_DOCUMENT && !isdone) { 47 | // 比较事件类型 48 | switch (eventType) { 49 | case XmlPullParser.START_DOCUMENT: 50 | case XmlPullParser.START_TAG: 51 | // 取得当前节点的 标记 52 | String tag = parser.getName(); 53 | if (xmlName[1].equals(tag)) { 54 | String message = parser.nextText(); 55 | if (xmlName[2].equals(message)) { 56 | wxSign = true; 57 | } 58 | } 59 | break; 60 | case XmlPullParser.END_TAG:// 结束标记 61 | String nameTag = parser.getName(); 62 | if (xmlName[1].equalsIgnoreCase(nameTag)) { 63 | isdone = true; 64 | } 65 | break; 66 | } 67 | // 手动指向下一个节点，继续解析 68 | eventType = parser.next(); 69 | } 70 | } catch (Exception e) { 71 | e.printStackTrace(); 72 | } 73 | return wxSign; 74 | } 75 | 76 | /** 77 | * 通过XML文件获取一个节点文本内容list集合(只支持两种格式的XML) 78 | * 79 | * @param xml xml文件 80 | * @param xmlLabelList XML里面的三级标签名字 81 | * XML样例： 82 | *
83 | *
84 | *
90 | * 这是二级标签
91 | *
95 | *
99 | *
100 | *
182 | * XML样例：
183 | *
184 | *
41 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 42 | *
43 | * @param zipName zip压缩文件名字。扩展名内部已定义。不能为null和空 44 | */ 45 | public static void zipFiles(Context context, Collection56 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 57 | *
58 | * @param zipName zip压缩文件名字。扩展名内部已定义。不能为null和空 59 | * @param buffSize 压缩文件缓存大小 60 | */ 61 | public static void zipFiles(Context context, Collection72 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 73 | *
74 | * @param zipName zip压缩文件名字。扩展名内部已定义。不能为null和空 75 | * @param comment 压缩文件注释 76 | */ 77 | public static void zipFiles(Context context, Collection88 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 89 | *
90 | * @param zipName zip压缩文件名字。扩展名内部已定义。不能为null和空 91 | * @param comment 压缩文件注释 92 | * @param buffSize 压缩文件缓存大小 93 | */ 94 | public static void zipFiles(Context context, String resFilePath, String zipCataloguePath, String zipName, String comment, int buffSize) { 95 | if (!TextUtils.isEmpty(resFilePath)) { 96 | ArrayList110 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 111 | *
112 | * @param zipName zip压缩文件名字。扩展名内部已定义。不能为null和空 113 | * @param comment 压缩文件注释 114 | */ 115 | public static void zipFiles(Context context, String resFilePath, String zipCataloguePath, String zipName, String comment) { 116 | if (!TextUtils.isEmpty(resFilePath)) { 117 | ArrayList131 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 132 | *
133 | * @param zipName zip压缩文件名字。扩展名内部已定义。不能为null和空 134 | * @param buffSize 压缩文件缓存大小 135 | */ 136 | public static void zipFiles(Context context, String resFilePath, String zipCataloguePath, String zipName,int buffSize) { 137 | if (!TextUtils.isEmpty(resFilePath)) { 138 | ArrayList152 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 153 | *
154 | * @param zipName zip压缩文件名字。扩展名内部已定义。不能为null和空 155 | */ 156 | public static void zipFiles(Context context, String resFilePath, String zipCataloguePath, String zipName) { 157 | if (!TextUtils.isEmpty(resFilePath)) { 158 | ArrayList172 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 173 | *
174 | * @param zipName zip压缩文件名字。扩展名内部已定义。不能为null和空 175 | * @param comment 压缩文件注释 176 | * @param buffSize 压缩文件缓存大小 177 | */ 178 | public static void zipFiles(Context context, Collection227 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 228 | *
229 | */ 230 | public static void unZipFiles(Context context, Collection251 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 252 | *
253 | * @param buffSize 解压文件缓存大小 254 | */ 255 | public static void unZipFiles(Context context, Collection276 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 277 | *
278 | */ 279 | public static void unZipFile(Context context, String zipFilePath, String unZipFolderPath) { 280 | unZipFile(context, zipFilePath, unZipFolderPath, BUFF_SIZE); 281 | } 282 | 283 | /** 284 | * 解压一个zip文件 285 | * 286 | * @param context 上下文。不能为null 287 | * @param zipFilePath 压缩文件路径。需要带文件扩展名，不能为null和空 288 | * @param unZipFolderPath 解压写出文件目录。样例:xxx/xxx。不能为null和空 289 | *290 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 291 | *
292 | * @param buffSize 解压文件缓存大小 293 | */ 294 | public static void unZipFile(Context context, String zipFilePath, String unZipFolderPath, int buffSize) { 295 | if (null != context && !TextUtils.isEmpty(zipFilePath) && !TextUtils.isEmpty(unZipFolderPath)) { 296 | String path = StaticFileUtils.getPath(context, unZipFolderPath); 297 | File desDir = new File(path); 298 | if (!desDir.exists() || !desDir.isDirectory()) { 299 | desDir.mkdirs(); 300 | } 301 | ZipFile zf = null; 302 | try { 303 | zf = new ZipFile(new File(zipFilePath)); 304 | for (Enumeration entries = zf.entries(); entries.hasMoreElements(); ) { 305 | ZipEntry entry = ((ZipEntry) entries.nextElement()); 306 | // 后面插入判断是否为文件夹，如果是不处理(因为程序会根据你的路径自动去文件之上的文件夹) 307 | String name = entry.getName(); 308 | if (name.endsWith(File.separator)) { 309 | continue; 310 | } 311 | 312 | InputStream in = null; 313 | OutputStream out = null; 314 | try { 315 | in = zf.getInputStream(entry); 316 | String str = path + File.separator + name; 317 | str = new String(str.getBytes("8859_1"), "GB2312"); 318 | File desFile = new File(str); 319 | if (!desFile.exists()) { 320 | File fileParentDir = desFile.getParentFile(); 321 | if (!fileParentDir.exists() && !fileParentDir.isDirectory()) { 322 | fileParentDir.mkdirs(); 323 | } 324 | desFile.createNewFile(); 325 | } 326 | out = new FileOutputStream(desFile); 327 | byte buffer[] = new byte[buffSize]; 328 | int realLength; 329 | while ((realLength = in.read(buffer)) > 0) { 330 | out.write(buffer, 0, realLength); 331 | } 332 | } finally { 333 | try { 334 | if (null != in) { 335 | in.close(); 336 | } 337 | if (null != out) { 338 | out.close(); 339 | } 340 | } catch (IOException e) { 341 | e.printStackTrace(); 342 | } 343 | } 344 | } 345 | 346 | } catch (IOException e) { 347 | e.printStackTrace(); 348 | } finally { 349 | try { 350 | if (null != zf) { 351 | zf.close(); 352 | } 353 | } catch (IOException e) { 354 | e.printStackTrace(); 355 | } 356 | } 357 | } else { 358 | Logger.e(TAG, "upZipFile()方法中有必须传值的参数未传入值"); 359 | } 360 | } 361 | 362 | /** 363 | * 解压压缩文件并查找包含传入文字的文件 364 | * 365 | * @param context 上下文。不能为null 366 | * @param zipFilePath 压缩文件路径。需要带文件扩展名，不能为null和空 367 | * @param unZipFolderPath 解压写出文件目录。样例:xxx/xxx。不能为null和空 368 | *369 | * 已经判断是否有SD卡。如果有就拼接SD卡路径，没有就拼接手机内存路径 370 | *
371 | * @param nameContains 传入的文件匹配名。不能为null和空 372 | */ 373 | public static ArrayList