Android-加速传感器或者OrientationEventListener做横竖屏切换

最新推荐文章于 2022-05-11 00:30:00 发布
最新推荐文章于 2022-05-11 00:30:00 发布
阅读量1w 收藏 11
点赞数 4
分类专栏： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/goldenfish1919/article/details/47423131
版权

在播放视频的时候，可能要做横竖屏的切换，但是，用户可以设置自己的手机关掉屏幕旋转，这个时候就需要想其他的办法了，比如：加速传感器或者OrientationEventListener。

1、这是用加速传感器来实现：

public class ScreenSwitchUtils {
	
	private static final String TAG = ScreenSwitchUtils.class.getSimpleName();
	
	private volatile static ScreenSwitchUtils mInstance;
	
	private Activity mActivity;
	
	// 是否是竖屏
	private boolean isPortrait = true;
	
	private SensorManager sm;
	private OrientationSensorListener listener;
	private Sensor sensor;

	private SensorManager sm1;
	private Sensor sensor1;
	private OrientationSensorListener1 listener1;
	
	private Handler mHandler = new Handler() {
		public void handleMessage(Message msg) {
			switch (msg.what) {
			case 888:
				int orientation = msg.arg1;
				if (orientation > 45 && orientation < 135) {

				} else if (orientation > 135 && orientation < 225) {

				} else if (orientation > 225 && orientation < 315) {
					if (isPortrait) {
						Log.e("test", "切换成横屏");
						mActivity.setRequestedOrientation(0);
						isPortrait = false;
					}
				} else if ((orientation > 315 && orientation < 360) || (orientation > 0 && orientation < 45)) {
					if (!isPortrait) {
						Log.e("test","切换成竖屏");
						mActivity.setRequestedOrientation(1);
						isPortrait = true;
					}
				}
				break;
			default:
				break;
			}

		};
	};
	
	/** 返回ScreenSwitchUtils单例 **/
    public static ScreenSwitchUtils init(Context context) {
        if (mInstance == null) {
            synchronized (ScreenSwitchUtils.class) {
                if (mInstance == null) {
                    mInstance = new ScreenSwitchUtils(context);
                }
            }
        }
        return mInstance;
    }

    private ScreenSwitchUtils(Context context) {
        Log.d(TAG, "init orientation listener.");
        // 注册重力感应器,监听屏幕旋转
        sm = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
        sensor = sm.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        listener = new OrientationSensorListener(mHandler);

        // 根据 旋转之后/点击全屏之后 两者方向一致,激活sm.
        sm1 = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
        sensor1 = sm1.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        listener1 = new OrientationSensorListener1();
    }
    
    /** 开始监听 */
    public void start(Activity activity) {
    	Log.d(TAG, "start orientation listener.");
        mActivity = activity;
        sm.registerListener(listener, sensor, SensorManager.SENSOR_DELAY_UI);
    }

    /** 停止监听 */
    public void stop() {
    	Log.d(TAG, "stop orientation listener.");
    	sm.unregisterListener(listener);
		sm1.unregisterListener(listener1);
    }
    
    /**
     * 手动横竖屏切换方向
     */
    public void toggleScreen() {
		sm.unregisterListener(listener);
		sm1.registerListener(listener1, sensor1,SensorManager.SENSOR_DELAY_UI);
		if (isPortrait) {
			isPortrait = false;
			// 切换成横屏
			mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
		} else {
			isPortrait = true;
			// 切换成竖屏
			mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
		}
	}
    
    public boolean isPortrait(){
    	return this.isPortrait;
    }
    
    /**
	 * 重力感应监听者
	 */
	public class OrientationSensorListener implements SensorEventListener {
		private static final int _DATA_X = 0;
		private static final int _DATA_Y = 1;
		private static final int _DATA_Z = 2;

		public static final int ORIENTATION_UNKNOWN = -1;

		private Handler rotateHandler;

		public OrientationSensorListener(Handler handler) {
			rotateHandler = handler;
		}

		public void onAccuracyChanged(Sensor arg0, int arg1) {
		}

		public void onSensorChanged(SensorEvent event) {
			float[] values = event.values;
			int orientation = ORIENTATION_UNKNOWN;
			float X = -values[_DATA_X];
			float Y = -values[_DATA_Y];
			float Z = -values[_DATA_Z];
			float magnitude = X * X + Y * Y;
			// Don't trust the angle if the magnitude is small compared to the y
			// value
			if (magnitude * 4 >= Z * Z) {
				// 屏幕旋转时
				float OneEightyOverPi = 57.29577957855f;
				float angle = (float) Math.atan2(-Y, X) * OneEightyOverPi;
				orientation = 90 - (int) Math.round(angle);
				// normalize to 0 - 359 range
				while (orientation >= 360) {
					orientation -= 360;
				}
				while (orientation < 0) {
					orientation += 360;
				}
			}
			if (rotateHandler != null) {
				rotateHandler.obtainMessage(888, orientation, 0).sendToTarget();
			}
		}
	}

