diff options
author | Camera Software Integration <camswint@localhost> | 2016-11-28 22:17:41 -0800 |
---|---|---|
committer | Gerrit - the friendly Code Review server <code-review@localhost> | 2016-11-28 22:17:41 -0800 |
commit | 1ac1654e76a15b1e0a871d0942900fd8d1bf88c5 (patch) | |
tree | d1ef384067d1a462ab6eb970f3c1ee56fc098a0a /src/com/android | |
parent | 3ef3c67fb0f74c36463fc197c1c79cda46fea453 (diff) | |
parent | 70790e941a1c23dc62b2bf06236cb4d8dde2bec9 (diff) | |
download | android_packages_apps_Snap-1ac1654e76a15b1e0a871d0942900fd8d1bf88c5.tar.gz android_packages_apps_Snap-1ac1654e76a15b1e0a871d0942900fd8d1bf88c5.tar.bz2 android_packages_apps_Snap-1ac1654e76a15b1e0a871d0942900fd8d1bf88c5.zip |
Merge "SnapdragonCamera: Add ProMode" into camera.lnx.1.0-dev.1.0
Diffstat (limited to 'src/com/android')
-rw-r--r-- | src/com/android/camera/CaptureModule.java | 51 | ||||
-rw-r--r-- | src/com/android/camera/CaptureUI.java | 14 | ||||
-rw-r--r-- | src/com/android/camera/SettingsManager.java | 39 | ||||
-rw-r--r-- | src/com/android/camera/ui/OneUICameraControls.java | 160 | ||||
-rw-r--r-- | src/com/android/camera/ui/ProMode.java | 372 |
5 files changed, 615 insertions, 21 deletions
diff --git a/src/com/android/camera/CaptureModule.java b/src/com/android/camera/CaptureModule.java index 42f94b6f5..84843e382 100644 --- a/src/com/android/camera/CaptureModule.java +++ b/src/com/android/camera/CaptureModule.java @@ -193,6 +193,12 @@ public class CaptureModule implements CameraModule, PhotoController, public static CameraCharacteristics.Key<Byte> MetaDataMonoOnlyKey = new CameraCharacteristics.Key<>("org.codeaurora.qcamera3.sensor_meta_data.is_mono_only", Byte.class); + public static CaptureRequest.Key<Integer> SELECT_PRIORITY = + new CaptureRequest.Key<>("org.codeaurora.qcamera3.iso_exp_priority.select_priority", + Integer.class); + public static CaptureRequest.Key<Long> ISO_EXP = + new CaptureRequest.Key<>("org.codeaurora.qcamera3.iso_exp_priority.use_iso_exp_priority", + Long.class); private boolean[] mTakingPicture = new boolean[MAX_NUM_CAM]; private int mControlAFMode = CameraMetadata.CONTROL_AF_MODE_CONTINUOUS_PICTURE; private int mLastResultAFState = -1; @@ -781,6 +787,13 @@ public class CaptureModule implements CameraModule, PhotoController, } } + private void applyFocusDistance(CaptureRequest.Builder builder, String value) { + if (value == null) return; + float valueF = Float.valueOf(value); + builder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_OFF); + builder.set(CaptureRequest.LENS_FOCUS_DISTANCE, valueF); + } + private void createSessions() { if (mPaused || !mCamerasOpened || !mSurfaceReady) return; if (isBackCamera()) { @@ -2069,6 +2082,13 @@ public class CaptureModule implements CameraModule, PhotoController, mUI.enableShutter(true); String scene = mSettingsManager.getValue(SettingsManager.KEY_SCENE_MODE); + boolean promode = false; + if (scene != null) { + int mode = Integer.parseInt(scene); + if (mode == SettingsManager.SCENE_MODE_PROMODE_INT) promode = true; + } + mUI.initializeProMode(promode); + if(isPanoSetting(scene)) { mActivity.onModuleSelected(ModuleSwitcher.PANOCAPTURE_MODULE_INDEX); } @@ -2284,16 +2304,17 @@ public class CaptureModule implements CameraModule, PhotoController, } private boolean isTouchToFocusAllowed() { - if (isTakingPicture() || mIsRecordingVideo || isSceneModeOn()) return false; + if (isTakingPicture() || mIsRecordingVideo || isTouchAfEnabledSceneMode()) return false; return true; } - private boolean isSceneModeOn() { + private boolean isTouchAfEnabledSceneMode() { String scene = mSettingsManager.getValue(SettingsManager.KEY_SCENE_MODE); if (scene == null) return false; int mode = Integer.parseInt(scene); - if (mode != SettingsManager.SCENE_MODE_DUAL_INT && mode != CaptureRequest - .CONTROL_SCENE_MODE_DISABLED) return true; + if (mode != CaptureRequest.CONTROL_SCENE_MODE_DISABLED + && mode < SettingsManager.SCENE_MODE_CUSTOM_START) + return true; return false; } @@ -3228,6 +3249,9 @@ public class CaptureModule implements CameraModule, PhotoController, updatePreview = true; applyFaceDetection(mPreviewRequestBuilder[cameraId]); break; + case SettingsManager.KEY_FOCUS_DISTANCE: + updatePreview = true; + applyFocusDistance(mPreviewRequestBuilder[cameraId], value); } return updatePreview; } @@ -3277,8 +3301,9 @@ public class CaptureModule implements CameraModule, PhotoController, request.set(CaptureRequest.CONTROL_MODE, CaptureRequest.CONTROL_MODE_AUTO); return; } - if (mode != CaptureRequest.CONTROL_SCENE_MODE_DISABLED && mode != - SettingsManager.SCENE_MODE_DUAL_INT) { + if (mode != CaptureRequest.CONTROL_SCENE_MODE_DISABLED + && mode != SettingsManager.SCENE_MODE_DUAL_INT + && mode != SettingsManager.SCENE_MODE_PROMODE_INT) { request.set(CaptureRequest.CONTROL_SCENE_MODE, mode); request.set(CaptureRequest.CONTROL_MODE, CaptureRequest.CONTROL_MODE_USE_SCENE_MODE); } else { @@ -3296,9 +3321,14 @@ public class CaptureModule implements CameraModule, PhotoController, private void applyIso(CaptureRequest.Builder request) { String value = mSettingsManager.getValue(SettingsManager.KEY_ISO); if (value == null) return; - if (value.equals("auto")) return; - int intValue = Integer.parseInt(value); - request.set(CaptureRequest.SENSOR_SENSITIVITY, intValue); + if (value.equals("auto")) { + request.set(SELECT_PRIORITY, null); + request.set(ISO_EXP, null); + } else { + long intValue = Integer.parseInt(value); + request.set(SELECT_PRIORITY, 0); + request.set(ISO_EXP, intValue); + } } private void applyColorEffect(CaptureRequest.Builder request) { @@ -3542,6 +3572,9 @@ public class CaptureModule implements CameraModule, PhotoController, case SettingsManager.KEY_FLASH_MODE: if (count == 0) restartSession(false); return; + case SettingsManager.KEY_SCENE_MODE: + restartAll(); + return; } if (isBackCamera()) { diff --git a/src/com/android/camera/CaptureUI.java b/src/com/android/camera/CaptureUI.java index 88460b865..9b224ff81 100644 --- a/src/com/android/camera/CaptureUI.java +++ b/src/com/android/camera/CaptureUI.java @@ -184,6 +184,7 @@ public class CaptureUI implements FocusOverlayManager.FocusUI, private PauseButton mPauseButton; private RotateImageView mMuteButton; private ImageView mSeekbarToggleButton; + private View mProModeCloseButton; int mPreviewWidth; int mPreviewHeight; @@ -283,6 +284,13 @@ public class CaptureUI implements FocusOverlayManager.FocusUI, }); setMakeupButtonIcon(); mFlashButton = (FlashToggleButton) mRootView.findViewById(R.id.flash_button); + mProModeCloseButton = mRootView.findViewById(R.id.promode_close_button); + mProModeCloseButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + mSettingsManager.setValue(SettingsManager.KEY_SCENE_MODE, "" + SettingsManager.SCENE_MODE_AUTO_INT); + } + }); initFilterModeButton(); initSceneModeButton(); initSwitchCamera(); @@ -425,6 +433,12 @@ public class CaptureUI implements FocusOverlayManager.FocusUI, } } + public void initializeProMode(boolean promode) { + mCameraControls.setProMode(promode); + if (promode) mVideoButton.setVisibility(View.INVISIBLE); + else mVideoButton.setVisibility(View.VISIBLE); + } + // called from onResume but only the first time public void initializeFirstTime() { // Initialize shutter button. diff --git a/src/com/android/camera/SettingsManager.java b/src/com/android/camera/SettingsManager.java index f64d64a01..359781266 100644 --- a/src/com/android/camera/SettingsManager.java +++ b/src/com/android/camera/SettingsManager.java @@ -86,15 +86,17 @@ public class SettingsManager implements ListMenu.SettingsListener { public static final int SCENE_MODE_NIGHT_INT = 5; // Custom-Scenemodes start from 100 - public static final int SCENE_MODE_DUAL_INT = 100; - public static final int SCENE_MODE_OPTIZOOM_INT = 101; - public static final int SCENE_MODE_UBIFOCUS_INT = 102; - public static final int SCENE_MODE_BESTPICTURE_INT = 103; - public static final int SCENE_MODE_PANORAMA_INT = 104; - public static final int SCENE_MODE_CHROMAFLASH_INT = 105; - public static final int SCENE_MODE_BLURBUSTER_INT = 106; - public static final int SCENE_MODE_SHARPSHOOTER_INT = 107; - public static final int SCENE_MODE_TRACKINGFOCUS_INT = 108; + public static final int SCENE_MODE_CUSTOM_START = 100; + public static final int SCENE_MODE_DUAL_INT = SCENE_MODE_CUSTOM_START; + public static final int SCENE_MODE_OPTIZOOM_INT = SCENE_MODE_CUSTOM_START + 1; + public static final int SCENE_MODE_UBIFOCUS_INT = SCENE_MODE_CUSTOM_START + 2; + public static final int SCENE_MODE_BESTPICTURE_INT = SCENE_MODE_CUSTOM_START + 3; + public static final int SCENE_MODE_PANORAMA_INT = SCENE_MODE_CUSTOM_START + 4; + public static final int SCENE_MODE_CHROMAFLASH_INT = SCENE_MODE_CUSTOM_START + 5; + public static final int SCENE_MODE_BLURBUSTER_INT = SCENE_MODE_CUSTOM_START + 6; + public static final int SCENE_MODE_SHARPSHOOTER_INT = SCENE_MODE_CUSTOM_START + 7; + public static final int SCENE_MODE_TRACKINGFOCUS_INT = SCENE_MODE_CUSTOM_START + 8; + public static final int SCENE_MODE_PROMODE_INT = SCENE_MODE_CUSTOM_START + 9; public static final String SCENE_MODE_DUAL_STRING = "100"; public static final String KEY_CAMERA_SAVEPATH = "pref_camera2_savepath_key"; public static final String KEY_RECORD_LOCATION = "pref_camera2_recordlocation_key"; @@ -134,6 +136,7 @@ public class SettingsManager implements ListMenu.SettingsListener { public static final String KEY_SHUTTER_SOUND = "pref_camera2_shutter_sound_key"; public static final String KEY_DEVELOPER_MENU = "pref_camera2_developer_menu_key"; public static final String KEY_RESTORE_DEFAULT = "pref_camera2_restore_default_key"; + public static final String KEY_FOCUS_DISTANCE = "pref_camera2_focus_distance_key"; private static final String TAG = "SnapCam_SettingsManager"; private static SettingsManager sInstance; @@ -425,6 +428,10 @@ public class SettingsManager implements ListMenu.SettingsListener { } } + public int getCurrentCameraId() { + return mCameraId; + } + public String getValue(String key) { Values values = mValuesMap.get(key); if (values == null) return null; @@ -467,6 +474,14 @@ public class SettingsManager implements ListMenu.SettingsListener { } } + public void setFocusDistance(float value) { + List<SettingState> list = new ArrayList<>(); + Values values = new Values("" + value, null); + SettingState ss = new SettingState(KEY_FOCUS_DISTANCE, values); + list.add(ss); + notifyListeners(list); + } + private void updateMapAndNotify(ListPreference pref) { String key = pref.getKey(); List changed = checkDependencyAndUpdate(key); @@ -996,6 +1011,11 @@ public class SettingsManager implements ListMenu.SettingsListener { return modes; } + public float getMinimumFocusDistance(int cameraId) { + return mCharacteristics.get(cameraId) + .get(CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE); + } + private List<String> getSupportedWhiteBalanceModes(int cameraId) { int[] whiteBalanceModes = mCharacteristics.get(cameraId).get(CameraCharacteristics .CONTROL_AWB_AVAILABLE_MODES); @@ -1020,6 +1040,7 @@ public class SettingsManager implements ListMenu.SettingsListener { if (BlurbusterFilter.isSupportedStatic()) modes.add(SCENE_MODE_BLURBUSTER_INT + ""); if (SharpshooterFilter.isSupportedStatic()) modes.add(SCENE_MODE_SHARPSHOOTER_INT + ""); if (TrackingFocusFrameListener.isSupportedStatic()) modes.add(SCENE_MODE_TRACKINGFOCUS_INT + ""); + modes.add("" + SCENE_MODE_PROMODE_INT); for (int mode : sceneModes) { modes.add("" + mode); } diff --git a/src/com/android/camera/ui/OneUICameraControls.java b/src/com/android/camera/ui/OneUICameraControls.java index 63e1b5b4d..413221211 100644 --- a/src/com/android/camera/ui/OneUICameraControls.java +++ b/src/com/android/camera/ui/OneUICameraControls.java @@ -27,15 +27,16 @@ import android.util.AttributeSet; import android.util.TypedValue; import android.view.View; import android.view.ViewGroup; +import android.widget.ImageView; import android.widget.LinearLayout; import android.widget.SeekBar; import android.widget.TextView; -import org.codeaurora.snapcam.R; - import com.android.camera.Storage; import com.android.camera.imageprocessor.filter.BeautificationFilter; +import org.codeaurora.snapcam.R; + public class OneUICameraControls extends RotatableLayout { private static final String TAG = "CAM_Controls"; @@ -53,6 +54,8 @@ public class OneUICameraControls extends RotatableLayout { private View mMakeupSeekBarLowText; private View mMakeupSeekBarHighText; private View mMakeupSeekBarLayout; + private ViewGroup mProModeLayout; + private View mProModeCloseButton; private ArrowTextView mRefocusToast; @@ -76,9 +79,27 @@ public class OneUICameraControls extends RotatableLayout { private int mHeight; private boolean mVisible; + private ProMode mProMode; + private ImageView mExposureIcon; + private ImageView mManualIcon; + private ImageView mWhiteBalanceIcon; + private ImageView mIsoIcon; + private TextView mExposureText; + private TextView mManualText; + private TextView mWhiteBalanceText; + private TextView mIsoText; + private boolean mProModeOn = false; + private LinearLayout mExposureLayout; + private LinearLayout mManualLayout; + private LinearLayout mWhiteBalanceLayout; + private LinearLayout mIsoLayout; + private RotateLayout mExposureRotateLayout; + private RotateLayout mManualRotateLayout; + private RotateLayout mWhiteBalanceRotateLayout; + private RotateLayout mIsoRotateLayout; + public OneUICameraControls(Context context, AttributeSet attrs) { super(context, attrs); - mPaint = new Paint(Paint.ANTI_ALIAS_FLAG); setWillNotDraw(false); @@ -117,6 +138,83 @@ public class OneUICameraControls extends RotatableLayout { mFilterModeSwitcher = findViewById(R.id.filter_mode_switcher); mRemainingPhotos = (LinearLayout) findViewById(R.id.remaining_photos); mRemainingPhotosText = (TextView) findViewById(R.id.remaining_photos_text); + mProModeLayout = (ViewGroup) findViewById(R.id.pro_mode_layout); + mProModeCloseButton = findViewById(R.id.promode_close_button); + + mExposureIcon = (ImageView) findViewById(R.id.exposure); + mManualIcon = (ImageView) findViewById(R.id.manual); + mWhiteBalanceIcon = (ImageView) findViewById(R.id.white_balance); + mIsoIcon = (ImageView) findViewById(R.id.iso); + mExposureText = (TextView) findViewById(R.id.exposure_value); + mManualText = (TextView) findViewById(R.id.manual_value); + mWhiteBalanceText = (TextView) findViewById(R.id.white_balance_value); + mIsoText = (TextView) findViewById(R.id.iso_value); + mProMode = (ProMode) findViewById(R.id.promode_slider); + mProMode.initialize(this); + + mExposureLayout = (LinearLayout) findViewById(R.id.exposure_layout); + mManualLayout = (LinearLayout) findViewById(R.id.manual_layout); + mWhiteBalanceLayout = (LinearLayout) findViewById(R.id.white_balance_layout); + mIsoLayout = (LinearLayout) findViewById(R.id.iso_layout); + + mExposureRotateLayout = (RotateLayout) findViewById(R.id.exposure_rotate_layout); + mManualRotateLayout = (RotateLayout) findViewById(R.id.manual_rotate_layout); + mWhiteBalanceRotateLayout = (RotateLayout) findViewById(R.id.white_balance_rotate_layout); + mIsoRotateLayout = (RotateLayout) findViewById(R.id.iso_rotate_layout); + + mExposureLayout.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + resetProModeIcons(); + int mode = mProMode.getMode(); + if (mode == ProMode.EXPOSURE_MODE) { + mProMode.setMode(ProMode.NO_MODE); + } else { + mExposureIcon.setImageResource(R.drawable.icon_exposure_blue); + mProMode.setMode(ProMode.EXPOSURE_MODE); + } + } + }); + mManualLayout.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + resetProModeIcons(); + int mode = mProMode.getMode(); + if (mode == ProMode.MANUAL_MODE) { + mProMode.setMode(ProMode.NO_MODE); + } else { + mManualIcon.setImageResource(R.drawable.icon_manual_blue); + mProMode.setMode(ProMode.MANUAL_MODE); + } + } + }); + mWhiteBalanceLayout.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + resetProModeIcons(); + int mode = mProMode.getMode(); + if (mode == ProMode.WHITE_BALANCE_MODE) { + mProMode.setMode(ProMode.NO_MODE); + } else { + mWhiteBalanceIcon.setImageResource(R.drawable.icon_white_balance_blue); + mProMode.setMode(ProMode.WHITE_BALANCE_MODE); + } + } + }); + mIsoLayout.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + resetProModeIcons(); + int mode = mProMode.getMode(); + if (mode == ProMode.ISO_MODE) { + mProMode.setMode(ProMode.NO_MODE); + } else { + mIsoIcon.setImageResource(R.drawable.icon_iso_blue); + mProMode.setMode(ProMode.ISO_MODE); + } + } + }); + mViews = new View[]{ mSceneModeSwitcher, mFilterModeSwitcher, mFrontBackSwitcher, mTsMakeupSwitcher, mFlashButton, mShutter, mPreview, mVideoShutter @@ -142,6 +240,14 @@ public class OneUICameraControls extends RotatableLayout { if(mMakeupSeekBar != null) { mMakeupSeekBar.setMinimumWidth(mWidth/2); } + + LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(mWidth/ 4,mWidth/4); + mExposureLayout.setLayoutParams(lp); + + mManualLayout.setLayoutParams(lp); + mWhiteBalanceLayout.setLayoutParams(lp); + mIsoLayout.setLayoutParams(lp); + initializeProMode(mProModeOn); } public boolean isControlRegion(int x, int y) { @@ -212,6 +318,7 @@ public class OneUICameraControls extends RotatableLayout { setLocation(mShutter, false, 2); setLocation(mVideoShutter, false, 3.15f); setLocationCustomBottom(mMakeupSeekBarLayout, 0, 1); + setLocation(mProModeCloseButton, false, 4); layoutToast(mRefocusToast, w, h, rotation); } @@ -332,6 +439,11 @@ public class OneUICameraControls extends RotatableLayout { ((Rotatable) v).setOrientation(orientation, animation); } } + mExposureRotateLayout.setOrientation(orientation, animation); + mManualRotateLayout.setOrientation(orientation, animation); + mWhiteBalanceRotateLayout.setOrientation(orientation, animation); + mIsoRotateLayout.setOrientation(orientation, animation); + mProMode.setOrientation(orientation); layoutRemaingPhotos(); } @@ -377,4 +489,46 @@ public class OneUICameraControls extends RotatableLayout { mPath.lineTo(x1, y1); } } + + public void setProMode(boolean promode) { + mProModeOn = promode; + initializeProMode(mProModeOn); + resetProModeIcons(); + } + + private void resetProModeIcons() { + mExposureIcon.setImageResource(R.drawable.icon_exposure); + mManualIcon.setImageResource(R.drawable.icon_manual); + mWhiteBalanceIcon.setImageResource(R.drawable.icon_white_balance); + mIsoIcon.setImageResource(R.drawable.icon_iso); + } + + public void initializeProMode(boolean promode) { + if (!promode) { + mProMode.setMode(ProMode.NO_MODE); + mProModeLayout.setVisibility(INVISIBLE); + mProModeCloseButton.setVisibility(INVISIBLE); + return; + } + mProModeLayout.setVisibility(VISIBLE); + mProModeCloseButton.setVisibility(VISIBLE); + mProModeLayout.setY(mHeight - mBottom - mProModeLayout.getHeight()); + } + + public void updateProModeText(int mode, String value) { + switch (mode) { + case ProMode.EXPOSURE_MODE: + mExposureText.setText(value); + break; + case ProMode.MANUAL_MODE: + mManualText.setText(value); + break; + case ProMode.WHITE_BALANCE_MODE: + mWhiteBalanceText.setText(value); + break; + case ProMode.ISO_MODE: + mIsoText.setText(value); + break; + } + } } diff --git a/src/com/android/camera/ui/ProMode.java b/src/com/android/camera/ui/ProMode.java new file mode 100644 index 000000000..9f7d576dc --- /dev/null +++ b/src/com/android/camera/ui/ProMode.java @@ -0,0 +1,372 @@ +/* + * Copyright (c) 2016, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package com.android.camera.ui; + +import android.content.Context; +import android.graphics.Canvas; +import android.graphics.Color; +import android.graphics.Paint; +import android.graphics.Path; +import android.graphics.PathMeasure; +import android.graphics.Point; +import android.util.AttributeSet; +import android.view.MotionEvent; +import android.view.View; +import android.view.ViewGroup; +import android.widget.ImageView; +import android.widget.TextView; + +import com.android.camera.SettingsManager; + +import org.codeaurora.snapcam.R; + +import java.util.ArrayList; + +public class ProMode extends View { + public static final int NO_MODE = -1; + public static final int EXPOSURE_MODE = 0; + public static final int MANUAL_MODE = 1; + public static final int WHITE_BALANCE_MODE = 2; + public static final int ISO_MODE = 3; + private static final int DRAG_Y_THRESHOLD = 100; + private static final int DRAG_X_THRESHOLD = 30; + private static final int BLUE = 0xff4693fb; + private static final int SELECTED_DOT_SIZE = 20; + private static final int DOT_SIZE = 10; + private static final int[] wbIcons = {R.drawable.auto, R.drawable.incandecent, + R.drawable.fluorescent, R.drawable.sunlight, R.drawable.cloudy}; + private static final int[] wbIconsBlue = {R.drawable.auto_blue, R.drawable.incandecent_blue, + R.drawable.fluorescent_blue, R.drawable.sunlight_blue, R.drawable.cloudy_blue}; + private static final int WB_ICON_SIZE = 80; + private PathMeasure mCurveMeasure; + private int mCurveLeft; + private int mCurveRight; + private float mSlider = -1; + private Paint mPaint = new Paint(); + private int mNums; + private int mIndex; + private Point[] mPoints; + private float mClickThreshold; + private int mStride; + private SettingsManager mSettingsManager; + private int mMode = NO_MODE; + private Context mContext; + private ViewGroup mParent; + private float minFocus; + private OneUICameraControls mUI; + private int mWidth; + private int mHeight; + private int mCurveY; + private ArrayList<View> mAddedViews; + private float curveCoordinate[] = new float[2]; + private Path mCurvePath = new Path(); + private int mCurveHeight; + private int mOrientation; + + public ProMode(Context context, AttributeSet attrs) { + super(context, attrs); + mContext = context; + mPaint.setStrokeWidth(7f); + mSettingsManager = SettingsManager.getInstance(); + } + + private void init() { + init(EXPOSURE_MODE); + init(WHITE_BALANCE_MODE); + init(ISO_MODE); + mUI.updateProModeText(MANUAL_MODE, "Manual"); + } + + private void init(int mode) { + String key = getKey(mode); + if (key == null) return; + int index = mSettingsManager.getValueIndex(key); + CharSequence[] cc = mSettingsManager.getEntries(key); + mUI.updateProModeText(mode, cc[index].toString()); + } + + @Override + protected void onDraw(Canvas canvas) { + super.onDraw(canvas); + + if (mMode != NO_MODE) { + mPaint.setColor(Color.WHITE); + mPaint.setStyle(Paint.Style.STROKE); + canvas.drawPath(mCurvePath, mPaint); + } + mPaint.setStyle(Paint.Style.FILL); + if (mMode == MANUAL_MODE) { + mPaint.setColor(Color.WHITE); + canvas.drawCircle(mCurveLeft, mCurveY, DOT_SIZE, mPaint); + canvas.drawCircle(mCurveRight, mCurveY, DOT_SIZE, mPaint); + mPaint.setColor(BLUE); + if (mSlider >= 0f) { + mCurveMeasure.getPosTan(mCurveMeasure.getLength() * mSlider, curveCoordinate, null); + canvas.drawCircle(curveCoordinate[0], curveCoordinate[1], SELECTED_DOT_SIZE, + mPaint); + } + } else { + for (int i = 0; i < mNums; i++) { + if (i == mIndex) { + mPaint.setColor(BLUE); + canvas.drawCircle(mPoints[i].x, mPoints[i].y, SELECTED_DOT_SIZE, mPaint); + } else { + mPaint.setColor(Color.WHITE); + canvas.drawCircle(mPoints[i].x, mPoints[i].y, DOT_SIZE, mPaint); + } + } + } + } + + public void initialize(OneUICameraControls ui) { + mParent = (ViewGroup) getParent(); + mUI = ui; + init(); + } + + @Override + protected void onLayout(boolean changed, int left, int top, int right, int bottom) { + super.onLayout(changed, left, top, right, bottom); + mWidth = right - left; + mHeight = bottom - top; + mCurveLeft = mWidth / 10; + mCurveRight = mWidth - mCurveLeft; + mCurveHeight = mWidth / 7; + mCurveY = (int) (mHeight * 0.67); + + float cx = (mCurveLeft + mCurveRight) / 2; + mCurvePath.moveTo(mCurveLeft, mCurveY); + mCurvePath.quadTo(cx, mCurveY - mCurveHeight, mCurveRight, mCurveY); + mCurveMeasure = new PathMeasure(mCurvePath, false); + } + + public void setOrientation(int orientation) { + mOrientation = orientation; + if (mAddedViews != null) { + int rotation = mOrientation; + if (rotation == 90 || rotation == 270) rotation += 180; + rotation %= 360; + for (View v : mAddedViews) { + v.setRotation(rotation); + } + } + } + + public int getMode() { + return mMode; + } + + public void setMode(int mode) { + mMode = mode; + removeViews(); + if (mMode == NO_MODE) { + setVisibility(INVISIBLE); + return; + } else { + setVisibility(VISIBLE); + } + mIndex = -1; + String key = currentKey(); + if (mMode == MANUAL_MODE) { + minFocus = mSettingsManager + .getMinimumFocusDistance(mSettingsManager.getCurrentCameraId()); + float value = 0.5f; + setSlider(value); + int stride = mCurveRight - mCurveLeft; + for (int i = 0; i < 2; i++) { + TextView v = new TextView(mContext); + String s = "infinity"; + if (i == 1) s = "macro"; + v.setText(s); + v.setTextColor(Color.WHITE); + v.measure(0, 0); + ViewGroup.LayoutParams lp = new ViewGroup.LayoutParams(v.getMeasuredWidth(), + v.getMeasuredHeight()); + v.setLayoutParams(lp); + v.setX(mCurveLeft + i * stride - v.getMeasuredWidth() / 2); + v.setY(mCurveY - 2 * v.getMeasuredHeight()); + mParent.addView(v); + mAddedViews.add(v); + } + } else { + if (key == null) return; + CharSequence[] cc = mSettingsManager.getEntries(key); + int length = mSettingsManager.getEntryValues(key).length; + int index = mSettingsManager.getValueIndex(key); + updateSlider(length); + + for (int i = 0; i < length; i++) { + View v; + if (mMode == WHITE_BALANCE_MODE) { + v = new ImageView(mContext); + ((ImageView) v).setImageResource(wbIcons[i]); + ViewGroup.LayoutParams lp = new ViewGroup.LayoutParams( + WB_ICON_SIZE, WB_ICON_SIZE); + v.setLayoutParams(lp); + v.setX(mPoints[i].x - WB_ICON_SIZE / 2); + v.setY(mPoints[i].y - 2 * WB_ICON_SIZE); + } else { + v = new TextView(mContext); + ((TextView) v).setText(cc[i]); + ((TextView) v).setTextColor(Color.WHITE); + v.measure(0, 0); + ViewGroup.LayoutParams lp = new ViewGroup.LayoutParams(v.getMeasuredWidth(), + v.getMeasuredHeight()); + v.setLayoutParams(lp); + v.setX(mPoints[i].x - v.getMeasuredWidth() / 2); + v.setY(mPoints[i].y - 2 * v.getMeasuredHeight()); + } + + + mParent.addView(v); + mAddedViews.add(v); + } + setIndex(index, true); + } + setOrientation(mOrientation); + } + + private String getKey(int mode) { + switch (mode) { + case EXPOSURE_MODE: + return SettingsManager.KEY_EXPOSURE; + case WHITE_BALANCE_MODE: + return SettingsManager.KEY_WHITE_BALANCE; + case ISO_MODE: + return SettingsManager.KEY_ISO; + } + return null; + } + + private String currentKey() { + return getKey(mMode); + } + + private void updateSlider(int n) { + mNums = n; + mStride = (mCurveRight - mCurveLeft) / (mNums - 1); + mClickThreshold = mStride * 0.45f; + mPoints = new Point[mNums]; + + float slide = 1f / (mNums - 1); + for (int i = 0; i < mNums; i++) { + mCurveMeasure.getPosTan(mCurveMeasure.getLength() * (slide * i), curveCoordinate, null); + mPoints[i] = new Point((int) curveCoordinate[0], (int) curveCoordinate[1]); + } + + invalidate(); + } + + public void setSlider(float slider) { + mSlider = slider; + mSettingsManager.setFocusDistance(mSlider * minFocus); + mUI.updateProModeText(mMode, "Manual"); + invalidate(); + } + + private void setIndex(int index, boolean force) { + if (mIndex == index && !force) return; + if (mIndex != -1) { + View v = mAddedViews.get(mIndex); + if (v instanceof TextView) { + ((TextView) v).setTextColor(Color.WHITE); + } else if (v instanceof ImageView) { + if (mMode == WHITE_BALANCE_MODE) { + ((ImageView) v).setImageResource(wbIcons[mIndex]); + } + } + } + + mIndex = index; + String key = currentKey(); + View v = mAddedViews.get(mIndex); + if (v instanceof TextView) { + ((TextView) v).setTextColor(BLUE); + } else if (v instanceof ImageView) { + if (mMode == WHITE_BALANCE_MODE) { + ((ImageView) v).setImageResource(wbIconsBlue[mIndex]); + } + } + if (key != null) mSettingsManager.setValueIndex(key, mIndex); + CharSequence[] cc = mSettingsManager.getEntries(key); + mUI.updateProModeText(mMode, cc[mIndex].toString()); + invalidate(); + } + + private void removeViews() { + ViewGroup vg = (ViewGroup) getParent(); + if (mAddedViews != null) { + for (int i = 0; i < mAddedViews.size(); i++) { + vg.removeView(mAddedViews.get(i)); + } + } + mAddedViews = new ArrayList<View>(); + } + + @Override + public boolean onTouchEvent(MotionEvent event) { + if (mMode == MANUAL_MODE) { + float slider = getSlider(event.getX(), event.getY()); + if (slider >= 0) { + setSlider(slider); + } + } else { + int idx = findButton(event.getX(), event.getY()); + if (idx != -1) { + setIndex(idx, false); + } + return true; + } + return true; + } + + private int findButton(float x, float y) { + for (int i = 0; i < mNums; i++) { + float xdiff = Math.abs(mPoints[i].x - x); + float ydiff = Math.abs(mPoints[i].y - y); + float dist = xdiff * xdiff + ydiff * ydiff; + if (dist < mClickThreshold * mClickThreshold) return i; + } + return -1; + } + + private float getSlider(float x, float y) { + if (x > mCurveLeft - DRAG_X_THRESHOLD && x < mCurveRight + DRAG_X_THRESHOLD + && y > mCurveY - mCurveHeight - DRAG_Y_THRESHOLD + && y < mCurveY + DRAG_Y_THRESHOLD) { + if (x < mCurveLeft) x = mCurveLeft; + if (x > mCurveRight) x = mCurveRight; + return (x - mCurveLeft) / (mCurveRight - mCurveLeft); + } else { + return -1; + } + } + +} |