android上的Util,工具类

最新推荐文章于 2024-03-30 00:41:23 发布
最新推荐文章于 2024-03-30 00:41:23 发布
阅读量513 收藏
点赞数
分类专栏： android 文章标签： 工具类 android
import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.drawable.GradientDrawable;
import android.graphics.drawable.ShapeDrawable;
import android.graphics.drawable.shapes.RoundRectShape;
import android.media.ThumbnailUtils;
import android.net.Uri;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.provider.MediaStore;
import android.util.Log;
import android.util.TypedValue;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.EditText;
import android.widget.Toast;
 
import java.io.*;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
 
/**
  * created by tedzyc
  */
public class Util {
 
     public static class Converter {
 
         public static int dp2px( int dp, Context context) {
             return ( int ) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, context.getResources().getDisplayMetrics());
         }
 
         public static float px2dp( float px, Context context) {
             return px / TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 1 , context.getResources().getDisplayMetrics());
         }
 
         public static byte [] bitmap2ByteArray(Bitmap bitmap) {
             ByteArrayOutputStream baos = new ByteArrayOutputStream();
             bitmap.compress(Bitmap.CompressFormat.PNG, 100 , baos);
             return baos.toByteArray();
         }
 
         public static Bitmap byteArray2Bitmap( byte [] byteArray) {
             return BitmapFactory.decodeByteArray(byteArray, 0 , byteArray.length);
         }
 
         public static String imageUri2Path(Context context, Uri contentUri) {
             Cursor c = context.getContentResolver().query(contentUri, null , null , null , null );
             c.moveToFirst();
             String mediaFilePath = c.getString(c.getColumnIndex(MediaStore.Images.Media.DATA));
             c.close();
             return mediaFilePath;
         }
     }
 
     public static class ReflectionUtil {
 
         public static Object invokeMethod(Object receiver, String methodName, Class<?>[] paramTypes, Object[] paramValues) {
             return invokeMethodInternal(receiver, receiver.getClass(), methodName, paramTypes, paramValues);
         }
 
         public static Object invokeStaticMethod(String className, String methodName, Class<?>[] paramTypes, Object[] paramValues) {
             try {
                 return invokeMethodInternal( null , Class.forName(className), methodName, paramTypes, paramValues);
             } catch (ClassNotFoundException e) {
                 e.printStackTrace();
             }
             return null ;
         }
 
         private static Object invokeMethodInternal(Object receiver, Class<?> clazz, String methodName, Class<?>[] paramTypes, Object[] paramValues) {
             try {
                 Method method = clazz.getDeclaredMethod(methodName, paramTypes);
                 method.setAccessible( true );
                 return method.invoke(receiver, paramValues);
             } catch (Exception e) {
                 e.printStackTrace();
             }
             return null ;
         }
     }
 
     public static class HandlerUtil {
 
         public static void sendMsg(Handler handler, int msgCode, Bundle bundle) {
             Message msg = handler.obtainMessage(msgCode);
             if (bundle != null ) {
                 msg.setData(bundle);
             }
             handler.sendMessage(msg);
         }
     }
 
     public static class FileUtil {
 
         /**
          * @param path : can be path of file or directory.
          */
         public static long getFileSize(String path) {
             return getFileSize( new File(path));
         }
 
         /**
          * @param file : can be file or directory.
          */
         public static long getFileSize(File file) {
             if (file.exists()) {
                 if (file.isDirectory()) {
                     long size = 0 ;
                     for (File subFile : file.listFiles()) {
                         size += getFileSize(subFile);
                     }
                     return size;
                 } else {
                     return file.length();
                 }
             } else {
                 throw new IllegalArgumentException( "File does not exist!" );
             }
         }
 
         public static void copyFile(String originalFilePath, String destFilePath) throws IOException {
             copyFile( new File(originalFilePath), destFilePath);
         }
 
         public static void copyFile(String originalFilePath, File destFile) throws IOException {
             copyFile( new File(originalFilePath), destFile);
         }
 
         public static void copyFile(File originalFile, String destFilePath) throws IOException {
             copyFile(originalFile, new File(destFilePath));
         }
 
         public static void copyFile(File originalFile, File destFile) throws IOException {
             copy( new FileInputStream(originalFile), new FileOutputStream(destFile));
         }
 
         public static void copy(InputStream inputStream, OutputStream outputStream) throws IOException {
             byte buf[] = new byte [ 1024 ];
             int numRead = 0 ;
 
             while ((numRead = inputStream.read(buf)) != - 1 ) {
                 outputStream.write(buf, 0 , numRead);
             }
 
             close(outputStream, inputStream);
         }
 
         /**
          * @param path : can be file's absolute path or directories' path.
          */
         public static void deleteFile(String path) {
             deleteFile( new File(path));
         }
 
         /**
          * @param file : can be file or directory.
          */
         public static void deleteFile(File file) {
             if (!file.exists()) {
                 LogUtil.e( "The file to be deleted does not exist! File's path is: " + file.getPath());
             } else {
                 deleteFileRecursively(file);
             }
         }
 
         /**
          * Invoker must ensure that the file to be deleted exists.
          */
         private static void deleteFileRecursively(File file) {
             if (file.isDirectory()) {
                 for (String fileName : file.list()) {
                     File item = new File(file, fileName);
 
                     if (item.isDirectory()) {
                         deleteFileRecursively(item);
                     } else {
                         if (!item.delete()) {
                             LogUtil.e( "Failed in recursively deleting a file, file's path is: " + item.getPath());
                         }
                     }
                 }
 
                 if (!file.delete()) {
                     LogUtil.e( "Failed in recursively deleting a directory, directories' path is: " + file.getPath());
                 }
             } else {
                 if (!file.delete()) {
                     LogUtil.e( "Failed in deleting this file, its path is: " + file.getPath());
                 }
             }
         }
 
         public static String readToString(File file) throws IOException {
             BufferedReader reader = new BufferedReader( new FileReader(file));
 
             StringBuffer buffer = new StringBuffer();
             String readLine = null ;
 
             while ((readLine = reader.readLine()) != null ) {
                 buffer.append(readLine);
                 buffer.append( "\n" );
             }
 
             reader.close();
 
             return buffer.toString();
         }
 
         public static byte [] readToByteArray(File file) throws IOException {
             ByteArrayOutputStream outputStream = new ByteArrayOutputStream( 1024 );
             copy( new FileInputStream(file), outputStream);
 
             return outputStream.toByteArray();
         }
 
         public static void writeByteArray( byte [] byteArray, String filePath) throws IOException {
             BufferedOutputStream outputStream = new BufferedOutputStream( new FileOutputStream(filePath));
             outputStream.write(byteArray);
             outputStream.close();
         }
 
         public static void saveBitmapToFile(String fileForSaving, Bitmap bitmap) {
             File targetFile = new File(Environment.getExternalStorageDirectory().getPath() + "/" + fileForSaving + ".png" );
 
             if (!targetFile.exists()) {
                 try {
                     targetFile.createNewFile();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
 
             try {
                 FileOutputStream fos = new FileOutputStream(targetFile);
                 bitmap.compress(Bitmap.CompressFormat.PNG, 100 , fos);
                 fos.flush();
                 fos.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
 
         /**
          * If sequentialPathStrs are "a","b","c", below method return "a/b/c"
          */
         public static String toCatenatedPath(String... sequentialPathStrs) {
             String catenatedPath = "" ;
             for ( int i = 0 ; i < sequentialPathStrs.length - 1 ; i++) {
                 catenatedPath += sequentialPathStrs[i] + File.separator;
             }
             catenatedPath += sequentialPathStrs[sequentialPathStrs.length - 1 ];
             return catenatedPath;
         }
     }
 
     public static class TimeUtil {
 
         public static String format(String pattern, long milliseconds) {
             return ( new SimpleDateFormat(pattern)).format( new Date(milliseconds));
         }
 
         /**
          * 将以毫秒为单位的时间转化为“小时：分钟：秒”的格式（不足1小时的没有小时部分）。
          * 适用于显示一段视频的时长（有些视频时长是大于1小时，有些是不足1小时的）
          */
         public static String formatHMS( long millis) {
             final long millisOfOneHour = TimeUnit.HOURS.toMillis( 1 );
 
             if (millis < millisOfOneHour) {
                 return String.format( "%1$tM:%1$tS" , millis);
             } else {
                 return String.format( "%1$d:%2$TM:%2$TS" , millis / millisOfOneHour, millis % millisOfOneHour);
             }
         }
     }
 
     public static class BitmapUtil {
 
         /**
          * 此函数用于提取缩略图，以节省内存。
          * l
          *
          * @param path
          * @param loseLessQuality 是否较少地丢失图片质量 如果为true表示按宽度和高度的缩小倍数中的较少者进行采样。
          */
         public static Bitmap sample( boolean isFromAssets, String path, int requireWidth, int requireHeight,
                                     boolean loseLessQuality) {
             BitmapFactory.Options options = new BitmapFactory.Options();
             options.inPurgeable = true ;
             options.inInputShareable = true ;
 
             /**
              * "options.inJustDecodeBounds = true"这步是为了设置options.inSampleSize
              */
             options.inJustDecodeBounds = true ;
             InputStream is = null ;
             try {
                 is = new FileInputStream(path);
             } catch (FileNotFoundException e) {
                 return null ;
             }
             BitmapFactory.decodeStream(is, null , options);
             int widthMinification = ( int ) Math.ceil(( float ) options.outWidth / ( float ) requireWidth);
             int heightMinification = ( int ) Math.ceil(( float ) options.outHeight / ( float ) requireHeight);
 
             if (loseLessQuality) {
                 options.inSampleSize = Math.min(widthMinification, heightMinification);
             } else {
                 options.inSampleSize = Math.max(widthMinification, heightMinification);
             }
             close(is);
 
             /**
              * 这一步做真正的提取缩略图
              */
             options.inJustDecodeBounds = false ;
             try {
                 is = new FileInputStream(path);
             } catch (FileNotFoundException e) {
                 return null ;
             }
             Bitmap bitmap = BitmapFactory.decodeStream(is, null , options);
             close(is);
 
             return bitmap;
         }
 
         /**
          * 根据指定的图像路径和大小来获取缩略图
          * 此方法有两点好处：
          * 1. 使用较小的内存空间，第一次获取的bitmap实际上为null，只是为了读取宽度和高度，
          * 第二次读取的bitmap是根据比例压缩过的图像，第三次读取的bitmap是所要的缩略图。
          * 2. 缩略图对于原图像来讲没有拉伸，这里使用了2.2版本的新工具ThumbnailUtils，使
          * 用这个工具生成的图像不会被拉伸。
          *
          * @param imagePath 图像的路径
          * @param width     指定输出图像的宽度
          * @param height    指定输出图像的高度
          * @return 生成的缩略图
          */
         public static Bitmap getImageThumbnail(String imagePath, int width, int height) {
             BitmapFactory.Options options = new BitmapFactory.Options();
             options.inJustDecodeBounds = true ;
             // 获取这个图片的宽和高，注意此处的bitmap为null
             BitmapFactory.decodeFile(imagePath, options);
 
             // 重新读入图片，读取缩放后的bitmap，注意这次要把options.inJustDecodeBounds 设为 false
             options.inJustDecodeBounds = false ; // 设为 false
             // 计算缩放比
             int h = options.outHeight;
             int w = options.outWidth;
             int beWidth = w / width;
             int beHeight = h / height;
             int be = 1 ;
             if (beWidth < beHeight) {
                 be = beWidth;
             } else {
                 be = beHeight;
             }
             if (be <= 0 ) {
                 be = 1 ;
             }
             options.inSampleSize = be;
             Bitmap bitmap = BitmapFactory.decodeFile(imagePath, options);
             // 利用ThumbnailUtils来创建缩略图，这里要指定要缩放哪个Bitmap对象
             bitmap = ThumbnailUtils.extractThumbnail(bitmap, width, height,
                     ThumbnailUtils.OPTIONS_RECYCLE_INPUT);
             return bitmap;
         }
 
         /**
          * 获取视频的缩略图
          * 先通过ThumbnailUtils来创建一个视频的缩略图，然后再利用ThumbnailUtils来生成指定大小的缩略图。
          * 如果想要的缩略图的宽和高都小于MICRO_KIND，则类型要使用MICRO_KIND作为kind的值，这样会节省内存。
          *
          * @param videoPath 视频的路径
          * @param width     指定输出视频缩略图的宽度
          * @param height    指定输出视频缩略图的高度度
          * @param kind      参照MediaStore.Images.Thumbnails类中的常量MINI_KIND和MICRO_KIND。
          *                  其中，MINI_KIND: 512 x 384，MICRO_KIND: 96 x 96
          * @return 指定大小的视频缩略图
          */
         public static Bitmap getVideoThumbnail(String videoPath, int width, int height, int kind) {
             Bitmap bitmap;
             // 获取视频的缩略图
             bitmap = ThumbnailUtils.createVideoThumbnail(videoPath, kind);
             bitmap = ThumbnailUtils.extractThumbnail(bitmap, width, height,
                     ThumbnailUtils.OPTIONS_RECYCLE_INPUT);
             return bitmap;
         }
     }
 
     public static class Sdcard {
 
         public static boolean isSdcardReadable() {
             return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
         }
 
         public static boolean checkIsSdcardFull(IOException e) {
             /** 在应用层通过异常判断是否是SD卡已满，除了下面的方式，目前尚未找到更好的方法。 **/
             return e.getMessage().contains( "No space left on device" );
         }
     }
 
     public static class Notifier {
 
         public static void showLongToast(CharSequence content, Context cxt) {
             Toast.makeText(cxt, content, Toast.LENGTH_LONG).show();
         }
 
         public static void showShortToast(CharSequence content, Context cxt) {
             Toast.makeText(cxt, content, Toast.LENGTH_SHORT).show();
         }
 
         public static void showLongToast(Context cxt, int resId) {
             showLongToast(cxt.getResources().getText(resId), cxt);
         }
 
         public static void showShortToast(Context cxt, int resId) {
             showShortToast(cxt.getResources().getText(resId), cxt);
         }
     }
 
     public static class GraphUtil {
 
         /**
          * this method is used more frequently
          */
         public static ShapeDrawable createRoundCornerShapeDrawable( float radius, int color) {
             float [] outerRadii = new float [ 8 ];
             for ( int i = 0 ; i < 8 ; i++) {
                 outerRadii[i] = radius;
             }
 
             ShapeDrawable sd = new ShapeDrawable( new RoundRectShape(outerRadii, null , null ));
             sd.getPaint().setColor(color);
 
             return sd;
         }
 
         public static ShapeDrawable createRoundCornerShapeDrawableWithBoarder( float radius, float borderLength, int borderColor) {
             float [] outerRadii = new float [ 8 ];
             float [] innerRadii = new float [ 8 ];
             for ( int i = 0 ; i < 8 ; i++) {
                 outerRadii[i] = radius + borderLength;
                 innerRadii[i] = radius;
             }
 
             ShapeDrawable sd = new ShapeDrawable( new RoundRectShape(outerRadii, new RectF(borderLength, borderLength,
                     borderLength, borderLength), innerRadii));
             sd.getPaint().setColor(borderColor);
 
             return sd;
         }
 
         /**
          * @param strokeWidth "stroke"表示描边, 传小于或等于0的值表示没有描边，同时忽略传入的strokeColor参数。
          */
         public static GradientDrawable createGradientDrawable( int fillColor, int strokeWidth, int strokeColor, float cornerRadius) {
             GradientDrawable gd = new GradientDrawable();
 
             gd.setColor(fillColor);
             if (strokeWidth > 0 ) {
                 gd.setStroke(strokeWidth, strokeColor);
             }
             gd.setCornerRadius(cornerRadius);
 
             return gd;
         }
     }
 
     public static class AnimUtil {
 
         public static void alphaAnim(View v, long duration, float animateToValue) {
             v.animate().setDuration(duration).alpha(animateToValue);
         }
     }
 
     public static class LogUtil {
 
         private static final String TAG = LogUtil. class .getPackage().getName();
 
         /** Define your log level for printing out detail here. **/
         private static final int PRINT_DETAIL_LOG_LEVEL = Log.ERROR;
 
         public static void v(Object object) {
             Log.v(TAG, buildMsg(Log.INFO, object));
         }
 
         public static void d(Object object) {
             Log.d(TAG, buildMsg(Log.INFO, object));
         }
 
         public static void i(Object object) {
             Log.i(TAG, buildMsg(Log.INFO, object));
         }
 
         public static void w(Object object) {
             Log.w(TAG, buildMsg(Log.INFO, object));
         }
 
         public static void e(Object object) {
             Log.e(TAG, buildMsg(Log.ERROR, object));
         }
 
         private static String buildMsg( int logLevel, Object object) {
             StringBuilder buffer = new StringBuilder();
 
             if (logLevel >= PRINT_DETAIL_LOG_LEVEL) {
                 StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[ 4 ];
                 buffer.append( "[ thread name is " );
                 buffer.append(Thread.currentThread().getName());
                 buffer.append( ", " );
                 buffer.append(stackTraceElement.getFileName());
                 buffer.append( ", method is " );
                 buffer.append(stackTraceElement.getMethodName());
                 buffer.append( "(), at line " );
                 buffer.append(stackTraceElement.getLineNumber());
                 buffer.append( " ]" );
                 buffer.append( "\n" );
             }
 
             buffer.append( "___" );
             buffer.append(object);
 
             return buffer.toString();
         }
     }
 
     public static class TextUtil {
 
         public static String getEditTextContent(EditText editText) {
             return editText.getText().toString();
         }
 
         public static boolean isChinese( char c) {
             Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
             if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
                     || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
                     || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
                     || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION
                     || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
                     || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS) {
                 return true ;
             }
             return false ;
         }
 
         public static boolean isEnglish( char c) {
             return (c >= 'a' && c <= 'z' ) || (c >= 'A' && c <= 'Z' );
         }
     }
 
     // >>>
     public static void setEnableForChildrenView(ViewGroup parent, boolean enabled) {
         for ( int i = 0 ; i < parent.getChildCount(); ++i) {
             View child = parent.getChildAt(i);
             child.setEnabled(enabled);
             if (child instanceof ViewGroup) {
                 setEnableForChildrenView((ViewGroup) child, enabled);
             }
         }
     }
 
     public static View getContentView(Activity activity) {
         return activity.getWindow().getDecorView().getRootView();
     }
 
     public static void freezeContentView(Activity activity) {
         setEnableForChildrenView(((ViewGroup) getContentView(activity)), false );
     }
     // <<<
 
     public static boolean isInsideView(MotionEvent event, View v) {
         Rect rect = new Rect();
         v.getGlobalVisibleRect(rect);
 
         return rect.contains(( int ) event.getRawX(), ( int ) event.getRawY());
     }
 
     public static void close(Closeable... closeables) {
         for (Closeable closeable : closeables) {
             if (closeable != null ) {
                 try {
                     closeable.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
     }
 
     public static boolean isExistedInDb(ContentResolver resolver, Uri uri, String selection, String[] selectionArgs) {
         Cursor c = resolver.query(uri, null , selection, selectionArgs, null );
         boolean isExistedInDb = (c != null || c.getCount() > 0 );
         if (c != null ) {
             c.close();
         }
         return isExistedInDb;
     }
}
ap0206107
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sm2多端加密解密，java，js，android，ios实战
王林冲的博客
07-27 3254
sm2多端加密解密，java，js，android，ios实战
Android_国密_SM2、SM3、SM4
ylineyline的专栏
05-31 9300
因业务要求，RSA、AES、MD5等加密方式，要合规，需要替换成，SM2、SM3、SM4。因此，个人整理资料，实现了一份。 一：参考 https://github.com/gotoworld/hsd-cipher-sm -- 代码主体 https://blog.csdn.net/wkernel/article/details/71193413 -- 对应关系 https:/...
Android 框架：快速开发中Util常用工具类总结，阿里架构师深入讲解Android开发
最新发布
m0_60721967的博客
03-30 784
*要想成为高级安卓工程师，必须掌握许多基础的知识。**在工作中，这些原理可以极大的帮助我们理解技术，在面试中，更是可以帮助我们应对大厂面试官的刁难。= null@see*/自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
SM2只有私钥情况下解密
csdn_zxw的博客
10-26 2261
结合了两个大佬的代码，目前应该都是第一个大佬的代码 第一个Android_国密_SM2、SM3、SM4_ylineyline的专栏-CSDN博客 第二个Android常用加密库集合_lambert_Lei的专栏-CSDN博客 首先导入包：Android_国密_SM2、SM3、SM4_ylineyline的专栏-CSDN博客 implementation 'org.bouncycastle:bcprov-jdk16:1.46' 接下来，都是自定义的东西不要找SM2的包在哪，SM2是自己的类 p
椭圆曲线加密算法SM2在Android用Java调用实现
moonshine99的专栏
03-02 3711
        SM2基于ECC，ECC（Elliptic Curves Cryptography）加密算法是一种公钥加密算法，与主流的RSA算法相比，ECC算法可以使用较短的密钥达到相同的安全程度。近年来，人们对ECC的认识已经不再处于研究阶段，开始逐步进入实际应用，如国家密码管理局颁布的SM2算法就是基于ECC算法的。  demo下载：  https://github.com/HungryGo...
android 国密签名,关于国密 （sm2,sm3,sm4）在Linux、python、Android、java、ios中的...
weixin_33048525的博客
05-27 3760
国密即国家密码局认定的国产密码算法。主要有SM1，SM2，SM3，SM4和最新的sm9。在国内环境主要使用的国家密码局认定的算法。SM2算法：SM2椭圆曲线公钥密码算法是我国自主设计的公钥密码算法，包括SM2-1椭圆曲线数字签名算法，SM2-2椭圆曲线密钥交换协议，SM2-3椭圆曲线公钥加密算法，分别用于实现数字签名密钥协商和数据加密等功能。SM2算法与RSA算法不同的是，SM2算法是基于椭圆曲线...
Android常用工具类Utils
10-08
android开发中常用的工具类封装，帮助开发者更轻松的实现如系统，图片，弹框，toast，文件，日志，通知栏，sp，线程管理，时间日期等等。
JAVA SHA256Util工具类
11-27
用java原生的摘要实现SHA256加密
Android史上最全Util工具类集锦
11-11
Android史上最全Util工具类集锦: 1.AppUtil 2.BitmapUtil 3.DataUtil 4.FileUtil 5.MobleInfoUtil 6.NetUtil 7.QRUtils(二维码生成工具) 8.ScreenUtil 9.SDCardUtil 10.StringUtils 吐血总结，希望对大家有用
Android文件操作工具类详解
01-03
本文实例为大家分享了Android文件操作工具类的具体代码，供大家参考，具体内容如下 贴上我写的一个文件操作工具类，基本上覆盖了各种文件操作： 1、文件的新建、删除； 2、文件的复制； 3、获取文件扩展名； 4、文件...
Android网络工具类NetworkUtils详解
01-20
网络工具类NetworkUtils，供大家参考，具体内容如下 提供的方法： 打开网络设置界面 openWirelessSettings 判断网络是否可用 isAvailable 判断网络是否连接 isConnected 判断网络是否是4G is4G 判断wifi是否连接...
Android开发中常见安全问题和解决方案
阿道夫的博客
12-31 1016
开发APP时经常有问到：“APP的安全怎么保障，应用程序被PJ了怎么办？手机被人捡去了怎么办？” 特别在号称“安全第一，风控牛逼”的银行系统内，移动产品安全性仍被持有怀疑态度。那我们来总结下APP安全的方向和具体知识。1.应用程序安全2.应用程序内敏感数据存储安全3.应用程序前后台数据报文传输安全以上是APP开发中需要注意的安全问题。不要等到项目投产时再去统一检测和检查APP安全问题。项目启动时，安全的事宜就要做到心里有数了。
Android平台使用大宝CA版本JCE完成SM2、SM3、SM4国密算法、密钥、国密数字证书的详细说明
upset_ming的博客
09-17 4017
系统要求 Android 5.0（API 21）及以上 功能介绍 SM2密钥对的生成功能 SM2密钥对的还原功能 SM2算法的非对称加解密功能 SM2算法的签名/验证功能 SM3算法的摘要功能 SM4算法的对称加解密功能 大宝CA版本Keystore文件（DCKS文件）存储SM2密钥对和国密数字证书的功能 Android调用JCE的主要代码 package com.doubl...
Android中常用的几种加密
vivian的专栏
03-24 816
Android中常用的几种加密
Android常用加密库集合
lambert_Lei的专栏
09-29 2474
QS，为了整合常用的各大加解密工具，把各大常用加密方式集合成一个工具库，目前包括： 1 RSA 2 AES 3 3DES/DES 4 HMAC_SHA1 5 国密SM2/SM3/SM4 6 MD5 7 DSA 使用简例 调用eg1（SM4对称加密）： AbstractCoder cipher=EncryptionManager.getCipher(EncryptionManager.Model....
鸿蒙开发如何实现SM2加密签名？【Bug已解决，原因已找到-鸿蒙开发】
一键难忘的博客
12-01 1479
鸿蒙开发如何实现SM2加密签名？【Bug已解决，原因已找到-鸿蒙开发】 OpenHarmony SDK API 10 已经发布了，可以从OpenHarmony每日构建站点获取最新的OpenHarmony SDK，每日构建流水线访问地址为:每日构建流水线会构建系统镜像、SDK等，常用的SDK使用下述流水线进行构建。最后调试结果：在api10 是自带SM2加密签名功能的。更换api方法：自取得的SDK需在DecEco Studio中被辨识方可操作。
快速集成Android最常用八种加密算法
...
02-22 1万+
数据的安全性可谓是重中之重的，前两年大司频发的安全事件也是被炒的热火朝天~究竟该如何增加数据机密安全性，我们来唠唠。 说到安全，范围大的让人喘不过气来，关于安全的知识以及如何防范，暂时先不涉入，踩得深了头皮容易发麻。我们就从最简单的加密来扯扯。
Android传输数据时加密详解
fengltxx的博客
11-06 9799
Android传输数据时加密详解 ONE Goal , ONE Passion ! ——————–MD5加密———————-MD5即Message-Digest Algorithm 5（信息-摘要算法5），用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD5实现。将数据（如汉字）运算为另一固定长度值，是杂凑算法的基础原理，MD5的前身有
几种常见的加密方式介绍
热门推荐
dirk2014的博客
12-08 1万+
密码学在计算机科学中使用非常广泛，HTTPS就是建立在密码学基础之上的一种安全的通信协议。HTTPS早在1994年由网景公司首次提出，而如今在众多互联网厂商的推广之下HTTPS已经被广泛使用在各种大小网站中。在完全理解HTTPS之前，有必要弄清楚一些密码学相关的概念，比如：明文、密文、密码、密钥、对称加密、非对称加密、摘要、数字签名、数字证书。 密码密码学中的密码（cipher）和我们日常生活中所
android studio cache 工具类
02-02
Android Studio Cache 工具类是一个用于管理和操作 Android Studio 缓存的工具类。它提供了一些方法来清理、获取和设置 Android Studio 缓存。 以下是一个简单的 Android Studio Cache 工具类的示例： ```java ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值