	public class OrientationSensorListener1 implements SensorEventListener {
		private static final int _DATA_X = 0;
		private static final int _DATA_Y = 1;
		private static final int _DATA_Z = 2;

		public static final int ORIENTATION_UNKNOWN = -1;

		public OrientationSensorListener1() {
		}

		public void onAccuracyChanged(Sensor arg0, int arg1) {
		}

		public void onSensorChanged(SensorEvent event) {
			float[] values = event.values;
			int orientation = ORIENTATION_UNKNOWN;
			float X = -values[_DATA_X];
			float Y = -values[_DATA_Y];
			float Z = -values[_DATA_Z];
			float magnitude = X * X + Y * Y;
			// Don't trust the angle if the magnitude is small compared to the y
			// value
			if (magnitude * 4 >= Z * Z) {
				// 屏幕旋转时
				float OneEightyOverPi = 57.29577957855f;
				float angle = (float) Math.atan2(-Y, X) * OneEightyOverPi;
				orientation = 90 - (int) Math.round(angle);
				// normalize to 0 - 359 range
				while (orientation >= 360) {
					orientation -= 360;
				}
				while (orientation < 0) {
					orientation += 360;
				}
			}
			if (orientation > 225 && orientation < 315) {// 检测到当前实际是横屏
				if (!isPortrait) {
					sm.registerListener(listener, sensor,SensorManager.SENSOR_DELAY_UI);
					sm1.unregisterListener(listener1);
				}
			} else if ((orientation > 315 && orientation < 360) || (orientation > 0 && orientation < 45)) {// 检测到当前实际是竖屏
				if (isPortrait) {
					sm.registerListener(listener, sensor,SensorManager.SENSOR_DELAY_UI);
					sm1.unregisterListener(listener1);
				}
			}
		}
	}
}

转载请标明出处：http://blog.csdn.net/goldenfish1919/article/details/47423131

使用的时候：

public class MainActivity extends Activity implements OnClickListener {

	private ScreenSwitchUtils instance;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		instance = ScreenSwitchUtils.init(this.getApplicationContext());
	}

	@Override
	protected void onStart() {
		super.onStart();
		instance.start(this);
	}

	@Override
	protected void onStop() {
		super.onStop();
		instance.stop();
	}

	@SuppressLint("NewApi")
	@Override
	public void onConfigurationChanged(Configuration newConfig) {
		super.onConfigurationChanged(newConfig);
		Log.e("test", "onConfigurationChanged");
		if (instance.isPortrait()) {
			// 切换成竖屏
			LayoutParams params1 = new RelativeLayout.LayoutParams(screenWidth, DensityUtil.dip2px(this, 160));
			videoView.setLayoutParams(params1);
			Toast.makeText(getApplicationContext(), "竖屏", 0).show();
			Log.e("test", "竖屏");
		} else {
			// 切换成横屏
			LayoutParams params1 = new RelativeLayout.LayoutParams(screenHeight, screenWidth);
			videoView.setLayoutParams(params1);
			Toast.makeText(getApplicationContext(), "横屏", 0).show();
			Log.e("test", "横屏");
		}
	}

	@Override
	public void onClick(View arg0) {
		switch (arg0.getId()) {
		case R.id.iv_stretch:
			instance.toggleScreen();
			break;
		}
	}
}

调用了activity.setRequestedOrientation()以后，会触发activity.onConfigurationChanged();可以在这里面重新设置播放界面的大小。


参考：http://download.csdn.net/download/liubo080852/8446445


2.还有一种更简单的方式OrientationEventListener：

public class ScreenOrientationUtil {
	
	private int mOrientation;
	private OrientationEventListener mOrEventListener;
	
	private int mOrientation1;
	private OrientationEventListener mOrEventListener1;
	
	private Activity mActivity;
	
	private static ScreenOrientationUtil instance = new ScreenOrientationUtil();
	
	public static ScreenOrientationUtil getInstance(){
		return instance;
	} 
	
	public void start(Activity activity){
		this.mActivity = activity;
		if(mOrEventListener == null){
			initListener();
		}
		mOrEventListener.enable();
	}
	
	public void stop(){
		if(mOrEventListener != null){
			mOrEventListener.disable();
		}
		if(mOrEventListener1 != null){
			mOrEventListener1.disable();
		}
	}
	
