APP
/
oxFaceAndroid
3
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

change detect img function & base64 function

main
MTing 2 weeks ago
parent
d2a0a64817
commit
e36aac4079
2 changed files with 524 additions and 63 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 462
      app/src/main/java/com/ouxuan/oxface/OXFaceOnlineActivity.java
  2. 125
      financelibrary/src/main/java/com/baidu/idl/face/main/finance/utils/BitmapUtils.java

462
app/src/main/java/com/ouxuan/oxface/OXFaceOnlineActivity.java
View File

@ -39,6 +39,8 @@ import com.baidu.idl.main.facesdk.FaceInfo;
import com.baidu.idl.main.facesdk.model.BDFaceImageInstance;
import com.ouxuan.oxface.utils.LogManager;
import java.util.List;
/**
* 简化版人脸识别界面 - 只显示视频流
*/
@ -51,6 +53,27 @@ public class OXFaceOnlineActivity extends BaseActivity implements View.OnClickLi
// 图片越大，性能消耗越大，也可以选择640*480， 1280*720
private static final int PREFER_WIDTH = SingleBaseConfig.getBaseConfig().getRgbAndNirWidth();
private static final int PERFER_HEIGH = SingleBaseConfig.getBaseConfig().getRgbAndNirHeight();
// 新增控制变量
private static int PROCESS_FRAME_INTERVAL = 10; // 降低处理频率，每隔10帧处理一次
private int frameCounter = 0;
private boolean needSendFaceImage = false; // 是否需要将人脸图片转为base64发送
private long lastProcessTime = 0;
private long lastBackgroundProcessTime = 0; // 应用在后台时的最后处理时间
private static long MIN_PROCESS_INTERVAL = 1000; // 增加最小处理间隔至1秒
// 智能调节处理频率的控制变量
private static final int FAST_PROCESS_FRAME_INTERVAL = 3; // 快速处理频率：每3帧处理一次
private static final long FAST_MIN_PROCESS_INTERVAL = 300; // 快速处理间隔：300ms
private static final int SLOW_PROCESS_FRAME_INTERVAL = 30; // 慢速处理频率：每30帧处理一次
private static final long SLOW_MIN_PROCESS_INTERVAL = 3000; // 慢速处理间隔：3000ms
private static final long FACE_DETECTION_TIMEOUT = 5000; // 人脸检测超时时间：5秒
private long lastFaceDetectedTime = 0; // 上次检测到人脸的时间
private boolean isFaceDetected = false; // 当前是否检测到人脸
private int consecutiveNoFaceCount = 0; // 连续未检测到人脸的次数
private static final int CONSECUTIVE_NO_FACE_THRESHOLD = 20; // 连续未检测到人脸的阈值
private Context mContext;
private AutoTexturePreviewView mAutoCameraPreviewView;
private TextureView mDrawDetectFaceView;
@ -133,6 +156,11 @@ public class OXFaceOnlineActivity extends BaseActivity implements View.OnClickLi
mContext = this;
initView();
// 初始化人脸检测状态
lastFaceDetectedTime = System.currentTimeMillis();
isFaceDetected = false;
consecutiveNoFaceCount = 0;
// 检查并请求相机权限
if (ContextCompat.checkSelfPermission(this, android.Manifest.permission.CAMERA)
!= PackageManager.PERMISSION_GRANTED) {
@ -143,6 +171,9 @@ public class OXFaceOnlineActivity extends BaseActivity implements View.OnClickLi
LogManager.logInfo(TAG, "相机权限已授予");
}
// 启动内存优化周期性任务
startMemoryOptimizationTask();
LogManager.logInfo(TAG, "OXFaceOnlineActivity onCreate");
}
@ -320,41 +351,164 @@ public class OXFaceOnlineActivity extends BaseActivity implements View.OnClickLi
private void startTestOpenDebugRegisterFunction() {
LogManager.logInfo(TAG, "启动摄像头预览");
// 设置摄像头方向
if (SingleBaseConfig.getBaseConfig().getRBGCameraId() != -1){
CameraPreviewManager.getInstance().setCameraFacing(SingleBaseConfig.getBaseConfig().getRBGCameraId());
} else {
CameraPreviewManager.getInstance().setCameraFacing(CameraPreviewManager.CAMERA_FACING_FRONT);
}
CameraPreviewManager.getInstance().startPreview(mContext, mAutoCameraPreviewView,
PREFER_WIDTH, PERFER_HEIGH, new CameraDataCallback() {
@Override
public void onGetCameraData(byte[] data, Camera camera, int width, int height) {
// 摄像头预览数据进行人脸检测
if (isNeedCamera) {
FaceSDKManager.getInstance().onDetectCheck(data, null, null,
height, width, 1, new FaceDetectCallBack() {
@Override
public void onFaceDetectCallback(LivenessModel livenessModel) {
// 开发模式结果输出
checkOpenDebugResult(livenessModel);
try {
// 设置摄像头方向
if (SingleBaseConfig.getBaseConfig().getRBGCameraId() != -1){
CameraPreviewManager.getInstance().setCameraFacing(SingleBaseConfig.getBaseConfig().getRBGCameraId());
} else {
CameraPreviewManager.getInstance().setCameraFacing(CameraPreviewManager.CAMERA_FACING_FRONT);
}
CameraPreviewManager.getInstance().startPreview(mContext, mAutoCameraPreviewView,
PREFER_WIDTH, PERFER_HEIGH, new CameraDataCallback() {
@Override
public void onGetCameraData(byte[] data, Camera camera, int width, int height) {
try {
// 摄像头预览数据进行人脸检测
if (isNeedCamera) {
// 增加帧计数器和时间间隔控制
frameCounter++;
long currentTime = System.currentTimeMillis();
// 智能调节处理频率
adjustProcessFrequency(currentTime);
// 只有当满足处理条件时才进行人脸检测
if (frameCounter % PROCESS_FRAME_INTERVAL == 0 &&
(currentTime - lastProcessTime) > MIN_PROCESS_INTERVAL) {
lastProcessTime = currentTime;
// 检查应用是否处于前台
if (!isApplicationInForeground()) {
// 如果应用在后台，减少处理频率，每隔10秒处理一次
if ((currentTime - lastBackgroundProcessTime) < 10000) {
return;
}
lastBackgroundProcessTime = currentTime;
}
FaceSDKManager.getInstance().onDetectCheck(data, null, null,
height, width, 1, new FaceDetectCallBack() {
@Override
public void onFaceDetectCallback(LivenessModel livenessModel) {
try {
// 更新人脸检测状态
updateFaceDetectionStatus(livenessModel);
// 开发模式结果输出
checkOpenDebugResult(livenessModel);
} catch (Exception e) {
LogManager.logError(TAG, "人脸检测回调处理异常", e);
}
}
@Override
public void onTip(int code, String msg) {
LogManager.logInfo(TAG, "人脸检测提示 - 代码: " + code + ", 消息: " + msg);
}
@Override
public void onTip(int code, String msg) {
try {
if(!msg.equals("未检测到人脸")){
LogManager.logInfo(TAG, "人脸检测提示onTip - 代码: " + code + ", 消息: " + msg);
}
} catch (Exception e) {
LogManager.logError(TAG, "人脸检测提示处理异常", e);
}
}
@Override
public void onFaceDetectDarwCallback(LivenessModel livenessModel) {
// 绘制人脸框
showFrame(livenessModel);
@Override
public void onFaceDetectDarwCallback(LivenessModel livenessModel) {
try {
// 绘制人脸框
showFrame(livenessModel);
} catch (Exception e) {
LogManager.logError(TAG, "人脸框绘制回调处理异常", e);
}
}
});
} else if (frameCounter % 30 == 0) {
// 对于跳过处理的帧，每30帧清空一次画布，确保无人脸时画面干净
try {
LivenessModel emptyModel = new LivenessModel();
emptyModel.setTrackFaceInfo(null);
showFrame(emptyModel);
} catch (Exception e) {
LogManager.logError(TAG, "清空画布时发生异常", e);
}
});
}
}
} catch (Exception e) {
LogManager.logError(TAG, "摄像头数据处理异常", e);
}
}
});
} catch (Exception e) {
LogManager.logError(TAG, "启动摄像头预览失败", e);
// 尝试重新初始化摄像头
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
if (!isFinishing()) {
LogManager.logInfo(TAG, "尝试重新启动摄像头预览");
startTestOpenDebugRegisterFunction();
}
});
}
}, 5000); // 5秒后重试
}
}
/**
* 智能调节处理频率
* @param currentTime 当前时间
*/
private void adjustProcessFrequency(long currentTime) {
// 如果检测到人脸，加速处理
if (isFaceDetected) {
if (PROCESS_FRAME_INTERVAL != FAST_PROCESS_FRAME_INTERVAL ||
MIN_PROCESS_INTERVAL != FAST_MIN_PROCESS_INTERVAL) {
PROCESS_FRAME_INTERVAL = FAST_PROCESS_FRAME_INTERVAL;
MIN_PROCESS_INTERVAL = FAST_MIN_PROCESS_INTERVAL;
LogManager.logInfo(TAG, "检测到人脸，加速处理频率：每" + PROCESS_FRAME_INTERVAL + "帧，最小间隔" + MIN_PROCESS_INTERVAL + "ms");
}
}
// 如果长时间未检测到人脸，降低处理频率以节省资源
else if (currentTime - lastFaceDetectedTime > FACE_DETECTION_TIMEOUT) {
// 检查是否已经处于慢速处理模式
if (PROCESS_FRAME_INTERVAL != SLOW_PROCESS_FRAME_INTERVAL ||
MIN_PROCESS_INTERVAL != SLOW_MIN_PROCESS_INTERVAL) {
PROCESS_FRAME_INTERVAL = SLOW_PROCESS_FRAME_INTERVAL;
MIN_PROCESS_INTERVAL = SLOW_MIN_PROCESS_INTERVAL;
LogManager.logInfo(TAG, "长时间未检测到人脸，降低处理频率：每" + PROCESS_FRAME_INTERVAL + "帧，最小间隔" + MIN_PROCESS_INTERVAL + "ms");
}
}
}
/**
* 更新人脸检测状态
* @param livenessModel 活体检测模型
*/
private void updateFaceDetectionStatus(LivenessModel livenessModel) {
long currentTime = System.currentTimeMillis();
// 检查是否检测到人脸
boolean faceDetected = (livenessModel != null &&
livenessModel.getTrackFaceInfo() != null &&
livenessModel.getTrackFaceInfo().length > 0);
if (faceDetected) {
// 检测到人脸
isFaceDetected = true;
lastFaceDetectedTime = currentTime;
consecutiveNoFaceCount = 0; // 重置连续未检测到人脸计数器
LogManager.logDebug(TAG, "检测到人脸");
} else {
// 未检测到人脸
consecutiveNoFaceCount++;
// 如果连续多次未检测到人脸，标记为未检测到人脸状态
if (consecutiveNoFaceCount >= CONSECUTIVE_NO_FACE_THRESHOLD) {
isFaceDetected = false;
LogManager.logDebug(TAG, "连续未检测到人脸，当前计数: " + consecutiveNoFaceCount);
}
}
}
/**
@ -366,26 +520,35 @@ public class OXFaceOnlineActivity extends BaseActivity implements View.OnClickLi
public void run() {
Canvas canvas = mDrawDetectFaceView.lockCanvas();
if (canvas == null) {
mDrawDetectFaceView.unlockCanvasAndPost(canvas);
return;
}
// 始终清空canvas
canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
// 如果没有模型数据，直接返回清空的画布
if (model == null) {
// 清空canvas
canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
mDrawDetectFaceView.unlockCanvasAndPost(canvas);
return;
}
// 获取人脸信息
FaceInfo[] faceInfos = model.getTrackFaceInfo();
// 如果没有检测到人脸，直接返回清空的画布
if (faceInfos == null || faceInfos.length == 0) {
// 清空canvas
canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
mDrawDetectFaceView.unlockCanvasAndPost(canvas);
return;
}
canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
for (int i = 0 ; i < faceInfos.length;i++) {
// 只在检测到人脸时绘制人脸框
for (int i = 0; i < faceInfos.length; i++) {
FaceInfo faceInfo = faceInfos[i];
// 如果人脸置信度太低，不绘制
if (faceInfo.score < 0.6) {
continue;
}
rectF.set(FaceOnDrawTexturViewUtil.getFaceRectTwo(faceInfo));
// 检测图片的坐标和显示的坐标不一样，需要转换。
@ -397,7 +560,8 @@ public class OXFaceOnlineActivity extends BaseActivity implements View.OnClickLi
FaceOnDrawTexturViewUtil.drawRect(canvas,
rectF, paint, 5f, 50f, 25f);
}
// 清空canvas
// 提交canvas
mDrawDetectFaceView.unlockCanvasAndPost(canvas);
}
});
@ -649,7 +813,61 @@ public class OXFaceOnlineActivity extends BaseActivity implements View.OnClickLi
@Override
protected void onDestroy() {
super.onDestroy();
LogManager.logInfo(TAG, "OXFaceOnlineActivity onDestroy");
// 停止摄像头预览
if (CameraPreviewManager.getInstance() != null) {
CameraPreviewManager.getInstance().stopPreview();
}
// 释放当前的LivenessModel资源
if (currentLivenessModel != null) {
BDFaceImageInstance image = currentLivenessModel.getBdFaceImageInstance();
if (image != null) {
image.destory();
}
// 清空引用
currentLivenessModel = null;
}
// 释放绘图资源
if (rectF != null) {
rectF = null;
}
if (paint != null) {
paint = null;
}
if (paintBg != null) {
paintBg = null;
}
// 清除其他相关资源
System.gc();
LogManager.logInfo(TAG, "OXFaceOnlineActivity onDestroy - 资源已释放");
}
@Override
protected void onStop() {
super.onStop();
LogManager.logInfo(TAG, "OXFaceOnlineActivity onStop - 应用进入后台");
// 应用进入后台时，进一步降低处理频率以节省资源
PROCESS_FRAME_INTERVAL = 30; // 后台时每30帧处理一次
MIN_PROCESS_INTERVAL = 3000; // 后台时最小间隔3秒
LogManager.logInfo(TAG, "后台模式处理频率：每" + PROCESS_FRAME_INTERVAL + "帧，最小间隔" + MIN_PROCESS_INTERVAL + "ms");
}
@Override
protected void onStart() {
super.onStart();
LogManager.logInfo(TAG, "OXFaceOnlineActivity onStart - 应用回到前台");
// 应用回到前台时，恢复正常的处理频率
PROCESS_FRAME_INTERVAL = FAST_PROCESS_FRAME_INTERVAL; // 前台时使用快速处理频率
MIN_PROCESS_INTERVAL = FAST_MIN_PROCESS_INTERVAL; // 前台时使用快速处理间隔
LogManager.logInfo(TAG, "前台模式处理频率：每" + PROCESS_FRAME_INTERVAL + "帧，最小间隔" + MIN_PROCESS_INTERVAL + "ms");
}
// ***************开发模式结果输出*************
@ -743,16 +961,27 @@ public class OXFaceOnlineActivity extends BaseActivity implements View.OnClickLi
if (livenessModel == null) {
return;
}
String base64img = getFaceImageBase64(currentLivenessModel);
if (base64img != null) {
// Log.i(TAG, "checkResultOnline: " + base64img);
Log.i(TAG, "checkResultOnline: Yes! Got a base64img!" );
} else {
Log.i(TAG, "run:checkResultOnline base64img score too low ");
layoutCompareStatus.setVisibility(View.VISIBLE);
textCompareStatus.setTextColor(Color.parseColor("#fec133"));
textCompareStatus.setText("请重新识别");
// 减少base64转换频率，只有在特定条件下才进行转换
// 例如：每3秒检查一次是否需要发送人脸图像
long currentTime = System.currentTimeMillis();
if (currentTime - searshTime > 3000) {
searshTime = currentTime;
needSendFaceImage = true;
String base64img = getFaceImageBase64(currentLivenessModel);
if (base64img != null) {
// 这里可以处理base64数据，如上传到服务器等
Log.i(TAG, "checkResultOnline: 获取到人脸base64数据");
// 处理完成后重置标志
needSendFaceImage = false;
} else {
Log.i(TAG, "run:checkResultOnline base64img score too low ");
layoutCompareStatus.setVisibility(View.VISIBLE);
textCompareStatus.setTextColor(Color.parseColor("#fec133"));
textCompareStatus.setText("请重新识别");
}
}
}
});
@ -762,15 +991,134 @@ public class OXFaceOnlineActivity extends BaseActivity implements View.OnClickLi
if (livenessModel == null) return null;
FaceInfo faceInfo = livenessModel.getFaceInfo();
if (true) { //判定条件
// 添加判断条件，减少不必要的base64转换
if (faceInfo != null && faceInfo.bestImageScore > SingleBaseConfig.getBaseConfig().getBestImageScore()) {
BDFaceImageInstance image = livenessModel.getBdFaceImageInstance();
Bitmap bitmap = BitmapUtils.getInstaceBmp(image);
String bitmap_str = BitmapUtils.bitmapToBase64(bitmap);
image.destory();
return bitmap_str; // 简化实现，实际项目中需要实现 bitmap 转 base64 的功能
} else {
return null;
if (image != null) {
Bitmap bitmap = BitmapUtils.getInstaceBmp(image);
// 仅在确实需要使用base64数据时才进行转换
if (needSendFaceImage) {
String bitmap_str = BitmapUtils.bitmapToBase64(bitmap);
image.destory();
return bitmap_str;
} else {
// 如果不需要发送，则不进行base64转换，直接释放资源
image.destory();
if (bitmap != null && !bitmap.isRecycled()) {
bitmap.recycle();
}
return "dummy_base64_placeholder";
}
}
}
return null;
}
/**
* 检查应用是否在前台
* @return 如果应用在前台，则返回true；否则返回false
*/
private boolean isApplicationInForeground() {
android.app.ActivityManager activityManager = (android.app.ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
List<android.app.ActivityManager.RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
if (appProcesses == null) {
return false;
}
String packageName = getPackageName();
for (android.app.ActivityManager.RunningAppProcessInfo appProcess : appProcesses) {
if (appProcess.importance == android.app.ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
&& appProcess.processName.equals(packageName)) {
return true;
}
}
return false;
}
/**
* 低内存时的处理
*/
@Override
public void onLowMemory() {
super.onLowMemory();
LogManager.logInfo(TAG, "系统内存不足，触发onLowMemory");
// 清理不必要的缓存
clearMemoryCache();
// 强制GC
System.gc();
}
/**
* 清理内存缓存
*/
private void clearMemoryCache() {
// 如果当前不在人脸检测状态，释放当前的LivenessModel
if (currentLivenessModel != null && !isNeedCamera) {
BDFaceImageInstance image = currentLivenessModel.getBdFaceImageInstance();
if (image != null) {
image.destory();
}
currentLivenessModel = null;
}
// 如果设备内存不足，考虑调整处理频率
PROCESS_FRAME_INTERVAL = Math.min(30, PROCESS_FRAME_INTERVAL + 5);
MIN_PROCESS_INTERVAL = Math.min(3000, MIN_PROCESS_INTERVAL + 500);
LogManager.logInfo(TAG, "内存不足，调整处理频率：每" + PROCESS_FRAME_INTERVAL + "帧，最小间隔" + MIN_PROCESS_INTERVAL + "ms");
}
/**
* 优化内存的周期性任务
*/
private void startMemoryOptimizationTask() {
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
// 获取当前应用内存使用情况
Runtime runtime = Runtime.getRuntime();
long usedMemory = (runtime.totalMemory() - runtime.freeMemory()) / (1024 * 1024);
long totalMemory = runtime.maxMemory() / (1024 * 1024);
float memoryUsageRatio = (float) usedMemory / totalMemory;
LogManager.logInfo(TAG, "内存使用情况：" + usedMemory + "MB/" + totalMemory +
"MB，使用率：" + (int)(memoryUsageRatio * 100) + "%");
// 如果内存使用率超过70%，主动清理内存
if (memoryUsageRatio > 0.7f) {
LogManager.logInfo(TAG, "内存使用率超过70%，主动清理内存");
clearMemoryCache();
System.gc();
}
// 如果内存使用率超过85%，进行更积极的清理
if (memoryUsageRatio > 0.85f) {
LogManager.logWarning(TAG, "内存使用率超过85%，进行积极清理");
// 进一步降低处理频率
PROCESS_FRAME_INTERVAL = Math.min(50, PROCESS_FRAME_INTERVAL + 10);
MIN_PROCESS_INTERVAL = Math.min(5000, MIN_PROCESS_INTERVAL + 1000);
// 清理更多资源
if (currentLivenessModel != null) {
BDFaceImageInstance image = currentLivenessModel.getBdFaceImageInstance();
if (image != null) {
image.destory();
}
currentLivenessModel = null;
}
LogManager.logInfo(TAG, "积极清理后调整处理频率：每" + PROCESS_FRAME_INTERVAL + "帧，最小间隔" + MIN_PROCESS_INTERVAL + "ms");
System.gc();
}
// 每30秒执行一次
if (!isFinishing()) {
new Handler().postDelayed(this, 30000);
}
}
}, 30000);
}
}

