/*
* Copyright (C) 2014 Jason Fang ( ijasonfang@gmail.com )
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/ package fyc.framework.util; import java.util.HashSet;
import java.util.Map;
import java.util.Set; import android.annotation.TargetApi;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.preference.PreferenceManager;
import android.support.v4.util.ArrayMap;
import android.text.TextUtils; /**
* SharePreferences Tool
*
* @author Jason Fang
* @datetime 2014年12月5日 下午5:28:22
*/
public class PrefsUtils {
static final boolean DEBUG = true; private static final String SECURITY_KEY = "iJasonfang"; /**
* Put Value
*
* @param context
* @param key
* @param value
* @return
*/
public static boolean putValue(Context context, String key, Object value) {
return putValue(context, null, key, value);
} public static boolean putValue(Context context, String key, Object value, boolean[] keyValueEncrypt) {
return putValue(context, null, key, value, keyValueEncrypt);
} public static boolean putValue(Context context, String name, String key, Object value) {
return putValue(context, name, key, value, new boolean[]{true, true});
} public static boolean putValue(Context context, String name, String key, Object value, boolean[] keyValueEncrypt) {
return putValue(context, name, key, value, Context.MODE_PRIVATE, keyValueEncrypt);
} public static boolean putValue(Context context, String name, String key, Object value, int mode, boolean[] keyValueEncrypt) {
ArrayMap<String, Object> map = new ArrayMap<String, Object>();
map.put(key, value);
return putValue(context, name, map, keyValueEncrypt);
} public static boolean putValue(Context context, String name, Map<String, Object> map, boolean[] keyValueEncrypt) {
return putValue(context, name, map, Context.MODE_PRIVATE, keyValueEncrypt);
} @TargetApi(11)
@SuppressWarnings("unchecked")
public static boolean putValue(Context context, String name, Map<String, Object> map, int mode, boolean[] keyValueEncrypt) {
SharedPreferences preferences = null;
if (TextUtils.isEmpty(name)) {
preferences = PreferenceManager.getDefaultSharedPreferences(context);
} else {
preferences = context.getSharedPreferences(name, mode);
} Editor editor = preferences.edit();
for (Map.Entry<String, Object> entry : map.entrySet()) {
String key = keyValueEncrypt[0] ? SecurityUtils.MD5(entry.getKey()) : entry.getKey();
Object value = entry.getValue(); if (keyValueEncrypt[1] && !(value instanceof Set)) {
editor.putString(key, SecurityUtils.DESencrypt(String.valueOf(value), SECURITY_KEY));
} else {
if (value instanceof Boolean) {
editor.putBoolean(key, Boolean.parseBoolean(String.valueOf(value)));
} else if (value instanceof Float) {
editor.putFloat(key, Float.parseFloat(String.valueOf(value)));
} else if (value instanceof Integer) {
editor.putInt(key, Integer.parseInt(String.valueOf(value)));
} else if (value instanceof Long) {
editor.putLong(key, Long.parseLong(String.valueOf(value)));
} else if (value instanceof String) {
editor.putString(key, String.valueOf(value));
} else if (value instanceof Set) {
if (keyValueEncrypt[1]) {
Set<String> sets = (Set<String>)value;
Set<String> tempSets = new HashSet<String>();
for (String s : sets) {
tempSets.add(SecurityUtils.DESencrypt(String.valueOf(s), SECURITY_KEY));
}
editor.putStringSet(key, tempSets);
} else {
editor.putStringSet(key, (Set<String>)value);
}
} else {
throw new IllegalArgumentException("Value type is not support!");
}
}
}
return editor.commit();
} /**
* Remove Key
* @param context
* @param key
*/
public static boolean removeKey(Context context, String key) {
return removeKey(context, null, key);
} public static boolean removeKey(Context context, String name, String key) {
return removeKey(context, name, key, false);
} public static boolean removeKey(Context context, String name, String key, boolean isKeyEncrypt) {
return removeKey(context, name, key, Context.MODE_PRIVATE, isKeyEncrypt);
} public static boolean removeKey(Context context, String name, String key, int mode, boolean isKeyEncrypt) {
SharedPreferences preferences = null;
if (TextUtils.isEmpty(name)) {
preferences = PreferenceManager.getDefaultSharedPreferences(context);
} else {
preferences = context.getSharedPreferences(name, mode);
} Editor editor = preferences.edit();
editor.remove(isKeyEncrypt ? SecurityUtils.DESencrypt(key, SECURITY_KEY) : key);
return editor.commit();
} /**
* Get String
*
* @param context
* @param key
* @param defValue
* @return
*/
public static String getString(Context context, String key, String defValue) {
return getString(context, null, key, defValue);
} public static String getString(Context context, String name, String key, String defValue) {
return getString(context, name, key, defValue, Context.MODE_PRIVATE, new boolean[]{true, true});
} public static String getString(Context context, String name, String key, String defValue, boolean[] keyValueEncrypt) {
return getString(context, name, key, defValue, Context.MODE_PRIVATE, keyValueEncrypt);
} public static String getString(Context context, String name, String key, String defValue, int mode, boolean[] keyValueEncrypt) {
SharedPreferences preferences = null;
if (TextUtils.isEmpty(name)) {
preferences = PreferenceManager.getDefaultSharedPreferences(context);
} else {
preferences = context.getSharedPreferences(name, mode);
} String value = preferences.getString(keyValueEncrypt[0] ? SecurityUtils.MD5(key) : key, defValue);
if (value.equals(defValue)) {
return value;
} else {
return keyValueEncrypt[1] ? SecurityUtils.DESdecrypt(value, SECURITY_KEY) : value;
}
} /**
* Get Int
*
* @param context
* @param key
* @param defValue
* @return
*/
public static int getInt(Context context, String key, int defValue) {
return getInt(context, null, key, defValue);
} public static int getInt(Context context, String name, String key, int defValue) {
return getInt(context, name, key, defValue, new boolean[]{true, true});
} public static int getInt(Context context, String name, String key, int defValue, boolean[] keyValueEncrypt) {
return getInt(context, name, key, defValue, Context.MODE_PRIVATE, keyValueEncrypt);
} public static int getInt(Context context, String name, String key, int defValue, int mode, boolean[] keyValueEncrypt) {
SharedPreferences preferences = null;
if (TextUtils.isEmpty(name)) {
preferences = PreferenceManager.getDefaultSharedPreferences(context);
} else {
preferences = context.getSharedPreferences(name, mode);
} if (keyValueEncrypt[1]) {
String value = getString(context, name, key, String.valueOf(defValue), mode, keyValueEncrypt);
try {
return Integer.valueOf(value);
} catch (Exception e) {
return defValue;
}
} else {
return preferences.getInt(keyValueEncrypt[0] ? SecurityUtils.MD5(key) : key, defValue);
}
} /**
* Get Long
*
* @param context
* @param key
* @param defValue
* @return
*/
public static long getLong(Context context, String key, long defValue) {
return getLong(context, null, key, defValue);
} public static long getLong(Context context, String name, String key, long defValue) {
return getLong(context, name, key, defValue, new boolean[]{true, true});
} public static long getLong(Context context, String name, String key, long defValue, boolean[] keyValueEncrypt) {
return getLong(context, name, key, defValue, Context.MODE_PRIVATE, keyValueEncrypt);
} public static long getLong(Context context, String name, String key, long defValue, int mode, boolean[] keyValueEncrypt) {
SharedPreferences preferences = null;
if (TextUtils.isEmpty(name)) {
preferences = PreferenceManager.getDefaultSharedPreferences(context);
} else {
preferences = context.getSharedPreferences(name, mode);
} if (keyValueEncrypt[1]) {
String value = getString(context, name, key, String.valueOf(defValue), mode, keyValueEncrypt); try {
return Long.valueOf(value);
} catch (Exception e) {
return defValue;
}
} else {
return preferences.getLong(keyValueEncrypt[0] ? SecurityUtils.MD5(key) : key, defValue);
}
} /**
* Get Float
*
* @param context
* @param key
* @param defValue
* @return
*/
public static float getFloat(Context context, String key, float defValue) {
return getFloat(context, null, key, defValue);
} public static float getFloat(Context context, String name, String key, float defValue) {
return getFloat(context, name, key, defValue, new boolean[]{true, true});
} public static float getFloat(Context context, String name, String key, float defValue, boolean[] keyValueEncrypt) {
return getFloat(context, name, key, defValue, Context.MODE_PRIVATE, keyValueEncrypt);
} public static float getFloat(Context context, String name, String key, float defValue, int mode, boolean[] keyValueEncrypt) {
SharedPreferences preferences = null;
if (TextUtils.isEmpty(name)) {
preferences = PreferenceManager.getDefaultSharedPreferences(context);
} else {
preferences = context.getSharedPreferences(name, mode);
} if (keyValueEncrypt[1]) {
String value = getString(context, name, key, String.valueOf(defValue), mode, keyValueEncrypt);
try {
return Float.valueOf(value);
} catch (Exception e) {
return defValue;
}
} else {
return preferences.getFloat(keyValueEncrypt[0] ? SecurityUtils.MD5(key) : key, defValue);
} } /**
* boolean
*
* @param context
* @param key
* @param defValue
* @return
*/
public static boolean getBoolean(Context context, String key, boolean defValue) {
return getBoolean(context, null, key, defValue);
} public static boolean getBoolean(Context context, String name, String key, boolean defValue) {
return getBoolean(context, name, key, defValue, new boolean[]{true, true});
} public static boolean getBoolean(Context context, String name, String key, boolean defValue, boolean[] keyValueEncrypt) {
return getBoolean(context, name, key, defValue, Context.MODE_PRIVATE, keyValueEncrypt);
} public static boolean getBoolean(Context context, String name, String key, boolean defValue, int mode, boolean[] keyValueEncrypt) {
SharedPreferences preferences = null;
if (TextUtils.isEmpty(name)) {
preferences = PreferenceManager.getDefaultSharedPreferences(context);
} else {
preferences = context.getSharedPreferences(name, mode);
} if (keyValueEncrypt[1]) {
String valueString = getString(context, name, key, String.valueOf(defValue), mode, keyValueEncrypt);
try {
return Boolean.valueOf(valueString);
} catch (Exception e) {
return defValue;
}
} else {
return preferences.getBoolean(keyValueEncrypt[0] ? SecurityUtils.MD5(key) : key, defValue);
}
} /**
* StringSet
*
* @param context
* @param key
* @param defValues
* @return
*/
public static Set<String> getStringSet(Context context, String key, Set<String> defValues) {
return getStringSet(context, null, key, defValues);
} public static Set<String> getStringSet(Context context, String name, String key, Set<String> defValues) {
return getStringSet(context, name, key, defValues, new boolean[]{true, true});
} public static Set<String> getStringSet(Context context, String name, String key, Set<String> defValues, boolean[] keyValueEncrypt) {
return getStringSet(context, name, key, defValues, Context.MODE_PRIVATE, keyValueEncrypt);
} /**
* @param context
* @param name
* @param key
* @param defValues
* @param mode
* @return
*/
@TargetApi(11)
public static Set<String> getStringSet(Context context, String name, String key, Set<String> defValues, int mode, boolean[] keyValueEncrypt) {
SharedPreferences preferences = null;
if (TextUtils.isEmpty(name)) {
preferences = PreferenceManager.getDefaultSharedPreferences(context);
} else {
preferences = context.getSharedPreferences(name, mode);
}
Set<String> valueSet = preferences.getStringSet(keyValueEncrypt[0] ? SecurityUtils.MD5(key) : key, defValues);
Set<String> tempValueSet = new HashSet<String>();
for (String s : valueSet) {
tempValueSet.add(SecurityUtils.DESdecrypt(s, SECURITY_KEY));
}
return tempValueSet;
} private PrefsUtils(){/*Do not new me*/};
}
加密工具类!
/*
* Copyright (C) 2014 Jason Fang ( ijasonfang@gmail.com )
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/ package fyc.framework.util; import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream; import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.DESedeKeySpec; import android.annotation.SuppressLint;
import android.text.TextUtils;
import android.util.Base64; /**
* 加密工具类
* @description
* @author Jason Fang
* @created 2013年10月31日
*/
public class SecurityUtils {
static final boolean DEBUG = true; /**
* MD5
* @param srcString
* @return
*/
public static String MD5(String srcString) {
if (TextUtils.isEmpty(srcString)) {
throw new IllegalArgumentException("srcString cannot be null!");
} try {
return MD5(srcString.getBytes("UTF-8"));
} catch (UnsupportedEncodingException e) {
return "";
}
} public static String MD5(byte[] srcBytes) {
if (srcBytes == null) {
throw new IllegalArgumentException("bytes cannot be null!");
} try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(srcBytes);
byte[] bytes = md.digest();
int i = 0;
StringBuffer buffer = new StringBuffer("");
for (int offset = 0; offset < bytes.length; offset++) {
i = bytes[offset];
if (i < 0) {
i += 256;
}
if (i < 16) {
buffer.append("0");
}
buffer.append(Integer.toHexString(i));
}
return buffer.toString();
} catch (Exception e) {
if (DEBUG) Flog.e(e);
}
return "";
}
/**
* @param dataSource
* @param password
* @return
*/
public static String DESencrypt(String dataSource, String password) {
return ConvertUtils.parseBytesToHexString(DESencrypt(dataSource.getBytes(), password));
} /**
* @param data
* @param password
* @return
*/
public static String DESdecrypt(String data, String password) {
byte[] bytes = DESdecrypt(ConvertUtils.parseHexStringToBytes(data), password);
if (bytes == null) {
return "";
}
return new String(bytes);
}
private SecurityUtils() {/*Do not new me*/};
}
ConvertUtils
/*
* Copyright (C) 2014 Jason Fang ( ijasonfang@gmail.com )
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/ package fyc.framework.util; import java.io.UnsupportedEncodingException;
import java.text.NumberFormat;
import java.util.Arrays;
import java.util.Map;
import java.util.Set; import android.content.Context;
import android.content.res.Resources;
import android.text.TextUtils;
import android.util.TypedValue; /**
* 转换工具集
* @author Jason Fang
* @datetime 2014年11月23日 上午11:22:25
*/
public class ConvertUtils {
static final boolean DEBUG = false;
/**
* byte[] to String
* @param bytes
* @return
*/
public static String parseBytesToHexString(byte[] bytes) {
if (bytes == null) return "";
StringBuffer sb = new StringBuffer();
for (int i = 0; i < bytes.length; i++) {
String x16 = Integer.toHexString(bytes[i]);
if (x16.length() < 2) {
sb.append("0" + x16);
} else if (x16.length() > 2) {
sb.append(x16.substring(x16.length() - 2));
} else {
sb.append(x16);
}
}
return sb.toString();
} /**
* String to byte[]
* @param intString
* @return
*/
public static byte[] parseHexStringToBytes(String intString) {
if (TextUtils.isEmpty(intString)) return null; if (intString.length() % 2 == 1) {
intString = "0" + intString;
}
byte[] bytes = new byte[intString.length() / 2]; try {
for (int i = 0; i < bytes.length; i++) {
bytes[i] = (byte)Integer.parseInt(intString.substring(i * 2, i * 2 + 2), 16);
} if (DEBUG) Flog.i("===parseStringToBytes===" + bytes.toString()); return bytes;
} catch (Exception e) {
Flog.e(e);
return null;
}
}
}