diff options
Diffstat (limited to 'src/com/android/camera/PhotoModule.java')
| -rw-r--r-- | src/com/android/camera/PhotoModule.java | 1527 |
1 files changed, 1462 insertions, 65 deletions
diff --git a/src/com/android/camera/PhotoModule.java b/src/com/android/camera/PhotoModule.java index 2afaf5bf5..3d6218281 100644 --- a/src/com/android/camera/PhotoModule.java +++ b/src/com/android/camera/PhotoModule.java @@ -30,6 +30,7 @@ import android.graphics.SurfaceTexture; import android.hardware.Camera.CameraInfo; import android.hardware.Camera.Parameters; import android.hardware.Camera.Size; +import android.hardware.Camera; import android.hardware.Sensor; import android.hardware.SensorEvent; import android.hardware.SensorEventListener; @@ -50,6 +51,12 @@ import android.view.KeyEvent; import android.view.OrientationEventListener; import android.view.View; import android.view.WindowManager; +import android.widget.Toast; +import android.widget.ProgressBar; +import android.widget.SeekBar; +import android.widget.SeekBar.OnSeekBarChangeListener; +import android.widget.LinearLayout; +import android.widget.TextView; import com.android.camera.CameraManager.CameraAFCallback; import com.android.camera.CameraManager.CameraAFMoveCallback; @@ -76,6 +83,14 @@ import java.io.IOException; import java.io.OutputStream; import java.util.List; import java.util.Vector; +import java.util.HashMap; +import android.util.AttributeSet; +import android.graphics.Canvas; +import android.graphics.Color; +import android.graphics.Paint; +import android.os.SystemProperties; +import java.util.Collections; +import java.util.Formatter; public class PhotoModule implements CameraModule, @@ -89,6 +104,20 @@ public class PhotoModule private static final String TAG = "CAM_PhotoModule"; + //QCom data members + public static boolean mBrightnessVisible = true; + private static final int MAX_SHARPNESS_LEVEL = 6; + private boolean mRestartPreview = false; + private int mSnapshotMode; + private int mBurstSnapNum = 1; + private int mReceivedSnapNum = 0; + public boolean mFaceDetectionEnabled = false; + + /*Histogram variables*/ + private GraphView mGraphView; + private static final int STATS_DATA = 257; + public static int statsdata[] = new int[STATS_DATA]; + public boolean mHiston = false; // We number the request code from 1000 to avoid collision with Gallery. private static final int REQUEST_CROP = 1000; @@ -102,7 +131,10 @@ public class PhotoModule private static final int CAMERA_OPEN_DONE = 8; private static final int OPEN_CAMERA_FAIL = 9; private static final int CAMERA_DISABLED = 10; - private static final int SWITCH_TO_GCAM_MODULE = 11; + private static final int SET_SKIN_TONE_FACTOR = 11; + private static final int SET_PHOTO_UI_PARAMS = 12; + private static final int SWITCH_TO_GCAM_MODULE = 13; + private static final int CONFIGURE_SKIN_TONE_FACTOR = 14; // The subset of parameters we need to update in setCameraParameters(). private static final int UPDATE_PARAM_INITIALIZE = 1; @@ -122,6 +154,7 @@ public class PhotoModule private int mCameraId; private Parameters mParameters; private boolean mPaused; + private View mRootView; private PhotoUI mUI; @@ -146,6 +179,8 @@ public class PhotoModule private boolean mAeLockSupported; private boolean mAwbLockSupported; private boolean mContinuousFocusSupported; + private boolean mTouchAfAecFlag; + private boolean mLongshotSave = false; // The degrees of the device rotated clockwise from its natural orientation. private int mOrientation = OrientationEventListener.ORIENTATION_UNKNOWN; @@ -156,6 +191,33 @@ public class PhotoModule private ContentProviderClient mMediaProviderClient; private boolean mFaceDetectionStarted = false; + private static final String PERSIST_LONG_ENABLE = "persist.camera.longshot.enable"; + private static final String PERSIST_LONG_SAVE = "persist.camera.longshot.save"; + private static final String PERSIST_PREVIEW_RESTART = "persist.camera.feature.restart"; + + private static final int MINIMUM_BRIGHTNESS = 0; + private static final int MAXIMUM_BRIGHTNESS = 6; + private int mbrightness = 3; + private int mbrightness_step = 1; + private ProgressBar brightnessProgressBar; + // Constant from android.hardware.Camera.Parameters + private static final String KEY_PICTURE_FORMAT = "picture-format"; + private static final String KEY_QC_RAW_PICUTRE_SIZE = "raw-size"; + public static final String PIXEL_FORMAT_JPEG = "jpeg"; + + private static final int MIN_SCE_FACTOR = -10; + private static final int MAX_SCE_FACTOR = +10; + private int SCE_FACTOR_STEP = 10; + private int mskinToneValue = 0; + private boolean mSkinToneSeekBar= false; + private boolean mSeekBarInitialized = false; + private SeekBar skinToneSeekBar; + private TextView LeftValue; + private TextView RightValue; + private TextView Title; + + private boolean mPreviewRestartSupport = false; + // mCropValue and mSaveUri are used only if isImageCaptureIntent() is true. private String mCropValue; private Uri mSaveUri; @@ -215,6 +277,7 @@ public class PhotoModule : null; private final CameraErrorCallback mErrorCallback = new CameraErrorCallback(); + private final StatsCallback mStatsCallback = new StatsCallback(); private long mFocusStartTime; private long mShutterCallbackTime; @@ -236,8 +299,10 @@ public class PhotoModule private FocusOverlayManager mFocusManager; private String mSceneMode; + private String mCurrTouchAfAec = Parameters.TOUCH_AF_AEC_ON; private final Handler mHandler = new MainHandler(); + private MessageQueue.IdleHandler mIdleHandler = null; private PreferenceGroup mPreferenceGroup; @@ -347,10 +412,47 @@ public class PhotoModule R.string.camera_disabled); break; } + case SET_SKIN_TONE_FACTOR: { + Log.v(TAG, "set tone bar: mSceneMode = " + mSceneMode); + setSkinToneFactor(); + mSeekBarInitialized = true; + // skin tone ie enabled only for party and portrait BSM + // when color effects are not enabled + String colorEffect = mPreferences.getString( + CameraSettings.KEY_COLOR_EFFECT, + mActivity.getString(R.string.pref_camera_coloreffect_default)); + if((Parameters.SCENE_MODE_PARTY.equals(mSceneMode) || + Parameters.SCENE_MODE_PORTRAIT.equals(mSceneMode))&& + (Parameters.EFFECT_NONE.equals(colorEffect))) { + ; + } + else{ + Log.v(TAG, "Skin tone bar: disable"); + disableSkinToneSeekBar(); + } + break; + } + case SET_PHOTO_UI_PARAMS: { + setCameraParametersWhenIdle(UPDATE_PARAM_PREFERENCE); + mUI.updateOnScreenIndicators(mParameters, mPreferenceGroup, + mPreferences); + break; + } case SWITCH_TO_GCAM_MODULE: { mActivity.onModuleSelected(ModuleSwitcher.GCAM_MODULE_INDEX); } + + case CONFIGURE_SKIN_TONE_FACTOR: { + if ((mCameraDevice != null) && isCameraIdle()) { + synchronized (mCameraDevice) { + mParameters = mCameraDevice.getParameters(); + mParameters.set("skinToneEnhancement", String.valueOf(msg.arg1)); + mCameraDevice.setParameters(mParameters); + } + } + break; + } } } } @@ -359,6 +461,7 @@ public class PhotoModule @Override public void init(CameraActivity activity, View parent) { mActivity = activity; + mRootView = parent; mUI = new PhotoUI(activity, this, parent); mPreferences = new ComboPreferences(mActivity); CameraSettings.upgradeGlobalPreferences(mPreferences.getGlobal()); @@ -379,6 +482,23 @@ public class PhotoModule mQuickCapture = mActivity.getIntent().getBooleanExtra(EXTRA_QUICK_CAPTURE, false); mLocationManager = new LocationManager(mActivity, mUI); mSensorManager = (SensorManager)(mActivity.getSystemService(Context.SENSOR_SERVICE)); + + brightnessProgressBar = (ProgressBar)mRootView.findViewById(R.id.progress); + if (brightnessProgressBar instanceof SeekBar) { + SeekBar seeker = (SeekBar) brightnessProgressBar; + seeker.setOnSeekBarChangeListener(mSeekListener); + } + brightnessProgressBar.setMax(MAXIMUM_BRIGHTNESS); + brightnessProgressBar.setProgress(mbrightness); + skinToneSeekBar = (SeekBar) mRootView.findViewById(R.id.skintoneseek); + skinToneSeekBar.setOnSeekBarChangeListener(mskinToneSeekListener); + skinToneSeekBar.setVisibility(View.INVISIBLE); + Title = (TextView)mRootView.findViewById(R.id.skintonetitle); + RightValue = (TextView)mRootView.findViewById(R.id.skintoneright); + LeftValue = (TextView)mRootView.findViewById(R.id.skintoneleft); + Storage.setSaveSDCard( + mPreferences.getString(CameraSettings.KEY_CAMERA_SAVEPATH, "0").equals("1")); + } private void initializeControlByIntent() { @@ -392,6 +512,7 @@ public class PhotoModule setCameraState(IDLE); startFaceDetection(); locationFirstRun(); + mUI.enableShutter(true); } // Prompt the user to pick to record location for the very first run of @@ -447,6 +568,7 @@ public class PhotoModule int height = root.getHeight(); mFocusManager.setPreviewSize(width, height); openCameraCommon(); + resizeForPreviewAspectRatio(); } private void switchCamera() { @@ -461,6 +583,7 @@ public class PhotoModule closeCamera(); mUI.collapseCameraControls(); mUI.clearFaces(); + disableSkinToneSeekBar(); if (mFocusManager != null) mFocusManager.removeMessages(); // Restart the camera and initialize the UI. From onCreate. @@ -484,6 +607,7 @@ public class PhotoModule // reset zoom value index mZoomValue = 0; + resizeForPreviewAspectRatio(); openCameraCommon(); // Start switch camera animation. Post a message because @@ -505,13 +629,18 @@ public class PhotoModule mUI.overrideSettings(CameraSettings.KEY_CAMERA_HDR_PLUS, mActivity.getString(R.string.setting_off_value)); } - updateSceneMode(); + updateCameraSettings(); showTapToFocusToastIfNeeded(); } @Override + public void onScreenSizeChanged(int width, int height) { + if (mFocusManager != null) mFocusManager.setPreviewSize(width, height); + } + + @Override public void onPreviewRectChanged(Rect previewRect) { if (mFocusManager != null) mFocusManager.setPreviewRect(previewRect); } @@ -526,6 +655,29 @@ public class PhotoModule } } + void setPreviewFrameLayoutCameraOrientation(){ + CameraInfo info = CameraHolder.instance().getCameraInfo()[mCameraId]; + //if camera mount angle is 0 or 180, we want to resize preview + if (info.orientation % 180 == 0){ + mUI.cameraOrientationPreviewResize(true); + } else{ + mUI.cameraOrientationPreviewResize(false); + } + } + + @Override + public void resizeForPreviewAspectRatio() { + if ( mCameraDevice == null || mParameters == null) { + Log.e(TAG, "Camera not yet initialized"); + return; + } + setPreviewFrameLayoutCameraOrientation(); + Size size = mParameters.getPreviewSize(); + Log.e(TAG,"Width = "+ size.width+ "Height = "+size.height); + mUI.setAspectRatio((float) size.width / size.height); + } + + private void keepMediaProviderInstance() { // We want to keep a reference to MediaProvider in camera's lifecycle. // TODO: Utilize mMediaProviderClient instance to replace @@ -560,8 +712,15 @@ public class PhotoModule } mNamedImages = new NamedImages(); + mGraphView = (GraphView)mRootView.findViewById(R.id.graph_view); + if(mGraphView == null){ + Log.e(TAG, "mGraphView is null"); + } else{ + mGraphView.setPhotoModuleObject(this); + } mFirstTimeInitialized = true; + Log.d(TAG, "addIdleHandler in first time initialization"); addIdleHandler(); mActivity.updateStorageSpaceAndHint(); @@ -579,6 +738,9 @@ public class PhotoModule s.setListener(this); } mNamedImages = new NamedImages(); + if (!mIsImageCaptureIntent) { + mUI.showSwitcher(); + } mUI.initializeSecondTime(mParameters); keepMediaProviderInstance(); } @@ -593,19 +755,32 @@ public class PhotoModule } private void addIdleHandler() { - MessageQueue queue = Looper.myQueue(); - queue.addIdleHandler(new MessageQueue.IdleHandler() { - @Override - public boolean queueIdle() { - Storage.ensureOSXCompatible(); - return false; - } - }); + if (mIdleHandler == null) { + mIdleHandler = new MessageQueue.IdleHandler() { + @Override + public boolean queueIdle() { + Storage.ensureOSXCompatible(); + return false; + } + }; + + MessageQueue queue = Looper.myQueue(); + queue.addIdleHandler(mIdleHandler); + } + } + + private void removeIdleHandler() { + if (mIdleHandler != null) { + MessageQueue queue = Looper.myQueue(); + queue.removeIdleHandler(mIdleHandler); + mIdleHandler = null; + } } @Override public void startFaceDetection() { - if (mFaceDetectionStarted) return; + if (mFaceDetectionEnabled == false + || mFaceDetectionStarted || mCameraState != IDLE) return; if (mParameters.getMaxNumDetectedFaces() > 0) { mFaceDetectionStarted = true; CameraInfo info = CameraHolder.instance().getCameraInfo()[mCameraId]; @@ -618,7 +793,7 @@ public class PhotoModule @Override public void stopFaceDetection() { - if (!mFaceDetectionStarted) return; + if (mFaceDetectionEnabled == false || !mFaceDetectionStarted) return; if (mParameters.getMaxNumDetectedFaces() > 0) { mFaceDetectionStarted = false; mCameraDevice.setFaceDetectionCallback(null, null); @@ -627,6 +802,34 @@ public class PhotoModule } } + private final class LongshotShutterCallback + implements CameraShutterCallback { + + @Override + public void onShutter(CameraProxy camera) { + mShutterCallbackTime = System.currentTimeMillis(); + mShutterLag = mShutterCallbackTime - mCaptureStartTime; + Log.e(TAG, "[KPI Perf] PROFILE_SHUTTER_LAG mShutterLag = " + mShutterLag + "ms"); + synchronized(mCameraDevice) { + + if (mCameraState != LONGSHOT) { + return; + } + + if (mLongshotSave) { + mCameraDevice.takePicture(mHandler, + new LongshotShutterCallback(), + mRawPictureCallback, mPostViewPictureCallback, + new LongshotPictureCallback(null)); + } else { + mCameraDevice.takePicture(mHandler,new LongshotShutterCallback(), + mRawPictureCallback, mPostViewPictureCallback, + new JpegPictureCallback(null)); + } + } + } + } + private final class ShutterCallback implements CameraShutterCallback { @@ -640,7 +843,7 @@ public class PhotoModule public void onShutter(CameraProxy camera) { mShutterCallbackTime = System.currentTimeMillis(); mShutterLag = mShutterCallbackTime - mCaptureStartTime; - Log.v(TAG, "mShutterLag = " + mShutterLag + "ms"); + Log.e(TAG, "[KPI Perf] PROFILE_SHUTTER_LAG mShutterLag = " + mShutterLag + "ms"); if (mNeedsAnimation) { mActivity.runOnUiThread(new Runnable() { @Override @@ -651,7 +854,26 @@ public class PhotoModule } } } - + private final class StatsCallback + implements android.hardware.Camera.CameraDataCallback { + @Override + public void onCameraData(int [] data, android.hardware.Camera camera) { + //if(!mPreviewing || !mHiston || !mFirstTimeInitialized){ + if(!mHiston || !mFirstTimeInitialized){ + return; + } + /*The first element in the array stores max hist value . Stats data begin from second value*/ + synchronized(statsdata) { + System.arraycopy(data,0,statsdata,0,STATS_DATA); + } + mActivity.runOnUiThread(new Runnable() { + public void run() { + if(mGraphView != null) + mGraphView.PreviewChanged(); + } + }); + } + } private final class PostViewPictureCallback implements CameraPictureCallback { @Override @@ -673,6 +895,64 @@ public class PhotoModule } } + private final class LongshotPictureCallback implements CameraPictureCallback { + Location mLocation; + + public LongshotPictureCallback(Location loc) { + mLocation = loc; + } + + @Override + public void onPictureTaken(final byte [] jpegData, CameraProxy camera) { + if (mPaused) { + return; + } + + mFocusManager.updateFocusUI(); // Ensure focus indicator is hidden. + + String jpegFilePath = new String(jpegData); + mNamedImages.nameNewImage(mCaptureStartTime); + NamedEntity name = mNamedImages.getNextNameEntity(); + String title = (name == null) ? null : name.title; + long date = (name == null) ? -1 : name.date; + + if (title == null) { + Log.e(TAG, "Unbalanced name/data pair"); + return; + } + + + if (date == -1 ) { + Log.e(TAG, "Invalid filename date"); + return; + } + + String dstPath = Storage.DIRECTORY; + File sdCard = android.os.Environment.getExternalStorageDirectory(); + File dstFile = new File(dstPath); + if (dstFile == null) { + Log.e(TAG, "Destination file path invalid"); + return; + } + + File srcFile = new File(jpegFilePath); + if (srcFile == null) { + Log.e(TAG, "Source file path invalid"); + return; + } + + if ( srcFile.renameTo(dstFile) ) { + Size s = mParameters.getPictureSize(); + String pictureFormat = mParameters.get(KEY_PICTURE_FORMAT); + mActivity.getMediaSaveService().addImage( + null, title, date, mLocation, s.width, s.height, + 0, null, mOnMediaSavedListener, mContentResolver, pictureFormat); + } else { + Log.e(TAG, "Failed to move jpeg file"); + } + } + } + private final class JpegPictureCallback implements CameraPictureCallback { Location mLocation; @@ -695,7 +975,15 @@ public class PhotoModule mUI.setSwipingEnabled(true); } + mReceivedSnapNum = mReceivedSnapNum + 1; mJpegPictureCallbackTime = System.currentTimeMillis(); + if(mSnapshotMode == CameraInfo.CAMERA_SUPPORT_MODE_ZSL) { + Log.v(TAG, "JpegPictureCallback : in zslmode"); + mParameters = mCameraDevice.getParameters(); + mBurstSnapNum = mParameters.getInt("num-snaps-per-shutter"); + } + Log.v(TAG, "JpegPictureCallback: Received = " + mReceivedSnapNum + + "Burst count = " + mBurstSnapNum); // If postview callback has arrived, the captured image is displayed // in postview callback. If not, the captured image is displayed in // raw picture callback. @@ -714,14 +1002,37 @@ public class PhotoModule + mPictureDisplayedToJpegCallbackTime + "ms"); mFocusManager.updateFocusUI(); // Ensure focus indicator is hidden. - if (!mIsImageCaptureIntent) { + + boolean needRestartPreview = !mIsImageCaptureIntent + && !mPreviewRestartSupport + && (mCameraState != LONGSHOT) + && (mSnapshotMode != CameraInfo.CAMERA_SUPPORT_MODE_ZSL) + && (mReceivedSnapNum == mBurstSnapNum); + if (needRestartPreview) { setupPreview(); + if (CameraUtil.FOCUS_MODE_CONTINUOUS_PICTURE.equals( + mFocusManager.getFocusMode())) { + mCameraDevice.cancelAutoFocus(); + } + }else if ((mReceivedSnapNum == mBurstSnapNum) + && (mCameraState != LONGSHOT)){ + mFocusManager.resetTouchFocus(); + if (CameraUtil.FOCUS_MODE_CONTINUOUS_PICTURE.equals( + mFocusManager.getFocusMode())) { + mCameraDevice.cancelAutoFocus(); + } + mUI.resumeFaceDetection(); + setCameraState(IDLE); } ExifInterface exif = Exif.getExif(jpegData); int orientation = Exif.getOrientation(exif); if (!mIsImageCaptureIntent) { + // Burst snapshot. Generate new image name. + if (mReceivedSnapNum > 1) + mNamedImages.nameNewImage(mCaptureStartTime); + // Calculate the width and the height of the jpeg. Size s = mParameters.getPictureSize(); int width, height; @@ -732,6 +1043,19 @@ public class PhotoModule width = s.height; height = s.width; } + + String pictureFormat = mParameters.get(KEY_PICTURE_FORMAT); + if (pictureFormat != null && !pictureFormat.equalsIgnoreCase(PIXEL_FORMAT_JPEG)) { + // overwrite width and height if raw picture + String pair = mParameters.get(KEY_QC_RAW_PICUTRE_SIZE); + if (pair != null) { + int pos = pair.indexOf('x'); + if (pos != -1) { + width = Integer.parseInt(pair.substring(0, pos)); + height = Integer.parseInt(pair.substring(pos + 1)); + } + } + } NamedEntity name = mNamedImages.getNextNameEntity(); String title = (name == null) ? null : name.title; long date = (name == null) ? -1 : name.date; @@ -762,12 +1086,22 @@ public class PhotoModule exif.setTag(directionRefTag); exif.setTag(directionTag); } + String mPictureFormat = mParameters.get(KEY_PICTURE_FORMAT); mActivity.getMediaSaveService().addImage( jpegData, title, date, mLocation, width, height, - orientation, exif, mOnMediaSavedListener, mContentResolver); + orientation, exif, mOnMediaSavedListener, mContentResolver, mPictureFormat); } // Animate capture with real jpeg data instead of a preview frame. - mUI.animateCapture(jpegData, orientation, mMirror); + if (mCameraState != LONGSHOT) { + Size pic_size = mParameters.getPictureSize(); + if ((pic_size.width <= 352) && (pic_size.height<= 288)) { + mUI.setDownFactor(2); //Downsample by 2 for CIF & below + } + else { + mUI.setDownFactor(4); + } + mUI.animateCapture(jpegData, orientation, mMirror); + } } else { mJpegImageData = jpegData; if (!mQuickCapture) { @@ -787,10 +1121,69 @@ public class PhotoModule mJpegCallbackFinishTime = now - mJpegPictureCallbackTime; Log.v(TAG, "mJpegCallbackFinishTime = " + mJpegCallbackFinishTime + "ms"); - mJpegPictureCallbackTime = 0; + + if (mReceivedSnapNum == mBurstSnapNum) + mJpegPictureCallbackTime = 0; + + if (mHiston && (mSnapshotMode ==CameraInfo.CAMERA_SUPPORT_MODE_ZSL)) { + mActivity.runOnUiThread(new Runnable() { + public void run() { + if (mGraphView != null) { + mGraphView.setVisibility(View.VISIBLE); + mGraphView.PreviewChanged(); + } + } + }); + } + if (mSnapshotMode == CameraInfo.CAMERA_SUPPORT_MODE_ZSL && + mCameraState != LONGSHOT && + mReceivedSnapNum == mBurstSnapNum) { + cancelAutoFocus(); + } } } + private OnSeekBarChangeListener mSeekListener = new OnSeekBarChangeListener() { + public void onStartTrackingTouch(SeekBar bar) { + // no support + } + public void onProgressChanged(SeekBar bar, int progress, boolean fromtouch) { + } + public void onStopTrackingTouch(SeekBar bar) { + } + }; + + private OnSeekBarChangeListener mskinToneSeekListener = new OnSeekBarChangeListener() { + public void onStartTrackingTouch(SeekBar bar) { + // no support + } + public void onProgressChanged(SeekBar bar, int progress, boolean fromtouch) { + int value = (progress + MIN_SCE_FACTOR) * SCE_FACTOR_STEP; + if(progress > (MAX_SCE_FACTOR - MIN_SCE_FACTOR)/2){ + RightValue.setText(String.valueOf(value)); + LeftValue.setText(""); + } else if (progress < (MAX_SCE_FACTOR - MIN_SCE_FACTOR)/2){ + LeftValue.setText(String.valueOf(value)); + RightValue.setText(""); + } else { + LeftValue.setText(""); + RightValue.setText(""); + } + if (value != mskinToneValue && mCameraDevice != null) { + mskinToneValue = value; + Message msg = mHandler.obtainMessage(CONFIGURE_SKIN_TONE_FACTOR, mskinToneValue, 0); + mHandler.sendMessage(msg); + } + } + + public void onStopTrackingTouch(SeekBar bar) { + Log.v(TAG, "Set onStopTrackingTouch mskinToneValue = " + mskinToneValue); + Editor editor = mPreferences.edit(); + editor.putString(CameraSettings.KEY_SKIN_TONE_ENHANCEMENT_FACTOR, + Integer.toString(mskinToneValue)); + editor.apply(); + } + }; private final class AutoFocusCallback implements CameraAFCallback { @Override public void onAutoFocus( @@ -799,7 +1192,16 @@ public class PhotoModule mAutoFocusTime = System.currentTimeMillis() - mFocusStartTime; Log.v(TAG, "mAutoFocusTime = " + mAutoFocusTime + "ms"); - setCameraState(IDLE); + //don't reset the camera state while capture is in progress + //otherwise, it might result in another takepicture + switch (mCameraState) { + case PhotoController.LONGSHOT: + case SNAPSHOT_IN_PROGRESS: + break; + default: + setCameraState(IDLE); + break; + } mFocusManager.onAutoFocus(focused, mUI.isShutterPressed()); } } @@ -851,6 +1253,7 @@ public class PhotoModule switch (state) { case PhotoController.PREVIEW_STOPPED: case PhotoController.SNAPSHOT_IN_PROGRESS: + case PhotoController.LONGSHOT: case PhotoController.SWITCHING_CAMERA: mUI.enableGestures(false); break; @@ -884,6 +1287,18 @@ public class PhotoModule mJpegImageData = null; final boolean animateBefore = (mSceneMode == CameraUtil.SCENE_MODE_HDR); + if(mHiston) { + if (mSnapshotMode != CameraInfo.CAMERA_SUPPORT_MODE_ZSL) { + mHiston = false; + mCameraDevice.setHistogramMode(null); + } + mActivity.runOnUiThread(new Runnable() { + public void run() { + if(mGraphView != null) + mGraphView.setVisibility(View.INVISIBLE); + } + }); + } if (animateBefore) { animateAfterShutter(); @@ -900,22 +1315,55 @@ public class PhotoModule } mJpegRotation = CameraUtil.getJpegRotation(mCameraId, orientation); mParameters.setRotation(mJpegRotation); - Location loc = mLocationManager.getCurrentLocation(); + String pictureFormat = mParameters.get(KEY_PICTURE_FORMAT); + Location loc = null; + if (pictureFormat != null && + PIXEL_FORMAT_JPEG.equalsIgnoreCase(pictureFormat)) { + loc = mLocationManager.getCurrentLocation(); + } CameraUtil.setGpsParameters(mParameters, loc); mCameraDevice.setParameters(mParameters); + mParameters = mCameraDevice.getParameters(); + + mBurstSnapNum = mParameters.getInt("num-snaps-per-shutter"); + mReceivedSnapNum = 0; + mPreviewRestartSupport = SystemProperties.getBoolean( + PERSIST_PREVIEW_RESTART, false); + mPreviewRestartSupport &= CameraSettings.isInternalPreviewSupported( + mParameters); + mPreviewRestartSupport &= (mBurstSnapNum == 1); + mPreviewRestartSupport &= PIXEL_FORMAT_JPEG.equalsIgnoreCase( + pictureFormat); // We don't want user to press the button again while taking a // multi-second HDR photo. mUI.enableShutter(false); - mCameraDevice.takePicture(mHandler, - new ShutterCallback(!animateBefore), - mRawPictureCallback, mPostViewPictureCallback, - new JpegPictureCallback(loc)); + + if (mCameraState == LONGSHOT) { + if(mLongshotSave) { + mCameraDevice.takePicture(mHandler, + new LongshotShutterCallback(), + mRawPictureCallback, mPostViewPictureCallback, + new LongshotPictureCallback(loc)); + } else { + mCameraDevice.takePicture(mHandler, + new LongshotShutterCallback(), + mRawPictureCallback, mPostViewPictureCallback, + new JpegPictureCallback(loc)); + } + } else { + mCameraDevice.takePicture(mHandler, + new ShutterCallback(!animateBefore), + mRawPictureCallback, mPostViewPictureCallback, + new JpegPictureCallback(loc)); + setCameraState(SNAPSHOT_IN_PROGRESS); + } mNamedImages.nameNewImage(mCaptureStartTime); - mFaceDetectionStarted = false; - setCameraState(SNAPSHOT_IN_PROGRESS); + if (mSnapshotMode != CameraInfo.CAMERA_SUPPORT_MODE_ZSL) { + mFaceDetectionStarted = false; + } UsageStatistics.onEvent(UsageStatistics.COMPONENT_CAMERA, UsageStatistics.ACTION_CAPTURE_DONE, "Photo", 0, UsageStatistics.hashFileName(mNamedImages.mQueue.lastElement().title + ".jpg")); @@ -938,29 +1386,168 @@ public class PhotoModule } } - private void updateSceneMode() { - // If scene mode is set, we cannot set flash mode, white balance, and - // focus mode, instead, we read it from driver + private void updateCameraSettings() { + String sceneMode = null; + String flashMode = null; + String redeyeReduction = null; + String aeBracketing = null; + String focusMode = null; + String colorEffect = null; + String exposureCompensation = null; + String touchAfAec = null; + + String ubiFocusOn = mActivity.getString(R.string. + pref_camera_advanced_feature_value_ubifocus_on); + String continuousShotOn = + mActivity.getString(R.string.setting_on_value); + String chromaFlashOn = mActivity.getString(R.string. + pref_camera_advanced_feature_value_chromaflash_on); + String optiZoomOn = mActivity.getString(R.string. + pref_camera_advanced_feature_value_optizoom_on); + String optiZoom = + mParameters.get(CameraSettings.KEY_QC_OPTI_ZOOM); + String chromaFlash = + mParameters.get(CameraSettings.KEY_QC_CHROMA_FLASH); + String ubiFocus = + mParameters.get(CameraSettings.KEY_QC_AF_BRACKETING); + String continuousShot = + mParameters.get("long-shot"); + + if ((continuousShot != null) && continuousShot.equals(continuousShotOn)) { + String pictureFormat = mActivity.getString(R.string. + pref_camera_picture_format_value_jpeg); + mUI.overrideSettings(CameraSettings.KEY_PICTURE_FORMAT, pictureFormat); + } else { + mUI.overrideSettings(CameraSettings.KEY_PICTURE_FORMAT, null); + } + if ((ubiFocus != null && ubiFocus.equals(ubiFocusOn)) || + (chromaFlash != null && chromaFlash.equals(chromaFlashOn)) || + (optiZoom != null && optiZoom.equals(optiZoomOn))) { + mSceneMode = sceneMode = Parameters.SCENE_MODE_AUTO; + flashMode = Parameters.FLASH_MODE_OFF; + focusMode = Parameters.FOCUS_MODE_INFINITY; + redeyeReduction = mActivity.getString(R.string. + pref_camera_redeyereduction_entry_disable); + aeBracketing = mActivity.getString(R.string. + pref_camera_ae_bracket_hdr_entry_off); + colorEffect = mActivity.getString(R.string. + pref_camera_coloreffect_default); + exposureCompensation = CameraSettings.EXPOSURE_DEFAULT_VALUE; + + overrideCameraSettings(flashMode, null, focusMode, + exposureCompensation, touchAfAec, null, + null, null, null, colorEffect, + sceneMode, redeyeReduction, aeBracketing); + } + + // If scene mode is set, for flash mode, white balance and focus mode + // read settings from preferences so we retain user preferences. if (!Parameters.SCENE_MODE_AUTO.equals(mSceneMode)) { - overrideCameraSettings(mParameters.getFlashMode(), - mParameters.getWhiteBalance(), mParameters.getFocusMode()); + flashMode = mPreferences.getString( + CameraSettings.KEY_FLASH_MODE, + mActivity.getString(R.string.pref_camera_flashmode_default)); + String whiteBalance = mPreferences.getString( + CameraSettings.KEY_WHITE_BALANCE, + mActivity.getString(R.string.pref_camera_whitebalance_default)); + focusMode = mFocusManager.getFocusMode(); + colorEffect = mParameters.getColorEffect(); + exposureCompensation = + Integer.toString(mParameters.getExposureCompensation()); + touchAfAec = mCurrTouchAfAec; + + overrideCameraSettings(flashMode, whiteBalance, focusMode, + exposureCompensation, touchAfAec, + mParameters.getAutoExposure(), + Integer.toString(mParameters.getSaturation()), + Integer.toString(mParameters.getContrast()), + Integer.toString(mParameters.getSharpness()), + colorEffect, + sceneMode, redeyeReduction, aeBracketing); + if (CameraUtil.SCENE_MODE_HDR.equals(mSceneMode)) { + mUI.overrideSettings(CameraSettings.KEY_LONGSHOT, + mActivity.getString(R.string.setting_off_value)); + } + } else if (mFocusManager.isZslEnabled()) { + focusMode = mParameters.getFocusMode(); + overrideCameraSettings(flashMode, null, focusMode, + exposureCompensation, touchAfAec, null, + null, null, null, colorEffect, + sceneMode, redeyeReduction, aeBracketing); } else { - overrideCameraSettings(null, null, null); + overrideCameraSettings(flashMode, null, focusMode, + exposureCompensation, touchAfAec, null, + null, null, null, colorEffect, + sceneMode, redeyeReduction, aeBracketing); + } + /* Disable focus if aebracket is ON */ + String aeBracket = mParameters.get(CameraSettings.KEY_QC_AE_BRACKETING); + if (!aeBracket.equalsIgnoreCase("off")) { + String fMode = Parameters.FLASH_MODE_OFF; + mUI.overrideSettings(CameraSettings.KEY_FLASH_MODE, fMode); + mParameters.setFlashMode(fMode); + } + if (Parameters.SCENE_MODE_AUTO.equals(mSceneMode)) { + mUI.overrideSettings(CameraSettings.KEY_LONGSHOT, null); } } private void overrideCameraSettings(final String flashMode, - final String whiteBalance, final String focusMode) { + final String whiteBalance, final String focusMode, + final String exposureMode, final String touchMode, + final String autoExposure, final String saturation, + final String contrast, final String sharpness, + final String coloreffect, final String sceneMode, + final String redeyeReduction, final String aeBracketing) { mUI.overrideSettings( CameraSettings.KEY_FLASH_MODE, flashMode, CameraSettings.KEY_WHITE_BALANCE, whiteBalance, - CameraSettings.KEY_FOCUS_MODE, focusMode); + CameraSettings.KEY_FOCUS_MODE, focusMode, + CameraSettings.KEY_EXPOSURE, exposureMode, + CameraSettings.KEY_TOUCH_AF_AEC, touchMode, + CameraSettings.KEY_AUTOEXPOSURE, autoExposure, + CameraSettings.KEY_SATURATION, saturation, + CameraSettings.KEY_CONTRAST, contrast, + CameraSettings.KEY_SHARPNESS, sharpness, + CameraSettings.KEY_COLOR_EFFECT, coloreffect, + CameraSettings.KEY_SCENE_MODE, sceneMode, + CameraSettings.KEY_REDEYE_REDUCTION, redeyeReduction, + CameraSettings.KEY_AE_BRACKET_HDR, aeBracketing); } private void loadCameraPreferences() { CameraSettings settings = new CameraSettings(mActivity, mInitialParams, mCameraId, CameraHolder.instance().getCameraInfo()); mPreferenceGroup = settings.getPreferenceGroup(R.xml.camera_preferences); + + int numOfCams = Camera.getNumberOfCameras(); + int backCamId = CameraHolder.instance().getBackCameraId(); + int frontCamId = CameraHolder.instance().getFrontCameraId(); + // We need to swap the list preference contents if back camera and front camera + // IDs are not 0 and 1 respectively + if ((numOfCams == 2) && ((backCamId != CameraInfo.CAMERA_FACING_BACK) + || (frontCamId != CameraInfo.CAMERA_FACING_FRONT))) { + Log.e(TAG,"loadCameraPreferences() updating camera_id pref"); + + IconListPreference switchIconPref = + (IconListPreference)mPreferenceGroup.findPreference( + CameraSettings.KEY_CAMERA_ID); + + int[] iconIds = {R.drawable.ic_switch_front, R.drawable.ic_switch_back}; + switchIconPref.setIconIds(iconIds); + + String[] entries = {mActivity.getResources().getString( + R.string.pref_camera_id_entry_front), mActivity.getResources(). + getString(R.string.pref_camera_id_entry_back)}; + switchIconPref.setEntries(entries); + + String[] labels = {mActivity.getResources().getString( + R.string.pref_camera_id_label_front), mActivity.getResources(). + getString(R.string.pref_camera_id_label_back)}; + switchIconPref.setLabels(labels); + + int[] largeIconIds = {R.drawable.ic_switch_front, R.drawable.ic_switch_back}; + switchIconPref.setLargeIconIds(largeIconIds); + } } @Override @@ -969,13 +1556,27 @@ public class PhotoModule // the camera then point the camera to floor or sky, we still have // the correct orientation. if (orientation == OrientationEventListener.ORIENTATION_UNKNOWN) return; + int oldOrientation = mOrientation; mOrientation = CameraUtil.roundOrientation(orientation, mOrientation); + if (oldOrientation != mOrientation) { + Log.v(TAG, "onOrientationChanged, update parameters"); + if (mParameters != null && mCameraDevice != null) { + onSharedPreferenceChanged(); + } + } // Show the toast after getting the first orientation changed. if (mHandler.hasMessages(SHOW_TAP_TO_FOCUS_TOAST)) { mHandler.removeMessages(SHOW_TAP_TO_FOCUS_TOAST); showTapToFocusToast(); } + + // need to re-initialize mGraphView to show histogram on rotate + mGraphView = (GraphView)mRootView.findViewById(R.id.graph_view); + if(mGraphView != null){ + mGraphView.setPhotoModuleObject(this); + mGraphView.PreviewChanged(); + } } @Override @@ -1089,6 +1690,23 @@ public class PhotoModule || (mCameraState == SNAPSHOT_IN_PROGRESS) || (mCameraState == PREVIEW_STOPPED)) return; + synchronized(mCameraDevice) { + if (mCameraState == LONGSHOT) { + mCameraDevice.setLongshot(false); + if (!mFocusManager.isZslEnabled()) { + setupPreview(); + } else { + setCameraState(IDLE); + mFocusManager.resetTouchFocus(); + if (CameraUtil.FOCUS_MODE_CONTINUOUS_PICTURE.equals( + mFocusManager.getFocusMode())) { + mCameraDevice.cancelAutoFocus(); + } + mUI.resumeFaceDetection(); + } + } + } + // Do not do focus if there is not enough storage. if (pressed && !canTakePicture()) return; @@ -1121,6 +1739,14 @@ public class PhotoModule mUI.hideSwitcher(); mUI.setSwipingEnabled(false); } + + //Need to disable focus for ZSL mode + if(mSnapshotMode == CameraInfo.CAMERA_SUPPORT_MODE_ZSL) { + mFocusManager.setZslEnable(true); + } else { + mFocusManager.setZslEnable(false); + } + // If the user wants to do a snapshot while the previous one is still // in progress, remember the fact and do it after we finish the previous // one and re-start the preview. Snapshot in progress also includes the @@ -1146,6 +1772,9 @@ public class PhotoModule mUI.cancelCountDown(); } if (seconds > 0) { + String zsl = mPreferences.getString(CameraSettings.KEY_ZSL, + mActivity.getString(R.string.pref_camera_zsl_default)); + mUI.overrideSettings(CameraSettings.KEY_ZSL, zsl); mUI.startCountDown(seconds, playSound); } else { mSnapshotOnIdle = false; @@ -1154,6 +1783,32 @@ public class PhotoModule } @Override + public void onShutterButtonLongClick() { + // Do not take the picture if there is not enough storage. + if (mActivity.getStorageSpaceBytes() <= Storage.LOW_STORAGE_THRESHOLD_BYTES) { + Log.i(TAG, "Not enough space or storage not ready. remaining=" + + mActivity.getStorageSpaceBytes()); + return; + } + + if ((null != mCameraDevice) && ((mCameraState == IDLE) || (mCameraState == FOCUSING))) { + //Add on/off Menu for longshot + String longshot_enable = mPreferences.getString( + CameraSettings.KEY_LONGSHOT, + mActivity.getString(R.string.pref_camera_longshot_default)); + + Log.d(TAG, "longshot_enable = " + longshot_enable); + if (longshot_enable.equals("on")) { + boolean enable = SystemProperties.getBoolean(PERSIST_LONG_SAVE, false); + mLongshotSave = enable; + mCameraDevice.setLongshot(true); + setCameraState(PhotoController.LONGSHOT); + mFocusManager.doSnap(); + } + } + } + + @Override public void installIntentFilter() { // Do nothing. } @@ -1212,6 +1867,12 @@ public class PhotoModule Log.v(TAG, "On resume."); onResumeTasks(); } + mHandler.post(new Runnable(){ + @Override + public void run(){ + mActivity.updateStorageSpaceAndHint(); + } + }); } private void onResumeTasks() { @@ -1226,6 +1887,11 @@ public class PhotoModule return; } + if (mSkinToneSeekBar != true) + { + Log.v(TAG, "Send tone bar: mSkinToneSeekBar = " + mSkinToneSeekBar); + mHandler.sendEmptyMessage(SET_SKIN_TONE_FACTOR); + } // If first time initialization is not finished, put it in the // message queue. if (!mFirstTimeInitialized) { @@ -1262,6 +1928,9 @@ public class PhotoModule if (msensor != null) { mSensorManager.unregisterListener(this, msensor); } + + Log.d(TAG, "remove idle handleer in onPause"); + removeIdleHandler(); } @Override @@ -1329,6 +1998,7 @@ public class PhotoModule public void onConfigurationChanged(Configuration newConfig) { Log.v(TAG, "onConfigurationChanged"); setDisplayOrientation(); + resizeForPreviewAspectRatio(); } @Override @@ -1361,6 +2031,10 @@ public class PhotoModule } } + protected CameraManager.CameraProxy getCamera() { + return mCameraDevice; + } + private boolean canTakePicture() { return isCameraIdle() && (mActivity.getStorageSpaceBytes() > Storage.LOW_STORAGE_THRESHOLD_BYTES); } @@ -1374,9 +2048,11 @@ public class PhotoModule @Override public void cancelAutoFocus() { - mCameraDevice.cancelAutoFocus(); - setCameraState(IDLE); - setCameraParameters(UPDATE_PARAM_PREFERENCE); + if (null != mCameraDevice ) { + mCameraDevice.cancelAutoFocus(); + setCameraState(IDLE); + setCameraParameters(UPDATE_PARAM_PREFERENCE); + } } // Preview area is touched. Handle touch focus. @@ -1388,7 +2064,10 @@ public class PhotoModule || mCameraState == PREVIEW_STOPPED) { return; } - + //If Touch AF/AEC is disabled in UI, return + if(this.mTouchAfAecFlag == false) { + return; + } // Check if metering area or focus area is supported. if (!mFocusAreaSupported && !mMeteringAreaSupported) return; mFocusManager.onSingleTapUp(x, y); @@ -1417,6 +2096,40 @@ public class PhotoModule onShutterButtonClick(); } return true; + case KeyEvent.KEYCODE_DPAD_LEFT: + if ( (mCameraState != PREVIEW_STOPPED) && + (mFocusManager.getCurrentFocusState() != mFocusManager.STATE_FOCUSING) && + (mFocusManager.getCurrentFocusState() != mFocusManager.STATE_FOCUSING_SNAP_ON_FINISH) ) { + if (mbrightness > MINIMUM_BRIGHTNESS) { + mbrightness-=mbrightness_step; + synchronized (mCameraDevice) { + /* Set the "luma-adaptation" parameter */ + mParameters = mCameraDevice.getParameters(); + mParameters.set("luma-adaptation", String.valueOf(mbrightness)); + mCameraDevice.setParameters(mParameters); + } + } + brightnessProgressBar.setProgress(mbrightness); + brightnessProgressBar.setVisibility(View.VISIBLE); + } + break; + case KeyEvent.KEYCODE_DPAD_RIGHT: + if ( (mCameraState != PREVIEW_STOPPED) && + (mFocusManager.getCurrentFocusState() != mFocusManager.STATE_FOCUSING) && + (mFocusManager.getCurrentFocusState() != mFocusManager.STATE_FOCUSING_SNAP_ON_FINISH) ) { + if (mbrightness < MAXIMUM_BRIGHTNESS) { + mbrightness+=mbrightness_step; + synchronized (mCameraDevice) { + /* Set the "luma-adaptation" parameter */ + mParameters = mCameraDevice.getParameters(); + mParameters.set("luma-adaptation", String.valueOf(mbrightness)); + mCameraDevice.setParameters(mParameters); + } + } + brightnessProgressBar.setProgress(mbrightness); + brightnessProgressBar.setVisibility(View.VISIBLE); + } + break; case KeyEvent.KEYCODE_DPAD_CENTER: // If we get a dpad center event without any focused view, move // the focus to the shutter button and press it. @@ -1547,7 +2260,6 @@ public class PhotoModule if (mCameraDevice != null && mCameraState != PREVIEW_STOPPED) { Log.v(TAG, "stopPreview"); mCameraDevice.stopPreview(); - mFaceDetectionStarted = false; } setCameraState(PREVIEW_STOPPED); if (mFocusManager != null) mFocusManager.onPreviewStopped(); @@ -1577,10 +2289,402 @@ public class PhotoModule private void updateCameraParametersZoom() { // Set zoom. if (mParameters.isZoomSupported()) { + Parameters p = mCameraDevice.getParameters(); + mZoomValue = p.getZoom(); mParameters.setZoom(mZoomValue); } } + private boolean needRestart() { + mRestartPreview = false; + String zsl = mPreferences.getString(CameraSettings.KEY_ZSL, + mActivity.getString(R.string.pref_camera_zsl_default)); + if(zsl.equals("on") && mSnapshotMode != CameraInfo.CAMERA_SUPPORT_MODE_ZSL + && mCameraState != PREVIEW_STOPPED) { + //Switch on ZSL Camera mode + Log.v(TAG, "Switching to ZSL Camera Mode. Restart Preview"); + mRestartPreview = true; + return mRestartPreview; + } + if(zsl.equals("off") && mSnapshotMode != CameraInfo.CAMERA_SUPPORT_MODE_NONZSL + && mCameraState != PREVIEW_STOPPED) { + //Switch on Normal Camera mode + Log.v(TAG, "Switching to Normal Camera Mode. Restart Preview"); + mRestartPreview = true; + return mRestartPreview; + } + return mRestartPreview; + } + + private void qcomUpdateAdvancedFeatures(String ubiFocus, + String chromaFlash, + String optiZoom) { + if (CameraUtil.isSupported(ubiFocus, + CameraSettings.getSupportedAFBracketingModes(mParameters))) { + mParameters.set(CameraSettings.KEY_QC_AF_BRACKETING, ubiFocus); + } + if (CameraUtil.isSupported(chromaFlash, + CameraSettings.getSupportedChromaFlashModes(mParameters))) { + mParameters.set(CameraSettings.KEY_QC_CHROMA_FLASH, chromaFlash); + } + if (CameraUtil.isSupported(optiZoom, + CameraSettings.getSupportedOptiZoomModes(mParameters))) { + mParameters.set(CameraSettings.KEY_QC_OPTI_ZOOM, optiZoom); + } + } + private void qcomUpdateCameraParametersPreference() { + //qcom Related Parameter update + //Set Brightness. + mParameters.set("luma-adaptation", String.valueOf(mbrightness)); + + String longshot_enable = mPreferences.getString( + CameraSettings.KEY_LONGSHOT, + mActivity.getString(R.string.pref_camera_longshot_default)); + mParameters.set("long-shot", longshot_enable); + + if (Parameters.SCENE_MODE_AUTO.equals(mSceneMode) || + CameraUtil.SCENE_MODE_HDR.equals(mSceneMode)) { + // Set Touch AF/AEC parameter. + String touchAfAec = mPreferences.getString( + CameraSettings.KEY_TOUCH_AF_AEC, + mActivity.getString(R.string.pref_camera_touchafaec_default)); + if (CameraUtil.isSupported(touchAfAec, mParameters.getSupportedTouchAfAec())) { + mCurrTouchAfAec = touchAfAec; + mParameters.setTouchAfAec(touchAfAec); + } + } else { + mParameters.setTouchAfAec(mParameters.TOUCH_AF_AEC_OFF); + mFocusManager.resetTouchFocus(); + } + try { + if(mParameters.getTouchAfAec().equals(mParameters.TOUCH_AF_AEC_ON)) + this.mTouchAfAecFlag = true; + else + this.mTouchAfAecFlag = false; + } catch(Exception e){ + Log.e(TAG, "Handled NULL pointer Exception"); + } + + // Set Picture Format + // Picture Formats specified in UI should be consistent with + // PIXEL_FORMAT_JPEG and PIXEL_FORMAT_RAW constants + String pictureFormat = mPreferences.getString( + CameraSettings.KEY_PICTURE_FORMAT, + mActivity.getString(R.string.pref_camera_picture_format_default)); + + //Change picture format to JPEG if camera is start from other APK by intent. + if (mIsImageCaptureIntent && !pictureFormat.equals(PIXEL_FORMAT_JPEG)) { + pictureFormat = PIXEL_FORMAT_JPEG; + Editor editor = mPreferences.edit(); + editor.putString(CameraSettings.KEY_PICTURE_FORMAT, + mActivity.getString(R.string.pref_camera_picture_format_value_jpeg)); + editor.apply(); + } + Log.v(TAG, "Picture format value =" + pictureFormat); + mParameters.set(KEY_PICTURE_FORMAT, pictureFormat); + + // Set JPEG quality. + String jpegQuality = mPreferences.getString( + CameraSettings.KEY_JPEG_QUALITY, + mActivity.getString(R.string.pref_camera_jpegquality_default)); + //mUnsupportedJpegQuality = false; + Size pic_size = mParameters.getPictureSize(); + if (pic_size == null) { + Log.e(TAG, "error getPictureSize: size is null"); + } + else{ + if("100".equals(jpegQuality) && (pic_size.width >= 3200)){ + //mUnsupportedJpegQuality = true; + }else { + mParameters.setJpegQuality(JpegEncodingQualityMappings.getQualityNumber(jpegQuality)); + } + } + + // Set Selectable Zone Af parameter. + String selectableZoneAf = mPreferences.getString( + CameraSettings.KEY_SELECTABLE_ZONE_AF, + mActivity.getString(R.string.pref_camera_selectablezoneaf_default)); + List<String> str = mParameters.getSupportedSelectableZoneAf(); + if (CameraUtil.isSupported(selectableZoneAf, mParameters.getSupportedSelectableZoneAf())) { + mParameters.setSelectableZoneAf(selectableZoneAf); + } + + // Set wavelet denoise mode + if (mParameters.getSupportedDenoiseModes() != null) { + String Denoise = mPreferences.getString( CameraSettings.KEY_DENOISE, + mActivity.getString(R.string.pref_camera_denoise_default)); + mParameters.setDenoise(Denoise); + } + // Set Redeye Reduction + String redeyeReduction = mPreferences.getString( + CameraSettings.KEY_REDEYE_REDUCTION, + mActivity.getString(R.string.pref_camera_redeyereduction_default)); + if (CameraUtil.isSupported(redeyeReduction, + mParameters.getSupportedRedeyeReductionModes())) { + mParameters.setRedeyeReductionMode(redeyeReduction); + } + // Set ISO parameter + String iso = mPreferences.getString( + CameraSettings.KEY_ISO, + mActivity.getString(R.string.pref_camera_iso_default)); + if (CameraUtil.isSupported(iso, + mParameters.getSupportedIsoValues())) { + mParameters.setISOValue(iso); + } + // Set color effect parameter. + String colorEffect = mPreferences.getString( + CameraSettings.KEY_COLOR_EFFECT, + mActivity.getString(R.string.pref_camera_coloreffect_default)); + Log.v(TAG, "Color effect value =" + colorEffect); + if (CameraUtil.isSupported(colorEffect, mParameters.getSupportedColorEffects())) { + mParameters.setColorEffect(colorEffect); + } + //Set Saturation + String saturationStr = mPreferences.getString( + CameraSettings.KEY_SATURATION, + mActivity.getString(R.string.pref_camera_saturation_default)); + int saturation = Integer.parseInt(saturationStr); + Log.v(TAG, "Saturation value =" + saturation); + if((0 <= saturation) && (saturation <= mParameters.getMaxSaturation())){ + mParameters.setSaturation(saturation); + } + // Set contrast parameter. + String contrastStr = mPreferences.getString( + CameraSettings.KEY_CONTRAST, + mActivity.getString(R.string.pref_camera_contrast_default)); + int contrast = Integer.parseInt(contrastStr); + Log.v(TAG, "Contrast value =" +contrast); + if((0 <= contrast) && (contrast <= mParameters.getMaxContrast())){ + mParameters.setContrast(contrast); + } + // Set sharpness parameter + String sharpnessStr = mPreferences.getString( + CameraSettings.KEY_SHARPNESS, + mActivity.getString(R.string.pref_camera_sharpness_default)); + int sharpness = Integer.parseInt(sharpnessStr) * + (mParameters.getMaxSharpness()/MAX_SHARPNESS_LEVEL); + Log.v(TAG, "Sharpness value =" + sharpness); + if((0 <= sharpness) && (sharpness <= mParameters.getMaxSharpness())){ + mParameters.setSharpness(sharpness); + } + // Set Face Recognition + String faceRC = mPreferences.getString( + CameraSettings.KEY_FACE_RECOGNITION, + mActivity.getString(R.string.pref_camera_facerc_default)); + Log.v(TAG, "Face Recognition value = " + faceRC); + if (CameraUtil.isSupported(faceRC, + CameraSettings.getSupportedFaceRecognitionModes(mParameters))) { + mParameters.set(CameraSettings.KEY_QC_FACE_RECOGNITION, faceRC); + } + // Set AE Bracketing + String aeBracketing = mPreferences.getString( + CameraSettings.KEY_AE_BRACKET_HDR, + mActivity.getString(R.string.pref_camera_ae_bracket_hdr_default)); + Log.v(TAG, "AE Bracketing value =" + aeBracketing); + if (CameraUtil.isSupported(aeBracketing, + CameraSettings.getSupportedAEBracketingModes(mParameters))) { + mParameters.set(CameraSettings.KEY_QC_AE_BRACKETING, aeBracketing); + } + // Set Advanced features. + String advancedFeature = mPreferences.getString( + CameraSettings.KEY_ADVANCED_FEATURES, + mActivity.getString(R.string.pref_camera_advanced_feature_default)); + Log.v(TAG, " advancedFeature value =" + advancedFeature); + + if(advancedFeature != null) { + String ubiFocusOff = mActivity.getString(R.string. + pref_camera_advanced_feature_value_ubifocus_off); + String chromaFlashOff = mActivity.getString(R.string. + pref_camera_advanced_feature_value_chromaflash_off); + String optiZoomOff = mActivity.getString(R.string. + pref_camera_advanced_feature_value_optizoom_off); + + if (advancedFeature.equals(mActivity.getString(R.string. + pref_camera_advanced_feature_value_ubifocus_on))) { + qcomUpdateAdvancedFeatures(advancedFeature, + chromaFlashOff, + optiZoomOff); + } else if (advancedFeature.equals(mActivity.getString(R.string. + pref_camera_advanced_feature_value_chromaflash_on))) { + qcomUpdateAdvancedFeatures(ubiFocusOff, + advancedFeature, + optiZoomOff); + } else if (advancedFeature.equals(mActivity.getString(R.string. + pref_camera_advanced_feature_value_optizoom_on))) { + qcomUpdateAdvancedFeatures(ubiFocusOff, + chromaFlashOff, + advancedFeature); + } else { + qcomUpdateAdvancedFeatures(ubiFocusOff, + chromaFlashOff, + optiZoomOff); + } + } + // Set auto exposure parameter. + String autoExposure = mPreferences.getString( + CameraSettings.KEY_AUTOEXPOSURE, + mActivity.getString(R.string.pref_camera_autoexposure_default)); + Log.v(TAG, "autoExposure value =" + autoExposure); + if (CameraUtil.isSupported(autoExposure, mParameters.getSupportedAutoexposure())) { + mParameters.setAutoExposure(autoExposure); + } + + // Set anti banding parameter. + String antiBanding = mPreferences.getString( + CameraSettings.KEY_ANTIBANDING, + mActivity.getString(R.string.pref_camera_antibanding_default)); + Log.v(TAG, "antiBanding value =" + antiBanding); + if (CameraUtil.isSupported(antiBanding, mParameters.getSupportedAntibanding())) { + mParameters.setAntibanding(antiBanding); + } + + String zsl = mPreferences.getString(CameraSettings.KEY_ZSL, + mActivity.getString(R.string.pref_camera_zsl_default)); + mParameters.setZSLMode(zsl); + if(zsl.equals("on")) { + //Switch on ZSL Camera mode + mSnapshotMode = CameraInfo.CAMERA_SUPPORT_MODE_ZSL; + mParameters.setCameraMode(1); + mFocusManager.setZslEnable(true); + + //Raw picture format is not supported under ZSL mode + mParameters.set(KEY_PICTURE_FORMAT, PIXEL_FORMAT_JPEG); + Editor editor = mPreferences.edit(); + editor.putString(CameraSettings.KEY_PICTURE_FORMAT, mActivity.getString(R.string.pref_camera_picture_format_value_jpeg)); + editor.apply(); + mUI.overrideSettings(CameraSettings.KEY_PICTURE_FORMAT, mActivity.getString(R.string.pref_camera_picture_format_entry_jpeg)); + + //Try to set CAF for ZSL + if(CameraUtil.isSupported(Parameters.FOCUS_MODE_CONTINUOUS_PICTURE, + mParameters.getSupportedFocusModes()) && !mFocusManager.isTouch()) { + mFocusManager.overrideFocusMode(Parameters.FOCUS_MODE_CONTINUOUS_PICTURE); + mParameters.setFocusMode(Parameters.FOCUS_MODE_CONTINUOUS_PICTURE); + } else if (mFocusManager.isTouch()) { + mFocusManager.overrideFocusMode(null); + mParameters.setFocusMode(mFocusManager.getFocusMode()); + } else { + // If not supported use the current mode + mFocusManager.overrideFocusMode(mFocusManager.getFocusMode()); + } + + if(!pictureFormat.equals(PIXEL_FORMAT_JPEG)) { + mActivity.runOnUiThread(new Runnable() { + public void run() { + Toast.makeText(mActivity, R.string.error_app_unsupported_raw, + Toast.LENGTH_SHORT).show(); + } + }); + } + } else if(zsl.equals("off")) { + mSnapshotMode = CameraInfo.CAMERA_SUPPORT_MODE_NONZSL; + mParameters.setCameraMode(0); + mFocusManager.setZslEnable(false); + mFocusManager.overrideFocusMode(null); + mParameters.setFocusMode(mFocusManager.getFocusMode()); + } + // Set face detetction parameter. + String faceDetection = mPreferences.getString( + CameraSettings.KEY_FACE_DETECTION, + mActivity.getString(R.string.pref_camera_facedetection_default)); + if (CameraUtil.isSupported(faceDetection, mParameters.getSupportedFaceDetectionModes())) { + mParameters.setFaceDetectionMode(faceDetection); + if(faceDetection.equals("on") && mFaceDetectionEnabled == false) { + mFaceDetectionEnabled = true; + startFaceDetection(); + } + if(faceDetection.equals("off") && mFaceDetectionEnabled == true) { + stopFaceDetection(); + mFaceDetectionEnabled = false; + } + } + // skin tone ie enabled only for auto,party and portrait BSM + // when color effects are not enabled + if((Parameters.SCENE_MODE_PARTY.equals(mSceneMode) || + Parameters.SCENE_MODE_PORTRAIT.equals(mSceneMode)) && + (Parameters.EFFECT_NONE.equals(colorEffect))) { + //Set Skin Tone Correction factor + Log.v(TAG, "set tone bar: mSceneMode = " + mSceneMode); + if(mSeekBarInitialized == true) + mHandler.sendEmptyMessage(SET_SKIN_TONE_FACTOR); + } + + //Set Histogram + String histogram = mPreferences.getString( + CameraSettings.KEY_HISTOGRAM, + mActivity.getString(R.string.pref_camera_histogram_default)); + if (CameraUtil.isSupported(histogram, + mParameters.getSupportedHistogramModes()) && mCameraDevice != null) { + // Call for histogram + if(histogram.equals("enable")) { + mActivity.runOnUiThread(new Runnable() { + public void run() { + if(mGraphView != null) { + mGraphView.setVisibility(View.VISIBLE); + mGraphView.PreviewChanged(); + } + } + }); + mCameraDevice.setHistogramMode(mStatsCallback); + mHiston = true; + } else { + mHiston = false; + mActivity.runOnUiThread(new Runnable() { + public void run() { + if (mGraphView != null) + mGraphView.setVisibility(View.INVISIBLE); + } + }); + mCameraDevice.setHistogramMode(null); + } + } + // Read Flip mode from adb command + //value: 0(default) - FLIP_MODE_OFF + //value: 1 - FLIP_MODE_H + //value: 2 - FLIP_MODE_V + //value: 3 - FLIP_MODE_VH + int preview_flip_value = SystemProperties.getInt("debug.camera.preview.flip", 0); + int video_flip_value = SystemProperties.getInt("debug.camera.video.flip", 0); + int picture_flip_value = SystemProperties.getInt("debug.camera.picture.flip", 0); + int rotation = CameraUtil.getJpegRotation(mCameraId, mOrientation); + mParameters.setRotation(rotation); + if (rotation == 90 || rotation == 270) { + // in case of 90 or 270 degree, V/H flip should reverse + if (preview_flip_value == 1) { + preview_flip_value = 2; + } else if (preview_flip_value == 2) { + preview_flip_value = 1; + } + if (video_flip_value == 1) { + video_flip_value = 2; + } else if (video_flip_value == 2) { + video_flip_value = 1; + } + if (picture_flip_value == 1) { + picture_flip_value = 2; + } else if (picture_flip_value == 2) { + picture_flip_value = 1; + } + } + String preview_flip = CameraUtil.getFilpModeString(preview_flip_value); + String video_flip = CameraUtil.getFilpModeString(video_flip_value); + String picture_flip = CameraUtil.getFilpModeString(picture_flip_value); + if(CameraUtil.isSupported(preview_flip, CameraSettings.getSupportedFlipMode(mParameters))){ + mParameters.set(CameraSettings.KEY_QC_PREVIEW_FLIP, preview_flip); + } + if(CameraUtil.isSupported(video_flip, CameraSettings.getSupportedFlipMode(mParameters))){ + mParameters.set(CameraSettings.KEY_QC_VIDEO_FLIP, video_flip); + } + if(CameraUtil.isSupported(picture_flip, CameraSettings.getSupportedFlipMode(mParameters))){ + mParameters.set(CameraSettings.KEY_QC_SNAPSHOT_PICTURE_FLIP, picture_flip); + } + /* Disable focus if aebracket is ON */ + String aeBracket = mParameters.get(CameraSettings.KEY_QC_AE_BRACKETING); + if (!aeBracket.equalsIgnoreCase("off")) { + String fMode = Parameters.FLASH_MODE_OFF; + mUI.overrideSettings(CameraSettings.KEY_FLASH_MODE, fMode); + mParameters.setFlashMode(fMode); + } + } @TargetApi(Build.VERSION_CODES.JELLY_BEAN) private void setAutoExposureLockIfSupported() { if (mAeLockSupported) { @@ -1623,9 +2727,19 @@ public class PhotoModule if (pictureSize == null) { CameraSettings.initialCameraPictureSize(mActivity, mParameters); } else { + Size old_size = mParameters.getPictureSize(); + Log.v(TAG, "old picture_size = " + old_size.width + " x " + old_size.height); List<Size> supported = mParameters.getSupportedPictureSizes(); CameraSettings.setCameraPictureSize( pictureSize, supported, mParameters); + Size size = mParameters.getPictureSize(); + Log.v(TAG, "new picture_size = " + size.width + " x " + size.height); + if (old_size != null && size != null) { + if(!size.equals(old_size) && mCameraState != PREVIEW_STOPPED) { + Log.v(TAG, "Picture Size changed. Restart Preview"); + mRestartPreview = true; + } + } } Size size = mParameters.getPictureSize(); @@ -1647,12 +2761,10 @@ public class PhotoModule mCameraDevice.setParameters(mParameters); } mParameters = mCameraDevice.getParameters(); + Log.v(TAG, "Preview Size changed. Restart Preview"); + mRestartPreview = true; } - if(optimalSize.width != 0 && optimalSize.height != 0) { - mUI.updatePreviewAspectRatio((float) optimalSize.width - / (float) optimalSize.height); - } Log.v(TAG, "Preview size is " + optimalSize.width + "x" + optimalSize.height); // Since changing scene mode may change supported values, set scene mode @@ -1673,6 +2785,11 @@ public class PhotoModule } else { if (hdrOn) { mSceneMode = CameraUtil.SCENE_MODE_HDR; + if (!(Parameters.SCENE_MODE_AUTO).equals(mParameters.getSceneMode())) { + mParameters.setSceneMode(Parameters.SCENE_MODE_AUTO); + mCameraDevice.setParameters(mParameters); + mParameters = mCameraDevice.getParameters(); + } } else { mSceneMode = mPreferences.getString( CameraSettings.KEY_SCENE_MODE, @@ -1749,12 +2866,15 @@ public class PhotoModule mParameters.setFocusMode(mFocusManager.getFocusMode()); } else { mFocusManager.overrideFocusMode(mParameters.getFocusMode()); + if (hdrOn) + mParameters.setFlashMode(Parameters.FLASH_MODE_OFF); } if (mContinuousFocusSupported && ApiHelper.HAS_AUTO_FOCUS_MOVE_CALLBACK) { updateAutoFocusMoveCallback(); } - + //QCom related parameters updated here. + qcomUpdateCameraParametersPreference(); return doGcamModeSwitch; } @@ -1772,25 +2892,27 @@ public class PhotoModule // the subsets actually need updating. The PREFERENCE set needs extra // locking because the preference can be changed from GLThread as well. private void setCameraParameters(int updateSet) { - boolean doModeSwitch = false; + synchronized (mCameraDevice) { + boolean doModeSwitch = false; - if ((updateSet & UPDATE_PARAM_INITIALIZE) != 0) { - updateCameraParametersInitialize(); - } + if ((updateSet & UPDATE_PARAM_INITIALIZE) != 0) { + updateCameraParametersInitialize(); + } - if ((updateSet & UPDATE_PARAM_ZOOM) != 0) { - updateCameraParametersZoom(); - } + if ((updateSet & UPDATE_PARAM_ZOOM) != 0) { + updateCameraParametersZoom(); + } - if ((updateSet & UPDATE_PARAM_PREFERENCE) != 0) { - doModeSwitch = updateCameraParametersPreference(); - } + if ((updateSet & UPDATE_PARAM_PREFERENCE) != 0) { + doModeSwitch = updateCameraParametersPreference(); + } - mCameraDevice.setParameters(mParameters); + mCameraDevice.setParameters(mParameters); - // Switch to gcam module if HDR+ was selected - if (doModeSwitch && !mIsImageCaptureIntent) { - mHandler.sendEmptyMessage(SWITCH_TO_GCAM_MODULE); + // Switch to gcam module if HDR+ was selected + if (doModeSwitch && !mIsImageCaptureIntent) { + mHandler.sendEmptyMessage(SWITCH_TO_GCAM_MODULE); + } } } @@ -1805,7 +2927,15 @@ public class PhotoModule return; } else if (isCameraIdle()) { setCameraParameters(mUpdateSet); - updateSceneMode(); + if(mRestartPreview && mCameraState != PREVIEW_STOPPED) { + Log.v(TAG, "Restarting Preview..."); + stopPreview(); + resizeForPreviewAspectRatio(); + startPreview(); + setCameraState(IDLE); + } + mRestartPreview = false; + updateCameraSettings(); mUpdateSet = 0; } else { if (!mHandler.hasMessages(SET_CAMERA_PARAMETERS_WHEN_IDLE)) { @@ -1838,6 +2968,30 @@ public class PhotoModule } } + // Return true if the preference has the specified key but not the value. + private static boolean notSame(ListPreference pref, String key, String value) { + return (key.equals(pref.getKey()) && !value.equals(pref.getValue())); + } + + @Override + public void onSharedPreferenceChanged(ListPreference pref) { + // ignore the events after "onPause()" + if (mPaused) return; + + //filter off unsupported settings + final String settingOff = mActivity.getString(R.string.setting_off_value); + if (!CameraSettings.isZSLHDRSupported(mParameters)) { + if (notSame(pref, CameraSettings.KEY_CAMERA_HDR, settingOff)) { + mUI.setPreference(CameraSettings.KEY_ZSL,settingOff); + } else if (notSame(pref,CameraSettings.KEY_ZSL,settingOff)) { + mUI.setPreference(CameraSettings.KEY_CAMERA_HDR, settingOff); + } + } + + //call generic onSharedPreferenceChanged + onSharedPreferenceChanged(); + } + @Override public void onSharedPreferenceChanged() { // ignore the events after "onPause()" @@ -1846,9 +3000,44 @@ public class PhotoModule boolean recordLocation = RecordLocationPreference.get( mPreferences, mContentResolver); mLocationManager.recordLocation(recordLocation); - - setCameraParametersWhenIdle(UPDATE_PARAM_PREFERENCE); - mUI.updateOnScreenIndicators(mParameters, mPreferenceGroup, mPreferences); + if(needRestart()){ + Log.v(TAG, "Restarting Preview... Camera Mode Changhed"); + stopPreview(); + startPreview(); + setCameraState(IDLE); + mRestartPreview = false; + } + /* Check if the PhotoUI Menu is initialized or not. This + * should be initialized during onCameraOpen() which should + * have been called by now. But for some reason that is not + * executed till now, then schedule these functionality for + * later by posting a message to the handler */ + if (mUI.mMenuInitialized) { + setCameraParametersWhenIdle(UPDATE_PARAM_PREFERENCE); + mUI.updateOnScreenIndicators(mParameters, mPreferenceGroup, + mPreferences); + } else { + mHandler.sendEmptyMessage(SET_PHOTO_UI_PARAMS); + } + resizeForPreviewAspectRatio(); + if (mSeekBarInitialized == true){ + Log.v(TAG, "onSharedPreferenceChanged Skin tone bar: change"); + // skin tone is enabled only for party and portrait BSM + // when color effects are not enabled + String colorEffect = mPreferences.getString( + CameraSettings.KEY_COLOR_EFFECT, + mActivity.getString(R.string.pref_camera_coloreffect_default)); + if((Parameters.SCENE_MODE_PARTY.equals(mSceneMode) || + Parameters.SCENE_MODE_PORTRAIT.equals(mSceneMode)) && + (Parameters.EFFECT_NONE.equals(colorEffect))) { + Log.v(TAG, "Party/Portrait + No effect, SkinToneBar enabled"); + } else { + disableSkinToneSeekBar(); + } + } + Storage.setSaveSDCard( + mPreferences.getString(CameraSettings.KEY_CAMERA_SAVEPATH, "0").equals("1")); + mActivity.updateStorageSpaceAndHint(); } @Override @@ -1921,6 +3110,7 @@ public class PhotoModule mSnapshotOnIdle = false; mFocusManager.doSnap(); mFocusManager.onShutterUp(); + mUI.overrideSettings(CameraSettings.KEY_ZSL, null); } @Override @@ -1988,12 +3178,91 @@ public class PhotoModule mHeading += 360; } } - @Override public void onPreviewFocusChanged(boolean previewFocused) { mUI.onPreviewFocusChanged(previewFocused); } + // TODO: Delete this function after old camera code is removed + @Override + public void onRestorePreferencesClicked() {} + private void setSkinToneFactor() { + if(mCameraDevice == null || mParameters == null || skinToneSeekBar == null) + return; + + String skinToneEnhancementPref = "enable"; + if(CameraUtil.isSupported(skinToneEnhancementPref, + mParameters.getSupportedSkinToneEnhancementModes())) { + if(skinToneEnhancementPref.equals("enable")) { + int skinToneValue =0; + int progress; + //get the value for the first time! + if (mskinToneValue ==0) { + String factor = mPreferences.getString( + CameraSettings.KEY_SKIN_TONE_ENHANCEMENT_FACTOR, "0"); + skinToneValue = Integer.parseInt(factor); + } + + Log.v(TAG, "Skin tone bar: enable = " + mskinToneValue); + enableSkinToneSeekBar(); + //As a wrokaround set progress again to show the actually progress on screen. + if (skinToneValue != 0) { + progress = (skinToneValue/SCE_FACTOR_STEP)-MIN_SCE_FACTOR; + skinToneSeekBar.setProgress(progress); + } + } else { + Log.v(TAG, "Skin tone bar: disable"); + disableSkinToneSeekBar(); + } + } else { + Log.v(TAG, "Skin tone bar: Not supported"); + skinToneSeekBar.setVisibility(View.INVISIBLE); + } + } + private void enableSkinToneSeekBar() { + int progress; + if(brightnessProgressBar != null) + brightnessProgressBar.setVisibility(View.INVISIBLE); + skinToneSeekBar.setMax(MAX_SCE_FACTOR-MIN_SCE_FACTOR); + skinToneSeekBar.setVisibility(View.VISIBLE); + skinToneSeekBar.requestFocus(); + if (mskinToneValue != 0) { + progress = (mskinToneValue/SCE_FACTOR_STEP)-MIN_SCE_FACTOR; + mskinToneSeekListener.onProgressChanged(skinToneSeekBar, progress, false); + } else { + progress = (MAX_SCE_FACTOR-MIN_SCE_FACTOR)/2; + RightValue.setText(""); + LeftValue.setText(""); + } + skinToneSeekBar.setProgress(progress); + mActivity.findViewById(R.id.linear).bringToFront(); + skinToneSeekBar.bringToFront(); + Title.setText("Skin Tone Enhancement"); + Title.setVisibility(View.VISIBLE); + RightValue.setVisibility(View.VISIBLE); + LeftValue.setVisibility(View.VISIBLE); + mSkinToneSeekBar = true; + } + + private void disableSkinToneSeekBar() { + skinToneSeekBar.setVisibility(View.INVISIBLE); + Title.setVisibility(View.INVISIBLE); + RightValue.setVisibility(View.INVISIBLE); + LeftValue.setVisibility(View.INVISIBLE); + mskinToneValue = 0; + mSkinToneSeekBar = false; + Editor editor = mPreferences.edit(); + editor.putString(CameraSettings.KEY_SKIN_TONE_ENHANCEMENT_FACTOR, + Integer.toString(mskinToneValue - MIN_SCE_FACTOR)); + editor.apply(); + if(brightnessProgressBar != null) + brightnessProgressBar.setVisibility(View.VISIBLE); +} + +/* + * Provide a mapping for Jpeg encoding quality levels + * from String representation to numeric representation. + */ @Override public boolean arePreviewControlsVisible() { return mUI.arePreviewControlsVisible(); @@ -2019,13 +3288,141 @@ public class PhotoModule } } } +} /* Below is no longer needed, except to get rid of compile error * TODO: Remove these */ +class JpegEncodingQualityMappings { + private static final String TAG = "JpegEncodingQualityMappings"; + private static final int DEFAULT_QUALITY = 85; + private static HashMap<String, Integer> mHashMap = + new HashMap<String, Integer>(); + + static { + mHashMap.put("normal", CameraProfile.QUALITY_LOW); + mHashMap.put("fine", CameraProfile.QUALITY_MEDIUM); + mHashMap.put("superfine", CameraProfile.QUALITY_HIGH); + } + + // Retrieve and return the Jpeg encoding quality number + // for the given quality level. + public static int getQualityNumber(String jpegQuality) { + try{ + int qualityPercentile = Integer.parseInt(jpegQuality); + if(qualityPercentile >= 0 && qualityPercentile <=100) + return qualityPercentile; + else + return DEFAULT_QUALITY; + } catch(NumberFormatException nfe){ + //chosen quality is not a number, continue + } + Integer quality = mHashMap.get(jpegQuality); + if (quality == null) { + Log.w(TAG, "Unknown Jpeg quality: " + jpegQuality); + return DEFAULT_QUALITY; + } + return CameraProfile.getJpegEncodingQualityParameter(quality.intValue()); + } +} - // TODO: Delete this function after old camera code is removed +class GraphView extends View { + private Bitmap mBitmap; + private Paint mPaint = new Paint(); + private Paint mPaintRect = new Paint(); + private Canvas mCanvas = new Canvas(); + private float mScale = (float)3; + private float mWidth; + private float mHeight; + private PhotoModule mPhotoModule; + private CameraManager.CameraProxy mGraphCameraDevice; + private float scaled; + private static final int STATS_SIZE = 256; + private static final String TAG = "GraphView"; + + + public GraphView(Context context, AttributeSet attrs) { + super(context,attrs); + + mPaint.setFlags(Paint.ANTI_ALIAS_FLAG); + mPaintRect.setColor(0xFFFFFFFF); + mPaintRect.setStyle(Paint.Style.FILL); + } @Override - public void onRestorePreferencesClicked() {} + protected void onSizeChanged(int w, int h, int oldw, int oldh) { + mBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.RGB_565); + mCanvas.setBitmap(mBitmap); + mWidth = w; + mHeight = h; + super.onSizeChanged(w, h, oldw, oldh); + } + @Override + protected void onDraw(Canvas canvas) { + Log.v(TAG, "in Camera.java ondraw"); + if(mPhotoModule == null || !mPhotoModule.mHiston ) { + Log.e(TAG, "returning as histogram is off "); + return; + } + if (mBitmap != null) { + final Paint paint = mPaint; + final Canvas cavas = mCanvas; + final float border = 5; + float graphheight = mHeight - (2 * border); + float graphwidth = mWidth - (2 * border); + float left,top,right,bottom; + float bargap = 0.0f; + float barwidth = graphwidth/STATS_SIZE; + + cavas.drawColor(0xFFAAAAAA); + paint.setColor(Color.BLACK); + + for (int k = 0; k <= (graphheight /32) ; k++) { + float y = (float)(32 * k)+ border; + cavas.drawLine(border, y, graphwidth + border , y, paint); + } + for (int j = 0; j <= (graphwidth /32); j++) { + float x = (float)(32 * j)+ border; + cavas.drawLine(x, border, x, graphheight + border, paint); + } + synchronized(PhotoModule.statsdata) { + //Assumption: The first element contains + // the maximum value. + int maxValue = Integer.MIN_VALUE; + if ( 0 == PhotoModule.statsdata[0] ) { + for ( int i = 1 ; i <= STATS_SIZE ; i++ ) { + if ( maxValue < PhotoModule.statsdata[i] ) { + maxValue = PhotoModule.statsdata[i]; + } + } + } else { + maxValue = PhotoModule.statsdata[0]; + } + mScale = ( float ) maxValue; + for(int i=1 ; i<=STATS_SIZE ; i++) { + scaled = (PhotoModule.statsdata[i]/mScale)*STATS_SIZE; + if(scaled >= (float)STATS_SIZE) + scaled = (float)STATS_SIZE; + left = (bargap * (i+1)) + (barwidth * i) + border; + top = graphheight + border; + right = left + barwidth; + bottom = top - scaled; + cavas.drawRect(left, top, right, bottom, mPaintRect); + } + } + canvas.drawBitmap(mBitmap, 0, 0, null); + } + if (mPhotoModule.mHiston && mPhotoModule!= null) { + mGraphCameraDevice = mPhotoModule.getCamera(); + if (mGraphCameraDevice != null){ + mGraphCameraDevice.sendHistogramData(); + } + } + } + public void PreviewChanged() { + invalidate(); + } + public void setPhotoModuleObject(PhotoModule photoModule) { + mPhotoModule = photoModule; + } } |