125
financelibrary/src/main/java/com/baidu/idl/face/main/finance/utils/BitmapUtils.java
View File

@ -529,13 +529,126 @@ public final class BitmapUtils {
* @return Base64编码的字符串
*/
public static String bitmapToBase64(Bitmap bm) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bm.compress(Bitmap.CompressFormat.JPEG, 30, baos);
byte[] byteArray = baos.toByteArray();
// 检查传入的位图是否有效
if (bm == null || bm.isRecycled()) {
Log.e(TAG, "尝试转换无效的Bitmap到Base64");
return null;
}
// 减小图像尺寸以降低内存占用
Bitmap scaledBitmap = null;
try {
// 判断是否需要缩放图片
int originalWidth = bm.getWidth();
int originalHeight = bm.getHeight();
int targetWidth = 320; // 设置合理的目标宽度
// 如果原图已经很小，直接使用更小的尺寸
if (originalWidth <= 160) {
targetWidth = originalWidth;
} else if (originalWidth <= 320) {
targetWidth = 160;
}
if (originalWidth > targetWidth) {
float scaleFactor = (float) targetWidth / originalWidth;
int targetHeight = (int) (originalHeight * scaleFactor);
scaledBitmap = Bitmap.createScaledBitmap(bm, targetWidth, targetHeight, true);
} else {
// 原图尺寸已经足够小，直接使用
scaledBitmap = bm;
}
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 使用更低的压缩质量(20%)进一步减小数据体积
scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 20, baos);
byte[] byteArray = baos.toByteArray();
try {
baos.close();
} catch (IOException e) {
Log.e(TAG, "关闭ByteArrayOutputStream失败: " + e.getMessage());
}
// 使用Base64进行编码
String encodedString = Base64.encodeToString(byteArray, Base64.DEFAULT);
// 使用NO_WRAP标志避免插入换行符，节省内存
String encodedString = Base64.encodeToString(byteArray, Base64.NO_WRAP);
// 立即释放字节数组
byteArray = null;
// 如果创建了新的缩放位图，则释放它
if (scaledBitmap != bm && scaledBitmap != null && !scaledBitmap.isRecycled()) {
scaledBitmap.recycle();
}
return encodedString;
} catch (OutOfMemoryError e) {
Log.e(TAG, "Bitmap转Base64时内存溢出: " + e.getMessage());
// 确保资源被释放
if (scaledBitmap != null && scaledBitmap != bm && !scaledBitmap.isRecycled()) {
scaledBitmap.recycle();
}
// 尝试更激进的压缩
return bitmapToBase64Aggressive(bm);
} catch (Exception e) {
Log.e(TAG, "Bitmap转Base64时发生错误: " + e.getMessage());
// 确保资源被释放
if (scaledBitmap != null && scaledBitmap != bm && !scaledBitmap.isRecycled()) {
scaledBitmap.recycle();
}
return null;
}
}
/**
* 更激进的Bitmap转Base64方法，用于内存不足时的备选方案
* @param bm 要转换的Bitmap
* @return Base64编码的字符串
*/
private static String bitmapToBase64Aggressive(Bitmap bm) {
if (bm == null || bm.isRecycled()) {
return null;
}
try {
// 使用更小的尺寸和更低的质量
int originalWidth = bm.getWidth();
int originalHeight = bm.getHeight();
int targetWidth = 160; // 更小的目标宽度
Bitmap scaledBitmap;
if (originalWidth > targetWidth) {
float scaleFactor = (float) targetWidth / originalWidth;
int targetHeight = (int) (originalHeight * scaleFactor);
scaledBitmap = Bitmap.createScaledBitmap(bm, targetWidth, targetHeight, true);
} else {
scaledBitmap = bm;
}
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 使用最低的压缩质量(10%)
scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 10, baos);
byte[] byteArray = baos.toByteArray();
try {
baos.close();
} catch (IOException e) {
Log.e(TAG, "关闭ByteArrayOutputStream失败: " + e.getMessage());
}
return encodedString;
String encodedString = Base64.encodeToString(byteArray, Base64.NO_WRAP);
// 立即释放资源
byteArray = null;
if (scaledBitmap != bm && scaledBitmap != null && !scaledBitmap.isRecycled()) {
scaledBitmap.recycle();
}
return encodedString;
} catch (Exception e) {
Log.e(TAG, "激进压缩Bitmap转Base64时发生错误: " + e.getMessage());
return null;
}
}
}
Write Preview
Loading…
Cancel
Save