/*

   * Copyright (C) 2007 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.

  */

 package com.android.camera;

 import com.android.gallery.R;

 import com.android.camera.gallery.IImage;

 import com.android.camera.gallery.IImageList;

 import android.app.WallpaperManager;

 import android.content.ContentResolver;

 import android.content.Context;

 import android.content.Intent;

 import android.graphics.Bitmap;

 import android.graphics.Canvas;

 import android.graphics.Matrix;

 import android.graphics.Path;

 import android.graphics.PointF;

 import android.graphics.PorterDuff;

 import android.graphics.Rect;

 import android.graphics.RectF;

 import android.graphics.Region;

 import android.media.FaceDetector;

 import android.net.Uri;

 import android.os.Bundle;

 import android.os.Handler;

 import android.provider.MediaStore;

 import android.util.AttributeSet;

 import android.util.Log;

 import android.view.MotionEvent;

 import android.view.View;

 import android.view.Window;

 import android.view.WindowManager;

 import android.widget.Toast;

 import java.io.File;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.util.ArrayList;

 import java.util.concurrent.CountDownLatch;

 public class CropImage extends MonitoredActivity {

     private static final String TAG = "CropImage";

     // These are various options can be specified in the intent.

     private Bitmap.CompressFormat mOutputFormat =

             Bitmap.CompressFormat.JPEG; // only used with mSaveUri

     private Uri mSaveUri = null;

     private boolean mSetWallpaper = false;

     private int mAspectX, mAspectY;

     private boolean mDoFaceDetection = true;

     private boolean mCircleCrop = false;

     private final Handler mHandler = new Handler();

     // These options specifiy the output image size and whether we should

     // scale the output to fit it (or just crop it).

     private int mOutputX, mOutputY;

     private boolean mScale;

     private boolean mScaleUp = true;

     boolean mWaitingToPick; // Whether we are wait the user to pick a face.

     boolean mSaving;  // Whether the "save" button is already clicked.

     private CropImageView mImageView;

     private ContentResolver mContentResolver;

     private Bitmap mBitmap;

     HighlightView mCrop;

     private IImageList mAllImages;

     private IImage mImage;

     @Override

     public void onCreate(Bundle icicle) {

         super.onCreate(icicle);

         mContentResolver = getContentResolver();

         requestWindowFeature(Window.FEATURE_NO_TITLE);

         setContentView(R.layout.cropimage);

         mImageView = (CropImageView) findViewById(R.id.image);

        MenuHelper.showStorageToast(this);

        Intent intent = getIntent();

        Bundle extras = intent.getExtras();

        if (extras != null) {

            if (extras.getString("circleCrop") != null) {

                mCircleCrop = true;

                mAspectX = 1;

                mAspectY = 1;

            }

            mSaveUri = (Uri) extras.getParcelable(MediaStore.EXTRA_OUTPUT);

            if (mSaveUri != null) {

                String outputFormatString = extras.getString("outputFormat");

                if (outputFormatString != null) {

                    mOutputFormat = Bitmap.CompressFormat.valueOf(

                            outputFormatString);

                }

            } else {

                mSetWallpaper = extras.getBoolean("setWallpaper");

            }

            mBitmap = (Bitmap) extras.getParcelable("data");

            mAspectX = extras.getInt("aspectX");

            mAspectY = extras.getInt("aspectY");

            mOutputX = extras.getInt("outputX");

            mOutputY = extras.getInt("outputY");

            mScale = extras.getBoolean("scale", true);

            mScaleUp = extras.getBoolean("scaleUpIfNeeded", true);

            mDoFaceDetection = extras.containsKey("noFaceDetection")

                    ? !extras.getBoolean("noFaceDetection")

                    : true;

        }

        if (mBitmap == null) {

            Uri target = intent.getData();

            mAllImages = ImageManager.makeImageList(mContentResolver, target,

                    ImageManager.SORT_ASCENDING);

            mImage = mAllImages.getImageForUri(target);

            if (mImage != null) {

                // Don't read in really large bitmaps. Use the (big) thumbnail

                // instead.

                // TODO when saving the resulting bitmap use the

                // decode/crop/encode api so we don't lose any resolution.

                mBitmap = mImage.thumbBitmap(IImage.ROTATE_AS_NEEDED);

            }

        }

        if (mBitmap == null) {

            finish();

            return;

        }

        // Make UI fullscreen.

        getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);

        findViewById(R.id.discard).setOnClickListener(

                new View.OnClickListener() {

                    public void onClick(View v) {

                        setResult(RESULT_CANCELED);

                        finish();

                    }

                });

        findViewById(R.id.save).setOnClickListener(

                new View.OnClickListener() {

                    public void onClick(View v) {

                        onSaveClicked();

                    }

                });

        startFaceDetection();

    }

    private void startFaceDetection() {

        if (isFinishing()) {

            return;

        }

        mImageView.setImageBitmapResetBase(mBitmap, true);

        Util.startBackgroundJob(this, null,

                getResources().getString(R.string.runningFaceDetection),

                new Runnable() {

            public void run() {

                final CountDownLatch latch = new CountDownLatch(1);

                final Bitmap b = (mImage != null)

                        ? mImage.fullSizeBitmap(IImage.UNCONSTRAINED,

                        1024 * 1024)

                        : mBitmap;

                mHandler.post(new Runnable() {

                    public void run() {

                        if (b != mBitmap && b != null) {

                            mImageView.setImageBitmapResetBase(b, true);

                            mBitmap.recycle();

                            mBitmap = b;

                        }

                        if (mImageView.getScale() == 1F) {

                            mImageView.center(true, true);

                        }

                        latch.countDown();

                    }

                });

                try {

                    latch.await();

                } catch (InterruptedException e) {

                    throw new RuntimeException(e);

                }

                mRunFaceDetection.run();

            }

        }, mHandler);

    }

    private void onSaveClicked() {

        // TODO this code needs to change to use the decode/crop/encode single

        // step api so that we don't require that the whole (possibly large)

        // bitmap doesn't have to be read into memory

        if (mCrop == null) {

            return;

        }

        if (mSaving) return;

        mSaving = true;

        Bitmap croppedImage;

        // If the output is required to a specific size, create an new image

        // with the cropped image in the center and the extra space filled.

        if (mOutputX != 0 && mOutputY != 0 && !mScale) {

            // Don't scale the image but instead fill it so it's the

            // required dimension

            croppedImage = Bitmap.createBitmap(mOutputX,