SnapdragonCamera: Add SettingsManager, scene, and filter

Add SettingsManager to work as a database for settings.
It will handle all dependencies and populate the values.
Add scene mode and filter.
Restructure UI and menu by combining them and leave the
handling of settings to SettingsManager

Change-Id: I185163fdddbffd29434e6a9c41b33be6d3388f88
CRs-Fixed: 1018118

1 files changed, 956 insertions, 411 deletions

diff --git a/src/com/android/camera/CaptureUI.java b/src/com/android/camera/CaptureUI.java
index a6accae7b..0060f2c8b 100644
--- a/src/com/android/camera/CaptureUI.java
+++ b/src/com/android/camera/CaptureUI.java
@@ -19,37 +19,35 @@
 
 package com.android.camera;
 
-import android.content.res.Configuration;
-import android.graphics.Matrix;
+import android.animation.Animator;
+import android.content.Context;
+import android.content.res.Resources;
 import android.graphics.Point;
-import android.graphics.RectF;
 import android.graphics.drawable.AnimationDrawable;
 import android.hardware.Camera.Face;
-import android.hardware.camera2.CameraCharacteristics;
+import android.text.TextUtils;
 import android.util.Log;
+import android.view.Display;
 import android.view.Gravity;
+import android.view.LayoutInflater;
 import android.view.MotionEvent;
 import android.view.SurfaceHolder;
-import android.view.SurfaceView;
 import android.view.View;
-import android.view.View.OnClickListener;
-import android.view.View.OnLayoutChangeListener;
 import android.view.ViewGroup;
+import android.view.ViewPropertyAnimator;
+import android.view.WindowManager;
 import android.widget.FrameLayout;
-import android.widget.FrameLayout.LayoutParams;
+import android.widget.ImageView;
 import android.widget.LinearLayout;
-import android.widget.ListView;
-import android.widget.PopupWindow;
+import android.widget.TextView;
 
-import com.android.camera.CameraPreference.OnPreferenceChangedListener;
-import com.android.camera.FocusOverlayManager.FocusUI;
+import com.android.camera.ui.AutoFitSurfaceView;
 import com.android.camera.ui.CameraControls;
-import com.android.camera.ui.CameraRootView;
 import com.android.camera.ui.FocusIndicator;
+import com.android.camera.ui.ListMenu;
 import com.android.camera.ui.ListSubMenu;
 import com.android.camera.ui.ModuleSwitcher;
 import com.android.camera.ui.PieRenderer;
-import com.android.camera.ui.PieRenderer.PieListener;
 import com.android.camera.ui.RenderOverlay;
 import com.android.camera.ui.RotateImageView;
 import com.android.camera.ui.RotateLayout;
@@ -60,150 +58,173 @@ import com.android.camera.util.CameraUtil;
 import org.codeaurora.snapcam.R;
 
 import java.util.List;
+import java.util.Locale;
 
-public class CaptureUI implements PieListener,
+public class CaptureUI implements FocusOverlayManager.FocusUI,
         PreviewGestures.SingleTapListener,
-        FocusUI,
-        SurfaceHolder.Callback,
         LocationManager.Listener,