	private void initListener(){
		mOrEventListener = new OrientationEventListener(mActivity) {
	        @Override
	        public void onOrientationChanged(int rotation) {
	        	Log.e("test", ""+rotation);
	            if (rotation == OrientationEventListener.ORIENTATION_UNKNOWN) {
	                return;
	            }
	            int orientation = convert2Orientation(rotation);
	            // 方向没有变化,跳过
	            if (orientation == mOrientation) {
	                return;
	            }
	            mOrientation = orientation;
	            mActivity.setRequestedOrientation(mOrientation);
	            
	        }
	    };
	    
	    mOrEventListener1 = new OrientationEventListener(mActivity) {
	        @Override
	        public void onOrientationChanged(int rotation) {
	            if (rotation == OrientationEventListener.ORIENTATION_UNKNOWN) {
	                return;
	            }
	            int orientation = convert2Orientation(rotation);
	            // 方向没有变化,跳过
	            if (orientation == mOrientation1) {
	                return;
	            }
	            mOrientation1 = orientation;
	            if(mOrientation1 == mOrientation){
	            	mOrEventListener1.disable();
	            	mOrEventListener.enable();
	            }
	        }
	    };
	}
	
	public boolean isPortrait(){
		if(mOrientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT || mOrientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT){
			return true;
		}
		return false;
	}
	
	public int getOrientation(){
		return mOrientation;
	}
	
	public void toggleScreen(){
		mOrEventListener.disable();
		mOrEventListener1.enable();
		int orientation = 0 ;
		if(mOrientation ==  ActivityInfo.SCREEN_ORIENTATION_PORTRAIT){
			orientation = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
		}else if(mOrientation == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE){
			orientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
		}else if(mOrientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE){
			orientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
		}else if(mOrientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT){
			orientation = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
		}
		mOrientation = orientation;
		mActivity.setRequestedOrientation(mOrientation);
	}
	
	private int convert2Orientation(int rotation){
		int orientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
        if (((rotation >= 0) && (rotation <= 45)) || (rotation > 315)) {
            orientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
        } else if ((rotation > 45) && (rotation <= 135)) {
            orientation = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
        } else if ((rotation > 135) && (rotation <= 225)) {
            orientation = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
        } else if ((rotation > 225) && (rotation <= 315)) {
            orientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
        } else {
            orientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
        }
        return orientation;
	}
}

貌似也可以啊！

代码在这里：http://download.csdn.net/detail/goldenfish1919/8999635


