src/com/android/camera/ui/CameraControls.java - fp2-dev/platform/packages/apps/Gallery2 - Gitiles

 /*
  * 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.ui;

 import android.app.Activity;
 import android.content.Context;
 import android.content.res.Configuration;
 import android.graphics.Rect;
 import android.util.AttributeSet;
 import android.view.Gravity;
 import android.view.View;
 import android.widget.FrameLayout;

 import com.android.camera.Util;
 import com.android.gallery3d.R;

 public class CameraControls extends RotatableLayout {

     private static final String TAG = "CAM_Controls";

     private View mBackgroundView;
     private View mShutter;
     private View mSwitcher;
     private View mMenu;
     private View mIndicators;
     private View mPreview;

     public CameraControls(Context context, AttributeSet attrs) {
         super(context, attrs);
     }

     public CameraControls(Context context) {
         super(context);
     }

     @Override
     public void onConfigurationChanged(Configuration config) {
         super.onConfigurationChanged(config);
         adjustBackground();
     }

     @Override
     public void onFinishInflate() {
         super.onFinishInflate();
         mBackgroundView = findViewById(R.id.blocker);
         mSwitcher = findViewById(R.id.camera_switcher);
         mShutter = findViewById(R.id.shutter_button);
         mMenu = findViewById(R.id.menu);
         mIndicators = findViewById(R.id.on_screen_indicators);
         mPreview = findViewById(R.id.preview_thumb);
     }

     @Override
     public void onLayout(boolean changed, int l, int t, int r, int b) {
         int orientation = getResources().getConfiguration().orientation;
         int rotation = Util.getDisplayRotation((Activity) getContext());
         int size = getResources().getDimensionPixelSize(R.dimen.camera_controls_size);
         rotation = correctRotation(rotation, orientation);
         super.onLayout(changed, l, t, r, b);
         Rect shutter = new Rect();
         topRight(mPreview, l, t, r, b, orientation, rotation);
         if (size > 0) {
             // restrict controls to size
             switch (rotation) {
             case 0:
             case 180:
                 l = (l + r - size) / 2;
                 r = l + size;
                 break;
             case 90:
             case 270:
                 t = (t + b - size) / 2;
                 b = t + size;
                 break;
             }
         }
         center(mShutter, l, t, r, b, orientation, rotation, shutter);
         center(mBackgroundView, l, t, r, b, orientation, rotation, new Rect());
         toLeft(mSwitcher, l, t, r, b, orientation, rotation, shutter);
         toRight(mMenu, l, t, r, b, orientation, rotation, shutter);
         toRight(mIndicators, l, t, r, b, orientation, rotation, shutter);
         View retake = findViewById(R.id.btn_retake);
         if (retake != null) {
             Rect retakeRect = new Rect();
             center(retake, l, t, r, b, orientation, rotation, retakeRect);
             View cancel = findViewById(R.id.btn_cancel);
             toLeft(cancel, l, t, r, b, orientation, rotation, shutter);
             View done = findViewById(R.id.btn_done);
             toRight(done, l, t, r, b, orientation, rotation, shutter);
         }
     }

     private int correctRotation(int rotation, int orientation) {
         // all the layout code assumes camera device orientation to be portrait
         // adjust rotation for landscape
         int camOrientation = (rotation % 180 == 0) ? Configuration.ORIENTATION_PORTRAIT
                 : Configuration.ORIENTATION_LANDSCAPE;
         if (camOrientation != orientation) {
             return (rotation + 90) % 360;
         }
         return rotation;
     }

     private void center(View v, int l, int t, int r, int b, int orientation, int rotation, Rect result) {
         FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) v.getLayoutParams();
         int tw = lp.leftMargin + v.getMeasuredWidth() + lp.rightMargin;
         int th = lp.topMargin + v.getMeasuredHeight() + lp.bottomMargin;
         switch (rotation) {
         case 0:
             // phone portrait; controls bottom
             result.left = (r + l) / 2 - tw / 2 + lp.leftMargin;
             result.right = (r + l) / 2 + tw / 2 - lp.rightMargin;
             result.bottom = b - lp.bottomMargin;
             result.top = b - th + lp.topMargin;
             break;
         case 90:
             // phone landscape: controls right
             result.right = r - lp.rightMargin;
             result.left = r - tw + lp.leftMargin;
             result.top = (b + t) / 2 - th / 2 + lp.topMargin;
             result.bottom = (b + t) / 2 + th / 2 - lp.bottomMargin;
             break;
         case 180:
             // phone upside down: controls top
             result.left = (r + l) / 2 - tw / 2 + lp.leftMargin;
             result.right = (r + l) / 2 + tw / 2 - lp.rightMargin;
             result.top = t + lp.topMargin;
             result.bottom = t + th - lp.bottomMargin;
             break;
         case 270:
             // reverse landscape: controls left
             result.left = l + lp.leftMargin;
             result.right = l + tw - lp.rightMargin;
             result.top = (b + t) / 2 - th / 2 + lp.topMargin;
             result.bottom = (b + t) / 2 + th / 2 - lp.bottomMargin;
             break;
         }
         v.layout(result.left, result.top, result.right, result.bottom);
     }

     private void toLeft(View v, int l, int t, int r, int b, int orientation, int rotation, Rect anchor) {
         FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) v.getLayoutParams();
         int tw = lp.leftMargin + v.getMeasuredWidth() + lp.rightMargin;
         int th = lp.topMargin + v.getMeasuredHeight() + lp.bottomMargin;
         Rect result = new Rect();
         switch (rotation) {
         case 0:
             // portrait, to left of anchor at bottom
             result.right = anchor.left - lp.rightMargin;
             result.left = anchor.left - tw + lp.leftMargin;
             result.bottom = b - lp.bottomMargin;
             result.top = b - th + lp.topMargin;
             break;
         case 90:
             // phone landscape: below anchor on right
             result.right = r - lp.rightMargin;
             result.left = r - tw + lp.leftMargin;
             result.top = anchor.bottom + lp.topMargin;
             result.bottom = anchor.bottom + th - lp.bottomMargin;
             break;
         case 180:
             // phone upside down: right of anchor at top
             result.left = anchor.right + lp.leftMargin;
             result.right = anchor.right + tw - lp.rightMargin;
             result.top = t + lp.topMargin;
             result.bottom = t + th - lp.bottomMargin;
             break;
         case 270:
             // reverse landscape: above anchor on left
             result.left = l + lp.leftMargin;
             result.right = l + tw - lp.rightMargin;
             result.bottom = anchor.top - lp.bottomMargin;
             result.top = anchor.top - th + lp.topMargin;
             break;
         }
         v.layout(result.left, result.top, result.right, result.bottom);
     }

     private void toRight(View v, int l, int t, int r, int b, int orientation, int rotation, Rect anchor) {
         FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) v.getLayoutParams();
         int tw = lp.leftMargin + v.getMeasuredWidth() + lp.rightMargin;
         int th = lp.topMargin + v.getMeasuredHeight() + lp.bottomMargin;
         Rect result = new Rect();
         switch (rotation) {
         case 0:
             // portrait, right of anchor at bottom
             result.left = anchor.right + lp.leftMargin;
             result.right = anchor.right + tw - lp.rightMargin;
             result.bottom = b - lp.bottomMargin;
             result.top = b - th + lp.topMargin;
             break;
         case 90:
             // phone landscape: above anchor on right
             result.right = r - lp.rightMargin;
             result.left = r - tw + lp.leftMargin;
             result.bottom = anchor.top - lp.bottomMargin;
             result.top = anchor.top - th + lp.topMargin;
             break;
         case 180:
             // phone upside down: left of anchor at top
             result.right = anchor.left - lp.rightMargin;
             result.left = anchor.left - tw + lp.leftMargin;
             result.top = t + lp.topMargin;
             result.bottom = t + th - lp.bottomMargin;
             break;
         case 270:
             // reverse landscape: below anchor on left
             result.left = l + lp.leftMargin;
             result.right = l + tw - lp.rightMargin;
             result.top = anchor.bottom + lp.topMargin;
             result.bottom = anchor.bottom + th - lp.bottomMargin;
             break;
         }
         v.layout(result.left, result.top, result.right, result.bottom);
     }

     private void topRight(View v, int l, int t, int r, int b, int orientation, int rotation) {
         // layout using the specific margins; the rotation code messes up the others
         int mt = getContext().getResources().getDimensionPixelSize(R.dimen.capture_margin_top);
         int mr = getContext().getResources().getDimensionPixelSize(R.dimen.capture_margin_right);
         v.layout(r - v.getMeasuredWidth() - mr, t + mt, r - mr, t + mt + v.getMeasuredHeight());
     }

     // In reverse landscape and reverse portrait, camera controls will be laid out
     // on the wrong side of the screen. We need to make adjustment to move the controls
     // to the USB side
     public void adjustControlsToRightPosition() {
         Configuration config = getResources().getConfiguration();
         int orientation = Util.getDisplayRotation((Activity) getContext());
         if (orientation == 270 && config.orientation == Configuration.ORIENTATION_LANDSCAPE) {
             flipChildren();
         }
         if (orientation == 180 && config.orientation == Configuration.ORIENTATION_PORTRAIT) {
             flipChildren();
         }
         adjustBackground();
     }

     private void adjustBackground() {
         // remove current drawable and reset rotation
         mBackgroundView.setBackgroundDrawable(null);
         mBackgroundView.setRotationX(0);
         mBackgroundView.setRotationY(0);
         // if the switcher background is top aligned we need to flip the background
         // drawable vertically; if left aligned, flip horizontally
         int gravity = ((LayoutParams) mBackgroundView.getLayoutParams()).gravity;
         if ((gravity & Gravity.TOP) == Gravity.TOP) {
             mBackgroundView.setRotationX(180);
         } else if ((gravity & Gravity.LEFT) == Gravity.LEFT) {
             mBackgroundView.setRotationY(180);
         }
         mBackgroundView.setBackgroundResource(R.drawable.switcher_bg);
     }

 }
	/*
	* 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.ui;

	import android.app.Activity;
	import android.content.Context;
	import android.content.res.Configuration;
	import android.graphics.Rect;
	import android.util.AttributeSet;
	import android.view.Gravity;
	import android.view.View;
	import android.widget.FrameLayout;

	import com.android.camera.Util;
	import com.android.gallery3d.R;

	public class CameraControls extends RotatableLayout {

	private static final String TAG = "CAM_Controls";

	private View mBackgroundView;
	private View mShutter;
	private View mSwitcher;
	private View mMenu;
	private View mIndicators;
	private View mPreview;

	public CameraControls(Context context, AttributeSet attrs) {
	super(context, attrs);
	}

	public CameraControls(Context context) {
	super(context);
	}

	@Override
	public void onConfigurationChanged(Configuration config) {
	super.onConfigurationChanged(config);
	adjustBackground();
	}

	@Override
	public void onFinishInflate() {
	super.onFinishInflate();
	mBackgroundView = findViewById(R.id.blocker);
	mSwitcher = findViewById(R.id.camera_switcher);
	mShutter = findViewById(R.id.shutter_button);
	mMenu = findViewById(R.id.menu);
	mIndicators = findViewById(R.id.on_screen_indicators);
	mPreview = findViewById(R.id.preview_thumb);
	}

	@Override
	public void onLayout(boolean changed, int l, int t, int r, int b) {
	int orientation = getResources().getConfiguration().orientation;
	int rotation = Util.getDisplayRotation((Activity) getContext());
	int size = getResources().getDimensionPixelSize(R.dimen.camera_controls_size);
	rotation = correctRotation(rotation, orientation);
	super.onLayout(changed, l, t, r, b);
	Rect shutter = new Rect();
	topRight(mPreview, l, t, r, b, orientation, rotation);
	if (size > 0) {
	// restrict controls to size
	switch (rotation) {
	case 0:
	case 180:
	l = (l + r - size) / 2;
	r = l + size;
	break;
	case 90:
	case 270:
	t = (t + b - size) / 2;
	b = t + size;
	break;
	}
	}
	center(mShutter, l, t, r, b, orientation, rotation, shutter);
	center(mBackgroundView, l, t, r, b, orientation, rotation, new Rect());
	toLeft(mSwitcher, l, t, r, b, orientation, rotation, shutter);
	toRight(mMenu, l, t, r, b, orientation, rotation, shutter);
	toRight(mIndicators, l, t, r, b, orientation, rotation, shutter);
	View retake = findViewById(R.id.btn_retake);
	if (retake != null) {
	Rect retakeRect = new Rect();
	center(retake, l, t, r, b, orientation, rotation, retakeRect);
	View cancel = findViewById(R.id.btn_cancel);
	toLeft(cancel, l, t, r, b, orientation, rotation, shutter);
	View done = findViewById(R.id.btn_done);
	toRight(done, l, t, r, b, orientation, rotation, shutter);
	}
	}

	private int correctRotation(int rotation, int orientation) {
	// all the layout code assumes camera device orientation to be portrait
	// adjust rotation for landscape
	int camOrientation = (rotation % 180 == 0) ? Configuration.ORIENTATION_PORTRAIT
	: Configuration.ORIENTATION_LANDSCAPE;
	if (camOrientation != orientation) {
	return (rotation + 90) % 360;
	}
	return rotation;
	}

	private void center(View v, int l, int t, int r, int b, int orientation, int rotation, Rect result) {
	FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) v.getLayoutParams();
	int tw = lp.leftMargin + v.getMeasuredWidth() + lp.rightMargin;
	int th = lp.topMargin + v.getMeasuredHeight() + lp.bottomMargin;
	switch (rotation) {
	case 0:
	// phone portrait; controls bottom
	result.left = (r + l) / 2 - tw / 2 + lp.leftMargin;
	result.right = (r + l) / 2 + tw / 2 - lp.rightMargin;
	result.bottom = b - lp.bottomMargin;
	result.top = b - th + lp.topMargin;
	break;
	case 90:
	// phone landscape: controls right
	result.right = r - lp.rightMargin;
	result.left = r - tw + lp.leftMargin;
	result.top = (b + t) / 2 - th / 2 + lp.topMargin;
	result.bottom = (b + t) / 2 + th / 2 - lp.bottomMargin;
	break;
	case 180:
	// phone upside down: controls top
	result.left = (r + l) / 2 - tw / 2 + lp.leftMargin;
	result.right = (r + l) / 2 + tw / 2 - lp.rightMargin;
	result.top = t + lp.topMargin;
	result.bottom = t + th - lp.bottomMargin;
	break;
	case 270:
	// reverse landscape: controls left
	result.left = l + lp.leftMargin;
	result.right = l + tw - lp.rightMargin;
	result.top = (b + t) / 2 - th / 2 + lp.topMargin;
	result.bottom = (b + t) / 2 + th / 2 - lp.bottomMargin;
	break;
	}
	v.layout(result.left, result.top, result.right, result.bottom);
	}

	private void toLeft(View v, int l, int t, int r, int b, int orientation, int rotation, Rect anchor) {
	FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) v.getLayoutParams();
	int tw = lp.leftMargin + v.getMeasuredWidth() + lp.rightMargin;
	int th = lp.topMargin + v.getMeasuredHeight() + lp.bottomMargin;
	Rect result = new Rect();
	switch (rotation) {
	case 0:
	// portrait, to left of anchor at bottom
	result.right = anchor.left - lp.rightMargin;
	result.left = anchor.left - tw + lp.leftMargin;
	result.bottom = b - lp.bottomMargin;
	result.top = b - th + lp.topMargin;
	break;
	case 90:
	// phone landscape: below anchor on right
	result.right = r - lp.rightMargin;
	result.left = r - tw + lp.leftMargin;
	result.top = anchor.bottom + lp.topMargin;
	result.bottom = anchor.bottom + th - lp.bottomMargin;
	break;
	case 180:
	// phone upside down: right of anchor at top
	result.left = anchor.right + lp.leftMargin;
	result.right = anchor.right + tw - lp.rightMargin;
	result.top = t + lp.topMargin;
	result.bottom = t + th - lp.bottomMargin;
	break;
	case 270:
	// reverse landscape: above anchor on left
	result.left = l + lp.leftMargin;
	result.right = l + tw - lp.rightMargin;
	result.bottom = anchor.top - lp.bottomMargin;
	result.top = anchor.top - th + lp.topMargin;
	break;
	}
	v.layout(result.left, result.top, result.right, result.bottom);
	}

	private void toRight(View v, int l, int t, int r, int b, int orientation, int rotation, Rect anchor) {
	FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) v.getLayoutParams();
	int tw = lp.leftMargin + v.getMeasuredWidth() + lp.rightMargin;
	int th = lp.topMargin + v.getMeasuredHeight() + lp.bottomMargin;
	Rect result = new Rect();
	switch (rotation) {
	case 0:
	// portrait, right of anchor at bottom
	result.left = anchor.right + lp.leftMargin;
	result.right = anchor.right + tw - lp.rightMargin;
	result.bottom = b - lp.bottomMargin;
	result.top = b - th + lp.topMargin;
	break;
	case 90:
	// phone landscape: above anchor on right
	result.right = r - lp.rightMargin;
	result.left = r - tw + lp.leftMargin;
	result.bottom = anchor.top - lp.bottomMargin;
	result.top = anchor.top - th + lp.topMargin;
	break;
	case 180:
	// phone upside down: left of anchor at top
	result.right = anchor.left - lp.rightMargin;
	result.left = anchor.left - tw + lp.leftMargin;
	result.top = t + lp.topMargin;
	result.bottom = t + th - lp.bottomMargin;
	break;
	case 270:
	// reverse landscape: below anchor on left
	result.left = l + lp.leftMargin;
	result.right = l + tw - lp.rightMargin;
	result.top = anchor.bottom + lp.topMargin;
	result.bottom = anchor.bottom + th - lp.bottomMargin;
	break;
	}
	v.layout(result.left, result.top, result.right, result.bottom);
	}

	private void topRight(View v, int l, int t, int r, int b, int orientation, int rotation) {
	// layout using the specific margins; the rotation code messes up the others
	int mt = getContext().getResources().getDimensionPixelSize(R.dimen.capture_margin_top);
	int mr = getContext().getResources().getDimensionPixelSize(R.dimen.capture_margin_right);
	v.layout(r - v.getMeasuredWidth() - mr, t + mt, r - mr, t + mt + v.getMeasuredHeight());
	}

	// In reverse landscape and reverse portrait, camera controls will be laid out
	// on the wrong side of the screen. We need to make adjustment to move the controls
	// to the USB side
	public void adjustControlsToRightPosition() {
	Configuration config = getResources().getConfiguration();
	int orientation = Util.getDisplayRotation((Activity) getContext());
	if (orientation == 270 && config.orientation == Configuration.ORIENTATION_LANDSCAPE) {
	flipChildren();
	}
	if (orientation == 180 && config.orientation == Configuration.ORIENTATION_PORTRAIT) {
	flipChildren();
	}
	adjustBackground();
	}

	private void adjustBackground() {
	// remove current drawable and reset rotation
	mBackgroundView.setBackgroundDrawable(null);
	mBackgroundView.setRotationX(0);
	mBackgroundView.setRotationY(0);
	// if the switcher background is top aligned we need to flip the background
	// drawable vertically; if left aligned, flip horizontally
	int gravity = ((LayoutParams) mBackgroundView.getLayoutParams()).gravity;
	if ((gravity & Gravity.TOP) == Gravity.TOP) {
	mBackgroundView.setRotationX(180);
	} else if ((gravity & Gravity.LEFT) == Gravity.LEFT) {
	mBackgroundView.setRotationY(180);
	}
	mBackgroundView.setBackgroundResource(R.drawable.switcher_bg);
	}

	}