-        CameraRootView.MyDisplayListener,
-        CameraManager.CameraFaceDetectionCallback {
-
+        CameraManager.CameraFaceDetectionCallback,
+        SettingsManager.Listener,
+        ListMenu.Listener,
+        ListSubMenu.Listener {
+    private static final int HIGHLIGHT_COLOR = 0xff33b5e5;
     private static final String TAG = "SnapCam_CaptureUI";
+    private static final int SETTING_MENU_NONE = 0;
+    private static final int SETTING_MENU_IN_ANIMATION = 1;
+    private static final int SETTING_MENU_ON = 2;
+    private static final int SETTING_MENU_LEVEL_ONE = 0;
+    private static final int SETTING_MENU_LEVEL_TWO = 1;
+    private static final int SCENE_AND_FILTER_MENU_NONE = 0;
+    private static final int SCENE_AND_FILTER_MENU_IN_ANIMATION = 1;
+    private static final int SCENE_AND_FILTER_MENU_ON = 2;
+    private static final int MODE_FILTER = 0;
+    private static final int MODE_SCENE = 1;
+    private static final int ANIMATION_DURATION = 300;
+    private static final int CLICK_THRESHOLD = 200;
     public boolean mMenuInitialized = false;
-    private boolean surface1created = false;
-    private boolean surface2created = false;
+    String[] mSettingKeys = new String[]{
+            SettingsManager.KEY_FLASH_MODE,
+            SettingsManager.KEY_RECORD_LOCATION,
+            SettingsManager.KEY_PICTURE_SIZE,
+            SettingsManager.KEY_JPEG_QUALITY,
+            SettingsManager.KEY_CAMERA_SAVEPATH,
+            SettingsManager.KEY_WHITE_BALANCE,
+            SettingsManager.KEY_CAMERA2,
+            SettingsManager.KEY_DUAL_CAMERA,
+            SettingsManager.KEY_CLEARSIGHT
+    };
+    String[] mDeveloperKeys = new String[]{
+            SettingsManager.KEY_FLASH_MODE,
+            SettingsManager.KEY_RECORD_LOCATION,
+            SettingsManager.KEY_PICTURE_SIZE,
+            SettingsManager.KEY_JPEG_QUALITY,
+            SettingsManager.KEY_CAMERA_SAVEPATH,
+            SettingsManager.KEY_WHITE_BALANCE,
+            SettingsManager.KEY_CAMERA2,
+            SettingsManager.KEY_DUAL_CAMERA,
+            SettingsManager.KEY_CLEARSIGHT,
+            SettingsManager.KEY_MONO_PREVIEW
+    };
     private CameraActivity mActivity;
-    private PhotoController mController;
-    private PreviewGestures mGestures;
-
     private View mRootView;
+    private View mPreviewCover;
+    private CaptureModule mModule;
+    private AutoFitSurfaceView mSurfaceView;
+    private AutoFitSurfaceView mSurfaceView2;
     private SurfaceHolder mSurfaceHolder;
     private SurfaceHolder mSurfaceHolder2;
+    private boolean surface1created = false;
+    private boolean surface2created = false;
+    private int mOrientation;
+    private RotateLayout mMenuLayout;
+    private RotateLayout mSubMenuLayout;
+    private int mSettingMenuState;
+    private int mSettingMenuLevel;
+    private int mSceneAndFilterMenuStatus;
+    private int mSceneAndFilterMenuMode;
+    private ListMenu mSettingMenu;
+    private ListSubMenu mSettingSubMenu;
+    private PreviewGestures mGestures;
+    private boolean mUIhidden = false;
+    private SettingsManager mSettingsManager;
     private SurfaceHolder.Callback callback = new SurfaceHolder.Callback() {
 
         // SurfaceHolder callbacks
         @Override
         public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
+            Log.v(TAG, "surfaceChanged: width =" + width + ", height = " + height);
         }
 
         @Override
         public void surfaceCreated(SurfaceHolder holder) {
-            mSurfaceHolder2 = holder;
-            if (surface1created) mController.onPreviewUIReady();
-            surface2created = true;
+            Log.v(TAG, "surfaceCreated");
+            mSurfaceHolder = holder;
+            if (surface2created) mModule.onPreviewUIReady();
+            surface1created = true;
         }
 
         @Override
         public void surfaceDestroyed(SurfaceHolder holder) {
-            mSurfaceHolder2 = null;
-            surface2created = false;
+            Log.v(TAG, "surfaceDestroyed");
+            mSurfaceHolder = null;
+            surface1created = false;
+            mModule.onPreviewUIDestroyed();
         }
     };
-    private PopupWindow mPopup;
+
     private ShutterButton mShutterButton;
     private RenderOverlay mRenderOverlay;
     private View mMenuButton;
-    private CaptureMenu mMenu;
     private ModuleSwitcher mSwitcher;
     private CameraControls mCameraControls;
-    // Small indicators which show the camera settings in the viewfinder.
-    private OnScreenIndicators mOnScreenIndicators;
     private PieRenderer mPieRenderer;
     private ZoomRenderer mZoomRenderer;
-    private int mPreviewWidth = 0;
-    private int mPreviewHeight = 0;
-    private int mOriginalPreviewWidth = 0;
-    private int mOriginalPreviewHeight = 0;
-    private float mSurfaceTextureUncroppedWidth;
-    private float mSurfaceTextureUncroppedHeight;
-
-    private SurfaceView mSurfaceView = null;
-    private SurfaceView mSurfaceView2 = null;
-    private Matrix mMatrix = null;
-    private boolean mAspectRatioResize;
-
-    private boolean mOrientationResize;
-    private boolean mPrevOrientationResize;
-    private View mPreviewCover;
-    private RotateLayout mMenuLayout;
-    private RotateLayout mSubMenuLayout;
-    private LinearLayout mPreviewMenuLayout;
-    private boolean mUIhidden = false;
-    private int mPreviewOrientation = -1;
 
     private int mScreenRatio = CameraUtil.RATIO_UNKNOWN;
     private int mTopMargin = 0;
     private int mBottomMargin = 0;
+    private LinearLayout mSceneAndFilterLayout;
+    private int mSceneAndFilterMenuSize;
 
-    private int mOrientation;
-    private OnLayoutChangeListener mLayoutListener = new OnLayoutChangeListener() {
+    private View mFilterModeSwitcher;
+    private View mSceneModeSwitcher;
+    private View mFrontBackSwitcher;
+
+    private SurfaceHolder.Callback callback2 = new SurfaceHolder.Callback() {
+
+        // SurfaceHolder callbacks
         @Override
-        public void onLayoutChange(View v, int left, int top, int right,
-                                   int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
-            int width = right - left;
-            int height = bottom - top;
-
-            int orientation = mActivity.getResources().getConfiguration().orientation;
-            if ((orientation == Configuration.ORIENTATION_PORTRAIT && width > height)
-                    || (orientation == Configuration.ORIENTATION_LANDSCAPE && width < height)) {
-                // The screen has rotated; swap SurfaceView width & height
-                // to ensure correct preview
-                int oldWidth = width;
-                width = height;
-                height = oldWidth;
-                Log.d(TAG, "Swapping SurfaceView width & height dimensions");
-                if (mOriginalPreviewWidth != 0 && mOriginalPreviewHeight != 0) {
-                    int temp = mOriginalPreviewWidth;
-                    mOriginalPreviewWidth = mOriginalPreviewHeight;
-                    mOriginalPreviewHeight = temp;
-                }
-            }
+        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
+        }
 
-            if (mPreviewWidth != width || mPreviewHeight != height
-                    || (mOrientationResize != mPrevOrientationResize)
-                    || mAspectRatioResize) {
-                if (mOriginalPreviewWidth == 0) mOriginalPreviewWidth = width;
-                if (mOriginalPreviewHeight == 0) mOriginalPreviewHeight = height;
-                mPreviewWidth = width;
-                mPreviewHeight = height;
-                setTransformMatrix(mPreviewWidth, mPreviewHeight);
-                mController.onScreenSizeChanged((int) mSurfaceTextureUncroppedWidth,
-                        (int) mSurfaceTextureUncroppedHeight);
-                mAspectRatioResize = false;
-            }
+        @Override
+        public void surfaceCreated(SurfaceHolder holder) {
+            mSurfaceHolder2 = holder;
+            if (surface1created) mModule.onPreviewUIReady();
+            surface2created = true;
+        }
 
-            if (mMenu != null)
-                mMenu.tryToCloseSubList();
+        @Override
+        public void surfaceDestroyed(SurfaceHolder holder) {
+            mSurfaceHolder2 = null;
+            surface2created = false;
         }
     };
 
-    public CaptureUI(CameraActivity activity, PhotoController controller, View parent) {
+    public CaptureUI(CameraActivity activity, CaptureModule module, View parent) {
         mActivity = activity;
-        mController = controller;
+        mModule = module;
         mRootView = parent;
+        mSettingsManager = SettingsManager.getInstance();
+        mSettingsManager.registerListener(this);
         mActivity.getLayoutInflater().inflate(R.layout.capture_module,
                 (ViewGroup) mRootView, true);
         mPreviewCover = mRootView.findViewById(R.id.preview_cover);
         // display the view
-        mSurfaceView = (SurfaceView) mRootView.findViewById(R.id.mdp_preview_content);
-        mSurfaceView2 = (SurfaceView) mRootView.findViewById(R.id.mdp_preview_content2);
+        mSurfaceView = (AutoFitSurfaceView) mRootView.findViewById(R.id.mdp_preview_content);
+        mSurfaceView2 = (AutoFitSurfaceView) mRootView.findViewById(R.id.mdp_preview_content2);
         mSurfaceView2.setZOrderMediaOverlay(true);
         mSurfaceHolder = mSurfaceView.getHolder();
-        mSurfaceHolder.addCallback(this);
+        mSurfaceHolder.addCallback(callback);
         mSurfaceHolder2 = mSurfaceView2.getHolder();
-        mSurfaceHolder2.addCallback(callback);
-        Log.v(TAG, "Using mdp_preview_content (MDP path)");
+        mSurfaceHolder2.addCallback(callback2);
 
         mRenderOverlay = (RenderOverlay) mRootView.findViewById(R.id.render_overlay);
         mShutterButton = (ShutterButton) mRootView.findViewById(R.id.shutter_button);
+        mFilterModeSwitcher = mRootView.findViewById(R.id.filter_mode_switcher);
+        mSceneModeSwitcher = mRootView.findViewById(R.id.scene_mode_switcher);
+        mFrontBackSwitcher = mRootView.findViewById(R.id.front_back_switcher);
+        initFilterModeButton();
+        initSceneModeButton();
+        initSwitchCamera();
+
         mSwitcher = (ModuleSwitcher) mRootView.findViewById(R.id.camera_switcher);
         mSwitcher.setCurrentIndex(ModuleSwitcher.PHOTO_MODULE_INDEX);
         mSwitcher.setSwitchListener(mActivity);
-        mSwitcher.setOnClickListener(new OnClickListener() {
+        mSwitcher.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
-                if (mController.getCameraState() == PhotoController.LONGSHOT) {
+                if (mModule.getCameraState() == PhotoController.LONGSHOT) {
                     return;
                 }
                 mSwitcher.showPopup();
@@ -217,10 +238,6 @@ public class CaptureUI implements PieListener,
 
         mCameraControls = (CameraControls) mRootView.findViewById(R.id.camera_controls);
 
-        initIndicators();
-        mOrientationResize = false;
-        mPrevOrientationResize = false;
-
         Point size = new Point();
         mActivity.getWindowManager().getDefaultDisplay().getSize(size);
         mScreenRatio = CameraUtil.determineRatio(size.x, size.y);
@@ -234,64 +251,11 @@ public class CaptureUI implements PieListener,
         mCameraControls.setMargins(mTopMargin, mBottomMargin);
     }
 
-    private void setTransformMatrix(int width, int height) {
-        mMatrix = mSurfaceView.getMatrix();
-
-        // Calculate the new preview rectangle.
-        RectF previewRect = new RectF(0, 0, width, height);
-        mMatrix.mapRect(previewRect);
-        mController.onPreviewRectChanged(CameraUtil.rectFToRect(previewRect));
-    }
-
-    // SurfaceHolder callbacks
-    @Override
-    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
-        Log.v(TAG, "surfaceChanged: width =" + width + ", height = " + height);
-    }
-
-    @Override
-    public void surfaceCreated(SurfaceHolder holder) {
-        Log.v(TAG, "surfaceCreated");
-        mSurfaceHolder = holder;
-        if (surface2created) mController.onPreviewUIReady();
-        surface1created = true;
-        if (mPreviewWidth != 0 && mPreviewHeight != 0) {
-            // Re-apply transform matrix for new surface texture
-            setTransformMatrix(mPreviewWidth, mPreviewHeight);
-        }
-    }
-
-    @Override
-    public void surfaceDestroyed(SurfaceHolder holder) {
-        Log.v(TAG, "surfaceDestroyed");
-        mSurfaceHolder = null;
-        surface1created = false;
-        mController.onPreviewUIDestroyed();
-    }
-
-    public View getRootView() {
-        return mRootView;
-    }
-
-    private void initIndicators() {
-        mOnScreenIndicators = new OnScreenIndicators(mActivity,
-                mRootView.findViewById(R.id.on_screen_indicators));
-    }
-
-    public void onCameraOpened(CameraCharacteristics[] characteristics,
-                               List<Integer> characteristicsIndex, PreferenceGroup prefGroup,
-                               OnPreferenceChangedListener listener) {
+    public void onCameraOpened(List<Integer> cameraIds) {
         if (mPieRenderer == null) {
             mPieRenderer = new PieRenderer(mActivity);
-            mPieRenderer.setPieListener(this);
             mRenderOverlay.addRenderer(mPieRenderer);
         }
-
-        if (mMenu == null) {
-            mMenu = new CaptureMenu(mActivity, this);
-            mMenu.setListener(listener);
-        }
-        mMenu.initialize(prefGroup);
         mMenuInitialized = true;
 
         if (mZoomRenderer == null) {
@@ -304,209 +268,659 @@ public class CaptureUI implements PieListener,
             mGestures = new PreviewGestures(mActivity, this, mZoomRenderer, mPieRenderer);
             mRenderOverlay.setGestures(mGestures);
         }
-        mGestures.setCaptureMenu(mMenu);
+        mGestures.setCaptureUI(this); // need to handle touch
 
-        mGestures.setZoomEnabled(CameraUtil.isZoomSupported(characteristics, characteristicsIndex));
+        mGestures.setZoomEnabled(mSettingsManager.isZoomSupported(cameraIds));
         mGestures.setRenderOverlay(mRenderOverlay);
         mRenderOverlay.requestLayout();
 
-        initializeZoom(characteristics, characteristicsIndex);
+        initializeZoom(cameraIds);
         mActivity.setPreviewGestures(mGestures);
     }
 
-    public void initializeControlByIntent() {
-        mMenuButton = mRootView.findViewById(R.id.menu);
-        mMenuButton.setOnClickListener(new OnClickListener() {
-            @Override
-            public void onClick(View v) {
-                if (mMenu != null) {
-                    mMenu.openFirstLevel();
-                }
-            }
-        });
-    }
-
-    public void hideUI() {
-        mSwitcher.closePopup();
-        if (mUIhidden)
-            return;
-        mUIhidden = true;
-        mCameraControls.hideUI();
-    }
-
-    public void showUI() {
-        if (!mUIhidden || (mMenu != null && mMenu.isMenuBeingShown()))
-            return;
-        mUIhidden = false;
-        mCameraControls.showUI();
-    }
-
-    public boolean arePreviewControlsVisible() {
-        return !mUIhidden;
+    public ViewGroup getSceneAndFilterLayout() {
+        return mSceneAndFilterLayout;
     }
 
     // called from onResume but only the first time
     public void initializeFirstTime() {
         // Initialize shutter button.
         mShutterButton.setImageResource(R.drawable.shutter_button_anim);
-        mShutterButton.setOnClickListener(new OnClickListener() {
+        mShutterButton.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
                 if (!CameraControls.isAnimating())
                     doShutterAnimation();
             }
         });
-        mShutterButton.setOnShutterButtonListener(mController);
+        mShutterButton.setOnShutterButtonListener(mModule);
         mShutterButton.setVisibility(View.VISIBLE);
     }
 
-    // called from onResume every other time
-    public void initializeSecondTime() {
-        if (mMenu != null) {
-            mMenu.reloadPreferences();
+    public void initializeZoom(List<Integer> ids) {
+        if (!mSettingsManager.isZoomSupported(ids) || (mZoomRenderer == null))
+            return;
+
+        Float zoomMax = mSettingsManager.getMaxZoom(ids);
+        mZoomRenderer.setZoomMax(zoomMax);
+        mZoomRenderer.setZoom(1f);
+        mZoomRenderer.setOnZoomChangeListener(new ZoomChangeListener());
+    }
+
+    public void enableGestures(boolean enable) {
+        if (mGestures != null) {
+            mGestures.setEnabled(enable);
         }
     }
 
-    public void doShutterAnimation() {
-        AnimationDrawable frameAnimation = (AnimationDrawable) mShutterButton.getDrawable();
-        frameAnimation.stop();
-        frameAnimation.start();
+    public boolean isPreviewMenuBeingShown() {
+        return mSceneAndFilterMenuStatus == SCENE_AND_FILTER_MENU_ON;
     }
 
-    public void initializeZoom(CameraCharacteristics[] characteristics,
-                               List<Integer> characteristicsIndex) {
-        if ((characteristics == null) || !CameraUtil.isZoomSupported(characteristics,
-                characteristicsIndex) || (mZoomRenderer == null))
-            return;
-        if (mZoomRenderer != null) {
-            float zoomMax = Float.MAX_VALUE;
-            for (int i = 0; i < characteristicsIndex.size(); i++) {
-                zoomMax = Math.min(characteristics[characteristicsIndex.get(i)].get
-                        (CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM), zoomMax);
+    public void removeSceneAndFilterMenu(boolean animate) {
+        if (animate) {
+            animateSlideOut(mSceneAndFilterLayout);
+        } else {
+            mSceneAndFilterMenuStatus = SCENE_AND_FILTER_MENU_NONE;
+            if (mSceneAndFilterLayout != null) {
+                ((ViewGroup) mRootView).removeView(mSceneAndFilterLayout);
+                mSceneAndFilterLayout = null;
             }
-            mZoomRenderer.setZoomMax(zoomMax);
-            mZoomRenderer.setZoom(1f);
-            mZoomRenderer.setOnZoomChangeListener(new ZoomChangeListener());
         }
     }
 
-    @Override
-    public void showGpsOnScreenIndicator(boolean hasSignal) {
+    public void initSwitchCamera() {
+        mFrontBackSwitcher.setVisibility(View.INVISIBLE);
+        String value = mSettingsManager.getValue(SettingsManager.KEY_CAMERA_ID);
+        if (value == null)
+            return;
+
+        int[] largeIcons = mSettingsManager.getResource(SettingsManager.KEY_CAMERA_ID,
+                SettingsManager.RESOURCE_TYPE_LARGEICON);
+        ((ImageView) mFrontBackSwitcher).setImageResource(largeIcons[mSettingsManager
+                .getValueIndex(SettingsManager.KEY_CAMERA_ID)]);
+        mFrontBackSwitcher.setVisibility(View.VISIBLE);
+        mFrontBackSwitcher.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                String value = mSettingsManager.getValue(SettingsManager.KEY_CAMERA_ID);
+                if (value == null)
+                    return;
+
+                int index = mSettingsManager.getValueIndex(SettingsManager.KEY_CAMERA_ID);
+                CharSequence[] entries = mSettingsManager.getEntries(SettingsManager.KEY_CAMERA_ID);
+                index = (index + 1) % entries.length;
+                mSettingsManager.setValueIndex(SettingsManager.KEY_CAMERA_ID, index);
+                int[] largeIcons = mSettingsManager.getResource(SettingsManager.KEY_CAMERA_ID,
+                        SettingsManager.RESOURCE_TYPE_LARGEICON);
+                ((ImageView) v).setImageResource(largeIcons[index]);
+            }
+        });
     }
 
-    @Override
-    public void hideGpsOnScreenIndicator() {
+    public void initSceneModeButton() {
+        mSceneModeSwitcher.setVisibility(View.INVISIBLE);
+        String value = mSettingsManager.getValue(SettingsManager.KEY_SCENE_MODE);
+        if (value == null) return;
+        updateSceneModeIcon();
+        mSceneModeSwitcher.setVisibility(View.VISIBLE);
+        mSceneModeSwitcher.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                addSceneMode();
+                ViewGroup menuLayout = getSceneAndFilterLayout();
+                if (menuLayout != null) {
+                    View view = menuLayout.getChildAt(0);
+                    adjustOrientation();
+                    animateSlideIn(view, mSceneAndFilterMenuSize, false);
+                }
+            }
+        });
     }
 
-    public void overrideSettings(final String... keyvalues) {
-        if (mMenu == null)
-            return;
-        mMenu.overrideSettings(keyvalues);
+    public void initFilterModeButton() {
+        mFilterModeSwitcher.setVisibility(View.INVISIBLE);
+        String value = mSettingsManager.getValue(SettingsManager.KEY_COLOR_EFFECT);
+        if (value == null) return;
+        changeFilterModeControlIcon(value);
+
+        updateFilterModeIcon(!mSettingsManager.isOverriden(SettingsManager.KEY_COLOR_EFFECT));
+        mFilterModeSwitcher.setVisibility(View.VISIBLE);
+        mFilterModeSwitcher.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                addFilterMode();
+                ViewGroup menuLayout = getSceneAndFilterLayout();
+                if (menuLayout != null) {
+                    View view = getSceneAndFilterLayout().getChildAt(0);
+                    adjustOrientation();
+                    animateSlideIn(view, mSceneAndFilterMenuSize, false);
+                }
+            }
+        });
     }
 
-    public void enableGestures(boolean enable) {
-        if (mGestures != null) {
-            mGestures.setEnabled(enable);
+    public void setSwitcherIndex() {
+        mSwitcher.setCurrentIndex(ModuleSwitcher.PHOTO_MODULE_INDEX);
+    }
+
+    public void addSceneMode() {
+        String value = mSettingsManager.getValue(SettingsManager.KEY_SCENE_MODE);
+        if (value == null) return;
+
+        int rotation = CameraUtil.getDisplayRotation(mActivity);
+        boolean mIsDefaultToPortrait = CameraUtil.isDefaultToPortrait(mActivity);
+        if (!mIsDefaultToPortrait) {
+            rotation = (rotation + 90) % 360;
+        }
+        WindowManager wm = (WindowManager) mActivity.getSystemService(Context.WINDOW_SERVICE);
+        Display display = wm.getDefaultDisplay();
+
+        CharSequence[] entries = mSettingsManager.getEntries(SettingsManager.KEY_SCENE_MODE);
+
+        int[] thumbnails = mSettingsManager.getResource(SettingsManager.KEY_SCENE_MODE,
+                SettingsManager.RESOURCE_TYPE_THUMBNAIL);
+        Resources r = mActivity.getResources();
+        int height = (int) (r.getDimension(R.dimen.scene_mode_height) + 2
+                * r.getDimension(R.dimen.scene_mode_padding) + 1);
+        int width = (int) (r.getDimension(R.dimen.scene_mode_width) + 2
+                * r.getDimension(R.dimen.scene_mode_padding) + 1);
+
+        int gridRes;
+        boolean portrait = (rotation == 0) || (rotation == 180);
+        int size = height;
+        if (portrait) {
+            gridRes = R.layout.vertical_grid;
+            size = width;
+        } else {
+            gridRes = R.layout.horiz_grid;
+        }
+        mSceneAndFilterMenuSize = size;
+        hideUI();
+
+        LayoutInflater inflater = (LayoutInflater) mActivity.getSystemService(
+                Context.LAYOUT_INFLATER_SERVICE);
+        FrameLayout gridOuterLayout = (FrameLayout) inflater.inflate(
+                gridRes, null, false);
+
+        removeSceneAndFilterMenu(false);
+        mSceneAndFilterMenuStatus = SCENE_AND_FILTER_MENU_ON;
+        mSceneAndFilterMenuMode = MODE_SCENE;
+        mSceneAndFilterLayout = new LinearLayout(mActivity);
+        ViewGroup.LayoutParams params = null;
+        if (portrait) {
+            params = new ViewGroup.LayoutParams(size, FrameLayout.LayoutParams.MATCH_PARENT);
+            mSceneAndFilterLayout.setLayoutParams(params);
+            ((ViewGroup) mRootView).addView(mSceneAndFilterLayout);
+        } else {
+            params = new ViewGroup.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, size);
+            mSceneAndFilterLayout.setLayoutParams(params);
+            ((ViewGroup) mRootView).addView(mSceneAndFilterLayout);
+            mSceneAndFilterLayout.setY(display.getHeight() - size);
         }
+        gridOuterLayout.setLayoutParams(new FrameLayout.LayoutParams(FrameLayout.LayoutParams
+                .MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT));
+        LinearLayout gridLayout = (LinearLayout) gridOuterLayout.findViewById(R.id.layout);
+
+        final View[] views = new View[entries.length];
+        int init = mSettingsManager.getValueIndex(SettingsManager.KEY_SCENE_MODE);
+        for (int i = 0; i < entries.length; i++) {
+            RotateLayout sceneBox = (RotateLayout) inflater.inflate(
+                    R.layout.scene_mode_view, null, false);
+
+            ImageView imageView = (ImageView) sceneBox.findViewById(R.id.image);
+            TextView label = (TextView) sceneBox.findViewById(R.id.label);
+            final int j = i;
+
+            sceneBox.setOnTouchListener(new View.OnTouchListener() {
+                private long startTime;
+
+                @Override
+                public boolean onTouch(View v, MotionEvent event) {
+                    if (event.getAction() == MotionEvent.ACTION_DOWN) {
+                        startTime = System.currentTimeMillis();
+                    } else if (event.getAction() == MotionEvent.ACTION_UP) {
+                        if (System.currentTimeMillis() - startTime < CLICK_THRESHOLD) {
+                            mSettingsManager.setValueIndex(SettingsManager.KEY_SCENE_MODE, j);
+                            updateSceneModeIcon();
+                            for (View v1 : views) {
+                                v1.setBackgroundResource(R.drawable.scene_mode_view_border);
+                            }
+                            View border = v.findViewById(R.id.border);
+                            border.setBackgroundResource(R.drawable
+                                    .scene_mode_view_border_selected);
+                            removeSceneAndFilterMenu(true);
+                        }
+                    }
+                    return true;
+                }
+            });
+
+            View border = sceneBox.findViewById(R.id.border);
+            views[j] = border;
+            if (i == init)
+                border.setBackgroundResource(R.drawable.scene_mode_view_border_selected);
+
+            imageView.setImageResource(thumbnails[i]);
+            label.setText(entries[i]);
+            gridLayout.addView(sceneBox);
+        }
+        mSceneAndFilterLayout.addView(gridOuterLayout);
     }
 
-    // forward from preview gestures to controller
-    @Override
-    public void onSingleTapUp(View view, int x, int y) {
-        mController.onSingleTapUp(view, x, y);
+    public void updateSceneModeIcon() {
+        int[] thumbnails = mSettingsManager.getResource(SettingsManager.KEY_SCENE_MODE,
+                SettingsManager.RESOURCE_TYPE_THUMBNAIL);
+        int thumbnail = thumbnails[mSettingsManager.getValueIndex(SettingsManager
+                .KEY_SCENE_MODE)];
+        if (thumbnail == -1)
+            thumbnail = 0;
+        ((ImageView) mSceneModeSwitcher).setImageResource(thumbnail);
     }
 
-    public boolean onBackPressed() {
-        if (mMenu != null && mMenu.handleBackKey()) {
-            return true;
+    public void addFilterMode() {
+        if (mSettingsManager.getValue(SettingsManager.KEY_COLOR_EFFECT) == null)
+            return;
+
+        int rotation = CameraUtil.getDisplayRotation(mActivity);
+        boolean mIsDefaultToPortrait = CameraUtil.isDefaultToPortrait(mActivity);
+        if (!mIsDefaultToPortrait) {
+            rotation = (rotation + 90) % 360;
+        }
+        WindowManager wm = (WindowManager) mActivity.getSystemService(Context.WINDOW_SERVICE);
+        Display display = wm.getDefaultDisplay();
+        CharSequence[] entries = mSettingsManager.getEntries(SettingsManager.KEY_COLOR_EFFECT);
+
+        Resources r = mActivity.getResources();
+        int height = (int) (r.getDimension(R.dimen.filter_mode_height) + 2
+                * r.getDimension(R.dimen.filter_mode_padding) + 1);
+        int width = (int) (r.getDimension(R.dimen.filter_mode_width) + 2
+                * r.getDimension(R.dimen.filter_mode_padding) + 1);
+
+        int gridRes;
+        boolean portrait = (rotation == 0) || (rotation == 180);
+        int size = height;
+        if (portrait) {
+            gridRes = R.layout.vertical_grid;
+            size = width;
+        } else {
+            gridRes = R.layout.horiz_grid;
         }
+        mSceneAndFilterMenuSize = size;
+        hideUI();
 
-        if (mPieRenderer != null && mPieRenderer.showsItems()) {
-            mPieRenderer.hide();
-            return true;
+        int[] thumbnails = mSettingsManager.getResource(SettingsManager.KEY_COLOR_EFFECT,
+                SettingsManager.RESOURCE_TYPE_THUMBNAIL);
+        LayoutInflater inflater = (LayoutInflater) mActivity.getSystemService(
+                Context.LAYOUT_INFLATER_SERVICE);
+        FrameLayout gridOuterLayout = (FrameLayout) inflater.inflate(
+                gridRes, null, false);
+
+        removeSceneAndFilterMenu(false);
+        mSceneAndFilterMenuStatus = SCENE_AND_FILTER_MENU_ON;
+        mSceneAndFilterMenuMode = MODE_FILTER;
+        mSceneAndFilterLayout = new LinearLayout(mActivity);
+
+        ViewGroup.LayoutParams params = null;
+        if (portrait) {
+            params = new ViewGroup.LayoutParams(size, FrameLayout.LayoutParams.MATCH_PARENT);
+            mSceneAndFilterLayout.setLayoutParams(params);
+            ((ViewGroup) mRootView).addView(mSceneAndFilterLayout);
+        } else {
+            params = new ViewGroup.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, size);
+            mSceneAndFilterLayout.setLayoutParams(params);
+            ((ViewGroup) mRootView).addView(mSceneAndFilterLayout);
+            mSceneAndFilterLayout.setY(display.getHeight() - size);
         }
-        // In image capture mode, back button should:
-        // 1) if there is any popup, dismiss them, 2) otherwise, get out of
-        // image capture
-        if (mController.isImageCaptureIntent()) {
-            mController.onCaptureCancelled();
-            return true;
-        } else if (!mController.isCameraIdle()) {
-            // ignore backs while we're taking a picture
-            return true;
+        gridOuterLayout.setLayoutParams(new FrameLayout.LayoutParams(FrameLayout.LayoutParams
+                .MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT));
+        LinearLayout gridLayout = (LinearLayout) gridOuterLayout.findViewById(R.id.layout);
+        final View[] views = new View[entries.length];
+
+        int init = mSettingsManager.getValueIndex(SettingsManager.KEY_COLOR_EFFECT);
+        for (int i = 0; i < entries.length; i++) {
+            RotateLayout filterBox = (RotateLayout) inflater.inflate(
+                    R.layout.filter_mode_view, null, false);
+            ImageView imageView = (ImageView) filterBox.findViewById(R.id.image);
+            final int j = i;
+
+            filterBox.setOnTouchListener(new View.OnTouchListener() {
+                private long startTime;
+
+                @Override
+                public boolean onTouch(View v, MotionEvent event) {
+                    if (event.getAction() == MotionEvent.ACTION_DOWN) {
+                        startTime = System.currentTimeMillis();
+                    } else if (event.getAction() == MotionEvent.ACTION_UP) {
+                        if (System.currentTimeMillis() - startTime < CLICK_THRESHOLD) {
+                            mSettingsManager.setValueIndex(SettingsManager
+                                    .KEY_COLOR_EFFECT, j);
+                            for (View v1 : views) {
+                                v1.setBackground(null);
+                            }
+                            ImageView image = (ImageView) v.findViewById(R.id.image);
+                            image.setBackgroundColor(HIGHLIGHT_COLOR);
+                        }
+                    }
+                    return true;
+                }
+            });
+
+            views[j] = imageView;
+            if (i == init)
+                imageView.setBackgroundColor(HIGHLIGHT_COLOR);
+            TextView label = (TextView) filterBox.findViewById(R.id.label);
+
+            imageView.setImageResource(thumbnails[i]);
+            label.setText(entries[i]);
+            gridLayout.addView(filterBox);
         }
-        if (mSwitcher != null && mSwitcher.showsPopup()) {
-            mSwitcher.closePopup();
-            return true;
+        mSceneAndFilterLayout.addView(gridOuterLayout);
+    }
+
+    private void changeFilterModeControlIcon(String value) {
+        int index;
+        if (value.equals("0")) {
+            index = 0;
         } else {
-            return false;
+            index = 1;
         }
+        ImageView iv = (ImageView) mFilterModeSwitcher;
+        iv.setImageResource(mSettingsManager.getResource(SettingsManager
+                .KEY_COLOR_EFFECT, SettingsManager.RESOURCE_TYPE_LARGEICON)[index]);
     }
 
-    public void onPreviewFocusChanged(boolean previewFocused) {
-        if (previewFocused) {
-            showUI();
+    private void updateFilterModeIcon(boolean enable) {
+        buttonSetEnabled(mFilterModeSwitcher, enable);
+    }
+
+    private void buttonSetEnabled(View v, boolean enable) {
+        v.setEnabled(enable);
+        if (v instanceof ViewGroup) {
+            View v2 = ((ViewGroup) v).getChildAt(0);
+            if (v2 != null)
+                v2.setEnabled(enable);
+        }
+    }
+
+    private void animateFadeOut(final View v, final int level) {
+        if (v == null || mSettingMenuState == SETTING_MENU_IN_ANIMATION)
+            return;
+        mSettingMenuState = SETTING_MENU_IN_ANIMATION;
+
+        ViewPropertyAnimator vp = v.animate();
+        vp.alpha(0f).setDuration(ANIMATION_DURATION);
+        vp.setListener(new Animator.AnimatorListener() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+            }
+
+            @Override
+            public void onAnimationRepeat(Animator animation) {
+
+            }
+
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                finishSettingMenuAnimateOut(level);
+            }
+
+            @Override
+            public void onAnimationCancel(Animator animation) {
+                finishSettingMenuAnimateOut(level);
+            }
+        });
+        vp.start();
+    }
+
+    private void animateSlideOut(final View v, final int level) {
+        if (v == null || mSettingMenuState == SETTING_MENU_IN_ANIMATION)
+            return;
+        mSettingMenuState = SETTING_MENU_IN_ANIMATION;
+        ViewPropertyAnimator vp = v.animate();
+        if (View.LAYOUT_DIRECTION_RTL == TextUtils
+                .getLayoutDirectionFromLocale(Locale.getDefault())) {
+            switch (getOrientation()) {
+                case 0:
+                    vp.translationXBy(v.getWidth());
+                    break;
+                case 90:
+                    vp.translationYBy(-2 * v.getHeight());
+                    break;
+                case 180:
+                    vp.translationXBy(-2 * v.getWidth());
+                    break;
+                case 270:
+                    vp.translationYBy(v.getHeight());
+                    break;
+            }
         } else {
-            hideUI();
+            switch (getOrientation()) {
+                case 0:
+                    vp.translationXBy(-v.getWidth());
+                    break;
+                case 90:
+                    vp.translationYBy(2 * v.getHeight());
+                    break;
+                case 180:
+                    vp.translationXBy(2 * v.getWidth());
+                    break;
+                case 270:
+                    vp.translationYBy(-v.getHeight());
+                    break;
+            }
         }
-        if (mGestures != null) {
-            mGestures.setEnabled(previewFocused);
+        vp.setListener(new Animator.AnimatorListener() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+            }
+
+            @Override
+            public void onAnimationRepeat(Animator animation) {
+
+            }
+
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                finishSettingMenuAnimateOut(level);
+            }
+
+            @Override
+            public void onAnimationCancel(Animator animation) {
+                finishSettingMenuAnimateOut(level);
+            }
+        });
+        vp.setDuration(ANIMATION_DURATION).start();
+    }
+
+    private void finishSettingMenuAnimateOut(int level) {
+        if (level == SETTING_MENU_LEVEL_ONE) {
+            mSettingMenuState = SETTING_MENU_ON;
+            removeSettingMenu(level, false);
+            cleanUpMenus();
+        } else if (level == SETTING_MENU_LEVEL_TWO) {
+            mSettingMenuState = SETTING_MENU_ON;
+            removeSettingMenu(level, false);
         }
-        if (mRenderOverlay != null) {
-            // this can not happen in capture mode
-            mRenderOverlay.setVisibility(previewFocused ? View.VISIBLE : View.GONE);
+    }
+
+    private void finishScenceAndFilterMenuAnimateOut() {
+        removeSceneAndFilterMenu(false);
+        cleanUpMenus();
+    }
+
+    public void animateFadeIn(View v) {
+        ViewPropertyAnimator vp = v.animate();
+        vp.alpha(0.85f).setDuration(ANIMATION_DURATION);
+        vp.start();
+    }
+
+    private void animateSlideOut(final View v) {
+        if (v == null || mSceneAndFilterMenuStatus == SCENE_AND_FILTER_MENU_IN_ANIMATION)
+            return;
+        mSceneAndFilterMenuStatus = SCENE_AND_FILTER_MENU_IN_ANIMATION;
+
+        ViewPropertyAnimator vp = v.animate();
+        if (View.LAYOUT_DIRECTION_RTL == TextUtils
+                .getLayoutDirectionFromLocale(Locale.getDefault())) {
+            vp.translationXBy(v.getWidth()).setDuration(ANIMATION_DURATION);
+        } else {
+            vp.translationXBy(-v.getWidth()).setDuration(ANIMATION_DURATION);
         }
-        if (mPieRenderer != null) {
-            mPieRenderer.setBlockFocus(!previewFocused);
+        vp.setListener(new Animator.AnimatorListener() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+            }
+
+            @Override
+            public void onAnimationRepeat(Animator animation) {
+
+            }
+
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                finishScenceAndFilterMenuAnimateOut();
+            }
+
+            @Override
+            public void onAnimationCancel(Animator animation) {
+                finishScenceAndFilterMenuAnimateOut();
+            }
+        });
+        vp.start();
+    }
+
+    public void animateSlideIn(View v, int delta, boolean forcePortrait) {
+        int orientation = getOrientation();
+        if (!forcePortrait)
+            orientation = 0;
+
+        ViewPropertyAnimator vp = v.animate();
+        float dest;
+        if (View.LAYOUT_DIRECTION_RTL == TextUtils
+                .getLayoutDirectionFromLocale(Locale.getDefault())) {
+            switch (orientation) {
+                case 0:
+                    dest = v.getX();
+                    v.setX(-(dest - delta));
+                    vp.translationX(dest);
+                    break;
+                case 90:
+                    dest = v.getY();
+                    v.setY(-(dest + delta));
+                    vp.translationY(dest);
+                    break;
+                case 180:
+                    dest = v.getX();
+                    v.setX(-(dest + delta));
+                    vp.translationX(dest);
+                    break;
+                case 270:
+                    dest = v.getY();
+                    v.setY(-(dest - delta));
+                    vp.translationY(dest);
+                    break;
+            }
+        } else {
+            switch (orientation) {
+                case 0:
+                    dest = v.getX();
+                    v.setX(dest - delta);
+                    vp.translationX(dest);
+                    break;
+                case 90:
+                    dest = v.getY();
+                    v.setY(dest + delta);
+                    vp.translationY(dest);
+                    break;
+                case 180:
+                    dest = v.getX();
+                    v.setX(dest + delta);
+                    vp.translationX(dest);
+                    break;
+                case 270:
+                    dest = v.getY();
+                    v.setY(dest - delta);
+                    vp.translationY(dest);
+                    break;
+            }
         }
-        setShowMenu(previewFocused);
+        vp.setDuration(ANIMATION_DURATION).start();
     }
 
-    public ViewGroup getMenuLayout() {
-        return mMenuLayout;
+    private void initializeSettingMenu() {
+        LayoutInflater inflater = (LayoutInflater) mActivity.getSystemService(
+                Context.LAYOUT_INFLATER_SERVICE);
+        mSettingMenu = (ListMenu) inflater.inflate(
+                R.layout.list_menu, null, false);
+
+        mSettingMenu.setSettingChangedListener(this);
+        mSettingMenu.setSettingsManager(mSettingsManager);
+
+        String[] keys = mSettingKeys;
+        if (mActivity.isDeveloperMenuEnabled())
+            keys = mDeveloperKeys;
+        mSettingMenu.initializeForCamera2(keys);
+    }
+
+    public boolean isMenuBeingShown() {
+        return mSettingMenuState != SETTING_MENU_NONE;
     }
 
-    public void showPopup(ListView popup, int level, boolean animate) {
+    public boolean isMenuBeingAnimated() {
+        return mSettingMenuState == SETTING_MENU_IN_ANIMATION;
+    }
+
+
+    public void showSettingMenu() {
+        if (isMenuBeingShown() || CameraControls.isAnimating()) {
+            return;
+        }
+        if (mSettingMenu == null) {
+            initializeSettingMenu();
+        }
+        showSettingMenu(SETTING_MENU_LEVEL_ONE, true);
+    }
+
+    private void showSettingMenu(int level, boolean animate) {
         FrameLayout.LayoutParams params;
         hideUI();
 
-        popup.setVisibility(View.VISIBLE);
-        if (level == 1) {
+        mSettingMenu.setVisibility(View.VISIBLE);
+        mSettingMenuState = SETTING_MENU_ON;
+        if (level == SETTING_MENU_LEVEL_ONE) {
+            mSettingMenuLevel = SETTING_MENU_LEVEL_ONE;
             if (mMenuLayout == null) {
                 mMenuLayout = new RotateLayout(mActivity, null);
                 if (mRootView.getLayoutDirection() != View.LAYOUT_DIRECTION_RTL) {
-                    params = new FrameLayout.LayoutParams(
-                            CameraActivity.SETTING_LIST_WIDTH_1, LayoutParams.WRAP_CONTENT,
-                            Gravity.LEFT | Gravity.TOP);
+                    params = new FrameLayout.LayoutParams(CameraActivity.SETTING_LIST_WIDTH_1,
+                            FrameLayout.LayoutParams.WRAP_CONTENT, Gravity.LEFT | Gravity.TOP);
                 } else {
-                    params = new FrameLayout.LayoutParams(
-                            CameraActivity.SETTING_LIST_WIDTH_1, LayoutParams.WRAP_CONTENT,
-                            Gravity.RIGHT | Gravity.TOP);
+                    params = new FrameLayout.LayoutParams(CameraActivity.SETTING_LIST_WIDTH_1,
+                            FrameLayout.LayoutParams.WRAP_CONTENT, Gravity.RIGHT | Gravity.TOP);
                 }
                 mMenuLayout.setLayoutParams(params);
                 ((ViewGroup) mRootView).addView(mMenuLayout);
             }
             mMenuLayout.setOrientation(mOrientation, true);
-            mMenuLayout.addView(popup);
-        }
-        if (level == 2) {
+            mMenuLayout.addView(mSettingMenu);
+        } else if (level == SETTING_MENU_LEVEL_TWO) {
+            mSettingMenuLevel = SETTING_MENU_LEVEL_TWO;
             if (mSubMenuLayout == null) {
                 mSubMenuLayout = new RotateLayout(mActivity, null);
                 ((ViewGroup) mRootView).addView(mSubMenuLayout);
             }
             if (mRootView.getLayoutDirection() != View.LAYOUT_DIRECTION_RTL) {
-                params = new FrameLayout.LayoutParams(
-                        CameraActivity.SETTING_LIST_WIDTH_2, LayoutParams.WRAP_CONTENT,
-                        Gravity.LEFT | Gravity.TOP);
+                params = new FrameLayout.LayoutParams(CameraActivity.SETTING_LIST_WIDTH_2,
+                        FrameLayout.LayoutParams.WRAP_CONTENT, Gravity.LEFT | Gravity.TOP);
             } else {
-                params = new FrameLayout.LayoutParams(
-                        CameraActivity.SETTING_LIST_WIDTH_2, LayoutParams.WRAP_CONTENT,
-                        Gravity.RIGHT | Gravity.TOP);
+                params = new FrameLayout.LayoutParams(CameraActivity.SETTING_LIST_WIDTH_2,
+                        FrameLayout.LayoutParams.WRAP_CONTENT, Gravity.RIGHT | Gravity.TOP);
             }
             int screenHeight = (mOrientation == 0 || mOrientation == 180)
                     ? mRootView.getHeight() : mRootView.getWidth();
-            int height = ((ListSubMenu) popup).getPreCalculatedHeight();
-            int yBase = ((ListSubMenu) popup).getYBase();
+            int height = mSettingSubMenu.getPreCalculatedHeight();
+            int yBase = mSettingSubMenu.getYBase();
             int y = Math.max(0, yBase);
             if (yBase + height > screenHeight)
                 y = Math.max(0, screenHeight - height);
@@ -518,112 +932,117 @@ public class CaptureUI implements PieListener,
 
             mSubMenuLayout.setLayoutParams(params);
 
-            mSubMenuLayout.addView(popup);
+            mSubMenuLayout.addView(mSettingSubMenu);
             mSubMenuLayout.setOrientation(mOrientation, true);
         }
         if (animate) {
-            if (level == 1)
-                mMenu.animateSlideIn(mMenuLayout, CameraActivity.SETTING_LIST_WIDTH_1, true);
-            if (level == 2)
-                mMenu.animateFadeIn(popup);
-        } else
-            popup.setAlpha(0.85f);
-    }
-
-    public void removeLevel2() {
-        if (mSubMenuLayout != null) {
-            View v = mSubMenuLayout.getChildAt(0);
-            mSubMenuLayout.removeView(v);
+            if (level == SETTING_MENU_LEVEL_ONE) {
+                animateSlideIn(mMenuLayout, CameraActivity.SETTING_LIST_WIDTH_1, true);
+            }
+            if (level == SETTING_MENU_LEVEL_TWO) {
+                animateFadeIn(mSettingSubMenu);
+            }
+        } else {
+            if (level == SETTING_MENU_LEVEL_ONE) {
+                mMenuLayout.setAlpha(0.85f);
+            }
+            if (level == SETTING_MENU_LEVEL_TWO) {
+                mSettingSubMenu.setAlpha(0.85f);
+            }
         }
     }
 
-    public void cleanupListview() {
-        showUI();
-        mActivity.setSystemBarsVisibility(false);
-    }
-
-    public void dismissAllPopup() {
-        if (mPopup != null && mPopup.isShowing()) {
-            mPopup.dismiss();
-        }
+    public void initializeControlByIntent() {
+        mMenuButton = mRootView.findViewById(R.id.menu);
+        mMenuButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                showSettingMenu();
+            }
+        });
     }
 
-    public void dismissLevel1() {
-        if (mMenuLayout != null) {
-            ((ViewGroup) mRootView).removeView(mMenuLayout);
-            mMenuLayout = null;
-        }
+    public void doShutterAnimation() {
+        AnimationDrawable frameAnimation = (AnimationDrawable) mShutterButton.getDrawable();
+        frameAnimation.stop();
+        frameAnimation.start();
     }
 
-    public void dismissLevel2() {
-        if (mSubMenuLayout != null) {
-            ((ViewGroup) mRootView).removeView(mSubMenuLayout);
-            mSubMenuLayout = null;
-        }
+    public void showUI() {
+        if (!mUIhidden || isMenuBeingShown())
+            return;
+        mUIhidden = false;
+        mCameraControls.showUI();
     }
 
-    public boolean sendTouchToPreviewMenu(MotionEvent ev) {
-        return mPreviewMenuLayout.dispatchTouchEvent(ev);
+    public void hideUI() {
+        mSwitcher.closePopup();
+        if (mUIhidden)
+            return;
+        mUIhidden = true;
+        mCameraControls.hideUI();
     }
 
-    public boolean sendTouchToMenu(MotionEvent ev) {
-        if (mMenuLayout != null) {
-            View v = mMenuLayout.getChildAt(0);
-            return v.dispatchTouchEvent(ev);
-        }
-        return false;
+    public void cleanUpMenus() {
+        showUI();
+        mActivity.setSystemBarsVisibility(false);
     }
 
-    public void dismissSceneModeMenu() {
-        if (mPreviewMenuLayout != null) {
-            ((ViewGroup) mRootView).removeView(mPreviewMenuLayout);
-            mPreviewMenuLayout = null;
-        }
+    public boolean arePreviewControlsVisible() {
+        return !mUIhidden;
     }
 
-    public void onShowSwitcherPopup() {
-        if (mPieRenderer != null && mPieRenderer.showsItems()) {
-            mPieRenderer.hide();
-        }
+    public void onOrientationChanged() {
+        removeSettingMenu(SETTING_MENU_LEVEL_TWO, false);
+        if (mSettingMenu != null)
+            mSettingMenu.resetHighlight();
     }
 
-    private void setShowMenu(boolean show) {
-        if (mOnScreenIndicators != null) {
-            mOnScreenIndicators.setVisibility(show ? View.VISIBLE : View.GONE);
-        }
+    public void removeAllSettingMenu(boolean animate) {
+        removeSettingMenu(SETTING_MENU_LEVEL_TWO, false);
+        removeSettingMenu(SETTING_MENU_LEVEL_ONE, animate);
     }
 
-    public boolean collapseCameraControls() {
-        // TODO: Mode switcher should behave like a popup and should hide itself when there
-        // is a touch outside of it.
-        mSwitcher.closePopup();
-        // Remove all the popups/dialog boxes
-        boolean ret = false;
-        if (mMenu != null) {
-            mMenu.removeAllView();
-        }
-        if (mPopup != null) {
-            dismissAllPopup();
-            ret = true;
-        }
-        onShowSwitcherPopup();
-        return ret;
+    public void removeAllSettingMenu() {
+        removeAllSettingMenu(false);
     }
 
-    public void setDisplayOrientation(int orientation) {
-        if ((mPreviewOrientation == -1 || mPreviewOrientation != orientation)
-                && mMenu != null && mMenu.isPreviewMenuBeingShown()) {
-            dismissSceneModeMenu();
+    public void removeSettingMenu(int level, boolean animate) {
+        if (mSettingMenuState == SETTING_MENU_NONE)
+            return;
+        if (!animate) {
+            if (level == SETTING_MENU_LEVEL_TWO) {
+                if (mSubMenuLayout != null) {
+                    mSubMenuLayout.removeView(mSubMenuLayout.getChildAt(0));
+                    mSubMenuLayout = null;
+                }
+                mSettingSubMenu = null;
+                mSettingMenuState = SETTING_MENU_ON;
+                mSettingMenuLevel = SETTING_MENU_LEVEL_ONE;
+            } else if (level == SETTING_MENU_LEVEL_ONE) {
+                mSettingMenu.resetHighlight();
+                if (mMenuLayout != null) {
+                    mMenuLayout.removeView(mMenuLayout.getChildAt(0));
+                    mMenuLayout = null;
+                }
+                mSettingMenu = null;
+                mSettingMenuState = SETTING_MENU_NONE;
+                cleanUpMenus();
+            }
+        } else {
+            if (level == SETTING_MENU_LEVEL_TWO) {
+                mSettingMenu.resetHighlight();
+                animateFadeOut(mSettingSubMenu, level);
+            } else if (level == SETTING_MENU_LEVEL_ONE) {
+                animateSlideOut(mSettingMenu, level);
+            }
         }
-        mPreviewOrientation = orientation;
     }
 
-    public boolean isShutterPressed() {
-        return mShutterButton.isPressed();
+    public void removeAllMenu() {
+        removeAllSettingMenu();
     }
 
-    // shutter button handling
-
     /**
      * Enables or disables the shutter button.
      */
@@ -633,29 +1052,36 @@ public class CaptureUI implements PieListener,
         }
     }
 
-    public void pressShutterButton() {
-        if (mShutterButton.isInTouchMode()) {
-            mShutterButton.requestFocusFromTouch();
-        } else {
-            mShutterButton.requestFocus();
+    private boolean handleBackKeyOnMenu() {
+        if (mSceneAndFilterMenuStatus == SCENE_AND_FILTER_MENU_ON) {
+            removeSceneAndFilterMenu(true);
+            return true;
         }
-        mShutterButton.setPressed(true);
-    }
-
-    @Override
-    public void onPieOpened(int centerX, int centerY) {
-        setSwipingEnabled(false);
-        // Close module selection menu when pie menu is opened.
-        mSwitcher.closePopup();
+        if (mSettingMenuState == SETTING_MENU_NONE)
+            return false;
+        if (mSettingMenuState == SETTING_MENU_ON) {
+            removeSettingMenu(mSettingMenuLevel, true);
+        }
+        return true;
     }
 
-    @Override
-    public void onPieClosed() {
-        setSwipingEnabled(true);
-    }
+    public boolean onBackPressed() {
+        if (handleBackKeyOnMenu()) return true;
+        if (mPieRenderer != null && mPieRenderer.showsItems()) {
+            mPieRenderer.hide();
+            return true;
+        }
 
-    public void setSwipingEnabled(boolean enable) {
-        mActivity.setSwipingEnabled(enable);
+        if (!mModule.isCameraIdle()) {
+            // ignore backs while we're taking a picture
+            return true;
+        }
+        if (mSwitcher != null && mSwitcher.showsPopup()) {
+            mSwitcher.closePopup();
+            return true;
+        } else {
+            return false;
+        }
     }
 
     public SurfaceHolder getSurfaceHolder() {
@@ -677,20 +1103,22 @@ public class CaptureUI implements PieListener,
         }
     }
 
-    public void hideSurfaceView() {
-        mSurfaceView.setVisibility(View.INVISIBLE);
-    }
-
-    public void showSurfaceView() {
-        mSurfaceView.setVisibility(View.VISIBLE);
-    }
-
     public void onPause() {
         // Clear UI.
         collapseCameraControls();
     }
 
-    // focus UI implementation
+    public boolean collapseCameraControls() {
+        // TODO: Mode switcher should behave like a popup and should hide itself when there
+        // is a touch outside of it.
+        mSwitcher.closePopup();
+        // Remove all the popups/dialog boxes
+        boolean ret = false;
+        removeAllMenu();
+        mCameraControls.showRefocusToast(false);
+        return ret;
+    }
+
     private FocusIndicator getFocusIndicator() {
         return mPieRenderer;
     }
@@ -703,10 +1131,6 @@ public class CaptureUI implements PieListener,
     public void clearFaces() {
     }
 
-    public void setPreference(String key, String value) {
-        mMenu.setPreference(key, value);
-    }
-
     @Override
     public void clearFocus() {
         FocusIndicator indicator = getFocusIndicator();
@@ -731,13 +1155,13 @@ public class CaptureUI implements PieListener,
     }
 
     @Override
-    public void onFocusFailed(boolean timeout) {
-        FocusIndicator indicator = getFocusIndicator();
-        if (indicator != null) indicator.showFail(timeout);
+    public void onFocusFailed(boolean timeOut) {
+
     }
 
     @Override
     public void pauseFaceDetection() {
+
     }
 
     @Override
@@ -754,11 +1178,20 @@ public class CaptureUI implements PieListener,
     public void onFaceDetection(Face[] faces, CameraManager.CameraProxy camera) {
     }
 
-    @Override
-    public void onDisplayChanged() {
-        Log.d(TAG, "Device flip detected.");
-        mCameraControls.checkLayoutFlip();
-        mController.updateCameraOrientation();
+    public Point getSurfaceViewSize() {
+        Point point = new Point();
+        if (mSurfaceView != null) point.set(mSurfaceView.getWidth(), mSurfaceView.getHeight());
+        return point;
+    }
+
+    public Point getSurfaceView2Size() {
+        Point point = new Point();
+        if (mSurfaceView2 != null) point.set(mSurfaceView2.getWidth(), mSurfaceView2.getHeight());
+        return point;
+    }
+
+    public void adjustOrientation() {
+        setOrientation(mOrientation, true);
     }
 
     public void setOrientation(int orientation, boolean animation) {
@@ -768,8 +1201,8 @@ public class CaptureUI implements PieListener,
             mMenuLayout.setOrientation(orientation, animation);
         if (mSubMenuLayout != null)
             mSubMenuLayout.setOrientation(orientation, animation);
-        if (mPreviewMenuLayout != null) {
-            ViewGroup vg = (ViewGroup) mPreviewMenuLayout.getChildAt(0);
+        if (mSceneAndFilterLayout != null) {
+            ViewGroup vg = (ViewGroup) mSceneAndFilterLayout.getChildAt(0);
             if (vg != null)
                 vg = (ViewGroup) vg.getChildAt(0);
             if (vg != null) {
@@ -779,33 +1212,145 @@ public class CaptureUI implements PieListener,
                 }
             }
         }
-
         RotateTextToast.setOrientation(orientation);
         if (mZoomRenderer != null) {
             mZoomRenderer.setOrientation(orientation);
         }
     }
 
-    public Point getSurfaceViewSize() {
-        Point point = new Point();
-        if (mSurfaceView != null) point.set(mSurfaceView.getWidth(), mSurfaceView.getHeight());
-        return point;
+    public int getOrientation() {
+        return mOrientation;
     }
 
-    public Point getSurfaceView2Size() {
-        Point point = new Point();
-        if (mSurfaceView2 != null) point.set(mSurfaceView2.getWidth(), mSurfaceView2.getHeight());
-        return point;
+    @Override
+    public void showGpsOnScreenIndicator(boolean hasSignal) {
+
     }
 
-    public int getOrientation() {
-        return mOrientation;
+    @Override
+    public void hideGpsOnScreenIndicator() {
+
+    }
+
+    @Override
+    public void onSingleTapUp(View view, int x, int y) {
+        mModule.onSingleTapUp(view, x, y);
+    }
+
+    public void onPreviewFocusChanged(boolean previewFocused) {
+        if (previewFocused) {
+            showUI();
+        } else {
+            hideUI();
+        }
+        if (mGestures != null) {
+            mGestures.setEnabled(previewFocused);
+        }
+        if (mRenderOverlay != null) {
+            // this can not happen in capture mode
+            mRenderOverlay.setVisibility(previewFocused ? View.VISIBLE : View.GONE);
+        }
+        if (mPieRenderer != null) {
+            mPieRenderer.setBlockFocus(!previewFocused);
+        }
+    }
+
+    public ViewGroup getMenuLayout() {
+        return mMenuLayout;
+    }
+
+    public boolean isShutterPressed() {
+        return mShutterButton.isPressed();
+    }
+
+    public void pressShutterButton() {
+        if (mShutterButton.isInTouchMode()) {
+            mShutterButton.requestFocusFromTouch();
+        } else {
+            mShutterButton.requestFocus();
+        }
+        mShutterButton.setPressed(true);
+    }
+
+    @Override
+    public void onSettingsChanged(List<SettingsManager.SettingState> settings) {
+        for (SettingsManager.SettingState setting : settings) {
+            String key = setting.key;
+            SettingsManager.Values values = setting.values;
+            String value = (values.overriddenValue == null) ? values.value : values.overriddenValue;
+            switch (key) {
+                case SettingsManager.KEY_CAMERA2:
+                    switchCameraMode(value);
+                    return;
+                case SettingsManager.KEY_CAMERA_ID:
+                case SettingsManager.KEY_DUAL_CAMERA:
+                case SettingsManager.KEY_CLEARSIGHT:
+                case SettingsManager.KEY_PICTURE_SIZE:
+                    mActivity.onModuleSelected(ModuleSwitcher.CAPTURE_MODULE_INDEX);
+                    return;
+                case SettingsManager.KEY_COLOR_EFFECT:
+                    changeFilterModeControlIcon(value);
+                    updateFilterModeIcon(values.overriddenValue == null);
+                    break;
+            }
+        }
+    }
+
+    public void setPreviewSize(int width, int height) {
+        mSurfaceView.setAspectRatio(width, height);
+    }
+
+    private void switchCameraMode(String value) {
+        if (value.equals("enable")) {
+            mActivity.onModuleSelected(ModuleSwitcher.CAPTURE_MODULE_INDEX);
+        } else {
+            mActivity.onModuleSelected(ModuleSwitcher.PHOTO_MODULE_INDEX);
+        }
+    }
+
+    @Override
+    public void onSettingChanged(ListPreference pref) {
+        removeAllSettingMenu();
+    }
+
+    @Override
+    public void onPreferenceClicked(ListPreference pref) {
+        onPreferenceClicked(pref, 0);
+    }
+
+    @Override
+    public void onPreferenceClicked(ListPreference pref, int y) {
+        LayoutInflater inflater = (LayoutInflater) mActivity.getSystemService(
+                Context.LAYOUT_INFLATER_SERVICE);
+        removeSettingMenu(SETTING_MENU_LEVEL_TWO, false);
+        mSettingSubMenu = (ListSubMenu) inflater.inflate(R.layout.list_sub_menu, null, false);
+        mSettingSubMenu.initialize(pref, y);
+        mSettingSubMenu.setSettingChangedListener(mSettingMenu);
+        mSettingSubMenu.setAlpha(0f);
+
+        if (mSettingMenuState == SETTING_MENU_ON) {
+            if (mSettingMenuLevel == SETTING_MENU_LEVEL_TWO) {
+                showSettingMenu(SETTING_MENU_LEVEL_TWO, false);
+            } else if (mSettingMenuLevel == SETTING_MENU_LEVEL_ONE) {
+                showSettingMenu(SETTING_MENU_LEVEL_TWO, true);
+            }
+        }
+    }
+
+    @Override
+    public void onListMenuTouched() {
+        removeSettingMenu(SETTING_MENU_LEVEL_TWO, false);
+    }
+
+    @Override
+    public void onListPrefChanged(ListPreference pref) {
+        removeAllSettingMenu();
     }
 
     private class ZoomChangeListener implements ZoomRenderer.OnZoomChangedListener {
         @Override
         public void onZoomValueChanged(float mZoomValue) {
-            mController.onZoomChanged(mZoomValue);
+            mModule.onZoomChanged(mZoomValue);
             if (mZoomRenderer != null) {
                 mZoomRenderer.setZoom(mZoomValue);
             }