若鱼1919
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
根据重力感应旋转屏幕-支持3个方向旋转-有代码解释
04-30
实现了根据重力感应来旋转屏幕，但只支持支持3个方向旋转，不支持竖直倒向旋转，代码有实现流程顺序的文字解释。
Android SensorManager传感器应用: 横竖屏方向自动切换 和 抖动恢复屏幕方向
intbird的专栏
10-14 1035
目录1. 问题来源2. 实现效果3. 示例说明5. 源码地址 之前写了一个简单的视频播放器: https://blog.csdn.net/intbird/article/details/105970536 里面考虑了一个屏幕方向的问题, 现在来简单实现一下 1. 问题来源 如果始终进行横竖屏切换, 不用其他条件(比如屏幕方向跟随人脸模式): 下面代码的 OrientationEventListener onOrientationChanged 判断屏幕角度 再进行 屏幕方向旋转 即可实现 但: 如果手机在
android sensor 横竖屏 方向,Android系统实现横竖屏两方向自动旋转的方法
weixin_31957989的博客
05-25 255
Android系统不像iOS有shouldAutorotateToInterfaceOrientation:以及项目info.plist中的支持屏幕朝向属性设置那么直白的屏幕朝向支持，而且2.2以下和2.3以上还有对自动旋屏功能支持的差异：在2.2一下，manifest中可以通过在2.3及以上的target下，可以通过设置public static final int ANDROID_BUILD_...
手机加速度传感器在Android横竖屏切换中的应用
研究员的自我修养
07-28 472
文章目录如何判断手机的横竖屏使用加速度计实现接口使用使用加速度计和磁力计获取手机倾斜角度加速度传感器在Android横竖屏切换中的应用 如何判断手机的横竖屏 这个问题依赖与手机上的传感器 一般获取手机倾斜角度，用加速度计和磁力计去判断 如果只是判断横竖屏 可以只用加速度计 加速度计普及度高 使用加速度计实现 参考了AOSP的通用实现 public class AccelerometerListener { // Device orientation public static final int
让android程序根据重力感应旋转屏幕(支持4个方向旋转)
热门推荐
风生水起
05-29 1万+
最近公司在做一个软件，用户要求软件能随着手机转动自动切换横屏和竖屏，而且要求就算是手机头下脚上的倒个个软件也要能自适应的变成合适的方向。熟悉android的人都知道，android系统的手机绝大部分只支持三种屏幕方向的重力感应自动切换，竖直，水平，反方向水平，独独不支持反方向竖直的重力感应切换。我由于一次偶然刷系统刷到了cm，发现这个系统居然支持竖直方向的重力感应屏幕自动切换，于是我想，这说明系统肯定是支持这个功能的，只是被屏蔽了起来而已。于是我就想，可不可以在源码里找到时哪里被屏蔽了，那我们就可以同过ja
android横竖屏切换不重启activity解决方案
09-05
部分网友会发现Activity在切换到后台或布局从横屏LANDSCAPE切换到PORTRAIT，会重新切换Activity会触发一次onCreate方法,使用其他的方法同样可以实现
Android横竖屏切换及其对应布局加载问题详解
01-20
本文为大家分享了Android横竖屏切换及其对应布局加载问题，供大家参考，具体内容如下 第一，横竖屏切换连带横竖屏布局问题： 如果要让软件在横竖屏之间切换，由于横竖屏的高宽会发生转换，有可能会要求不同的布局。...
Android实现横竖屏切换的实例代码
08-30
本篇文章主要介绍了Android实现横竖屏切换的实例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
android中Activity横竖屏切换的那些事
08-31
本篇文章主要介绍了android中Activity横竖屏切换的那些事，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
防止activity转屏幕后调用oncreate的方法
07-29 807
在介绍之前，我们需要先了解默认情况下android屏幕旋转的机制： 默认情况下，当用户手机的重力感应器打开后，旋转屏幕方向，会导致当前activity发生onDestroy-> onCreate，这样会重新构造当前activity和界面布局，如果在Camera界面，则表现为卡顿或者黑屏一段时间。如果是在横竖屏UI设计方面，那么想很好地支持屏幕旋转，则建议在res中建立layout-land和la
android之Display.getRotation()_传感器控制屏幕旋转
移动编程
08-11 1632
在看android自带的samples源码里面的AccelerometerPlayActivity时,看到下面这段代码,很不理解 public void onSensorChanged(SensorEvent event) { if(event.sensor.getType() != Sensor.TYPE_ACCELEROMETER){ return; } switch (m...
Android屏幕重力感应旋转
weixin_30456039的博客
01-30 157
public class MainActivity extends AppCompatActivity { 　　private MyOrientoinListener myOrientoinListener; @Override protected void onCreate(Bundle savedInstanceState) { sup...
Android 根据sensor重力感应 app横竖屏旋转
安卓兼职framework和app工程师的博客
05-11 1413
在app开发中，当系统禁止自动旋转以后，app需要横竖屏旋转该怎么做呢，那就只能根据sensor 重力感应的值来实现屏幕旋转了 1.获取sensor重力感应的值 import android.hardware.Sensor; import android.hardware.SensorEvent; import android.hardware.SensorEventListener; import android.os.Handler; public class OrientationSensorLis
android实现自动横竖屏切换,android 中实现横竖屏切换【原创】
weixin_42478292的博客
05-26 1436
我们在使用android手机的时候，发现一些应用有横竖屏切换的功能，一般实现有以下几种方法：一、设置1.通过XML设置横竖屏切换在项目的 AndroidManifest.xml中找到你所指定的activity中加上android:screenOrientation属性，它有以下几个参数：“unspecified” 默认值 由系统来判断显示方向.判定的策略是和设备相关的，所以不同的设备会有不同的显示...
android 屏幕旋转（横屏、竖屏、反向横屏、反向竖屏）的实现
tracy的博客
10-31 8505
android 屏幕旋转（横屏、竖屏、反向横屏、反向竖屏）的实现前言：根据屏幕的旋转自动实现应用界面旋转，横屏、竖屏、反向横屏、反向竖屏。
重力传感器（二）——屏幕旋转OrientationEventListener监听
Flying snow
09-04 1503
（1）OrientationEventListener源码 //frameworks/base/core/java/android/view/OrientationEventListener.java /** * Helper class for receiving notifications from the SensorManager when * the orientation of the device has changed. */ public abstract class Orient
Android Sensor 自动旋转控制
Shangri
11-24 919
android 旋转监听
android横竖屏切换适配
最新发布
06-10
Android横竖屏切换适配主要包括以下几个方面： 1. 配置AndroidManifest.xml文件：在activity节点中添加android:configChanges="orientation|keyboardHidden|screenSize"属性，表示Activity不会重新创建，而是会调用onConfigurationChanged()方法进行处理。 2. 创建layout-land目录：在res目录下创建一个新的目录，名称为layout-land，该目录下的布局文件将会在横屏时使用。 3. 适配布局：横竖屏布局不同，需要根据需要进行适配。可以使用ConstraintLayout等布局来实现自适应布局。 4. 处理Activity生命周期：横竖屏切换会触发Activity的生命周期，需要在onPause()和onResume()等方法中进行数据的保存和恢复。 总之，横竖屏切换适配需要注意布局的适配和数据的保存恢复，同时也要注意不要重复创建Activity，保证用户体验。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值