重力感应器控制屏幕横竖屏

心已赠人 2022-05-21 11:48 185阅读 0赞

工具类:

public class ScreenSwitchUtils { 
    
        private static ScreenSwitchUtils mInstance;
    
        private static Object lock = new Object();
        private OrientationSensorListener listener;
        private SensorManager sm;
        private Sensor sensor;
        private Activity mActivity;
        private  static final int ORIENTATION_SUCCESS = 1;
        private Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                if (msg.what == ORIENTATION_SUCCESS) {
                    int orientation = msg.arg1;
                    if (orientation > 45 && orientation < 135) {
                        mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
                    } else if (orientation > 135 && orientation < 225) {
                        mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT);
                    } else if (orientation > 225 && orientation < 315) {
                        mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
                    } else if ((orientation > 315 && orientation < 360) || (orientation > 0 && orientation < 45)) {
                        mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
                    }
                }
            }
        };
    
    
        public ScreenSwitchUtils(Context context) {
            sm = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
            sensor = sm.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
            listener = new OrientationSensorListener(handler);
            sm.registerListener(listener, sensor, SensorManager.SENSOR_DELAY_UI);
        }
    
        public static ScreenSwitchUtils newInstance(Context context) {
            if (mInstance == null) {
                synchronized (lock) {
                    if (mInstance == null) {
                        mInstance = new ScreenSwitchUtils(context);
                    }
                }
            }
            return mInstance;
        }
    
    
        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) {
                // TODO Auto-generated method stub
    
            }
    
            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(ORIENTATION_SUCCESS, orientation, 0).sendToTarget();
                }
    
            }
    
        }
    
        /** * 开始监听 */
        public void start(Activity activity) {
            mActivity = activity;
            sm.registerListener(listener, sensor, SensorManager.SENSOR_DELAY_UI);
        }
    
        /** * 停止监听 */
        public void stop() {
            sm.unregisterListener(listener);
        }
    
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55
 *  56
 *  57
 *  58
 *  59
 *  60
 *  61
 *  62
 *  63
 *  64
 *  65
 *  66
 *  67
 *  68
 *  69
 *  70
 *  71
 *  72
 *  73
 *  74
 *  75
 *  76
 *  77
 *  78
 *  79
 *  80
 *  81
 *  82
 *  83
 *  84
 *  85
 *  86
 *  87
 *  88
 *  89
 *  90
 *  91
 *  92
 *  93
 *  94
 *  95
 *  96
 *  97
 *  98
 *  99
 *  100
 *  101
 *  102
 *  103
 *  104
 *  105
 *  106
 *  107
 *  108
 *  109
 *  110
 *  111
 *  112
 *  113
 *  114

调用:

public class MainActivity extends AppCompatActivity { 
        private  ScreenSwitchUtils mScreenSwitchUtils;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            mScreenSwitchUtils = ScreenSwitchUtils.newInstance(this);
        }
    
        @Override
        protected void onResume() {
            super.onResume();
            mScreenSwitchUtils.start(this);
        }
    
        @Override
        protected void onPause() {
            super.onPause();
            mScreenSwitchUtils.stop();
        }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21

清单文件在Activity中添加:

android:configChanges="orientation|keyboard"