android.graphics.Bitmap.CompressFormat Java Examples

@Override
public void onBitmapLoaded(Bitmap bitmap, LoadedFrom arg1) {
    mDetailImageView.setImageBitmap(bitmap);
    mDetailPicture = bitmap;
    mLoadingGif.setVisibility(View.INVISIBLE);
    mPrePlayButton.setVisibility(View.VISIBLE);
    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    mDetailPicture.compress(CompressFormat.JPEG, 100, bytes);

    File file = new File(mContext.getCacheDir(), "toshare.jpg");
    try {
        if (file.exists()) {
            file.delete();
        }
        file.createNewFile();
        FileOutputStream fo = new FileOutputStream(file);
        fo.write(bytes.toByteArray());
        fo.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
 

public void saveBitmap(String fileName, Bitmap bitmap) throws IOException {
	fileName = fileName.replaceAll("[^\\w]", "");
	if (bitmap == null) {
		return;
	}
	String path = getStorageDirectory();
	File foldFile = new File(path);
	if (!foldFile.exists()) {
		foldFile.mkdir();
	}
	File file = new File(path + File.separator + fileName);
	file.createNewFile();
	FileOutputStream outputStream = new FileOutputStream(file);
	bitmap.compress(CompressFormat.JPEG, 80, outputStream);
	outputStream.flush();
	outputStream.close();
}
 

public static byte[] bmpToByteArray(final Bitmap bmp, final boolean needRecycle) {
	ByteArrayOutputStream output = new ByteArrayOutputStream();
	bmp.compress(CompressFormat.PNG, 100, output);
	if (needRecycle) {
		bmp.recycle();
	}
	
	byte[] result = output.toByteArray();
	try {
		output.close();
	} catch (Exception e) {
		e.printStackTrace();
	}
	
	return result;
}
 

final ShareParams shareDataToShareParams(Platform plat) {
	if (plat == null || shareParamsMap == null) {
		toast("ssdk_oks_share_failed");
		return null;
	}

	try {
		String imagePath = R.forceCast(shareParamsMap.get("imagePath"));
		Bitmap viewToShare = R.forceCast(shareParamsMap.get("viewToShare"));
		if (TextUtils.isEmpty(imagePath) && viewToShare != null && !viewToShare.isRecycled()) {
			String path = R.getCachePath(plat.getContext(), "screenshot");
			File ss = new File(path, String.valueOf(System.currentTimeMillis()) + ".jpg");
			FileOutputStream fos = new FileOutputStream(ss);
			viewToShare.compress(CompressFormat.JPEG, 100, fos);
			fos.flush();
			fos.close();
			shareParamsMap.put("imagePath", ss.getAbsolutePath());
		}
	} catch (Throwable t) {
		t.printStackTrace();
		toast("ssdk_oks_share_failed");
		return null;
	}

	return new ShareParams(shareParamsMap);
}
 

public static String saveScreenBitmap(Activity activity) {
    Bitmap bitmap = screenShot(activity);
    File file = new File(DirectoryPath.getX8LocalSar() + "/" + DateUtil.getStringByFormat(System.currentTimeMillis(), DateUtil.dateFormatYYMMDDHHMMSS) + ".jpeg");
    String s = "";
    try {
        if (!file.exists()) {
            if (file.getParentFile().exists()) {
                file.createNewFile();
            } else {
                file.getParentFile().mkdirs();
            }
        }
        if (save(bitmap, file, CompressFormat.JPEG, true)) {
            X8ToastUtil.showToast(activity, activity.getString(R.string.x8_ai_fly_sar_save_pic_tip), 0);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return s;
}
 

private String ouputModifiedBitmap(Bitmap bitmap, Uri uri) throws IOException {
    // Create an ExifHelper to save the exif data that is lost during compression
    String modifiedPath = getTempDirectoryPath() + "/modified.jpg";

    OutputStream os = new FileOutputStream(modifiedPath);
    bitmap.compress(Bitmap.CompressFormat.JPEG, this.mQuality, os);
    os.close();

    // Some content: URIs do not map to file paths (e.g. picasa).
    String realPath = FileHelper.getRealPath(uri, this.cordova);
    ExifHelper exif = new ExifHelper();
    if (realPath != null && this.encodingType == JPEG) {
        try {
            exif.createInFile(realPath);
            exif.readExifData();
            if (this.correctOrientation && this.orientationCorrected) {
                exif.resetOrientation();
            }
            exif.createOutFile(modifiedPath);
            exif.writeExifData();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return modifiedPath;
}
 

public static byte[] bmpToByteArray(final Bitmap bmp, final boolean needRecycle) {
	ByteArrayOutputStream output = new ByteArrayOutputStream();
	bmp.compress(CompressFormat.PNG, 100, output);
	if (needRecycle) {
		bmp.recycle();
	}
	
	byte[] result = output.toByteArray();
	try {
		output.close();
	} catch (Exception e) {
		e.printStackTrace();
	}
	
	return result;
}
 

/**
 * Returns a compressed JPEG byte representation of this Pix.
 *
 * @param pixs A source pix image.
 * @param quality The quality of the compressed image. Valid range is 0-100.
 * @param progressive Whether to use progressive compression.
 * @return a compressed JPEG byte array representation of the Pix
 */
public static byte[] compressToJpeg(Pix pixs, int quality, boolean progressive) {
    if (pixs == null)
        throw new IllegalArgumentException("Source pix must be non-null");
    if (quality < 0 || quality > 100)
        throw new IllegalArgumentException("Quality must be between 0 and 100 (inclusive)");

    final ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
    final Bitmap bmp = WriteFile.writeBitmap(pixs);
    bmp.compress(CompressFormat.JPEG, quality, byteStream);
    bmp.recycle();

    final byte[] encodedData = byteStream.toByteArray();

    try {
        byteStream.close();
    } catch (IOException e) {
        e.printStackTrace();
    }

    return encodedData;
}
 

/**
 * Retrieves {@link java.io.InputStream} of image by URI (image is accessed using {@link android.content.ContentResolver}).
 *
 * @param imageUri Image URI
 * @param extra    Auxiliary object which was passed to {@link com.nostra13.universalimageloader.core.DisplayImageOptions.Builder#extraForDownloader(Object)
 *                 DisplayImageOptions.extraForDownloader(Object)}; can be null
 * @return {@link java.io.InputStream} of image
 * @throws java.io.FileNotFoundException if the provided URI could not be opened
 */
protected InputStream getStreamFromContent(String imageUri, Object extra) throws FileNotFoundException {
	ContentResolver res = context.getContentResolver();

	Uri uri = Uri.parse(imageUri);
	if (isVideoUri(uri)) { // video thumbnail
		Long origId = Long.valueOf(uri.getLastPathSegment());
		Bitmap bitmap = MediaStore.Video.Thumbnails
				.getThumbnail(res, origId, MediaStore.Images.Thumbnails.MINI_KIND, null);
		if (bitmap != null) {
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			bitmap.compress(CompressFormat.PNG, 0, bos);
			return new ByteArrayInputStream(bos.toByteArray());
		}
	} else if (imageUri.startsWith(CONTENT_CONTACTS_URI_PREFIX)) { // contacts photo
		return ContactsContract.Contacts.openContactPhotoInputStream(res, uri, true);
	}

	return res.openInputStream(uri);
}
 

/**
    * 根据文件的路径获取Video文件缩略图流数据
    * @param filePath
    * @return
    */
@TargetApi(Build.VERSION_CODES.FROYO)
private InputStream getVideoThumbnailStream(String filePath) {
	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) {
           //创建缩略图
		Bitmap bitmap = ThumbnailUtils
				.createVideoThumbnail(filePath, MediaStore.Images.Thumbnails.FULL_SCREEN_KIND);
		if (bitmap != null) {
               //图像转成流传入
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			bitmap.compress(CompressFormat.PNG, 0, bos);
			return new ByteArrayInputStream(bos.toByteArray());
		}
	}
	return null;
}
 

public void writeBtimapToSD(
		Context ctx, String dir, String file, Bitmap img, CompressFormat format) 
		throws Exception{
	if(!hasSDCard()){
		return;
	}
	if (img == null) {
		return;
	}
	String path = dir + EncryptTools.instance().toMD5(file);
	File targetFile = new File(path);
	if(targetFile.exists()){
		return;
	}
	targetFile.createNewFile();
		FileOutputStream fo = new FileOutputStream(path);
	img.compress(format, 100, fo);
	fo.flush();
	fo.close();
}
 

public static String makeThumbnail(File imageFile) {
    String thumbFilePath = StorageUtil.getWritePath(imageFile.getName(), StorageType.TYPE_THUMB_IMAGE);
    File thumbFile = AttachmentStore.create(thumbFilePath);
    if (thumbFile == null) {
        return null;
    }

    boolean result = scaleThumbnail(
            imageFile,
            thumbFile,
            MsgViewHolderThumbBase.getImageMaxEdge(),
            MsgViewHolderThumbBase.getImageMinEdge(),
            CompressFormat.JPEG,
            60);
    if (!result) {
        AttachmentStore.delete(thumbFilePath);
        return null;
    }

    return thumbFilePath;
}
 

private String ouputModifiedBitmap(Bitmap bitmap, Uri uri) throws IOException {
    // Create an ExifHelper to save the exif data that is lost during compression
    String modifiedPath = getTempDirectoryPath() + "/modified.jpg";

    OutputStream os = new FileOutputStream(modifiedPath);
    bitmap.compress(Bitmap.CompressFormat.JPEG, this.mQuality, os);
    os.close();

    // Some content: URIs do not map to file paths (e.g. picasa).
    String realPath = FileHelper.getRealPath(uri, this.cordova);
    ExifHelper exif = new ExifHelper();
    if (realPath != null && this.encodingType == JPEG) {
        try {
            exif.createInFile(realPath);
            exif.readExifData();
            if (this.correctOrientation && this.orientationCorrected) {
                exif.resetOrientation();
            }
            exif.createOutFile(modifiedPath);
            exif.writeExifData();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return modifiedPath;
}
 

public static byte[] bmpToByteArray(final Bitmap bmp, final boolean needRecycle) {
	ByteArrayOutputStream output = new ByteArrayOutputStream();
	bmp.compress(CompressFormat.PNG, 100, output);
	if (needRecycle) {
		bmp.recycle();
	}
	
	byte[] result = output.toByteArray();
	try {
		output.close();
	} catch (Exception e) {
		Log.e("bmpToByteArray", "bmpToByteArray error", e);
	}
	
	return result;
}
 

public static byte[] bmpToByteArray(final Bitmap bmp, final boolean needRecycle) {
	ByteArrayOutputStream output = new ByteArrayOutputStream();
	bmp.compress(CompressFormat.PNG, 100, output);
	if (needRecycle) {
		bmp.recycle();
	}
	
	byte[] result = output.toByteArray();
	try {
		output.close();
	} catch (Exception e) {
		e.printStackTrace();
	}
	
	return result;
}
 

final ShareParams shareDataToShareParams(Platform plat) {
	if (plat == null || shareParamsMap == null) {
		toast("ssdk_oks_share_failed");
		return null;
	}

	try {
		String imagePath = ResHelper.forceCast(shareParamsMap.get("imagePath"));
		Bitmap viewToShare = ResHelper.forceCast(shareParamsMap.get("viewToShare"));
		if (TextUtils.isEmpty(imagePath) && viewToShare != null && !viewToShare.isRecycled()) {
			String path = ResHelper.getCachePath(plat.getContext(), "screenshot");
			File ss = new File(path, String.valueOf(System.currentTimeMillis()) + ".jpg");
			FileOutputStream fos = new FileOutputStream(ss);
			viewToShare.compress(CompressFormat.JPEG, 100, fos);
			fos.flush();
			fos.close();
			shareParamsMap.put("imagePath", ss.getAbsolutePath());
		}
	} catch (Throwable t) {
		t.printStackTrace();
		toast("ssdk_oks_share_failed");
		return null;
	}

	return new ShareParams(shareParamsMap);
}
 

/**
 * 按采样大小压缩
 *
 * @param src        源图片
 * @param sampleSize 采样率大小
 * @param recycle    是否回收
 * @return 按采样率压缩后的图片
 */
public static Bitmap compressBySampleSize(Bitmap src, int sampleSize, boolean recycle) {
    if (isEmptyBitmap(src)) return null;
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inSampleSize = sampleSize;
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    src.compress(CompressFormat.JPEG, 100, baos);
    byte[] bytes = baos.toByteArray();
    if (recycle && !src.isRecycled()) src.recycle();
    return BitmapFactory.decodeByteArray(bytes, 0, bytes.length, options);
}
 

public static File getScaledImageFileWithMD5(File imageFile, String mimeType) {
    String filePath = imageFile.getPath();

    if (!isInvalidPictureFile(mimeType)) {
        return null;
    }

    String tempFilePath = getTempFilePath(FileUtil.getExtensionName(filePath));
    Log.i("ImageUtil", "tempFilePath:"+tempFilePath);
    File tempImageFile = AttachmentStore.create(tempFilePath);
    if (tempImageFile == null) {
        return null;
    }

    CompressFormat compressFormat = CompressFormat.JPEG;
    // 压缩数值由第三方开发者自行决定
    int maxWidth = 720;
    int quality = 60;

    if (ImageUtil.scaleImage(imageFile, tempImageFile, maxWidth, compressFormat, quality)) {
        return tempImageFile;
    } else {
        return null;
    }
}
 

public static byte[] bmpToByteArray(final Bitmap bmp, final boolean needRecycle) {
	ByteArrayOutputStream output = new ByteArrayOutputStream();
	bmp.compress(CompressFormat.PNG, 100, output);
	if (needRecycle) {
		bmp.recycle();
	}
	
	byte[] result = output.toByteArray();
	try {
		output.close();
	} catch (Exception e) {
		e.printStackTrace();
	}
	
	return result;
}
 

/**
 * Extracts the icon from an APK and writes it to the repo as a PNG
 */
private void copyIconToRepo(Drawable drawable, String packageName, int versionCode) {
    Bitmap bitmap;
    if (drawable instanceof BitmapDrawable) {
        bitmap = ((BitmapDrawable) drawable).getBitmap();
    } else {
        bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(),
                drawable.getIntrinsicHeight(), Config.ARGB_8888);
        Canvas canvas = new Canvas(bitmap);
        drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
        drawable.draw(canvas);
    }
    File png = getIconFile(packageName, versionCode);
    OutputStream out;
    try {
        out = new BufferedOutputStream(new FileOutputStream(png));
        bitmap.compress(CompressFormat.PNG, 100, out);
        out.close();
    } catch (Exception e) {
        Log.e(TAG, "Error copying icon to repo", e);
    }
}
 

private String ouputModifiedBitmap(Bitmap bitmap, Uri uri) throws IOException {
    // Create an ExifHelper to save the exif data that is lost during compression
    String modifiedPath = getTempDirectoryPath() + "/modified.jpg";

    OutputStream os = new FileOutputStream(modifiedPath);
    bitmap.compress(Bitmap.CompressFormat.JPEG, this.mQuality, os);
    os.close();

    // Some content: URIs do not map to file paths (e.g. picasa).
    String realPath = FileHelper.getRealPath(uri, this.cordova);
    ExifHelper exif = new ExifHelper();
    if (realPath != null && this.encodingType == JPEG) {
        try {
            exif.createInFile(realPath);
            exif.readExifData();
            if (this.correctOrientation && this.orientationCorrected) {
                exif.resetOrientation();
            }
            exif.createOutFile(modifiedPath);
            exif.writeExifData();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return modifiedPath;
}
 

final ShareParams shareDataToShareParams(Platform plat) {
	if (plat == null || shareParamsMap == null) {
		toast("ssdk_oks_share_failed");
		return null;
	}

	try {
		String imagePath = ResHelper.forceCast(shareParamsMap.get("imagePath"));
		Bitmap viewToShare = ResHelper.forceCast(shareParamsMap.get("viewToShare"));
		if (TextUtils.isEmpty(imagePath) && viewToShare != null && !viewToShare.isRecycled()) {
			String path = ResHelper.getCachePath(plat.getContext(), "screenshot");
			File ss = new File(path, String.valueOf(System.currentTimeMillis()) + ".jpg");
			FileOutputStream fos = new FileOutputStream(ss);
			viewToShare.compress(CompressFormat.JPEG, 100, fos);
			fos.flush();
			fos.close();
			shareParamsMap.put("imagePath", ss.getAbsolutePath());
		}
	} catch (Throwable t) {
		t.printStackTrace();
		toast("ssdk_oks_share_failed");
		return null;
	}

	return new ShareParams(shareParamsMap);
}
 

public static boolean writeToFile(final File file, final Bitmap bitmap) {
    if ((bitmap == null) || (file == null) || file.exists()) {
        return false;
    }
    BufferedOutputStream bos = null;
    try {
        bos = new BufferedOutputStream(new FileOutputStream(file),
                ImageHelper.OUTPUT_BUFFER_SIZE);
        return bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bos);
    } catch (final IOException e) {
        if (AppContext.DEBUG) {
            Log.d(ImageHelper.TAG, "writeToFile:" + e.getMessage());
        }
    } finally {
        IOHelper.forceClose(bos);
    }
    return false;
}
 

/**
 * Compress bitmap using jpeg, convert to Base64 encoded string, and return to JavaScript.
 *
 * @param bitmap
 */
public void processPicture(Bitmap bitmap) {
    ByteArrayOutputStream jpeg_data = new ByteArrayOutputStream();
    try {
        if (bitmap.compress(CompressFormat.JPEG, mQuality, jpeg_data)) {
            byte[] code = jpeg_data.toByteArray();
            byte[] output = Base64.encode(code, Base64.DEFAULT);
            String js_out = new String(output);
            this.callbackContext.success(js_out);
            js_out = null;
            output = null;
            code = null;
        }
    } catch (Exception e) {
        this.failPicture("Error compressing image.");
    }
    jpeg_data = null;
}
 

/**
 * 按质量压缩
 *
 * @param src         源图片
 * @param maxByteSize 允许最大值字节数
 * @param recycle     是否回收
 * @return 质量压缩压缩过的图片
 */
public static Bitmap compressByQuality(Bitmap src, long maxByteSize, boolean recycle) {
    if (isEmptyBitmap(src) || maxByteSize <= 0) return null;
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    int quality = 100;
    src.compress(CompressFormat.JPEG, quality, baos);
    while (baos.toByteArray().length > maxByteSize && quality >= 0) {
        baos.reset();
        src.compress(CompressFormat.JPEG, quality -= 5, baos);
    }
    if (quality < 0) return null;
    byte[] bytes = baos.toByteArray();
    if (recycle && !src.isRecycled()) src.recycle();
    return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
}
 

/**
 * 按质量压缩
 *
 * @param src         源图片
 * @param maxByteSize 允许最大值字节数
 * @param recycle     是否回收
 * @return 质量压缩压缩过的图片
 */
public static Bitmap compressByQuality(Bitmap src, long maxByteSize, boolean recycle) {
    if (isEmptyBitmap(src) || maxByteSize <= 0) return null;
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    int quality = 100;
    src.compress(CompressFormat.JPEG, quality, baos);
    while (baos.toByteArray().length > maxByteSize && quality > 0) {
        baos.reset();
        src.compress(CompressFormat.JPEG, quality -= 5, baos);
    }
    if (quality < 0) return null;
    byte[] bytes = baos.toByteArray();
    if (recycle && !src.isRecycled()) src.recycle();
    return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
}
 

/**
 * 按质量压缩
 *
 * @param src     源图片
 * @param quality 质量
 * @param recycle 是否回收
 * @return 质量压缩后的图片
 */
public static Bitmap compressByQuality(Bitmap src, @IntRange(from = 0, to = 100) int quality, boolean recycle) {
    if (isEmptyBitmap(src)) return null;
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    src.compress(Bitmap.CompressFormat.JPEG, quality, baos);
    byte[] bytes = baos.toByteArray();
    if (recycle && !src.isRecycled()) src.recycle();
    return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
}
 

public static Uri getImageUri(Context inContext, Bitmap inImage) {
	ByteArrayOutputStream bytes = new ByteArrayOutputStream();
	inImage.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
	String path = Images.Media.insertImage(inContext.getContentResolver(),
			inImage, "Title", null);
	return Uri.parse(path);
}
 

public void saveCustomIcon(String appComponent, String iconComponent) {
	File customIconFile = MyCache.getCustomIconFile(this, appComponent);
	Bitmap customBitmap = LauncherApp.getInstance().getIconPackManager().getBitmap(iconComponent);
	if (customIconFile != null) {
		try {
			// save icon in cache
			FileOutputStream out = new FileOutputStream(customIconFile);
			customBitmap.compress(CompressFormat.PNG, 100, out);
			out.close();
		} catch (Exception e) {
			customIconFile.delete();
		}
	}
}
 

public static String ocr(Bitmap image) throws IOException {
	// ============ 读图片数据===========
	// DataInputStream in = new DataInputStream(new FileInputStream(img));
	ByteArrayOutputStream stream = new ByteArrayOutputStream();
	image.compress(CompressFormat.JPEG, 100, stream);
	stream.close();
	return ocr(stream.toByteArray());
}