android常用工具类(不定时更新)
2017-09-14 本文已影响163人
ccccccal
工具类已经作为library上传到jiepack，欢迎star
CommonUtils
SHA加密算法
public static String enn(String inStr){
MessageDigest sha = null;
try {
sha = MessageDigest.getInstance("SHA");
} catch (Exception e) {
e.printStackTrace();
}
byte[] byteArray = new byte[0];
try {
byteArray = inStr.getBytes("UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
byte[] md5Bytes = sha.digest(byteArray);
StringBuffer hexValue = new StringBuffer();
for (int i = 0; i < md5Bytes.length; i++) {
int val = ((int) md5Bytes[i]) & 0xff;
if (val < 16) {
hexValue.append("0");
}
hexValue.append(Integer.toHexString(val));
}
return hexValue.toString();
}
获得版本名字，以及版本号
//版本名
public static String getVersionName(Context context) {
return getPackageInfo(context).versionName;
}
//版本号
public static String getVersionCode(Context context) {
return getPackageInfo(context).versionCode+"";
}
private static PackageInfo getPackageInfo(Context context) {
PackageInfo pi = null;
try {
PackageManager pm = context.getPackageManager();
pi = pm.getPackageInfo(context.getPackageName(),PackageManager.GET_CONFIGURATIONS);
return pi;
} catch (Exception e) {
e.printStackTrace();
}
return pi;
}
时间格式化
/**
* @param time
* @return long类型日期格式化
*/
public static String getTimeForLong(long time) {
return new SimpleDateFormat("yyyy-MM-dd ").format(new Date(time)).toString();
}
/**
* @param time
* @return Data类型日期格式化
*/
public static String getTimeForData(Date time) {
return new SimpleDateFormat("yyyy-MM-dd ").format(time).toString();
}
/**
* @param
* @return time long类型日期格式化-带时分秒
*/
public static String getlongTimeForLong(long time) {
return new SimpleDateFormat("yyyy-MM-dd HH-mm-ss").format(new Date(time)).toString();
}
/**
* @param
* @return time Data类型日期格式化-带时分秒
*/
public static String getlongTimeForData(Date time) {
return new SimpleDateFormat("yyyy-MM-dd HH-mm-ss").format(time).toString();
}
/**
* \
*
* @param
* @return data Data转化为long类型
* @throws ParseException
*/
public static long getLongForData(Date data) throws ParseException {
return new SimpleDateFormat("yyyy-MM-dd HH-mm-ss").parse(String.valueOf(data)).getTime();
}
修改状态栏字体为黑色，兼容魅族和小米
/**
* 修改状态栏为全透明
*/
@TargetApi(19)
public static void transparencyBar(Activity activity) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
Window window = activity.getWindow();
window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
| View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
window.setStatusBarColor(Color.TRANSPARENT);
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
Window window = activity.getWindow();
window.setFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS,
WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
}
}
/**
* 修改状态栏颜色，支持4.4以上版本
*/
public static void setStatusBarColor(Activity activity, int colorId) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
Window window = activity.getWindow();
// window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
window.setStatusBarColor(activity.getResources().getColor(colorId));
}
}
/**
* 设置状态栏黑色字体图标，
* 适配4.4以上版本MIUIV、Flyme和6.0以上版本其他Android
*
* @param activity
* @return 1:MIUUI 2:Flyme 3:android6.0
*/
public static int StatusBarLightMode(Activity activity) {
int result = 0;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
if (MIUISetStatusBarLightMode(activity.getWindow(), true)) {
result = 1;
} else if (FlymeSetStatusBarLightMode(activity.getWindow(), true)) {
result = 2;
} else if (android.os.Build.BRAND.equals("OPPO")) {
return 4;
} else if (android.os.Build.BRAND.equals("VIVO")) {
return 5;
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
activity.getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
result = 3;
}
}
return result;
}
/**
* 已知系统类型时，设置状态栏黑色字体图标。
* 适配4.4以上版本MIUIV、Flyme和6.0以上版本其他Android
*
* @param activity
* @param type 1:MIUUI 2:Flyme 3:android6.0
*/
public static void StatusBarLightMode(Activity activity, int type) {
if (type == 1) {
MIUISetStatusBarLightMode(activity.getWindow(), true);
} else if (type == 2) {
FlymeSetStatusBarLightMode(activity.getWindow(), true);
} else if (type == 3) {
activity.getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
}
}
/**
* 清除MIUI或flyme或6.0以上版本状态栏黑色字体
*/
public static void StatusBarDarkMode(Activity activity, int type) {
if (type == 1) {
MIUISetStatusBarLightMode(activity.getWindow(), false);
} else if (type == 2) {
FlymeSetStatusBarLightMode(activity.getWindow(), false);
} else if (type == 3) {
activity.getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_VISIBLE);
}
}
/**
* 设置状态栏图标为深色和魅族特定的文字风格
* 可以用来判断是否为Flyme用户
*
* @param window 需要设置的窗口
* @param dark 是否把状态栏字体及图标颜色设置为深色
* @return boolean 成功执行返回true
*/
public static boolean FlymeSetStatusBarLightMode(Window window, boolean dark) {
boolean result = false;
if (window != null) {
try {
WindowManager.LayoutParams lp = window.getAttributes();
Field darkFlag = WindowManager.LayoutParams.class
.getDeclaredField("MEIZU_FLAG_DARK_STATUS_BAR_ICON");
Field meizuFlags = WindowManager.LayoutParams.class
.getDeclaredField("meizuFlags");
darkFlag.setAccessible(true);
meizuFlags.setAccessible(true);
int bit = darkFlag.getInt(null);
int value = meizuFlags.getInt(lp);
if (dark) {
value |= bit;
} else {
value &= ~bit;
}
meizuFlags.setInt(lp, value);
window.setAttributes(lp);
result = true;
} catch (Exception e) {
}
}
return result;
}
/**
* 设置状态栏字体图标为深色，需要MIUIV6以上
*
* @param window 需要设置的窗口
* @param dark 是否把状态栏字体及图标颜色设置为深色
* @return boolean 成功执行返回true
*/
public static boolean MIUISetStatusBarLightMode(Window window, boolean dark) {
boolean result = false;
if (window != null) {
Class clazz = window.getClass();
try {
int darkModeFlag = 0;
Class layoutParams = Class.forName("android.view.MiuiWindowManager$LayoutParams");
Field field = layoutParams.getField("EXTRA_FLAG_STATUS_BAR_DARK_MODE");
darkModeFlag = field.getInt(layoutParams);
Method extraFlagField = clazz.getMethod("setExtraFlags", int.class, int.class);
if (dark) {
extraFlagField.invoke(window, darkModeFlag, darkModeFlag);//状态栏透明且黑色字体
} else {
extraFlagField.invoke(window, 0, darkModeFlag);//清除黑色字体
}
result = true;
} catch (Exception e) {
}
}
return result;
}
判断是否为手机号，正则表达式
/**
* 判断是否为手机号
*/
public static boolean isPhone(String inputText) {
Pattern p = Pattern.compile("^1(3[0-9]|4[57]|5[0-35-9]|8[0-9]|7[0678])\\d{8}$");
Matcher m = p.matcher(inputText);
return m.matches();
}
RecyclerView 分割线
public class RecycleViewDivider extends RecyclerView.ItemDecoration {
private static final int[] ATTRS = new int[]{
android.R.attr.listDivider
};
public static final int HORIZONTAL_LIST = LinearLayoutManager.HORIZONTAL;
public static final int VERTICAL_LIST = LinearLayoutManager.VERTICAL;
private Drawable mDivider;
private int mOrientation;
public RecycleViewDivider(Context context, int orientation) {
final TypedArray a = context.obtainStyledAttributes(ATTRS);
mDivider = a.getDrawable(0);
a.recycle();
setOrientation(orientation);
}
public void setOrientation(int orientation) {
if (orientation != HORIZONTAL_LIST && orientation != VERTICAL_LIST) {
throw new IllegalArgumentException("invalid orientation");
}
mOrientation = orientation;
}
@Override
public void onDraw(Canvas c, RecyclerView parent) {
if (mOrientation == VERTICAL_LIST) {
drawVertical(c, parent);
} else {
drawHorizontal(c, parent);
}
}
public void drawVertical(Canvas c, RecyclerView parent) {
final int left = parent.getPaddingLeft();
final int right = parent.getWidth() - parent.getPaddingRight();
final int childCount = parent.getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = parent.getChildAt(i);
android.support.v7.widget.RecyclerView v = new android.support.v7.widget.RecyclerView(parent.getContext());
final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) child
.getLayoutParams();
final int top = child.getBottom() + params.bottomMargin;
final int bottom = top + mDivider.getIntrinsicHeight();
mDivider.setBounds(left, top, right, bottom);
mDivider.draw(c);
}
}
public void drawHorizontal(Canvas c, RecyclerView parent) {
final int top = parent.getPaddingTop();
final int bottom = parent.getHeight() - parent.getPaddingBottom();
final int childCount = parent.getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = parent.getChildAt(i);
final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) child
.getLayoutParams();
final int left = child.getRight() + params.rightMargin;
final int right = left + mDivider.getIntrinsicHeight();
mDivider.setBounds(left, top, right, bottom);
mDivider.draw(c);
}
}
@Override
public void getItemOffsets(Rect outRect, int itemPosition, RecyclerView parent) {
if (mOrientation == VERTICAL_LIST) {
outRect.set(0, 0, 0, mDivider.getIntrinsicHeight());
} else {
outRect.set(0, 0, mDivider.getIntrinsicWidth(), 0);
}
}
}
禁止规定时间内多次点击
//防止用户多次点击同一个按钮造成多余操作
public class NoDoubleClickUtils {
private static long lastClickTime=0;
private final static int SPACE_TIME = 500;
public synchronized static boolean isDoubleClick(Context context) {
long currentTime = System.currentTimeMillis();
boolean isClick2;
if (currentTime - lastClickTime > SPACE_TIME) {
isClick2 = false;
} else {
isClick2 = true;
ToastUtils.show(context,"请勿重复操作");
}
lastClickTime = currentTime;
return isClick2;
}
}
RecyclerView自定义LinearLayoutManager用于嵌套scrollVIew
public class MyLinearLayoutManager extends LinearLayoutManager {
private static final String TAG = MyLinearLayoutManager.class.getSimpleName();
public MyLinearLayoutManager(Context context) {
super(context);
}
public MyLinearLayoutManager(Context context, int orientation, boolean reverseLayout) {
super(context, orientation, reverseLayout);
}
private int[] mMeasuredDimension = new int[2];
@Override
public void onMeasure(RecyclerView.Recycler recycler, RecyclerView.State state,
int widthSpec, int heightSpec) {
final int widthMode = View.MeasureSpec.getMode(widthSpec);
final int heightMode = View.MeasureSpec.getMode(heightSpec);
final int widthSize = View.MeasureSpec.getSize(widthSpec);
final int heightSize = View.MeasureSpec.getSize(heightSpec);
int width = 0;
int height = 0;
for (int i = 0; i < getItemCount(); i++) {
measureScrapChild(recycler, i,
View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
mMeasuredDimension);
if (getOrientation() == HORIZONTAL) {
width = width + mMeasuredDimension[0];
if (i == 0) {
height = mMeasuredDimension[1];
}
} else {
height = height + mMeasuredDimension[1];
if (i == 0) {
width = mMeasuredDimension[0];
}
}
}
switch (widthMode) {
case View.MeasureSpec.EXACTLY:
width = widthSize;
case View.MeasureSpec.AT_MOST:
case View.MeasureSpec.UNSPECIFIED:
}
switch (heightMode) {
case View.MeasureSpec.EXACTLY:
height = heightSize;
case View.MeasureSpec.AT_MOST:
case View.MeasureSpec.UNSPECIFIED:
}
setMeasuredDimension(width, height);
}
private void measureScrapChild(RecyclerView.Recycler recycler, int position, int widthSpec,
int heightSpec, int[] measuredDimension) {
try {
View view = recycler.getViewForPosition(0);//fix 动态添加时报IndexOutOfBoundsException
if (view != null) {
RecyclerView.LayoutParams p = (RecyclerView.LayoutParams) view.getLayoutParams();
int childWidthSpec = ViewGroup.getChildMeasureSpec(widthSpec,
getPaddingLeft() + getPaddingRight(), p.width);
int childHeightSpec = ViewGroup.getChildMeasureSpec(heightSpec,
getPaddingTop() + getPaddingBottom(), p.height);
view.measure(childWidthSpec, childHeightSpec);
measuredDimension[0] = view.getMeasuredWidth() + p.leftMargin + p.rightMargin;
measuredDimension[1] = view.getMeasuredHeight() + p.bottomMargin + p.topMargin;
recycler.recycleView(view);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
}
}
}
判断是否联网
/**
* 网络连接通畅
*/
public static boolean isNetworkAvalible(Context context) {
// 获得网络状态管理器
ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (null == connectivityManager) {
return false;
} else {
// 建立网络数组
NetworkInfo[] net_info = connectivityManager.getAllNetworkInfo();
if (net_info != null) {
for (NetworkInfo networkInfo : net_info) {
// 判断获得的网络状态是否是处于连接状态
if (networkInfo.getState() == NetworkInfo.State.CONNECTED) {
return true;
}
}
}
}
return false;
}
获得唯一标识，以及每次安装都会产生的UUID
public class Installation {
private static final String INSTALLATION = "INSTALLATION";
/**
* @return 活动页面唯一标识码
*/
public static String getJustOneKey() {
String ss = Build.SERIAL;
String m_szDevIDShort = "g" +
Build.BOARD.length() % 10 +
Build.BRAND.length() % 10 +
Build.CPU_ABI.length() % 10 +
Build.DEVICE.length() % 10 +
Build.DISPLAY.length() % 10 +
Build.HOST.length() % 10 +
Build.ID.length() % 10 +
Build.MANUFACTURER.length() % 10 +
Build.MODEL.length() % 10 +
Build.PRODUCT.length() % 10 +
Build.TAGS.length() % 10 +
Build.TYPE.length() % 10 +
Build.USER.length() % 10;
return MD5.md5(getReallykey(ss) + m_szDevIDShort);
}
private static String getReallykey(String key) {
if (key != null && !key.isEmpty())
return key;
return null;
}
/**
* @param context application对象
* @return uuid
*/
public synchronized static String id(Context context) {
String userId;
File installation = new File(context.getFilesDir(), INSTALLATION);
try {
if (!installation.exists())
writeInstallationFile(installation);
userId = readInstallationFile(installation);
} catch (Exception e) {
throw new RuntimeException(e);
}
return "g" + userId.replace("-", "");
}
private static String readInstallationFile(File installation) throws IOException {
RandomAccessFile f = new RandomAccessFile(installation, "r");
byte[] bytes = new byte[(int) f.length()];
f.readFully(bytes);
f.close();
return new String(bytes);
}
private static void writeInstallationFile(File installation) throws IOException {
FileOutputStream out = new FileOutputStream(installation);
String id = UUID.randomUUID().toString();
out.write(id.getBytes());
out.close();
}
}
Glide清除缓存
// 清除Glide内存缓存
public static boolean clearCacheMemory(Context context) {
try {
if (Looper.myLooper() == Looper.getMainLooper()) { //只能在主线程执行
Glide.get(context).clearMemory();
return true;
}
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
// 清除图片磁盘缓存，调用Glide自带方法
public static boolean clearCacheDiskSelf(final Context context) {
try {
if (Looper.myLooper() == Looper.getMainLooper()) {
new Thread(new Runnable() {
@Override
public void run() {
Glide.get(context).clearDiskCache();
}
}).start();
} else {
Glide.get(context).clearDiskCache();
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
获得屏幕亮度以及设置屏幕亮度
/**
* 获取屏幕亮度
*/
public static int getScreenBrightness(Activity activity) {
int value = 0;
ContentResolver cr = activity.getContentResolver();
try {
value = Settings.System.getInt(cr, Settings.System.SCREEN_BRIGHTNESS);
} catch (Settings.SettingNotFoundException e) {
e.printStackTrace();
}
return value;
}
/**
* 设置屏幕亮度
*/
public static void setScreenBrightness(Activity activity, int value) {
WindowManager.LayoutParams params = activity.getWindow().getAttributes();
params.screenBrightness = value / 255f;
activity.getWindow().setAttributes(params);
}
Android7.0获得真实的uri
public static Uri getImageContentUri(Context context, File imageFile) {
String filePath = imageFile.getAbsolutePath();
Cursor cursor = context.getContentResolver().query(
MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
new String[]{MediaStore.Images.Media._ID},
MediaStore.Images.Media.DATA + "=? ",
new String[]{filePath}, null);
if (cursor != null && cursor.moveToFirst()) {
int id = cursor.getInt(cursor
.getColumnIndex(MediaStore.MediaColumns._ID));
Uri baseUri = Uri.parse("content://media/external/images/media");
return Uri.withAppendedPath(baseUri, "" + id);
} else {
if (imageFile.exists()) {
ContentValues values = new ContentValues();
values.put(MediaStore.Images.Media.DATA, filePath);
return context.getContentResolver().insert(
MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
} else {
return null;
}
}
}
判断HTML内容，需要jsoup
/**
* 字数是否符合要求
*
* @param string
* @return
*/
public static final boolean htmlLengthIsAble(String string) {
int length = getLengthFromHtmlString(string) + getImgSizeFromHtmlString(string);
return length >= 10 && length <= 10000 ? true : false;
}
private static final int getLengthFromHtmlString(String string) {
if (null == string || string.trim().isEmpty()) {
return 0;
}
return getContentFromHtmlString(string).length();
}
private static final String getContentFromHtmlString(String string) {
Document document = Jsoup.parse(string, "utf-8");
return document.body().text();
}
/**
* @param string
* @return
*/
private static final int getImgSizeFromHtmlString(String string) {
Document document = Jsoup.parse(string, "utf-8");
Elements images = document.getElementsByTag("img");
return images.size();
}
EditText设置眼睛用于显示密码和隐藏密码
/**
* 显示密码和隐藏密码
*/
public static void showOrHidePassword(ImageView eyes, EditText ed) {
if (eyes.getTag() == null) {
eyes.setTag("show");
eyes.setImageResource(R.drawable.eye2);
ed.setInputType(InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);
ed.setSelection(ed.length());
} else {
eyes.setTag(null);
eyes.setImageResource(R.drawable.eye1);
ed.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
ed.setSelection(ed.length());
}
}
判断字符串中是否含有Emoji表情
public static boolean containsEmoji (String source)
{
int len = source.length();
boolean isEmoji = false;
for (int i = 0; i < len; i++)
{
char hs = source.charAt(i);
if (0xd800 <= hs && hs <= 0xdbff)
{
if (source.length() > 1)
{
char ls = source.charAt(i + 1);
int uc = ((hs - 0xd800) * 0x400) + (ls - 0xdc00) + 0x10000;
if (0x1d000 <= uc && uc <= 0x1f77f)
{
return true;
}
}
}
else
{
// non surrogate
if (0x2100 <= hs && hs <= 0x27ff && hs != 0x263b)
{
return true;
}
else if (0x2B05 <= hs && hs <= 0x2b07)
{
return true;
}
else if (0x2934 <= hs && hs <= 0x2935)
{
return true;
}
else if (0x3297 <= hs && hs <= 0x3299)
{
return true;
}
else if (hs == 0xa9 || hs == 0xae || hs == 0x303d
|| hs == 0x3030 || hs == 0x2b55 || hs == 0x2b1c
|| hs == 0x2b1b || hs == 0x2b50 || hs == 0x231a)
{
return true;
}
if (!isEmoji && source.length() > 1 && i < source.length() - 1)
{
char ls = source.charAt(i + 1);
if (ls == 0x20e3)
{
return true;
}
}
}
}
return isEmoji;
}
生成随机验证码
public class Code {
//随机数数组
private static final char[] CHARS = {
'2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'm',
'n', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
};
private static Code bmpCode;
public static Code getInstance() {
if(bmpCode == null)
bmpCode = new Code();
return bmpCode;
}
//default settings
//验证码默认随机数的个数
private static final int DEFAULT_CODE_LENGTH = 4;
//默认字体大小
private static final int DEFAULT_FONT_SIZE = 25;
//默认线条的条数
private static final int DEFAULT_LINE_NUMBER = 2;
//padding值
private static final int BASE_PADDING_LEFT = 10, RANGE_PADDING_LEFT = 15, BASE_PADDING_TOP = 15, RANGE_PADDING_TOP = 10;
//验证码的默认宽高
private static final int DEFAULT_WIDTH = 120, DEFAULT_HEIGHT = 40;
//settings decided by the layout xml
//canvas width and height
private int width = DEFAULT_WIDTH, height = DEFAULT_HEIGHT;
//random word space and pading_top
private int base_padding_left = BASE_PADDING_LEFT, range_padding_left = RANGE_PADDING_LEFT,
base_padding_top = BASE_PADDING_TOP, range_padding_top = RANGE_PADDING_TOP;
//number of chars, lines; font size
private int codeLength = DEFAULT_CODE_LENGTH, line_number = DEFAULT_LINE_NUMBER, font_size = DEFAULT_FONT_SIZE;
//variables
private String code;
private int padding_left, padding_top;
private Random random = new Random();
//验证码图片
public Bitmap createBitmap() {
padding_left = 0;
Bitmap bp = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
Canvas c = new Canvas(bp);
code = createCode();
c.drawColor(Color.WHITE);
Paint paint = new Paint();
paint.setAntiAlias(true);
paint.setTextSize(font_size);
//画验证码
for (int i = 0; i < code.length(); i++) {
randomTextStyle(paint);
randomPadding();
c.drawText(code.charAt(i) + "", padding_left, padding_top, paint);
}
//画线条
for (int i = 0; i < line_number; i++) {
drawLine(c, paint);
}
c.save( Canvas.ALL_SAVE_FLAG );//保存
c.restore();//
return bp;
}
public String getCode() {
return code;
}
//生成验证码
private String createCode() {
StringBuilder buffer = new StringBuilder();
for (int i = 0; i < codeLength; i++) {
buffer.append(CHARS[random.nextInt(CHARS.length)]);
}
return buffer.toString();
}
//画干扰线
private void drawLine(Canvas canvas, Paint paint) {
int startX = random.nextInt(width);
int startY = random.nextInt(height);
int stopX = random.nextInt(width);
int stopY = random.nextInt(height);
paint.setStrokeWidth(1);
paint.setColor(Color.parseColor("#32cd99"));
canvas.drawLine(startX, startY, stopX, stopY, paint);
}
private int randomColor(int rate) {
int red = random.nextInt(256) / rate;
int green = random.nextInt(256) / rate;
int blue = random.nextInt(256) / rate;
return Color.rgb(red, green, blue);
}
//随机生成文字样式，颜色，粗细，倾斜度
private void randomTextStyle(Paint paint) {
paint.setColor(Color.parseColor("#527f76"));
paint.setFakeBoldText(random.nextBoolean()); //true为粗体，false为非粗体
float skewX = random.nextInt(11) / 10;
skewX = random.nextBoolean() ? skewX : -skewX;
paint.setTextSkewX(skewX); //float类型参数，负数表示右斜，整数左斜
//paint.setUnderlineText(true); //true为下划线，false为非下划线
//paint.setStrikeThruText(true); //true为删除线，false为非删除线
}
//随机生成padding值
private void randomPadding() {
padding_left += base_padding_left + random.nextInt(range_padding_left);
padding_top = base_padding_top + random.nextInt(range_padding_top);
}
}
Activity管理类
public class AppManager {
private static Stack<Activity> activityStack;
private static AppManager instance;
public AppManager() {
}
/**
* 单一实例
*/
public static AppManager getAppManager() {
if (instance == null) {
instance = new AppManager();
}
return instance;
}
/**
* 添加Activity到堆栈
*/
public void addActivity(Activity activity) {
if (activityStack == null) {
activityStack = new Stack<>();
}
activityStack.add(activity);
}
/**
* 获取当前Activity（堆栈中最后一个压入的）
*/
public Activity currentActivity() {
Activity activity = activityStack.lastElement();
return activity;
}
/**
* 结束当前Activity（堆栈中最后一个压入的）
*/
public void finishActivity() {
Activity activity = activityStack.lastElement();
finishActivity(activity);
}
/**
* 结束指定的Activity
*/
public void finishActivity(Activity activity) {
if (activity != null) {
activityStack.remove(activity);
activity.finish();
activity = null;
}
}
/**
* 结束指定类名的Activity
*/
public void finishActivity(Class<?> cls) {
for (Activity activity : activityStack) {
if (activity.getClass().equals(cls)) {
finishActivity(activity);
}
}
}
/**
* 结束所有Activity
*/
public void finishAllActivity() {
for (int i = 0, size = activityStack.size(); i < size; i++) {
if (null != activityStack.get(i)) {
activityStack.get(i).finish();
}
}
activityStack.clear();
}
/**
* 退出应用程序
*/
public void AppExit(Context context) {
try {
finishAllActivity();
System.exit(0);
android.os.Process.killProcess(android.os.Process.myPid());
} catch (Exception e) {
}
}
/**
* 结束指定的Activity
*/
public void getActivity(Activity activity) {
if (activity != null) {
activityStack.remove(activity);
activity.finish();
activity = null;
}
}
/**
* 得到指定类名的Activity
*/
public Activity getActivity(Class<?> cls) {
for (Activity activity : activityStack) {
if (activity.getClass().equals(cls)) {
return activity;
}
}
return null;
}
}
自定义电池
public class BatteryView extends View {
private int mPower = 100;
private int orientation;
private int width;
private int height;
private int mColor;
public BatteryView(Context context) {
super(context);
}
public BatteryView(Context context, AttributeSet attrs) {
super(context, attrs);
TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.Battery);
mColor = typedArray.getColor(R.styleable.Battery_batteryColor, 0xFFFFFFFF);
orientation = typedArray.getInt(R.styleable.Battery_batteryOrientation, 0);
mPower = typedArray.getInt(R.styleable.Battery_batteryPower, 100);
width = getMeasuredWidth();
height = getMeasuredHeight();
/**
* recycle() :官方的解释是：回收TypedArray，以便后面重用。在调用这个函数后，你就不能再使用这个TypedArray。
* 在TypedArray后调用recycle主要是为了缓存。当recycle被调用后，这就说明这个对象从现在可以被重用了。
*TypedArray 内部持有部分数组，它们缓存在Resources类中的静态字段中，这样就不用每次使用前都需要分配内存。
*/
typedArray.recycle();
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
//对View上的內容进行测量后得到的View內容占据的宽度
width = getMeasuredWidth();
//对View上的內容进行测量后得到的View內容占据的高度
height = getMeasuredHeight();
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
//判断电池方向 horizontal: 0 vertical: 1
if (orientation == 0) {
drawHorizontalBattery(canvas);
} else {
drawVerticalBattery(canvas);
}
}
/**
* 绘制水平电池
* @param canvas
*/
private void drawHorizontalBattery(Canvas canvas) {
Paint paint = new Paint();
paint.setColor(mColor);
paint.setStyle(Paint.Style.STROKE);
float strokeWidth = width / 20.f;
float strokeWidth_2 = strokeWidth / 2;
paint.setStrokeWidth(strokeWidth);
RectF r1 = new RectF(strokeWidth_2, strokeWidth_2, width - strokeWidth - strokeWidth_2 - 5, height - strokeWidth_2 - 8);
//设置外边框颜色为黑色
paint.setColor(getResources().getColor(R.color.battery));
canvas.drawRect(r1, paint);
paint.setStrokeWidth(0);
paint.setStyle(Paint.Style.FILL);
//画电池内矩形电量
float offset = (width - strokeWidth * 2) * mPower / 100.f;
RectF r2 = new RectF(strokeWidth + 3, strokeWidth + 3, offset - 7, height - strokeWidth - 11);
//根据电池电量决定电池内矩形电量颜色
if (mPower < 20) {
paint.setColor(Color.RED);
}
if (mPower >= 20) {
paint.setColor(getResources().getColor(R.color.battery));
}
canvas.drawRect(r2, paint);
//画电池头
RectF r3 = new RectF(width - strokeWidth - 5, height * 0.3f - 2, width - 5, height * 0.7f - 6);
//设置电池头颜色为黑色
paint.setColor(getResources().getColor(R.color.battery));
canvas.drawRect(r3, paint);
}
/**
* 绘制垂直电池
*
* @param canvas
*/
private void drawVerticalBattery(Canvas canvas) {
Paint paint = new Paint();
paint.setColor(mColor);
paint.setStyle(Paint.Style.STROKE);
float strokeWidth = height / 20.0f;
float strokeWidth2 = strokeWidth / 2;
paint.setStrokeWidth(strokeWidth);
int headHeight = (int) (strokeWidth + 0.5f);
RectF rect = new RectF(strokeWidth2, headHeight + strokeWidth2, width - strokeWidth2, height - strokeWidth2);
canvas.drawRect(rect, paint);
paint.setStrokeWidth(0);
float topOffset = (height - headHeight - strokeWidth) * (100 - mPower) / 100.0f;
RectF rect2 = new RectF(strokeWidth, headHeight + strokeWidth + topOffset, width - strokeWidth, height - strokeWidth);
paint.setStyle(Paint.Style.FILL);
canvas.drawRect(rect2, paint);
RectF headRect = new RectF(width / 4.0f, 0, width * 0.75f, headHeight);
canvas.drawRect(headRect, paint);
}
/**
* 设置电池电量
*
* @param power
*/
public void setPower(int power) {
this.mPower = power;
if (mPower < 0) {
mPower = 100;
}
invalidate();//刷新VIEW
}
/**
* 设置电池颜色
*
* @param color
*/
public void setColor(int color) {
this.mColor = color;
invalidate();
}
/**
* 获取电池电量
*
* @return
*/
public int getPower() {
return mPower;
}
}
