diff options
| -rw-r--r--[-rwxr-xr-x] | res/values/arrays.xml | 2 | ||||
| -rw-r--r-- | res/values/qcomarrays.xml | 39 | ||||
| -rw-r--r-- | res/values/qcomstrings.xml | 35 | ||||
| -rw-r--r--[-rwxr-xr-x] | res/values/strings.xml | 2 | ||||
| -rw-r--r-- | res/xml/camera_preferences.xml | 21 | ||||
| -rw-r--r-- | src/com/android/camera/CameraSettings.java | 87 | ||||
| -rw-r--r-- | src/com/android/camera/PhotoMenu.java | 8 | ||||
| -rw-r--r-- | src/com/android/camera/PhotoModule.java | 610 |
8 files changed, 777 insertions, 27 deletions
diff --git a/res/values/arrays.xml b/res/values/arrays.xml index d9312c57a..71b4afccd 100755..100644 --- a/res/values/arrays.xml +++ b/res/values/arrays.xml @@ -19,7 +19,7 @@ <!-- Camera Preferences Video Quality entries --> <string-array name="pref_video_quality_entries" translatable="false"> <item>@string/pref_video_quality_entry_4kdci</item> - <item>@string/pref_video_quality_entry_2160p</item> + <item>@string/pref_video_quality_entry_2160p</item> <item>@string/pref_video_quality_entry_1080p</item> <item>@string/pref_video_quality_entry_720p</item> <item>@string/pref_video_quality_entry_480p</item> diff --git a/res/values/qcomarrays.xml b/res/values/qcomarrays.xml index 9b71634a2..0b1037e72 100644 --- a/res/values/qcomarrays.xml +++ b/res/values/qcomarrays.xml @@ -559,6 +559,45 @@ <item>@string/pref_camera_selectablezoneaf_value_frameaverage</item> </string-array> + + <string-array name="pref_camera_manual_exp_entries" translatable="false"> + <item>@string/pref_camera_manual_exp_entry_ISO_priority</item> + <item>@string/pref_camera_manual_exp_entry_exptime_priority</item> + <item>@string/pref_camera_manual_exp_entry_user_setting</item> + <item>@string/pref_camera_manual_exp_entry_off</item> + </string-array> + + <string-array name="pref_camera_manual_exp_entry_values" translatable="false"> + <item>@string/pref_camera_manual_exp_value_ISO_priority</item> + <item>@string/pref_camera_manual_exp_value_exptime_priority</item> + <item>@string/pref_camera_manual_exp_value_user_setting</item> + <item>@string/pref_camera_manual_exp_value_off</item> + </string-array> + + <string-array name="pref_camera_manual_wb_entries" translatable="false"> + <item>@string/pref_camera_manual_wb_entry_color_temperature</item> + <item>@string/pref_camera_manual_wb_entry_rbgb_gains</item> + <item>@string/pref_camera_manual_wb_entry_off</item> + </string-array> + + <string-array name="pref_camera_manual_wb_entry_values" translatable="false"> + <item>@string/pref_camera_manual_wb_value_color_temperature</item> + <item>@string/pref_camera_manual_wb_value_rbgb_gains</item> + <item>@string/pref_camera_manual_wb_value_off</item> + </string-array> + + <string-array name="pref_camera_manual_focus_entries" translatable="false"> + <item>@string/pref_camera_manual_focus_entry_scale_mode</item> + <item>@string/pref_camera_manual_focus_entry_diopter_mode</item> + <item>@string/pref_camera_manual_focus_entry_off</item> + </string-array> + + <string-array name="pref_camera_manual_focus_entry_values" translatable="false"> + <item>@string/pref_camera_manual_focus_value_scale_mode</item> + <item>@string/pref_camera_manual_focus_value_diopter_mode</item> + <item>@string/pref_camera_manual_focus_value_off</item> + </string-array> + <!-- ZSL dialog box entries --> <string-array name="pref_camera_zsl_entries" translatable="false"> <item>@string/pref_camera_zsl_entry_off</item> diff --git a/res/values/qcomstrings.xml b/res/values/qcomstrings.xml index 93a39003d..c72f9bb1e 100644 --- a/res/values/qcomstrings.xml +++ b/res/values/qcomstrings.xml @@ -166,6 +166,41 @@ <string name="pref_camera_advanced_feature_value_trueportrait_off">true-portrait-off</string> <string name="pref_camera_advanced_feature_value_multi_touch_focus_off">multi-touch-focus-off</string> + <!-- Manual exposure control entry values --> + <string name="pref_camera_manual_exp_title">Manual Exposure</string> + <string name="pref_camera_manual_exp_entry_ISO_priority">ISO priority</string> + <string name="pref_camera_manual_exp_entry_exptime_priority">Exposure time priority</string> + <string name="pref_camera_manual_exp_entry_user_setting">User setting</string> + <string name="pref_camera_manual_exp_entry_off">Off</string> + + <string name="pref_camera_manual_exp_default">off</string> + <string name="pref_camera_manual_exp_value_ISO_priority">iso-priority</string> + <string name="pref_camera_manual_exp_value_exptime_priority">exp-time-priority</string> + <string name="pref_camera_manual_exp_value_user_setting">user-setting</string> + <string name="pref_camera_manual_exp_value_off">off</string> + + <!-- Manual white balance entry values --> + <string name="pref_camera_manual_wb_title">Manual White balance</string> + <string name="pref_camera_manual_wb_entry_color_temperature">Color temperature</string> + <string name="pref_camera_manual_wb_entry_rbgb_gains">RBGB gains</string> + <string name="pref_camera_manual_wb_entry_off">Off</string> + + <string name="pref_camera_manual_wb_default">off</string> + <string name="pref_camera_manual_wb_value_color_temperature">color-temperature</string> + <string name="pref_camera_manual_wb_value_rbgb_gains">rbgb-gains</string> + <string name="pref_camera_manual_wb_value_off">off</string> + + <!-- Manual Focus entry values --> + <string name="pref_camera_manual_focus_title">Manual Focus</string> + <string name="pref_camera_manual_focus_entry_scale_mode">Scale mode</string> + <string name="pref_camera_manual_focus_entry_diopter_mode">Diopter mode</string> + <string name="pref_camera_manual_focus_entry_off">Off</string> + + <string name="pref_camera_manual_focus_default">off</string> + <string name="pref_camera_manual_focus_value_scale_mode">scale-mode</string> + <string name="pref_camera_manual_focus_value_diopter_mode">diopter-mode</string> + <string name="pref_camera_manual_focus_value_off">off</string> + <!-- Settings screen, ZSL location dialog choices --> <string name="pref_camera_zsl_entry_off">Off</string> <string name="pref_camera_zsl_entry_on">On</string> diff --git a/res/values/strings.xml b/res/values/strings.xml index d597e5af0..2d3aee027 100755..100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -244,7 +244,7 @@ Videos will be recorded in 4k DCI quality. [CHAR LIMIT=24] --> <string name="pref_video_quality_entry_4kdci" translatable="false"> 4k DCI</string> - <!-- Video quality setting entry. + <!-- Video quality setting entry. Videos will be recorded in 4k UHD quality. [CHAR LIMIT=24] --> <string name="pref_video_quality_entry_2160p" translatable="false"> 4k UHD</string> diff --git a/res/xml/camera_preferences.xml b/res/xml/camera_preferences.xml index 4052b9634..39c54daa7 100644 --- a/res/xml/camera_preferences.xml +++ b/res/xml/camera_preferences.xml @@ -282,4 +282,25 @@ camera:title="@string/pref_camera_hdr_need_1x_title" camera:entries="@array/pref_camera_hdr_need_1x_entries" camera:entryValues="@array/pref_camera_hdr_need_1x_entryvalues" /> + + <ListPreference + camera:key="pref_camera_manual_exp_key" + camera:defaultValue="@string/pref_camera_manual_exp_default" + camera:title="@string/pref_camera_manual_exp_title" + camera:entries="@array/pref_camera_manual_exp_entries" + camera:entryValues="@array/pref_camera_manual_exp_entry_values" /> + + <ListPreference + camera:key="pref_camera_manual_wb_key" + camera:defaultValue="@string/pref_camera_manual_wb_default" + camera:title="@string/pref_camera_manual_wb_title" + camera:entries="@array/pref_camera_manual_wb_entries" + camera:entryValues="@array/pref_camera_manual_wb_entry_values" /> + + <ListPreference + camera:key="pref_camera_manual_focus_key" + camera:defaultValue="@string/pref_camera_manual_focus_default" + camera:title="@string/pref_camera_manual_focus_title" + camera:entries="@array/pref_camera_manual_focus_entries" + camera:entryValues="@array/pref_camera_manual_focus_entry_values" /> </PreferenceGroup> diff --git a/src/com/android/camera/CameraSettings.java b/src/com/android/camera/CameraSettings.java index 4c2a20651..356869b9b 100644 --- a/src/com/android/camera/CameraSettings.java +++ b/src/com/android/camera/CameraSettings.java @@ -184,6 +184,50 @@ public class CameraSettings { private static final String VIDEO_QUALITY_YOUTUBE = "youtube"; + //manual 3A keys and parameter strings + public static final String KEY_MANUAL_EXPOSURE = "pref_camera_manual_exp_key"; + public static final String KEY_MANUAL_WB = "pref_camera_manual_wb_key"; + public static final String KEY_MANUAL_FOCUS = "pref_camera_manual_focus_key"; + + public static final String KEY_MANUAL_EXPOSURE_MODES = "manual-exp-modes"; + public static final String KEY_MANUAL_WB_MODES = "manual-wb-modes"; + public static final String KEY_MANUAL_FOCUS_MODES = "manual-focus-modes"; + //manual exposure + public static final String KEY_MIN_EXPOSURE_TIME = "min-exposure-time"; + public static final String KEY_MAX_EXPOSURE_TIME = "max-exposure-time"; + public static final String KEY_EXPOSURE_TIME = "exposure-time"; + public static final String KEY_MIN_ISO = "min-iso"; + public static final String KEY_MAX_ISO = "max-iso"; + public static final String KEY_CONTINUOUS_ISO = "continuous-iso"; + public static final String KEY_MANUAL_ISO = "manual"; + public static final String KEY_CURRENT_ISO = "cur-iso"; + public static final String KEY_CURRENT_EXPOSURE_TIME = "cur-exposure-time"; + + //manual WB + public static final String KEY_MIN_WB_GAIN = "min-wb-gain"; + public static final String KEY_MAX_WB_GAIN = "max-wb-gain"; + public static final String KEY_MANUAL_WB_GAINS = "manual-wb-gains"; + public static final String KEY_MIN_WB_CCT = "min-wb-cct"; + public static final String KEY_MAX_WB_CCT = "max-wb-cct"; + public static final String KEY_MANUAL_WB_CCT = "wb-manual-cct"; + public static final String KEY_MANUAL_WHITE_BALANCE = "manual"; + public static final String KEY_MANUAL_WB_TYPE = "manual-wb-type"; + public static final String KEY_MANUAL_WB_VALUE = "manual-wb-value"; + + //manual focus + public static final String KEY_MIN_FOCUS_SCALE = "min-focus-pos-ratio"; + public static final String KEY_MAX_FOCUS_SCALE = "max-focus-pos-ratio"; + public static final String KEY_MIN_FOCUS_DIOPTER = "min-focus-pos-diopter"; + public static final String KEY_MAX_FOCUS_DIOPTER = "max-focus-pos-diopter"; + public static final String KEY_MANUAL_FOCUS_TYPE = "manual-focus-pos-type"; + public static final String KEY_MANUAL_FOCUS_POSITION = "manual-focus-position"; + public static final String KEY_MANUAL_FOCUS_SCALE = "cur-focus-scale"; + public static final String KEY_MANUAL_FOCUS_DIOPTER = "cur-focus-diopter"; + + public static final String KEY_QC_SUPPORTED_MANUAL_FOCUS_MODES = "manual-focus-modes"; + public static final String KEY_QC_SUPPORTED_MANUAL_EXPOSURE_MODES = "manual-exposure-modes"; + public static final String KEY_QC_SUPPORTED_MANUAL_WB_MODES = "manual-wb-modes"; + public static final String EXPOSURE_DEFAULT_VALUE = "0"; public static final int CURRENT_VERSION = 5; @@ -511,6 +555,9 @@ public class CameraSettings { ListPreference video_cds_mode = group.findPreference(KEY_VIDEO_CDS_MODE); ListPreference tnr_mode = group.findPreference(KEY_TNR_MODE); ListPreference video_tnr_mode = group.findPreference(KEY_VIDEO_TNR_MODE); + ListPreference manualFocus = group.findPreference(KEY_MANUAL_FOCUS); + ListPreference manualExposure = group.findPreference(KEY_MANUAL_EXPOSURE); + ListPreference manualWB = group.findPreference(KEY_MANUAL_WB); if (hdr_need_1x != null) { filterUnsupportedOptions(group, @@ -633,6 +680,21 @@ public class CameraSettings { filterUnsupportedOptions(group, videoRotation, mParameters.getSupportedVideoRotationValues()); } + + if (manualFocus != null) { + filterUnsupportedOptions(group, + manualFocus, getSupportedManualFocusModes(mParameters)); + } + + if (manualWB != null) { + filterUnsupportedOptions(group, + manualWB, getSupportedManualWBModes(mParameters)); + } + + if (manualExposure != null) { + filterUnsupportedOptions(group, + manualExposure, getSupportedManualExposureModes(mParameters)); + } } private void initPreference(PreferenceGroup group) { @@ -1130,4 +1192,29 @@ public class CameraSettings { } return ret; } + + public static List<String> getSupportedManualExposureModes(Parameters params) { + String str = params.get(KEY_QC_SUPPORTED_MANUAL_EXPOSURE_MODES); + if (str == null) { + return null; + } + return split(str); + } + + public static List<String> getSupportedManualFocusModes(Parameters params) { + String str = params.get(KEY_QC_SUPPORTED_MANUAL_FOCUS_MODES); + if (str == null) { + return null; + } + return split(str); + } + + public static List<String> getSupportedManualWBModes(Parameters params) { + String str = params.get(KEY_QC_SUPPORTED_MANUAL_WB_MODES); + if (str == null) { + return null; + } + return split(str); + } + } diff --git a/src/com/android/camera/PhotoMenu.java b/src/com/android/camera/PhotoMenu.java index 0d4643bf7..629d91526 100644 --- a/src/com/android/camera/PhotoMenu.java +++ b/src/com/android/camera/PhotoMenu.java @@ -137,7 +137,10 @@ public class PhotoMenu extends PieController CameraSettings.KEY_FLASH_MODE, CameraSettings.KEY_FOCUS_MODE, CameraSettings.KEY_REDEYE_REDUCTION, - CameraSettings.KEY_AE_BRACKET_HDR + CameraSettings.KEY_AE_BRACKET_HDR, + CameraSettings.KEY_MANUAL_EXPOSURE, + CameraSettings.KEY_MANUAL_WB, + CameraSettings.KEY_MANUAL_FOCUS }; PieItem item1 = makeItem(R.drawable.ic_settings_holo_light_01); @@ -314,6 +317,9 @@ public class PhotoMenu extends PieController } if ((zsl != null) && Parameters.ZSL_ON.equals(zsl)) { popup3.setPreferenceEnabled(CameraSettings.KEY_FOCUS_MODE,false); + popup3.setPreferenceEnabled(CameraSettings.KEY_MANUAL_EXPOSURE,false); + popup3.setPreferenceEnabled(CameraSettings.KEY_MANUAL_WB,false); + popup3.setPreferenceEnabled(CameraSettings.KEY_MANUAL_FOCUS,false); } if ((faceDetection != null) && !Parameters.FACE_DETECTION_ON.equals(faceDetection)){ popup2.setPreferenceEnabled(CameraSettings.KEY_FACE_RECOGNITION,false); diff --git a/src/com/android/camera/PhotoModule.java b/src/com/android/camera/PhotoModule.java index 151388dd3..299540010 100644 --- a/src/com/android/camera/PhotoModule.java +++ b/src/com/android/camera/PhotoModule.java @@ -76,6 +76,11 @@ import com.android.camera.util.GcamHelper; import com.android.camera.util.UsageStatistics; import org.codeaurora.snapcam.R; +import android.widget.EditText; +import android.app.AlertDialog; +import android.content.DialogInterface; +import android.text.InputType; + import com.android.internal.util.MemInfoReader; import android.app.ActivityManager; @@ -344,6 +349,11 @@ public class PhotoModule // True if all the parameters needed to start preview is ready. private boolean mCameraPreviewParamsReady = false; + private int mManual3AEnabled = 0; + private static final int MANUAL_FOCUS = 1; + private static final int MANUAL_WB = 2; + private static final int MANUAL_EXPOSURE = 4; + private MediaSaveService.OnMediaSavedListener mOnMediaSavedListener = new MediaSaveService.OnMediaSavedListener() { @Override @@ -688,6 +698,7 @@ public class PhotoModule } updateCameraSettings(); showTapToFocusToastIfNeeded(); + resetManual3ASettings(); } @Override @@ -710,6 +721,37 @@ public class PhotoModule } } + private void resetManual3ASettings() { + String manualExposureDefault = mActivity.getString( + R.string.pref_camera_manual_exp_default); + String manualExposureMode = mPreferences.getString( + CameraSettings.KEY_MANUAL_EXPOSURE, manualExposureDefault); + if (!manualExposureMode.equals(manualExposureDefault)) { + mUI.setPreference( + CameraSettings.KEY_MANUAL_EXPOSURE, manualExposureDefault); + UpdateManualExposureSettings(); + } + String manualFocusDefault = mActivity.getString( + R.string.pref_camera_manual_focus_default); + String manualFocusMode = mPreferences.getString( + CameraSettings.KEY_MANUAL_FOCUS, manualFocusDefault); + if (!manualFocusMode.equals(manualFocusDefault)) { + mUI.setPreference( + CameraSettings.KEY_MANUAL_FOCUS, manualFocusDefault); + UpdateManualFocusSettings(); + } + String manualWBDefault = mActivity.getString( + R.string.pref_camera_manual_wb_default); + String manualWBMode = mPreferences.getString( + CameraSettings.KEY_MANUAL_WB, manualWBDefault); + if (!manualWBMode.equals(manualWBDefault)) { + mUI.setPreference( + CameraSettings.KEY_MANUAL_WB, manualWBDefault); + UpdateManualWBSettings(); + } + mManual3AEnabled = 0; + } + void setPreviewFrameLayoutCameraOrientation(){ CameraInfo info = CameraHolder.instance().getCameraInfo()[mCameraId]; //if camera mount angle is 0 or 180, we want to resize preview @@ -1556,6 +1598,60 @@ public class PhotoModule } } + private void updateCommonManual3ASettings() { + String touchAfAec = mParameters.TOUCH_AF_AEC_OFF; + mSceneMode = Parameters.SCENE_MODE_AUTO; + String flashMode = Parameters.FLASH_MODE_OFF; + String redeyeReduction = mActivity.getString(R.string. + pref_camera_redeyereduction_entry_disable); + String aeBracketing = mActivity.getString(R.string. + pref_camera_ae_bracket_hdr_entry_off); + String colorEffect = mActivity.getString(R.string. + pref_camera_coloreffect_default); + String exposureCompensation = CameraSettings.EXPOSURE_DEFAULT_VALUE; + + if (mManual3AEnabled > 0) { + overrideCameraSettings(flashMode, null, null, + exposureCompensation, touchAfAec, + mParameters.getAutoExposure(), + Integer.toString(mParameters.getSaturation()), + Integer.toString(mParameters.getContrast()), + Integer.toString(mParameters.getSharpness()), + colorEffect, + mSceneMode, redeyeReduction, aeBracketing); + mUI.overrideSettings(CameraSettings.KEY_LONGSHOT, + mActivity.getString(R.string.setting_off_value)); + } else { + //enable all + touchAfAec = mActivity.getString( + R.string.pref_camera_touchafaec_default); + overrideCameraSettings(null, null, null, + null, touchAfAec, null, + null, null, null, null, + null, null, null); + mUI.overrideSettings(CameraSettings.KEY_LONGSHOT, null); + } + + String isoMode = mParameters.getISOValue(); + final String isoManual = CameraSettings.KEY_MANUAL_ISO; + if (isoMode.equals(isoManual)) { + final String isoPref = mPreferences.getString( + CameraSettings.KEY_ISO, + mActivity.getString(R.string.pref_camera_iso_default)); + mUI.overrideSettings(CameraSettings.KEY_ISO, isoPref); + } + if ((mManual3AEnabled & MANUAL_WB) != 0) { + String whiteBalance = mPreferences.getString( + CameraSettings.KEY_WHITE_BALANCE, + mActivity.getString(R.string.pref_camera_whitebalance_default)); + mUI.overrideSettings(CameraSettings.KEY_WHITE_BALANCE, whiteBalance); + } + if ((mManual3AEnabled & MANUAL_FOCUS) != 0) { + mUI.overrideSettings(CameraSettings.KEY_FOCUS_MODE, + mFocusManager.getFocusMode()); + } + } + private void updateCameraSettings() { String sceneMode = null; String flashMode = null; @@ -1597,6 +1693,11 @@ public class PhotoModule mParameters.get(CameraSettings.KEY_QC_MULTI_TOUCH_FOCUS); String continuousShot = mParameters.get("long-shot"); + + if (mManual3AEnabled > 0) { + disableLongShot = true; + } + if ((continuousShot != null) && continuousShot.equals(continuousShotOn)) { String pictureFormat = mActivity.getString(R.string. pref_camera_picture_format_value_jpeg); @@ -1670,10 +1771,14 @@ public class PhotoModule null, null, null, colorEffect, sceneMode, redeyeReduction, aeBracketing); } else { - overrideCameraSettings(flashMode, null, focusMode, - exposureCompensation, touchAfAec, null, - null, null, null, colorEffect, - sceneMode, redeyeReduction, aeBracketing); + if (mManual3AEnabled > 0) { + updateCommonManual3ASettings(); + } else { + 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); @@ -2176,6 +2281,7 @@ public class PhotoModule if (mCameraDevice != null && mCameraState != PREVIEW_STOPPED) { mCameraDevice.cancelAutoFocus(); } + resetManual3ASettings(); // If the camera has not been opened asynchronously yet, // and startPreview hasn't been called, then this is a no-op. // (e.g. onResume -> onPause -> onResume). @@ -2708,12 +2814,14 @@ public class PhotoModule 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, + if ((mManual3AEnabled & MANUAL_EXPOSURE) == 0) { + 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( @@ -3004,8 +3112,10 @@ public class PhotoModule mSnapshotMode = CameraInfo.CAMERA_SUPPORT_MODE_NONZSL; mParameters.setCameraMode(0); mFocusManager.setZslEnable(false); - mFocusManager.overrideFocusMode(null); - mParameters.setFocusMode(mFocusManager.getFocusMode()); + if ((mManual3AEnabled & MANUAL_FOCUS) == 0) { + mFocusManager.overrideFocusMode(null); + mParameters.setFocusMode(mFocusManager.getFocusMode()); + } } // Set face detetction parameter. String faceDetection = mPreferences.getString( @@ -3151,8 +3261,10 @@ public class PhotoModule setMeteringAreasIfSupported(); // initialize focus mode - mFocusManager.overrideFocusMode(null); - mParameters.setFocusMode(mFocusManager.getFocusMode()); + if ((mManual3AEnabled & MANUAL_FOCUS) == 0) { + mFocusManager.overrideFocusMode(null); + mParameters.setFocusMode(mFocusManager.getFocusMode()); + } // Set picture size. String pictureSize = mPreferences.getString( @@ -3335,22 +3447,26 @@ public class PhotoModule } // Set white balance parameter. - String whiteBalance = mPreferences.getString( - CameraSettings.KEY_WHITE_BALANCE, - mActivity.getString(R.string.pref_camera_whitebalance_default)); - if (CameraUtil.isSupported(whiteBalance, - mParameters.getSupportedWhiteBalance())) { - mParameters.setWhiteBalance(whiteBalance); - } else { - whiteBalance = mParameters.getWhiteBalance(); - if (whiteBalance == null) { - whiteBalance = Parameters.WHITE_BALANCE_AUTO; + if ((mManual3AEnabled & MANUAL_WB) == 0) { + String whiteBalance = mPreferences.getString( + CameraSettings.KEY_WHITE_BALANCE, + mActivity.getString(R.string.pref_camera_whitebalance_default)); + if (CameraUtil.isSupported(whiteBalance, + mParameters.getSupportedWhiteBalance())) { + mParameters.setWhiteBalance(whiteBalance); + } else { + whiteBalance = mParameters.getWhiteBalance(); + if (whiteBalance == null) { + whiteBalance = Parameters.WHITE_BALANCE_AUTO; + } } } // Set focus mode. - mFocusManager.overrideFocusMode(null); - mParameters.setFocusMode(mFocusManager.getFocusMode()); + if ((mManual3AEnabled & MANUAL_FOCUS) == 0) { + mFocusManager.overrideFocusMode(null); + mParameters.setFocusMode(mFocusManager.getFocusMode()); + } } else { mFocusManager.overrideFocusMode(mParameters.getFocusMode()); if (hdrOn) @@ -3465,6 +3581,439 @@ public class PhotoModule } } + private void UpdateManualFocusSettings() { + //dismiss all popups first, because we need to show edit dialog + mUI.collapseCameraControls(); + final AlertDialog.Builder alert = new AlertDialog.Builder(mActivity); + LinearLayout linear = new LinearLayout(mActivity); + linear.setOrientation(1); + alert.setTitle("Manual Focus Settings"); + alert.setNegativeButton("Cancel",new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog,int id) + { + dialog.cancel(); + } + }); + final TextView focusPositionText = new TextView(mActivity); + String scaleMode = mActivity.getString( + R.string.pref_camera_manual_focus_value_scale_mode); + String diopterMode = mActivity.getString( + R.string.pref_camera_manual_focus_value_diopter_mode); + String manualFocusMode = mPreferences.getString( + CameraSettings.KEY_MANUAL_FOCUS, + mActivity.getString(R.string.pref_camera_manual_focus_default)); + + Log.v(TAG, "manualFocusMode selected = " + manualFocusMode); + if (manualFocusMode.equals(scaleMode)) { + final SeekBar focusbar = new SeekBar(mActivity); + final int minFocusPos = mParameters.getInt(CameraSettings.KEY_MIN_FOCUS_SCALE); + final int maxFocusPos = mParameters.getInt(CameraSettings.KEY_MAX_FOCUS_SCALE); + //update mparameters to fetch latest focus position + mParameters = mCameraDevice.getParameters(); + final int CurFocusPos = mParameters.getInt(CameraSettings.KEY_MANUAL_FOCUS_SCALE); + focusbar.setProgress(CurFocusPos); + focusPositionText.setText("Current focus position is " + CurFocusPos); + + alert.setMessage("Enter focus position in the range of " + minFocusPos + + " to " + maxFocusPos); + + focusbar.setOnSeekBarChangeListener(new OnSeekBarChangeListener() { + @Override + public void onStopTrackingTouch(SeekBar seekBar) { + } + + @Override + public void onStartTrackingTouch(SeekBar seekBar) { + } + + @Override + public void onProgressChanged(SeekBar seekBar, int progress,boolean fromUser) { + focusPositionText.setText("Current focus position is " + progress); + } + }); + linear.addView(focusbar); + linear.addView(focusPositionText); + alert.setView(linear); + alert.setPositiveButton("Ok",new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog,int id) + { + int focusPos = focusbar.getProgress(); + Log.v(TAG, "Setting focus position : " + focusPos); + mManual3AEnabled |= MANUAL_FOCUS; + mParameters.setFocusMode(Parameters.FOCUS_MODE_MANUAL_POSITION); + mParameters.set(CameraSettings.KEY_MANUAL_FOCUS_TYPE, 2); // 2 for scale mode + mParameters.set(CameraSettings.KEY_MANUAL_FOCUS_POSITION, focusPos); + updateCommonManual3ASettings(); + onSharedPreferenceChanged(); + } + }); + alert.show(); + } else if (manualFocusMode.equals(diopterMode)) { + String minFocusStr = mParameters.get(CameraSettings.KEY_MIN_FOCUS_DIOPTER); + String maxFocusStr = mParameters.get(CameraSettings.KEY_MAX_FOCUS_DIOPTER); + final double minFocusPos = Double.parseDouble(minFocusStr); + final double maxFocusPos = Double.parseDouble(maxFocusStr); + final EditText input = new EditText(mActivity); + int floatType = InputType.TYPE_NUMBER_FLAG_DECIMAL | InputType.TYPE_CLASS_NUMBER; + input.setInputType(floatType); + alert.setMessage("Enter focus position in the range of " + minFocusPos + + " to " + maxFocusPos); + //update mparameters to fetch latest focus position + mParameters = mCameraDevice.getParameters(); + final String CurFocusPos = mParameters.get(CameraSettings.KEY_MANUAL_FOCUS_DIOPTER); + focusPositionText.setText("Current focus position is " + CurFocusPos); + linear.addView(input); + linear.addView(focusPositionText); + alert.setView(linear); + alert.setPositiveButton("Ok",new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog,int id) + { + double focuspos = 0; + String focusStr = input.getText().toString(); + if (focusStr.length() > 0) { + focuspos = Double.parseDouble(focusStr); + } else { + Toast.makeText(mActivity, "Invalid focus position", + Toast.LENGTH_SHORT).show(); + return; + } + if (focuspos >= minFocusPos && focuspos <= maxFocusPos) { + Log.v(TAG, "Setting focus position : " + focusStr); + mManual3AEnabled |= MANUAL_FOCUS; + mParameters.setFocusMode(Parameters.FOCUS_MODE_MANUAL_POSITION); + //focus type 3 is diopter mode + mParameters.set(CameraSettings.KEY_MANUAL_FOCUS_TYPE, 3); + mParameters.set(CameraSettings.KEY_MANUAL_FOCUS_POSITION, focusStr); + updateCommonManual3ASettings(); + onSharedPreferenceChanged(); + } else { + Toast.makeText(mActivity, "Invalid focus position", + Toast.LENGTH_SHORT).show(); + } + } + }); + alert.show(); + } else { + mManual3AEnabled &= ~MANUAL_FOCUS; + mParameters.setFocusMode(mFocusManager.getFocusMode()); + mUI.overrideSettings(CameraSettings.KEY_FOCUS_MODE, null); + updateCommonManual3ASettings(); + onSharedPreferenceChanged(); + } + } + + private void UpdateManualWBSettings() { + //dismiss all popups first, because we need to show edit dialog + mUI.collapseCameraControls(); + final AlertDialog.Builder alert = new AlertDialog.Builder(mActivity); + LinearLayout linear = new LinearLayout(mActivity); + linear.setOrientation(1); + alert.setTitle("Manual White Balance Settings"); + alert.setNegativeButton("Cancel",new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog,int id) + { + dialog.cancel(); + } + }); + + String cctMode = mActivity.getString( + R.string.pref_camera_manual_wb_value_color_temperature); + String rgbGainMode = mActivity.getString( + R.string.pref_camera_manual_wb_value_rbgb_gains); + String manualWBMode = mPreferences.getString( + CameraSettings.KEY_MANUAL_WB, + mActivity.getString(R.string.pref_camera_manual_wb_default)); + final String wbPref = mPreferences.getString( + CameraSettings.KEY_WHITE_BALANCE, + mActivity.getString(R.string.pref_camera_whitebalance_default)); + Log.v(TAG, "manualWBMode selected = " + manualWBMode); + if (manualWBMode.equals(cctMode)) { + final TextView CCTtext = new TextView(mActivity); + final EditText CCTinput = new EditText(mActivity); + CCTinput.setInputType(InputType.TYPE_CLASS_NUMBER); + final int minCCT = mParameters.getInt(CameraSettings.KEY_MIN_WB_CCT); + final int maxCCT = mParameters.getInt(CameraSettings.KEY_MAX_WB_CCT); + + //refresh camera parameters to get latest CCT value + mParameters = mCameraDevice.getParameters(); + String currentCCT = mParameters.get(CameraSettings.KEY_MANUAL_WB_CCT); + if (currentCCT != null) { + CCTtext.setText("Current CCT is " + currentCCT); + } + alert.setMessage("Enter CCT value in the range of " + minCCT+ " to " + maxCCT); + linear.addView(CCTinput); + linear.addView(CCTtext); + alert.setView(linear); + alert.setPositiveButton("Ok",new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog,int id) + { + int newCCT = -1; + String cct = CCTinput.getText().toString(); + if (cct.length() > 0) { + newCCT = Integer.parseInt(cct); + } + if (newCCT <= maxCCT && newCCT >= minCCT) { + mManual3AEnabled |= MANUAL_WB; + Log.v(TAG, "Setting CCT value : " + newCCT); + mParameters.setWhiteBalance(CameraSettings.KEY_MANUAL_WHITE_BALANCE); + //0 corresponds to manual CCT mode + mParameters.set(CameraSettings.KEY_MANUAL_WB_TYPE, 0); + mParameters.set(CameraSettings.KEY_MANUAL_WB_VALUE, newCCT); + updateCommonManual3ASettings(); + onSharedPreferenceChanged(); + } else { + Toast.makeText(mActivity, "Invalid CCT", Toast.LENGTH_SHORT).show(); + } + } + }); + alert.show(); + } else if (manualWBMode.equals(rgbGainMode)) { + final TextView RGBtext = new TextView(mActivity); + final EditText Rinput = new EditText(mActivity); + Rinput.setHint("Enter R gain here"); + final EditText Ginput = new EditText(mActivity); + Ginput.setHint("Enter G gain here"); + final EditText Binput = new EditText(mActivity); + Binput.setHint("Enter B gain here"); + + int floatType = InputType.TYPE_NUMBER_FLAG_DECIMAL | InputType.TYPE_CLASS_NUMBER; + Rinput.setInputType(floatType); + Ginput.setInputType(floatType); + Binput.setInputType(floatType); + + String minGainStr = mParameters.get(CameraSettings.KEY_MIN_WB_GAIN); + final double minGain = Double.parseDouble(minGainStr); + String maxGainStr = mParameters.get(CameraSettings.KEY_MAX_WB_GAIN); + final double maxGain = Double.parseDouble(maxGainStr); + + //refresh camera parameters to get latest WB gains + mParameters = mCameraDevice.getParameters(); + String currentGains = mParameters.get(CameraSettings.KEY_MANUAL_WB_GAINS); + if (currentGains != null) { + RGBtext.setText("Current RGB gains are " + currentGains); + } + + alert.setMessage("Enter RGB gains in the range of " + minGain + + " to " + maxGain); + linear.addView(Rinput); + linear.addView(Ginput); + linear.addView(Binput); + linear.addView(RGBtext); + alert.setView(linear); + alert.setPositiveButton("Ok",new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog,int id) + { + String Rgain = Rinput.getText().toString(); + String Ggain = Ginput.getText().toString(); + String Bgain = Binput.getText().toString(); + if (Rgain.length() > 0 && Ggain.length() > 0 && Bgain.length() > 0) { + double Rgainf = Double.parseDouble(Rgain); + double Ggainf = Double.parseDouble(Ggain); + double Bgainf = Double.parseDouble(Bgain); + String RGBGain = Rgain + "," + Ggain + "," + Bgain; + if (Rgainf <= maxGain && Rgainf >= minGain && + Ggainf <= maxGain && Ggainf >= minGain && + Bgainf <= maxGain && Bgainf >= minGain) { + Log.v(TAG, "Setting RGB gains : " + RGBGain); + mManual3AEnabled |= MANUAL_WB; + mParameters.setWhiteBalance(CameraSettings.KEY_MANUAL_WHITE_BALANCE); + // 1 corresponds to manual WB gain mode + mParameters.set(CameraSettings.KEY_MANUAL_WB_TYPE, 1); + mParameters.set(CameraSettings.KEY_MANUAL_WB_VALUE, RGBGain); + updateCommonManual3ASettings(); + onSharedPreferenceChanged(); + } else { + Toast.makeText(mActivity, "Invalid RGB gains", + Toast.LENGTH_SHORT).show(); + } + } else { + Toast.makeText(mActivity, "Invalid RGB gains", + Toast.LENGTH_SHORT).show(); + } + } + }); + alert.show(); + } else { + //reset white balance + mManual3AEnabled &= ~MANUAL_WB; + mUI.overrideSettings(CameraSettings.KEY_WHITE_BALANCE, null); + updateCommonManual3ASettings(); + onSharedPreferenceChanged(); + } + } + + private void UpdateManualExposureSettings() { + //dismiss all popups first, because we need to show edit dialog + mUI.collapseCameraControls(); + final AlertDialog.Builder alert = new AlertDialog.Builder(mActivity); + LinearLayout linear = new LinearLayout(mActivity); + linear.setOrientation(1); + final TextView ISOtext = new TextView(mActivity); + final EditText ISOinput = new EditText(mActivity); + final TextView ExpTimeText = new TextView(mActivity); + final EditText ExpTimeInput = new EditText(mActivity); + ISOinput.setInputType(InputType.TYPE_CLASS_NUMBER); + int floatType = InputType.TYPE_NUMBER_FLAG_DECIMAL | InputType.TYPE_CLASS_NUMBER; + ExpTimeInput.setInputType(floatType); + alert.setTitle("Manual Exposure Settings"); + alert.setNegativeButton("Cancel",new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog,int id) + { + dialog.cancel(); + } + }); + + mParameters = mCameraDevice.getParameters(); + final int minISO = mParameters.getInt(CameraSettings.KEY_MIN_ISO); + final int maxISO = mParameters.getInt(CameraSettings.KEY_MAX_ISO); + String isoMode = mParameters.getISOValue(); + final String isoManual = CameraSettings.KEY_MANUAL_ISO; + String currentISO = mParameters.get(CameraSettings.KEY_CURRENT_ISO); + if (currentISO != null) { + ISOtext.setText("Current ISO is " + currentISO); + } + + final String minExpTime = mParameters.get(CameraSettings.KEY_MIN_EXPOSURE_TIME); + final String maxExpTime = mParameters.get(CameraSettings.KEY_MAX_EXPOSURE_TIME); + String currentExpTime = mParameters.get(CameraSettings.KEY_CURRENT_EXPOSURE_TIME); + if (currentExpTime != null) { + ExpTimeText.setText("Current exposure time is " + currentExpTime); + } + + String isoPriority = mActivity.getString( + R.string.pref_camera_manual_exp_value_ISO_priority); + String expTimePriority = mActivity.getString( + R.string.pref_camera_manual_exp_value_exptime_priority); + String userSetting = mActivity.getString( + R.string.pref_camera_manual_exp_value_user_setting); + String manualExposureMode = mPreferences.getString( + CameraSettings.KEY_MANUAL_EXPOSURE, + mActivity.getString(R.string.pref_camera_manual_exp_default)); + Log.v(TAG, "manual Exposure Mode selected = " + manualExposureMode); + if (manualExposureMode.equals(isoPriority)) { + alert.setMessage("Enter ISO in the range of " + minISO + " to " + maxISO); + linear.addView(ISOinput); + linear.addView(ISOtext); + alert.setView(linear); + alert.setPositiveButton("Ok",new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog,int id) + { + int newISO = -1; + String iso = ISOinput.getText().toString(); + Log.v(TAG, "string iso length " + iso.length()); + if (iso.length() > 0) { + newISO = Integer.parseInt(iso); + } + if (newISO <= maxISO && newISO >= minISO) { + Log.v(TAG, "Setting ISO : " + newISO); + mManual3AEnabled |= MANUAL_EXPOSURE; + mParameters.setISOValue(isoManual); + mParameters.set(CameraSettings.KEY_CONTINUOUS_ISO, newISO); + mParameters.set(CameraSettings.KEY_EXPOSURE_TIME, "0"); + updateCommonManual3ASettings(); + onSharedPreferenceChanged(); + } else { + Toast.makeText(mActivity, "Invalid ISO", Toast.LENGTH_SHORT).show(); + } + } + }); + alert.show(); + } else if (manualExposureMode.equals(expTimePriority)) { + alert.setMessage("Enter exposure time in the range of " + minExpTime + + "ms to " + maxExpTime + "ms"); + linear.addView(ExpTimeInput); + linear.addView(ExpTimeText); + alert.setView(linear); + alert.setPositiveButton("Ok",new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog,int id) + { + double newExpTime = -1; + String expTime = ExpTimeInput.getText().toString(); + if (expTime.length() > 0) { + newExpTime = Double.parseDouble(expTime); + } + if (newExpTime <= Double.parseDouble(maxExpTime) && + newExpTime >= Double.parseDouble(minExpTime)) { + Log.v(TAG, "Setting Exposure time : " + newExpTime); + mManual3AEnabled |= MANUAL_EXPOSURE; + mParameters.set(CameraSettings.KEY_EXPOSURE_TIME, expTime); + mParameters.setISOValue(Parameters.ISO_AUTO); + mUI.setPreference(CameraSettings.KEY_ISO, Parameters.ISO_AUTO); + mUI.overrideSettings(CameraSettings.KEY_ISO, null); + updateCommonManual3ASettings(); + onSharedPreferenceChanged(); + } else { + Toast.makeText(mActivity, "Invalid exposure time", + Toast.LENGTH_SHORT).show(); + } + } + }); + alert.show(); + } else if (manualExposureMode.equals(userSetting)) { + alert.setMessage("Full manual mode - Enter both ISO and Exposure Time"); + final TextView ISORangeText = new TextView(mActivity); + final TextView ExpTimeRangeText = new TextView(mActivity); + ISORangeText.setText("Enter ISO in the range of " + minISO + " to " + maxISO); + ExpTimeRangeText.setText("Enter exposure time in the range of " + minExpTime + + "ms to " + maxExpTime + "ms"); + linear.addView(ISORangeText); + linear.addView(ISOinput); + linear.addView(ISOtext); + linear.addView(ExpTimeRangeText); + linear.addView(ExpTimeInput); + linear.addView(ExpTimeText); + alert.setView(linear); + alert.setPositiveButton("Ok",new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog,int id) + { + int newISO = -1; + String iso = ISOinput.getText().toString(); + Log.v(TAG, "string iso length " + iso.length()); + if (iso.length() > 0) { + newISO = Integer.parseInt(iso); + } + double newExpTime = -1; + String expTime = ExpTimeInput.getText().toString(); + if (expTime.length() > 0) { + newExpTime = Double.parseDouble(expTime); + } + if (newISO <= maxISO && newISO >= minISO && + newExpTime <= Double.parseDouble(maxExpTime) && + newExpTime >= Double.parseDouble(minExpTime)) { + mManual3AEnabled |= MANUAL_EXPOSURE; + Log.v(TAG, "Setting ISO : " + newISO); + mParameters.setISOValue(isoManual); + mParameters.set(CameraSettings.KEY_CONTINUOUS_ISO, newISO); + Log.v(TAG, "Setting Exposure time : " + newExpTime); + mParameters.set(CameraSettings.KEY_EXPOSURE_TIME, expTime); + updateCommonManual3ASettings(); + onSharedPreferenceChanged(); + } else { + Toast.makeText(mActivity, "Invalid input", Toast.LENGTH_SHORT).show(); + } + } + }); + alert.show(); + } else { + mManual3AEnabled &= ~MANUAL_EXPOSURE; + //auto exposure mode - reset both exposure time and ISO + mParameters.set(CameraSettings.KEY_EXPOSURE_TIME, "0"); + mUI.overrideSettings(CameraSettings.KEY_ISO, null); + updateCommonManual3ASettings(); + onSharedPreferenceChanged(); + } + } + // 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())); @@ -3485,6 +4034,19 @@ public class PhotoModule } } + if(CameraSettings.KEY_MANUAL_EXPOSURE.equals(pref.getKey())) { + UpdateManualExposureSettings(); + return; + } + if (CameraSettings.KEY_MANUAL_WB.equals(pref.getKey())) { + UpdateManualWBSettings(); + return; + } + if (CameraSettings.KEY_MANUAL_FOCUS.equals(pref.getKey())) { + UpdateManualFocusSettings(); + return; + } + //call generic onSharedPreferenceChanged onSharedPreferenceChanged(); } |