Merge "SnapdragonCamera: Move the files to the correct location"

1 files changed, 476 insertions, 0 deletions

diff --git a/src/com/android/camera/TsMakeupManager.java b/src/com/android/camera/TsMakeupManager.java
new file mode 100644
index 000000000..db3505b45
--- /dev/null
+++ b/src/com/android/camera/TsMakeupManager.java
@@ -0,0 +1,476 @@
+/*
+* Copyright (C) 2014,2015 Thundersoft Corporation
+* All rights Reserved
+*
+* 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.Resources;
+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.View;
+import android.view.View.OnClickListener;
+import android.view.WindowManager;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.RelativeLayout;
+import android.widget.SeekBar;
+import android.widget.TextView;
+import android.widget.LinearLayout.LayoutParams;
+import android.widget.SeekBar.OnSeekBarChangeListener;
+
+import com.android.camera.ui.RotateLayout;
+import com.android.camera.util.CameraUtil;
+
+import org.codeaurora.snapcam.R;
+
+public class TsMakeupManager implements OnSeekBarChangeListener {
+    private static final String TAG = "TsMakeupManager";
+    private PhotoUI mUI;
+    private PhotoMenu mMenu;
+    private CameraActivity mActivity;
+    private PreferenceGroup mPreferenceGroup;
+    private View mTsMakeupSwitcher;
+
+    private RelativeLayout mMakeupLayoutRoot;
+    private LinearLayout mMakeupLevelRoot;
+    private LinearLayout mMakeupSingleRoot;
+
+    public static final String MAKEUP_ON     = "On";
+    public static final String MAKEUP_OFF    = "Off";
+    public static final String MAKEUP_NONE   = "none";
+
+    private static final int MODE_NONE = 0;
+    private static final int MODE_WHITEN = 1;
+    private static final int MODE_CLEAN = 2;
+    private int mMode = MODE_NONE;
+    private int mSingleSelectedIndex = MODE_NONE;
+
+    private static final int MAKEUP_UI_STATUS_NONE      = 0;
+    private static final int MAKEUP_UI_STATUS_ON        = 1;
+    private static final int MAKEUP_UI_STATUS_OFF       = 2;
+    private static final int MAKEUP_UI_STATUS_DISMISS   = 3;
+    private int mMakeupUIStatus = MAKEUP_UI_STATUS_NONE;
+
+    private static final int CLICK_THRESHOLD = 200;
+
+    public static final boolean HAS_TS_MAKEUP = android.os.SystemProperties.getBoolean("persist.ts.rtmakeup", false);
+
+    private MakeupLevelListener mMakeupLevelListener;
+    interface MakeupLevelListener {
+        void onMakeupLevel(String key, String value);
+    }
+
+    public void setMakeupLevelListener(MakeupLevelListener l) {
+        mMakeupLevelListener = l;
+    }
+
+    public TsMakeupManager(CameraActivity activity, PhotoMenu menu, PhotoUI ui, PreferenceGroup preferenceGroup, View makeupSwitcher) {
+        mActivity = activity;
+        mUI = ui;
+        mMenu = menu;
+        mPreferenceGroup = preferenceGroup;
+        mTsMakeupSwitcher = makeupSwitcher;
+
+        mMakeupLayoutRoot = (RelativeLayout) mUI.getRootView().findViewById(R.id.id_tsmakeup_level_layout_root);
+
+        mMakeupUIStatus = MAKEUP_UI_STATUS_NONE;
+    }
+
+    public View getMakeupLayoutRoot() {
+        return mMakeupLayoutRoot;
+    }
+
+    public boolean isShowMakeup() {
+        return mMakeupLayoutRoot != null && mMakeupLayoutRoot.isShown();
+    }
+
+    public void removeAllViews() {
+        if(mMakeupSingleRoot != null) {
+            mMakeupSingleRoot.removeAllViews();
+            mMakeupSingleRoot = null;
+        }
+        if(mMakeupLevelRoot != null) {
+            mMakeupLevelRoot.removeAllViews();
+            mMakeupLevelRoot = null;
+        }
+        if(mMakeupLayoutRoot != null) {
+            mMakeupLayoutRoot.removeAllViews();
+        }
+    }
+
+    public void dismissMakeupUI() {
+        mMakeupUIStatus = MAKEUP_UI_STATUS_DISMISS;
+        removeAllViews();
+        if(mMakeupLayoutRoot != null) {
+            mMakeupLayoutRoot.setVisibility(View.GONE);
+        }
+    }
+
+    public void resetMakeupUIStatus() {
+        mMakeupUIStatus = MAKEUP_UI_STATUS_NONE;
+    }
+
+    private void changeMakeupIcon(String value) {
+        if( !TextUtils.isEmpty(value) ) {
+            String prefValue = MAKEUP_ON;
+            if(MAKEUP_OFF.equals(value)) {
+                prefValue = MAKEUP_OFF;
+            }
+            final IconListPreference pref = (IconListPreference) mPreferenceGroup
+                    .findPreference(CameraSettings.KEY_TS_MAKEUP_UILABLE);
+            if(pref == null)
+                return;
+            pref.setValue(prefValue);
+            int index = pref.getCurrentIndex();
+            ImageView iv = (ImageView) mTsMakeupSwitcher;
+            iv.setImageResource(((IconListPreference) pref).getLargeIconIds()[index]);
+            pref.setMakeupSeekBarValue(prefValue);
+        }
+    }
+
+    public void hideMakeupUI() {
+        final IconListPreference pref = (IconListPreference) mPreferenceGroup
+                .findPreference(CameraSettings.KEY_TS_MAKEUP_UILABLE);
+        if(pref == null)
+            return;
+        mMakeupUIStatus = MAKEUP_UI_STATUS_NONE;
+        String tsMakeupOn = pref.getValue();
+        Log.d(TAG, "TsMakeupManager.hideMakeupUI(): tsMakeupOn is " + tsMakeupOn);
+        if(MAKEUP_ON.equals(tsMakeupOn)) {
+            int index = pref.findIndexOfValue(pref.getValue());
+            CharSequence[] values = pref.getEntryValues();
+            index = (index + 1) % values.length;
+            pref.setMakeupSeekBarValue((String)values[index]);
+            ImageView iv = (ImageView) mTsMakeupSwitcher;
+            iv.setImageResource(((IconListPreference) pref).getLargeIconIds()[index]);
+            mMakeupLevelListener.onMakeupLevel(CameraSettings.KEY_TS_MAKEUP_LEVEL, pref.getValue());
+
+            IconListPreference levelPref = (IconListPreference) mPreferenceGroup
+                    .findPreference(CameraSettings.KEY_TS_MAKEUP_LEVEL);
+            levelPref.setValueIndex(0); //Turn Off the Makeup feature;
+
+
+            mMakeupLayoutRoot.setVisibility(View.GONE);
+            mMakeupLayoutRoot.removeAllViews();
+            if(mMakeupSingleRoot != null) {
+                mMakeupSingleRoot.removeAllViews();
+                mMakeupSingleRoot = null;
+            }
+            if(mMakeupLevelRoot != null) {
+                mMakeupLevelRoot.removeAllViews();
+                mMakeupLevelRoot = null;
+            }
+        }
+    }
+
+    public void showMakeupView() {
+        mMakeupUIStatus = MAKEUP_UI_STATUS_OFF;
+        mMakeupLayoutRoot.setVisibility(View.GONE);
+        mMakeupLayoutRoot.removeAllViews();
+        if(mMakeupSingleRoot != null) {
+            mMakeupSingleRoot.removeAllViews();
+            mMakeupSingleRoot = null;
+        }
+        if(mMakeupLevelRoot != null) {
+            mMakeupLevelRoot.removeAllViews();
+            mMakeupLevelRoot = null;
+        }
+
+        if(mMakeupSingleRoot != null && mMakeupSingleRoot.getVisibility() == View.VISIBLE) {
+            showSingleView(MAKEUP_NONE);
+            return;
+        }
+
+        if(mMakeupUIStatus == MAKEUP_UI_STATUS_DISMISS)
+            return;
+
+        mMakeupLayoutRoot.setVisibility(View.VISIBLE);
+        final IconListPreference pref = (IconListPreference) mPreferenceGroup
+                .findPreference(CameraSettings.KEY_TS_MAKEUP_LEVEL);
+        if (pref == null)
+            return;
+
+        if(mMakeupLevelRoot != null) {
+            mMakeupLevelRoot.removeAllViews();
+            mMakeupLevelRoot = null;
+        }
+        mMakeupLayoutRoot.removeAllViews();
+
+        mMakeupUIStatus = MAKEUP_UI_STATUS_ON;
+
+        int rotation = CameraUtil.getDisplayRotation(mActivity);
+        boolean mIsDefaultToPortrait = CameraUtil.isDefaultToPortrait(mActivity);
+        if (!mIsDefaultToPortrait) {
+            rotation = (rotation + 90) % 360;
+        }
+        CharSequence[] entries = pref.getEntries();
+        int[] thumbnails = pref.getThumbnailIds();
+
+        WindowManager wm = (WindowManager) mActivity.getSystemService(Context.WINDOW_SERVICE);
+        Display display = wm.getDefaultDisplay();
+        int width = display.getWidth();
+        int height = display.getHeight();
+        Resources r = mActivity.getResources();
+        int margin = (int) (r.getDimension(R.dimen.tsmakeup_mode_paddingBottom));
+        int levelBgSize = (int) (r.getDimension(R.dimen.tsmakeup_mode_level_size));
+
+        Log.d(TAG, "TsMakeupManager.showMakeupView(): rotation is " + rotation + ", WH is (" + width + ", " + height + "), margin is "
+                + margin + ", levelBgSize is " + levelBgSize);
+
+        int gridRes = 0;
+        boolean portrait = (rotation == 0) || (rotation == 180);
+        int size = height;
+        if (portrait) {
+            gridRes = R.layout.ts_makeup_level_view_port;
+            size = width;
+        } else {
+            gridRes = R.layout.ts_makeup_level_view_land;
+            size = height;
+        }
+        int itemWidth = size / entries.length;
+
+        LayoutInflater inflater = (LayoutInflater) mActivity.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+
+        LinearLayout layout = (LinearLayout) inflater.inflate(gridRes, null, false);
+        mMakeupLevelRoot = layout;
+        mUI.setMakeupMenuLayout(layout);
+
+        LinearLayout.LayoutParams params = null;
+        if(portrait) {
+            params = new LayoutParams(itemWidth, itemWidth);
+            params.gravity = Gravity.CENTER_VERTICAL;
+        } else {
+            params = new LayoutParams(itemWidth, itemWidth);
+            params.gravity = Gravity.CENTER_HORIZONTAL;
+        }
+
+        RelativeLayout.LayoutParams rootParams = null;
+        if(rotation == 0) {
+            rootParams = new RelativeLayout.LayoutParams(size, levelBgSize);
+//            rootParams.bottomMargin = margin;
+            rootParams.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
+        } else if(rotation == 90) {
+            rootParams = new RelativeLayout.LayoutParams(levelBgSize, size);
+//            rootParams.rightMargin = margin;
+            rootParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
+        } else if(rotation == 180) {
+            rootParams = new RelativeLayout.LayoutParams(size, levelBgSize);
+//            rootParams.topMargin = margin;
+            rootParams.addRule(RelativeLayout.ALIGN_PARENT_TOP);
+        } else if(rotation == 270) {
+            rootParams = new RelativeLayout.LayoutParams(levelBgSize, size);
+//            rootParams.leftMargin = margin;
+            rootParams.addRule(RelativeLayout.ALIGN_PARENT_LEFT);
+        }
+
+        final View[] views = new View[entries.length];
+        int init = pref.getCurrentIndex();
+        for (int i = 0; i < entries.length; i++) {
+            RotateLayout layout2 = (RotateLayout) inflater.inflate(
+                    R.layout.ts_makeup_item_view, null, false);
+
+            ImageView imageView = (ImageView) layout2.findViewById(R.id.image);
+            TextView label = (TextView) layout2.findViewById(R.id.label);
+            final int j = i;
+
+            layout2.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) {
+                            pref.setValueIndex(j);
+                            changeMakeupIcon(pref.getValue());
+                            mMakeupLevelListener.onMakeupLevel(pref.getKey(), pref.getValue());
+                            for (View v1 : views) {
+                                v1.setSelected(false);
+                            }
+                            View border = v.findViewById(R.id.image);
+                            border.setSelected(true);
+
+                            showSingleView(pref.getValue());
+                            mUI.adjustOrientation();
+                        }
+                    }
+                    return true;
+                }
+            });
+
+            View border = layout2.findViewById(R.id.image);
+            views[j] = border;
+            if (i == init) {
+                border.setSelected(true);
+            }
+            imageView.setImageResource(thumbnails[i]);
+            label.setText(entries[i]);
+            layout.addView(layout2, params);
+        }
+        mMakeupLayoutRoot.addView(layout, rootParams);
+    }
+
+    private void showSingleView(String value) {
+        if(MAKEUP_NONE.equals(value)) {
+            if(mMakeupSingleRoot != null) {
+                mMakeupSingleRoot.removeAllViews();
+                mMakeupSingleRoot = null;
+            }
+            mMakeupLayoutRoot.removeAllViews();
+            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();
+            int width = display.getWidth();
+            int height = display.getHeight();
+            Resources r = mActivity.getResources();
+            int margin = (int) (r.getDimension(R.dimen.tsmakeup_mode_paddingBottom));
+            int levelBgSize = (int) (r.getDimension(R.dimen.tsmakeup_mode_level_size));
+
+            Log.d(TAG, "TsMakeupManager.showSingleView(): rotation is " + rotation + ", WH is (" + width + ", " + height + "), margin is "
+                    + margin + ", levelBgSize is " + levelBgSize);
+
+            int gridRes = R.layout.ts_makeup_single_level_view_port;
+            int size = width;
+
+            LayoutInflater inflater = (LayoutInflater) mActivity.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+
+            final LinearLayout layout = (LinearLayout) inflater.inflate(gridRes, null, false);
+            mMakeupSingleRoot = layout;
+            mUI.setMakeupMenuLayout(layout);
+
+            RelativeLayout.LayoutParams rootParams = new RelativeLayout.LayoutParams(size, android.widget.RelativeLayout.LayoutParams.WRAP_CONTENT);
+            rootParams.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
+
+            mMakeupLayoutRoot.addView(layout, rootParams);
+            final SeekBar seekBar = (SeekBar) layout.findViewById(R.id.seekbar_makeup_level);
+            seekBar.setOnSeekBarChangeListener(this);
+            setSingleView(layout);
+
+            mMode = MODE_NONE;
+
+            layout.findViewById(R.id.id_layout_makeup_back).setOnClickListener(new OnClickListener() {
+                @Override
+                public void onClick(View v) {
+                    mMakeupSingleRoot.removeAllViews();
+                    mMakeupLayoutRoot.removeView(mMakeupSingleRoot);
+                    mMakeupSingleRoot = null;
+
+                    mSingleSelectedIndex = MODE_NONE;
+                    mMode = MODE_NONE;
+
+                    showMakeupView();
+                    mUI.adjustOrientation();
+                }
+            });
+
+            layout.findViewById(R.id.id_layout_makeup_whiten).setOnClickListener(new OnClickListener() {
+                @Override
+                public void onClick(View v) {
+                    if(mMode == MODE_WHITEN) {
+                        seekBar.setVisibility(View.GONE);
+                        mMode = MODE_NONE;
+                        return;
+                    }
+                    mSingleSelectedIndex = MODE_WHITEN;
+                    seekBar.setVisibility(View.VISIBLE);
+                    seekBar.setProgress(getPrefValue(CameraSettings.KEY_TS_MAKEUP_LEVEL_WHITEN));
+                    mMode = MODE_WHITEN;
+                    setSingleView(layout);
+                }
+            });
+
+            layout.findViewById(R.id.id_layout_makeup_clean).setOnClickListener(new OnClickListener() {
+                @Override
+                public void onClick(View v) {
+                    if(mMode == MODE_CLEAN) {
+                        seekBar.setVisibility(View.GONE);
+                        mMode = MODE_NONE;
+                        return;
+                    }
+                    mSingleSelectedIndex = MODE_CLEAN;
+                    seekBar.setVisibility(View.VISIBLE);
+                    seekBar.setProgress(getPrefValue(CameraSettings.KEY_TS_MAKEUP_LEVEL_CLEAN));
+                    mMode = MODE_CLEAN;
+                    setSingleView(layout);
+                }
+            });
+        }
+    }
+
+    private void setSingleView(LinearLayout layout) {
+        if(mSingleSelectedIndex == MODE_WHITEN) {
+            layout.findViewById(R.id.id_iv_makeup_whiten).setSelected(true);
+            layout.findViewById(R.id.id_iv_makeup_clean).setSelected(false);
+        } else if(mSingleSelectedIndex == MODE_CLEAN) {
+            layout.findViewById(R.id.id_iv_makeup_whiten).setSelected(false);
+            layout.findViewById(R.id.id_iv_makeup_clean).setSelected(true);
+        }
+    }
+
+    @Override
+    public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
+    }
+
+    @Override
+    public void onStartTrackingTouch(SeekBar seekBar) {
+
+    }
+
+    @Override
+    public void onStopTrackingTouch(SeekBar seekBar) {
+        setSeekbarValue(seekBar.getProgress());
+    }
+
+    private void setSeekbarValue(int value) {
+        String key = CameraSettings.KEY_TS_MAKEUP_LEVEL_WHITEN;
+        if(mMode == MODE_CLEAN) {
+            key = CameraSettings.KEY_TS_MAKEUP_LEVEL_CLEAN;
+        }
+        Log.d(TAG, "TsMakeupManager.onStopTrackingTouch(): value is " + value + ", key is " + key);
+        setEffectValue(key, String.valueOf(value));
+    }
+
+    private void setEffectValue(String key, String value) {
+        final ListPreference pref = (ListPreference) mPreferenceGroup.findPreference(key);
+        if (pref == null)
+            return;
+
+        pref.setMakeupSeekBarValue(value);
+        mMakeupLevelListener.onMakeupLevel(key, value);
+    }
+
+    private int getPrefValue(String key) {
+        ListPreference pref = mPreferenceGroup.findPreference(key);
+        String value = pref.getValue();
+        Log.d(TAG, "TsMakeupManager.getPrefValue(): value is " + value + ", key is " + key);
+        if(TextUtils.isEmpty(value)) {
+            value = mActivity.getString(R.string.pref_camera_tsmakeup_level_default);
+        }
+        return Integer.parseInt(value);
+    }
+}