Back to project page Keep-score.
The source code is released under:
MIT License
If you think the Android project Keep-score listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
package gr.sv1jsb.cropimage; /*//from w ww. j av a2 s. c o m * Copyright (C) 2009 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import android.app.Activity; import android.app.ProgressDialog; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Canvas; import android.graphics.Matrix; import android.graphics.Rect; import android.os.Handler; import android.view.Surface; import java.io.Closeable; /** * Collection of utility functions used in this package. */ public class Util { private static final String TAG = "db.Util"; private Util() { } /* * Compute the sample size as a function of minSideLength * and maxNumOfPixels. * minSideLength is used to specify that minimal width or height of a bitmap. * maxNumOfPixels is used to specify the maximal size in pixels that are tolerable * in terms of memory usage. * * The function returns a sample size based on the constraints. * Both size and minSideLength can be passed in as IImage.UNCONSTRAINED, * which indicates no care of the corresponding constraint. * The functions prefers returning a sample size that * generates a smaller bitmap, unless minSideLength = IImage.UNCONSTRAINED. */ public static Bitmap transform(Matrix scaler, Bitmap source, int targetWidth, int targetHeight, boolean scaleUp) { int deltaX = source.getWidth() - targetWidth; int deltaY = source.getHeight() - targetHeight; if (!scaleUp && (deltaX < 0 || deltaY < 0)) { /* * In this case the bitmap is smaller, at least in one dimension, * than the target. Transform it by placing as much of the image * as possible into the target and leaving the top/bottom or * left/right (or both) black. */ Bitmap b2 = Bitmap.createBitmap(targetWidth, targetHeight, Bitmap.Config.ARGB_8888); Canvas c = new Canvas(b2); int deltaXHalf = Math.max(0, deltaX / 2); int deltaYHalf = Math.max(0, deltaY / 2); Rect src = new Rect( deltaXHalf, deltaYHalf, deltaXHalf + Math.min(targetWidth, source.getWidth()), deltaYHalf + Math.min(targetHeight, source.getHeight())); int dstX = (targetWidth - src.width()) / 2; int dstY = (targetHeight - src.height()) / 2; Rect dst = new Rect( dstX, dstY, targetWidth - dstX, targetHeight - dstY); c.drawBitmap(source, src, dst, null); return b2; } float bitmapWidthF = source.getWidth(); float bitmapHeightF = source.getHeight(); float bitmapAspect = bitmapWidthF / bitmapHeightF; float viewAspect = (float) targetWidth / targetHeight; if (bitmapAspect > viewAspect) { float scale = targetHeight / bitmapHeightF; if (scale < .9F || scale > 1F) { scaler.setScale(scale, scale); } else { scaler = null; } } else { float scale = targetWidth / bitmapWidthF; if (scale < .9F || scale > 1F) { scaler.setScale(scale, scale); } else { scaler = null; } } Bitmap b1; if (scaler != null) { // this is used for minithumb and crop, so we want to mFilter here. b1 = Bitmap.createBitmap(source, 0, 0, source.getWidth(), source.getHeight(), scaler, true); } else { b1 = source; } int dx1 = Math.max(0, b1.getWidth() - targetWidth); int dy1 = Math.max(0, b1.getHeight() - targetHeight); Bitmap b2 = Bitmap.createBitmap( b1, dx1 / 2, dy1 / 2, targetWidth, targetHeight); if (b1 != source) { b1.recycle(); } return b2; } public static void closeSilently(Closeable c) { if (c == null) return; try { c.close(); } catch (Throwable t) { // do nothing } } private static class BackgroundJob extends MonitoredActivity.LifeCycleAdapter implements Runnable { private final MonitoredActivity mActivity; private final ProgressDialog mDialog; private final Runnable mJob; private final Handler mHandler; private final Runnable mCleanupRunner = new Runnable() { public void run() { mActivity.removeLifeCycleListener(BackgroundJob.this); if (mDialog.getWindow() != null) mDialog.dismiss(); } }; public BackgroundJob(MonitoredActivity activity, Runnable job, ProgressDialog dialog, Handler handler) { mActivity = activity; mDialog = dialog; mJob = job; mActivity.addLifeCycleListener(this); mHandler = handler; } public void run() { try { mJob.run(); } finally { mHandler.post(mCleanupRunner); } } @Override public void onActivityDestroyed(MonitoredActivity activity) { // We get here only when the onDestroyed being called before // the mCleanupRunner. So, run it now and remove it from the queue mCleanupRunner.run(); mHandler.removeCallbacks(mCleanupRunner); } @Override public void onActivityStopped(MonitoredActivity activity) { mDialog.hide(); } @Override public void onActivityStarted(MonitoredActivity activity) { mDialog.show(); } } public static void startBackgroundJob(MonitoredActivity activity, String title, String message, Runnable job, Handler handler) { // Make the progress dialog uncancelable, so that we can gurantee // the thread will be done before the activity getting destroyed. ProgressDialog dialog = ProgressDialog.show( activity, title, message, true, false); new Thread(new BackgroundJob(activity, job, dialog, handler)).start(); } // Returns Options that set the puregeable flag for Bitmap decode. public static BitmapFactory.Options createNativeAllocOptions() { BitmapFactory.Options options = new BitmapFactory.Options(); //options.inNativeAlloc = true; return options; } // Thong added for rotate public static Bitmap rotateImage(Bitmap src, float degree) { // create new matrix Matrix matrix = new Matrix(); // setup rotation degree matrix.postRotate(degree); Bitmap bmp = Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true); return bmp; } public static int getOrientationInDegree(Activity activity) { int rotation = activity.getWindowManager().getDefaultDisplay() .getRotation(); int degrees = 0; switch (rotation) { case Surface.ROTATION_0: degrees = 0; break; case Surface.ROTATION_90: degrees = 90; break; case Surface.ROTATION_180: degrees = 180; break; case Surface.ROTATION_270: degrees = 270; break; } return degrees; } }