| /* |
| * Copyright (C) 2013 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.camera; |
| |
| import android.content.Context; |
| import android.content.res.TypedArray; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.widget.ImageButton; |
| import android.widget.LinearLayout; |
| |
| import com.android.camera.app.AppController; |
| import com.android.camera.app.CameraAppUI; |
| import com.android.camera.settings.Keys; |
| import com.android.camera.settings.SettingsManager; |
| import com.android.camera.ui.RadioOptions; |
| import com.android.camera.util.PhotoSphereHelper; |
| import com.android.camera.widget.ModeOptions; |
| import com.android.camera2.R; |
| |
| /** |
| * A class for generating pre-initialized |
| * {@link #android.widget.ImageButton}s. |
| */ |
| public class ButtonManager implements SettingsManager.OnSettingChangedListener { |
| public static final int BUTTON_FLASH = 0; |
| public static final int BUTTON_TORCH = 1; |
| public static final int BUTTON_HDR_PLUS_FLASH = 2; |
| public static final int BUTTON_CAMERA = 3; |
| public static final int BUTTON_HDR_PLUS = 4; |
| public static final int BUTTON_HDR = 5; |
| public static final int BUTTON_CANCEL = 6; |
| public static final int BUTTON_DONE = 7; |
| public static final int BUTTON_RETAKE = 8; |
| public static final int BUTTON_REVIEW = 9; |
| public static final int BUTTON_GRID_LINES = 10; |
| public static final int BUTTON_EXPOSURE_COMPENSATION = 11; |
| public static final int BUTTON_COUNTDOWN = 12; |
| |
| /** For two state MultiToggleImageButtons, the off index. */ |
| public static final int OFF = 0; |
| /** For two state MultiToggleImageButtons, the on index. */ |
| public static final int ON = 1; |
| |
| private static final int NO_RESOURCE = -1; |
| |
| /** A reference to the application's settings manager. */ |
| private final SettingsManager mSettingsManager; |
| |
| /** Bottom bar options toggle buttons. */ |
| private MultiToggleImageButton mButtonCamera; |
| private MultiToggleImageButton mButtonFlash; |
| private MultiToggleImageButton mButtonHdr; |
| private MultiToggleImageButton mButtonGridlines; |
| private MultiToggleImageButton mButtonCountdown; |
| |
| /** Intent UI buttons. */ |
| private ImageButton mButtonCancel; |
| private ImageButton mButtonDone; |
| private ImageButton mButtonRetake; // same as review. |
| |
| private ImageButton mButtonExposureCompensation; |
| private ImageButton mExposureN2; |
| private ImageButton mExposureN1; |
| private ImageButton mExposure0; |
| private ImageButton mExposureP1; |
| private ImageButton mExposureP2; |
| private RadioOptions mModeOptionsExposure; |
| private RadioOptions mModeOptionsPano; |
| private View mModeOptionsButtons; |
| private ModeOptions mModeOptions; |
| |
| private int mMinExposureCompensation; |
| private int mMaxExposureCompensation; |
| private float mExposureCompensationStep; |
| |
| /** A listener for button enabled and visibility |
| state changes. */ |
| private ButtonStatusListener mListener; |
| |
| /** An reference to the gcam mode index. */ |
| private static int sGcamIndex; |
| |
| /** Whether Camera Button can be enabled by generic operations. */ |
| private boolean mIsCameraButtonBlocked; |
| |
| private final AppController mAppController; |
| |
| /** |
| * Get a new global ButtonManager. |
| */ |
| public ButtonManager(AppController app) { |
| mAppController = app; |
| |
| Context context = app.getAndroidContext(); |
| sGcamIndex = context.getResources().getInteger(R.integer.camera_mode_gcam); |
| |
| mSettingsManager = app.getSettingsManager(); |
| mSettingsManager.addListener(this); |
| } |
| |
| /** |
| * Load references to buttons under a root View. |
| * Call this after the root clears/reloads all of its children |
| * to prevent stale references button views. |
| */ |
| public void load(View root) { |
| getButtonsReferences(root); |
| } |
| |
| /** |
| * ButtonStatusListener provides callbacks for when button's |
| * visibility changes and enabled status changes. |
| */ |
| public interface ButtonStatusListener { |
| /** |
| * A button's visibility has changed. |
| */ |
| public void onButtonVisibilityChanged(ButtonManager buttonManager, int buttonId); |
| |
| /** |
| * A button's enabled state has changed. |
| */ |
| public void onButtonEnabledChanged(ButtonManager buttonManager, int buttonId); |
| } |
| |
| /** |
| * Sets the ButtonStatusListener. |
| */ |
| public void setListener(ButtonStatusListener listener) { |
| mListener = listener; |
| } |
| |
| /** |
| * Gets references to all known buttons. |
| */ |
| private void getButtonsReferences(View root) { |
| mButtonCamera |
| = (MultiToggleImageButton) root.findViewById(R.id.camera_toggle_button); |
| mButtonFlash |
| = (MultiToggleImageButton) root.findViewById(R.id.flash_toggle_button); |
| mButtonHdr |
| = (MultiToggleImageButton) root.findViewById(R.id.hdr_plus_toggle_button); |
| mButtonGridlines |
| = (MultiToggleImageButton) root.findViewById(R.id.grid_lines_toggle_button); |
| mButtonCancel |
| = (ImageButton) root.findViewById(R.id.cancel_button); |
| mButtonDone |
| = (ImageButton) root.findViewById(R.id.done_button); |
| mButtonRetake |
| = (ImageButton) root.findViewById(R.id.retake_button); |
| |
| mButtonExposureCompensation = |
| (ImageButton) root.findViewById(R.id.exposure_button); |
| mExposureN2 = (ImageButton) root.findViewById(R.id.exposure_n2); |
| mExposureN1 = (ImageButton) root.findViewById(R.id.exposure_n1); |
| mExposure0 = (ImageButton) root.findViewById(R.id.exposure_0); |
| mExposureP1 = (ImageButton) root.findViewById(R.id.exposure_p1); |
| mExposureP2 = (ImageButton) root.findViewById(R.id.exposure_p2); |
| mModeOptionsExposure = (RadioOptions) root.findViewById(R.id.mode_options_exposure); |
| mModeOptionsPano = (RadioOptions) root.findViewById(R.id.mode_options_pano); |
| mModeOptionsButtons = root.findViewById(R.id.mode_options_buttons); |
| mModeOptions = (ModeOptions) root.findViewById(R.id.mode_options); |
| |
| mButtonCountdown = (MultiToggleImageButton) root.findViewById(R.id.countdown_toggle_button); |
| } |
| |
| @Override |
| public void onSettingChanged(SettingsManager settingsManager, String key) { |
| MultiToggleImageButton button = null; |
| int index = 0; |
| |
| if (key.equals(Keys.KEY_FLASH_MODE)) { |
| index = mSettingsManager.getIndexOfCurrentValue(mAppController.getCameraScope(), |
| Keys.KEY_FLASH_MODE); |
| button = getButtonOrError(BUTTON_FLASH); |
| } else if (key.equals(Keys.KEY_VIDEOCAMERA_FLASH_MODE)) { |
| index = mSettingsManager.getIndexOfCurrentValue(mAppController.getCameraScope(), |
| Keys.KEY_VIDEOCAMERA_FLASH_MODE); |
| button = getButtonOrError(BUTTON_TORCH); |
| } else if (key.equals(Keys.KEY_HDR_PLUS_FLASH_MODE)) { |
| index = mSettingsManager.getIndexOfCurrentValue(mAppController.getModuleScope(), |
| Keys.KEY_HDR_PLUS_FLASH_MODE); |
| button = getButtonOrError(BUTTON_HDR_PLUS_FLASH); |
| } else if (key.equals(Keys.KEY_CAMERA_ID)) { |
| index = mSettingsManager.getIndexOfCurrentValue(mAppController.getModuleScope(), |
| Keys.KEY_CAMERA_ID); |
| button = getButtonOrError(BUTTON_CAMERA); |
| } else if (key.equals(Keys.KEY_CAMERA_HDR_PLUS)) { |
| index = mSettingsManager.getIndexOfCurrentValue(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_CAMERA_HDR_PLUS); |
| button = getButtonOrError(BUTTON_HDR_PLUS); |
| } else if (key.equals(Keys.KEY_CAMERA_HDR)) { |
| index = mSettingsManager.getIndexOfCurrentValue(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_CAMERA_HDR); |
| button = getButtonOrError(BUTTON_HDR); |
| } else if (key.equals(Keys.KEY_CAMERA_GRID_LINES)) { |
| index = mSettingsManager.getIndexOfCurrentValue(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_CAMERA_GRID_LINES); |
| button = getButtonOrError(BUTTON_GRID_LINES); |
| } else if (key.equals(Keys.KEY_CAMERA_PANO_ORIENTATION)) { |
| updatePanoButtons(); |
| } else if (key.equals(Keys.KEY_EXPOSURE)) { |
| updateExposureButtons(); |
| } else if (key.equals(Keys.KEY_COUNTDOWN_DURATION)) { |
| index = mSettingsManager.getIndexOfCurrentValue(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_COUNTDOWN_DURATION); |
| button = getButtonOrError(BUTTON_COUNTDOWN); |
| } |
| |
| if (button != null && button.getState() != index) { |
| button.setState(Math.max(index, 0), false); |
| } |
| } |
| |
| /** |
| * A callback executed in the state listener of a button. |
| * |
| * Used by a module to set specific behavior when a button's |
| * state changes. |
| */ |
| public interface ButtonCallback { |
| public void onStateChanged(int state); |
| } |
| |
| /** |
| * Returns the appropriate {@link com.android.camera.MultiToggleImageButton} |
| * based on button id. An IllegalStateException will be throw if the |
| * button could not be found in the view hierarchy. |
| */ |
| private MultiToggleImageButton getButtonOrError(int buttonId) { |
| switch (buttonId) { |
| case BUTTON_FLASH: |
| if (mButtonFlash == null) { |
| throw new IllegalStateException("Flash button could not be found."); |
| } |
| return mButtonFlash; |
| case BUTTON_TORCH: |
| if (mButtonFlash == null) { |
| throw new IllegalStateException("Torch button could not be found."); |
| } |
| return mButtonFlash; |
| case BUTTON_HDR_PLUS_FLASH: |
| if (mButtonFlash == null) { |
| throw new IllegalStateException("Hdr plus torch button could not be found."); |
| } |
| return mButtonFlash; |
| case BUTTON_CAMERA: |
| if (mButtonCamera == null) { |
| throw new IllegalStateException("Camera button could not be found."); |
| } |
| return mButtonCamera; |
| case BUTTON_HDR_PLUS: |
| if (mButtonHdr == null) { |
| throw new IllegalStateException("Hdr plus button could not be found."); |
| } |
| return mButtonHdr; |
| case BUTTON_HDR: |
| if (mButtonHdr == null) { |
| throw new IllegalStateException("Hdr button could not be found."); |
| } |
| return mButtonHdr; |
| case BUTTON_GRID_LINES: |
| if (mButtonGridlines == null) { |
| throw new IllegalStateException("Grid lines button could not be found."); |
| } |
| return mButtonGridlines; |
| case BUTTON_COUNTDOWN: |
| if (mButtonCountdown == null) { |
| throw new IllegalStateException("Countdown button could not be found."); |
| } |
| return mButtonCountdown; |
| default: |
| throw new IllegalArgumentException("button not known by id=" + buttonId); |
| } |
| } |
| |
| /** |
| * Returns the appropriate {@link android.widget.ImageButton} |
| * based on button id. An IllegalStateException will be throw if the |
| * button could not be found in the view hierarchy. |
| */ |
| private ImageButton getImageButtonOrError(int buttonId) { |
| switch (buttonId) { |
| case BUTTON_CANCEL: |
| if (mButtonCancel == null) { |
| throw new IllegalStateException("Cancel button could not be found."); |
| } |
| return mButtonCancel; |
| case BUTTON_DONE: |
| if (mButtonDone == null) { |
| throw new IllegalStateException("Done button could not be found."); |
| } |
| return mButtonDone; |
| case BUTTON_RETAKE: |
| if (mButtonRetake == null) { |
| throw new IllegalStateException("Retake button could not be found."); |
| } |
| return mButtonRetake; |
| case BUTTON_REVIEW: |
| if (mButtonRetake == null) { |
| throw new IllegalStateException("Review button could not be found."); |
| } |
| return mButtonRetake; |
| case BUTTON_EXPOSURE_COMPENSATION: |
| if (mButtonExposureCompensation == null) { |
| throw new IllegalStateException("Exposure Compensation button could not be found."); |
| } |
| return mButtonExposureCompensation; |
| default: |
| throw new IllegalArgumentException("button not known by id=" + buttonId); |
| } |
| } |
| |
| /** |
| * Initialize a known button by id with a state change callback, and then |
| * enable the button. |
| * |
| * @param buttonId The id if the button to be initialized. |
| * @param cb The callback to be executed after the button state change. |
| */ |
| public void initializeButton(int buttonId, ButtonCallback cb) { |
| initializeButton(buttonId, cb, null); |
| } |
| |
| /** |
| * Initialize a known button by id, with a state change callback and a state |
| * pre-change callback, and then enable the button. |
| * |
| * @param buttonId The id if the button to be initialized. |
| * @param cb The callback to be executed after the button state change. |
| * @param preCb The callback to be executed before the button state change. |
| */ |
| public void initializeButton(int buttonId, ButtonCallback cb, ButtonCallback preCb) { |
| MultiToggleImageButton button = getButtonOrError(buttonId); |
| switch (buttonId) { |
| case BUTTON_FLASH: |
| initializeFlashButton(button, cb, preCb, R.array.camera_flashmode_icons); |
| break; |
| case BUTTON_TORCH: |
| initializeTorchButton(button, cb, preCb, R.array.video_flashmode_icons); |
| break; |
| case BUTTON_HDR_PLUS_FLASH: |
| initializeHdrPlusFlashButton(button, cb, preCb, R.array.camera_flashmode_icons); |
| break; |
| case BUTTON_CAMERA: |
| initializeCameraButton(button, cb, preCb, R.array.camera_id_icons); |
| break; |
| case BUTTON_HDR_PLUS: |
| initializeHdrPlusButton(button, cb, preCb, R.array.pref_camera_hdr_plus_icons); |
| break; |
| case BUTTON_HDR: |
| initializeHdrButton(button, cb, preCb, R.array.pref_camera_hdr_icons); |
| break; |
| case BUTTON_GRID_LINES: |
| initializeGridLinesButton(button, cb, preCb, R.array.grid_lines_icons); |
| break; |
| case BUTTON_COUNTDOWN: |
| initializeCountdownButton(button, cb, preCb, R.array.countdown_duration_icons); |
| break; |
| default: |
| throw new IllegalArgumentException("button not known by id=" + buttonId); |
| } |
| |
| showButton(buttonId); |
| enableButton(buttonId); |
| } |
| |
| /** |
| * Initialize a known button with a click listener and a drawable resource id, |
| * and a content description resource id. |
| * Sets the button visible. |
| */ |
| public void initializePushButton(int buttonId, View.OnClickListener cb, |
| int imageId, int contentDescriptionId) { |
| ImageButton button = getImageButtonOrError(buttonId); |
| button.setOnClickListener(cb); |
| if (imageId != NO_RESOURCE) { |
| button.setImageResource(imageId); |
| } |
| if (contentDescriptionId != NO_RESOURCE) { |
| button.setContentDescription(mAppController |
| .getAndroidContext().getResources().getString(contentDescriptionId)); |
| } |
| |
| if (!button.isEnabled()) { |
| button.setEnabled(true); |
| if (mListener != null) { |
| mListener.onButtonEnabledChanged(this, buttonId); |
| } |
| } |
| button.setTag(R.string.tag_enabled_id, buttonId); |
| |
| if (button.getVisibility() != View.VISIBLE) { |
| button.setVisibility(View.VISIBLE); |
| if (mListener != null) { |
| mListener.onButtonVisibilityChanged(this, buttonId); |
| } |
| } |
| } |
| |
| /** |
| * Initialize a known button with a click listener and a resource id. |
| * Sets the button visible. |
| */ |
| public void initializePushButton(int buttonId, View.OnClickListener cb, |
| int imageId) { |
| initializePushButton(buttonId, cb, imageId, NO_RESOURCE); |
| } |
| |
| /** |
| * Initialize a known button with a click listener. Sets the button visible. |
| */ |
| public void initializePushButton(int buttonId, View.OnClickListener cb) { |
| initializePushButton(buttonId, cb, NO_RESOURCE, NO_RESOURCE); |
| } |
| |
| /** |
| * Sets the camera button in its disabled (greyed out) state and blocks it |
| * so no generic operation can enable it until it's explicitly re-enabled by |
| * calling {@link #enableCameraButton()}. |
| */ |
| public void disableCameraButtonAndBlock() { |
| mIsCameraButtonBlocked = true; |
| disableButton(BUTTON_CAMERA); |
| } |
| |
| /** |
| * Sets a button in its disabled (greyed out) state. |
| */ |
| public void disableButton(int buttonId) { |
| View button; |
| if (buttonId == BUTTON_EXPOSURE_COMPENSATION) { |
| button = getImageButtonOrError(buttonId); |
| } else { |
| button = getButtonOrError(buttonId); |
| } |
| // HDR and HDR+ buttons share the same button object, |
| // but change actual image icons at runtime. |
| // This extra check is to ensure the correct icons are used |
| // in the case of the HDR[+] button being disabled at startup, |
| // e.g. app startup with front-facing camera. |
| // b/18104680 |
| if (buttonId == BUTTON_HDR_PLUS) { |
| initializeHdrPlusButtonIcons((MultiToggleImageButton) button, R.array.pref_camera_hdr_plus_icons); |
| } else if (buttonId == BUTTON_HDR) { |
| initializeHdrButtonIcons((MultiToggleImageButton) button, R.array.pref_camera_hdr_icons); |
| } |
| |
| if (button.isEnabled()) { |
| button.setEnabled(false); |
| if (mListener != null) { |
| mListener.onButtonEnabledChanged(this, buttonId); |
| } |
| } |
| button.setTag(R.string.tag_enabled_id, null); |
| } |
| |
| /** |
| * Enables the camera button and removes the block that was set by |
| * {@link #disableCameraButtonAndBlock()}. |
| */ |
| public void enableCameraButton() { |
| mIsCameraButtonBlocked = false; |
| enableButton(BUTTON_CAMERA); |
| } |
| |
| /** |
| * Enables a button that has already been initialized. |
| */ |
| public void enableButton(int buttonId) { |
| // If Camera Button is blocked, ignore the request. |
| if(buttonId == BUTTON_CAMERA && mIsCameraButtonBlocked) { |
| return; |
| } |
| ImageButton button; |
| // Manual exposure uses a regular image button instead of a |
| // MultiToggleImageButton, so it requires special handling. |
| // TODO: Redesign ButtonManager's button getter methods into one method. |
| if (buttonId == BUTTON_EXPOSURE_COMPENSATION) { |
| button = getImageButtonOrError(buttonId); |
| } else { |
| button = getButtonOrError(buttonId); |
| } |
| if (!button.isEnabled()) { |
| button.setEnabled(true); |
| if (mListener != null) { |
| mListener.onButtonEnabledChanged(this, buttonId); |
| } |
| } |
| button.setTag(R.string.tag_enabled_id, buttonId); |
| } |
| |
| /** |
| * Disable click reactions for a button without affecting visual state. |
| * For most cases you'll want to use {@link #disableButton(int)}. |
| * @param buttonId The id of the button. |
| */ |
| public void disableButtonClick(int buttonId) { |
| ImageButton button = getButtonOrError(buttonId); |
| if (button instanceof MultiToggleImageButton) { |
| ((MultiToggleImageButton) button).setClickEnabled(false); |
| } |
| } |
| |
| /** |
| * Enable click reactions for a button without affecting visual state. |
| * For most cases you'll want to use {@link #enableButton(int)}. |
| * @param buttonId The id of the button. |
| */ |
| public void enableButtonClick(int buttonId) { |
| ImageButton button = getButtonOrError(buttonId); |
| if (button instanceof MultiToggleImageButton) { |
| ((MultiToggleImageButton) button).setClickEnabled(true); |
| } |
| } |
| |
| /** |
| * Hide a button by id. |
| */ |
| public void hideButton(int buttonId) { |
| View button; |
| try { |
| button = getButtonOrError(buttonId); |
| } catch (IllegalArgumentException e) { |
| button = getImageButtonOrError(buttonId); |
| } |
| if (button.getVisibility() == View.VISIBLE) { |
| button.setVisibility(View.GONE); |
| if (mListener != null) { |
| mListener.onButtonVisibilityChanged(this, buttonId); |
| } |
| } |
| } |
| |
| /** |
| * Show a button by id. |
| */ |
| public void showButton(int buttonId) { |
| View button; |
| try { |
| button = getButtonOrError(buttonId); |
| } catch (IllegalArgumentException e) { |
| button = getImageButtonOrError(buttonId); |
| } |
| if (button.getVisibility() != View.VISIBLE) { |
| button.setVisibility(View.VISIBLE); |
| if (mListener != null) { |
| mListener.onButtonVisibilityChanged(this, buttonId); |
| } |
| } |
| } |
| |
| |
| public void setToInitialState() { |
| mModeOptions.setMainBar(ModeOptions.BAR_STANDARD); |
| } |
| |
| public void setExposureCompensationCallback(final CameraAppUI.BottomBarUISpec |
| .ExposureCompensationSetCallback cb) { |
| if (cb == null) { |
| mModeOptionsExposure.setOnOptionClickListener(null); |
| } else { |
| mModeOptionsExposure |
| .setOnOptionClickListener(new RadioOptions.OnOptionClickListener() { |
| @Override |
| public void onOptionClicked(View v) { |
| int comp = Integer.parseInt((String)(v.getTag())); |
| |
| if (mExposureCompensationStep != 0.0f) { |
| int compValue = |
| Math.round(comp / mExposureCompensationStep); |
| cb.setExposure(compValue); |
| } |
| } |
| }); |
| } |
| } |
| |
| /** |
| * Set the exposure compensation parameters supported by the current camera mode. |
| * @param min Minimum exposure compensation value. |
| * @param max Maximum exposure compensation value. |
| * @param step Expsoure compensation step value. |
| */ |
| public void setExposureCompensationParameters(int min, int max, float step) { |
| mMaxExposureCompensation = max; |
| mMinExposureCompensation = min; |
| mExposureCompensationStep = step; |
| |
| |
| setVisible(mExposureN2, (Math.round(min * step) <= -2)); |
| setVisible(mExposureN1, (Math.round(min * step) <= -1)); |
| setVisible(mExposureP1, (Math.round(max * step) >= 1)); |
| setVisible(mExposureP2, (Math.round(max * step) >= 2)); |
| |
| updateExposureButtons(); |
| } |
| |
| private static void setVisible(View v, boolean visible) { |
| if (visible) { |
| v.setVisibility(View.VISIBLE); |
| } else { |
| v.setVisibility(View.INVISIBLE); |
| } |
| } |
| |
| /** |
| * @return The exposure compensation step value. |
| **/ |
| public float getExposureCompensationStep() { |
| return mExposureCompensationStep; |
| } |
| |
| /** |
| * Check if a button is enabled with the given button id.. |
| */ |
| public boolean isEnabled(int buttonId) { |
| View button; |
| try { |
| button = getButtonOrError(buttonId); |
| } catch (IllegalArgumentException e) { |
| button = getImageButtonOrError(buttonId); |
| } |
| |
| Integer enabledId = (Integer) button.getTag(R.string.tag_enabled_id); |
| if (enabledId != null) { |
| return (enabledId.intValue() == buttonId) && button.isEnabled(); |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Check if a button is visible. |
| */ |
| public boolean isVisible(int buttonId) { |
| View button; |
| try { |
| button = getButtonOrError(buttonId); |
| } catch (IllegalArgumentException e) { |
| button = getImageButtonOrError(buttonId); |
| } |
| return (button.getVisibility() == View.VISIBLE); |
| } |
| |
| /** |
| * Initialize a flash button. |
| */ |
| private void initializeFlashButton(MultiToggleImageButton button, |
| final ButtonCallback cb, final ButtonCallback preCb, int resIdImages) { |
| |
| if (resIdImages > 0) { |
| button.overrideImageIds(resIdImages); |
| } |
| button.overrideContentDescriptions(R.array.camera_flash_descriptions); |
| |
| int index = mSettingsManager.getIndexOfCurrentValue(mAppController.getCameraScope(), |
| Keys.KEY_FLASH_MODE); |
| button.setState(index >= 0 ? index : 0, false); |
| |
| setPreChangeCallback(button, preCb); |
| |
| button.setOnStateChangeListener(new MultiToggleImageButton.OnStateChangeListener() { |
| @Override |
| public void stateChanged(View view, int state) { |
| mSettingsManager.setValueByIndex(mAppController.getCameraScope(), |
| Keys.KEY_FLASH_MODE, state); |
| if (cb != null) { |
| cb.onStateChanged(state); |
| } |
| } |
| }); |
| } |
| |
| /** |
| * Initialize video torch button |
| */ |
| private void initializeTorchButton(MultiToggleImageButton button, |
| final ButtonCallback cb, final ButtonCallback preCb, int resIdImages) { |
| |
| if (resIdImages > 0) { |
| button.overrideImageIds(resIdImages); |
| } |
| button.overrideContentDescriptions(R.array.video_flash_descriptions); |
| |
| int index = mSettingsManager.getIndexOfCurrentValue(mAppController.getCameraScope(), |
| Keys.KEY_VIDEOCAMERA_FLASH_MODE); |
| button.setState(index >= 0 ? index : 0, false); |
| |
| setPreChangeCallback(button, preCb); |
| |
| button.setOnStateChangeListener(new MultiToggleImageButton.OnStateChangeListener() { |
| @Override |
| public void stateChanged(View view, int state) { |
| mSettingsManager.setValueByIndex(mAppController.getCameraScope(), |
| Keys.KEY_VIDEOCAMERA_FLASH_MODE, state); |
| if (cb != null) { |
| cb.onStateChanged(state); |
| } |
| } |
| }); |
| } |
| |
| /** |
| * Initialize hdr plus flash button |
| */ |
| private void initializeHdrPlusFlashButton(MultiToggleImageButton button, |
| final ButtonCallback cb, final ButtonCallback preCb, int resIdImages) { |
| |
| if (resIdImages > 0) { |
| button.overrideImageIds(resIdImages); |
| } |
| button.overrideContentDescriptions(R.array.hdr_plus_flash_descriptions); |
| |
| int index = mSettingsManager.getIndexOfCurrentValue(mAppController.getModuleScope(), |
| Keys.KEY_HDR_PLUS_FLASH_MODE); |
| button.setState(index >= 0 ? index : 0, false); |
| |
| setPreChangeCallback(button, preCb); |
| |
| button.setOnStateChangeListener(new MultiToggleImageButton.OnStateChangeListener() { |
| @Override |
| public void stateChanged(View view, int state) { |
| mSettingsManager.setValueByIndex(mAppController.getModuleScope(), |
| Keys.KEY_HDR_PLUS_FLASH_MODE, state); |
| if (cb != null) { |
| cb.onStateChanged(state); |
| } |
| } |
| }); |
| } |
| |
| /** |
| * Initialize a camera button. |
| */ |
| private void initializeCameraButton(final MultiToggleImageButton button, |
| final ButtonCallback cb, final ButtonCallback preCb, int resIdImages) { |
| |
| if (resIdImages > 0) { |
| button.overrideImageIds(resIdImages); |
| } |
| |
| int index = mSettingsManager.getIndexOfCurrentValue(mAppController.getModuleScope(), |
| Keys.KEY_CAMERA_ID); |
| button.setState(index >= 0 ? index : 0, false); |
| |
| setPreChangeCallback(button, preCb); |
| |
| button.setOnStateChangeListener(new MultiToggleImageButton.OnStateChangeListener() { |
| @Override |
| public void stateChanged(View view, int state) { |
| mSettingsManager.setValueByIndex(mAppController.getModuleScope(), |
| Keys.KEY_CAMERA_ID, state); |
| int cameraId = mSettingsManager.getInteger(mAppController.getModuleScope(), |
| Keys.KEY_CAMERA_ID); |
| // This is a quick fix for ISE in Gcam module which can be |
| // found by rapid pressing camera switch button. The assumption |
| // here is that each time this button is clicked, the listener |
| // will do something and then enable this button again. |
| button.setEnabled(false); |
| if (cb != null) { |
| cb.onStateChanged(cameraId); |
| } |
| mAppController.getCameraAppUI().onChangeCamera(); |
| } |
| }); |
| } |
| |
| /** |
| * Initialize an hdr plus button. |
| */ |
| private void initializeHdrPlusButton(MultiToggleImageButton button, |
| final ButtonCallback cb, final ButtonCallback preCb, int resIdImages) { |
| |
| initializeHdrPlusButtonIcons(button, resIdImages); |
| |
| int index = mSettingsManager.getIndexOfCurrentValue(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_CAMERA_HDR_PLUS); |
| button.setState(index >= 0 ? index : 0, false); |
| |
| setPreChangeCallback(button, preCb); |
| |
| button.setOnStateChangeListener(new MultiToggleImageButton.OnStateChangeListener() { |
| @Override |
| public void stateChanged(View view, int state) { |
| mSettingsManager.setValueByIndex(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_CAMERA_HDR_PLUS, state); |
| if (cb != null) { |
| cb.onStateChanged(state); |
| } |
| } |
| }); |
| } |
| |
| private void initializeHdrPlusButtonIcons(MultiToggleImageButton button, int resIdImages) { |
| if (resIdImages > 0) { |
| button.overrideImageIds(resIdImages); |
| } |
| button.overrideContentDescriptions(R.array.hdr_plus_descriptions); |
| } |
| |
| /** |
| * Initialize an hdr button. |
| */ |
| private void initializeHdrButton(MultiToggleImageButton button, |
| final ButtonCallback cb, final ButtonCallback preCb, int resIdImages) { |
| |
| initializeHdrButtonIcons(button, resIdImages); |
| |
| int index = mSettingsManager.getIndexOfCurrentValue(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_CAMERA_HDR); |
| button.setState(index >= 0 ? index : 0, false); |
| |
| setPreChangeCallback(button, preCb); |
| |
| button.setOnStateChangeListener(new MultiToggleImageButton.OnStateChangeListener() { |
| @Override |
| public void stateChanged(View view, int state) { |
| mSettingsManager.setValueByIndex(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_CAMERA_HDR, state); |
| if (cb != null) { |
| cb.onStateChanged(state); |
| } |
| } |
| }); |
| } |
| |
| private void initializeHdrButtonIcons(MultiToggleImageButton button, int resIdImages) { |
| if (resIdImages > 0) { |
| button.overrideImageIds(resIdImages); |
| } |
| button.overrideContentDescriptions(R.array.hdr_descriptions); |
| } |
| |
| /** |
| * Initialize a countdown timer button. |
| */ |
| private void initializeCountdownButton(MultiToggleImageButton button, |
| final ButtonCallback cb, final ButtonCallback preCb, int resIdImages) { |
| if (resIdImages > 0) { |
| button.overrideImageIds(resIdImages); |
| } |
| |
| int index = mSettingsManager.getIndexOfCurrentValue(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_COUNTDOWN_DURATION); |
| button.setState(index >= 0 ? index : 0, false); |
| |
| setPreChangeCallback(button, preCb); |
| |
| button.setOnStateChangeListener(new MultiToggleImageButton.OnStateChangeListener() { |
| @Override |
| public void stateChanged(View view, int state) { |
| mSettingsManager.setValueByIndex(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_COUNTDOWN_DURATION, state); |
| if(cb != null) { |
| cb.onStateChanged(state); |
| } |
| } |
| }); |
| } |
| |
| /** |
| * Update the visual state of the manual exposure buttons |
| */ |
| public void updateExposureButtons() { |
| int compValue = mSettingsManager.getInteger(mAppController.getCameraScope(), |
| Keys.KEY_EXPOSURE); |
| if (mExposureCompensationStep != 0.0f) { |
| int comp = Math.round(compValue * mExposureCompensationStep); |
| mModeOptionsExposure.setSelectedOptionByTag(String.valueOf(comp)); |
| } |
| } |
| |
| /** |
| * Initialize a grid lines button. |
| */ |
| private void initializeGridLinesButton(MultiToggleImageButton button, |
| final ButtonCallback cb, final ButtonCallback preCb, int resIdImages) { |
| |
| if (resIdImages > 0) { |
| button.overrideImageIds(resIdImages); |
| } |
| button.overrideContentDescriptions(R.array.grid_lines_descriptions); |
| |
| setPreChangeCallback(button, preCb); |
| |
| button.setOnStateChangeListener(new MultiToggleImageButton.OnStateChangeListener() { |
| @Override |
| public void stateChanged(View view, int state) { |
| mSettingsManager.setValueByIndex(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_CAMERA_GRID_LINES, state); |
| if (cb != null) { |
| cb.onStateChanged(state); |
| } |
| } |
| }); |
| |
| int index = mSettingsManager.getIndexOfCurrentValue(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_CAMERA_GRID_LINES); |
| button.setState(index >= 0 ? index : 0, true); |
| } |
| |
| public boolean isPanoEnabled() { |
| return mModeOptions.getMainBar() == ModeOptions.BAR_PANO; |
| } |
| |
| /** |
| * Initialize a panorama orientation buttons. |
| */ |
| public void initializePanoOrientationButtons(final ButtonCallback cb) { |
| int resIdImages = PhotoSphereHelper.getPanoramaOrientationOptionArrayId(); |
| int resIdDescriptions = PhotoSphereHelper.getPanoramaOrientationDescriptions(); |
| if (resIdImages > 0) { |
| TypedArray imageIds = null; |
| TypedArray descriptionIds = null; |
| try { |
| mModeOptions.setMainBar(ModeOptions.BAR_PANO); |
| imageIds = mAppController |
| .getAndroidContext().getResources().obtainTypedArray(resIdImages); |
| descriptionIds = mAppController |
| .getAndroidContext().getResources().obtainTypedArray(resIdDescriptions); |
| mModeOptionsPano.removeAllViews(); |
| final boolean isHorizontal = |
| (mModeOptionsPano.getOrientation() == LinearLayout.HORIZONTAL); |
| final int numImageIds = imageIds.length(); |
| for (int index = 0; index < numImageIds; index++) { |
| int i; |
| // if in portrait orientation (pano bar horizonal), order buttons normally |
| // if in landscape orientation (pano bar vertical), reverse button order |
| if (isHorizontal) { |
| i = index; |
| } else { |
| i = numImageIds - index - 1; |
| } |
| |
| int imageId = imageIds.getResourceId(i, 0); |
| if (imageId > 0) { |
| ImageButton imageButton = (ImageButton) LayoutInflater |
| .from(mAppController.getAndroidContext()) |
| .inflate(R.layout.mode_options_imagebutton_template, |
| mModeOptionsPano, false); |
| imageButton.setImageResource(imageId); |
| imageButton.setTag(String.valueOf(i)); |
| mModeOptionsPano.addView(imageButton); |
| |
| int descriptionId = descriptionIds.getResourceId(i, 0); |
| if (descriptionId > 0) { |
| imageButton.setContentDescription( |
| mAppController.getAndroidContext().getString(descriptionId)); |
| } |
| } |
| } |
| mModeOptionsPano.updateListeners(); |
| mModeOptionsPano |
| .setOnOptionClickListener(new RadioOptions.OnOptionClickListener() { |
| @Override |
| public void onOptionClicked(View v) { |
| if (cb != null) { |
| int state = Integer.parseInt((String)v.getTag()); |
| mSettingsManager.setValueByIndex(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_CAMERA_PANO_ORIENTATION, |
| state); |
| cb.onStateChanged(state); |
| } |
| } |
| }); |
| updatePanoButtons(); |
| } finally { |
| if (imageIds != null) { |
| imageIds.recycle(); |
| } |
| if (descriptionIds != null) { |
| descriptionIds.recycle(); |
| } |
| } |
| } |
| } |
| |
| private void updatePanoButtons() { |
| int modeIndex = mSettingsManager.getIndexOfCurrentValue(SettingsManager.SCOPE_GLOBAL, |
| Keys.KEY_CAMERA_PANO_ORIENTATION); |
| mModeOptionsPano.setSelectedOptionByTag(String.valueOf(modeIndex)); |
| } |
| |
| private void setPreChangeCallback(MultiToggleImageButton button, final ButtonCallback preCb) { |
| button.setOnPreChangeListener(new MultiToggleImageButton.OnStateChangeListener() { |
| @Override |
| public void stateChanged(View view, int state) { |
| if(preCb != null) { |
| preCb.onStateChanged(state); |
| } |
| } |
| }); |
| } |
| } |
