android - rotar - porque no gira la pantalla de mi samsung

Obtén orientación del teléfono pero fija la orientación de la pantalla al retrato

Question

Quiero obtener la orientación del teléfono, pero mantener la orientación de la pantalla al retrato. Así que no importa que el usuario gire el teléfono a horizontal o vertical, la vista se mantiene igual, pero puedo ver si está en horizontal o vertical.

Configurando la actividad en android: screenOrientation = "portrait" arreglará ambos, pero no podré detectar la orientación del teléfono a través de

public void onConfigurationChanged(Configuration newConfig) {
    switch (newConfig.orientation) {
    case Configuration.ORIENTATION_PORTRAIT:
        Toast.makeText(this, "Portrait", Toast.LENGTH_SHORT).show();
        break;
    case Configuration.ORIENTATION_LANDSCAPE:
        Toast.makeText(this, "Landscape", Toast.LENGTH_SHORT).show();
        break;
    default:
        break;
    }
}

¿Alguien tiene una idea de cómo arreglar eso?

Answer 1

¿Podrías satisfacer tus necesidades con el acelerómetro? Si es así, quizás algo como este fragmento (no probado) se adapte a sus propósitos.

SensorManager sensorManager = (SensorManager) this.getSystemService(Context.SENSOR_SERVICE);
        sensorManager.registerListener(new SensorEventListener() {
            int orientation=-1;;

            @Override
            public void onSensorChanged(SensorEvent event) {
                if (event.values[1]<6.5 && event.values[1]>-6.5) {
                    if (orientation!=1) {
                        Log.d("Sensor", "Landscape");
                    }
                    orientation=1;
                } else {
                    if (orientation!=0) {
                        Log.d("Sensor", "Portrait");
                    }
                    orientation=0;
                }
            }

            @Override
            public void onAccuracyChanged(Sensor sensor, int accuracy) {
                // TODO Auto-generated method stub

            }
        }, sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_GAME);

Answer 2

Aquí hay una clase multiuso para administrar fácilmente los cambios de orientación de la pantalla:

public class OrientationManager extends OrientationEventListener {

    public enum ScreenOrientation {
        REVERSED_LANDSCAPE, LANDSCAPE, PORTRAIT, REVERSED_PORTRAIT
    }

    public ScreenOrientation screenOrientation; 
    private OrientationListener listener;

    public OrientationManager(Context context, int rate, OrientationListener listener) {
        super(context, rate);
        setListener(listener);
    }

    public OrientationManager(Context context, int rate) {
        super(context, rate);
    }

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

    @Override
    public void onOrientationChanged(int orientation) {
        if (orientation == -1){
            return;
        }
        ScreenOrientation newOrientation;
        if (orientation >= 60 && orientation <= 140){
            newOrientation = ScreenOrientation.REVERSED_LANDSCAPE;
        } else if (orientation >= 140 && orientation <= 220) {
            newOrientation = ScreenOrientation.REVERSED_PORTRAIT;
        } else if (orientation >= 220 && orientation <= 300) {
            newOrientation = ScreenOrientation.LANDSCAPE;
        } else {
            newOrientation = ScreenOrientation.PORTRAIT;                    
        }
        if(newOrientation != screenOrientation){
            screenOrientation = newOrientation;
            if(listener != null){
                listener.onOrientationChange(screenOrientation);
            }           
        }
    }

    public void setListener(OrientationListener listener){
        this.listener = listener;
    }

    public ScreenOrientation getScreenOrientation(){
        return screenOrientation;
    }

    public interface OrientationListener {

        public void onOrientationChange(ScreenOrientation screenOrientation);
    }
}

Esto es mucho más simple, reutilizable, y también puede obtener las orientaciones REVERSE_LANDSCAPE y REVERSE_PORTRAIT.

Debe implementar OrientationListener para recibir una notificación solo cuando se produce un cambio de orientación.

No se olvide de llamar a OrientationManager.enable () para comenzar el seguimiento de la orientación, y luego llame a OrientationManager.disable () (estos dos métodos se heredan de la clase OrientationEventListener)

ACTUALIZACIÓN: ejemplo de caso de uso

MyFragment extends Fragment implements OrientationListener {

    ...

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        orientationManager = new OrientationManager(getActivity(), SensorManager.SENSOR_DELAY_NORMAL, this);
        orientationManager.enable();        
    }

    @Override
    public void onOrientationChange(ScreenOrientation screenOrientation) {
        switch(screenOrientation){
            case PORTRAIT:
            case REVERSED_PORTRAIT:
                MainActivityBase.getInstance().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            break;
            case REVERSED_LANDSCAPE:
                MainActivityBase.getInstance().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
            break;
            case LANDSCAPE:
                MainActivityBase.getInstance().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
            break;
        }
    }
}

Answer 3

En caso de que alguien esté buscando una solución Webview / javascript para la pregunta, lo siguiente puede hacer eso.

Esto activará eventos personalizados ''voltear'' en la ventana, con ''parámetros extra'' como jquery los tiene. También establece window.flip, análogo a window.orientation:

$(window).on(''flip'',function(ev,angle,orientation) {
    console.log(angle,orientation);
    alert(window.flip);
});

if (window.DeviceOrientationEvent) {
    jQuery.flip = {
        debug       : false,
        interval    : 1000,
        checked     : false,
        betaflat    : 25,
        gammaflat   : 45,
        orientation : ''portrait-primary'',
        angles      : {
            ''portrait-primary''      : 0,
            ''portrait-secondary''    : 0,
            ''landscape-primary''     : 90,
            ''landscape-secondary''   : -90       
        },
        timer       : null,
        check       : function(ev) {
            if (!this.checked) {
                var trigger=false;
                if (this.debug) console.log([ev.alpha,ev.beta,ev.gamma]);
                if (ev.beta>this.betaflat) {
                    // if beta is big its portrait
                    if (this.debug) console.log(''beta portrait pri'');
                    if (this.orientation!=''portrait-primary'') {
                        this.orientation=''portrait-primary'';
                        trigger=true;
                    }
                } else if (ev.beta<-this.betaflat) {
                    // if beta is big its portrait
                    if (this.debug) console.log(''beta portrait sec'');
                    if (this.orientation!=''portrait-secondary'') {
                        this.orientation=''portrait-secondary'';
                        trigger=true;
                    }
                } else if (ev.gamma>this.gammaflat) {

                    // else if gamma is big its landscape
                    if (this.debug) console.log(''gamma landscape pri'');
                    if (this.orientation!=''landscape-primary'') {
                        this.orientation=''landscape-primary'';
                        trigger=true;
                    }

                } else if (ev.gamma<-this.gammaflat) {

                    // else if gamma is big its landscape
                    if (this.debug) console.log(''gamma landscape sec'');
                    if (this.orientation!=''landscape-secondary'') {
                        this.orientation=''landscape-secondary'';
                        trigger=true;
                    }

                }
                if (trigger) {
                    if (this.debug) console.log(''trigger flip'');
                    window.flip = this.angles[this.orientation];
                    $(window).trigger(''flip'',[window.flip,this.orientation]);
                    this.checked=true;
                }
            }
        }
    }
    $(document).ready(function() {
        setInterval(function() {jQuery.flip.checked=false},jQuery.flip.interval);
        $(window).on(''deviceorientation'',function(ev) { jQuery.flip.check(ev.originalEvent) });
    });
} else {
    if (this.debug) console.log(''DeviceOrientationEvent not supported'');
}

El jquery no es realmente necesario. Lo tenía requerido de todos modos.

Answer 4

Necesitaba una solución que me diera la orientación solo a pedido. Este me funcionó:

public class SensorOrientationChecker {

public final String TAG = getClass().getSimpleName();

int mOrientation = 0;
private SensorEventListener mSensorEventListener;
private SensorManager mSensorManager;

private static SensorOrientationChecker mInstance;

public static SensorOrientationChecker getInstance() {
    if (mInstance == null)
        mInstance = new SensorOrientationChecker();

    return mInstance;
}

private SensorOrientationChecker() {
    mSensorEventListener = new Listener();
    Context applicationContext = GlobalData.getInstance().getContext();
    mSensorManager = (SensorManager) applicationContext.getSystemService(Context.SENSOR_SERVICE);

}

/**
 * Call on activity onResume()
 */
public void onResume() {
    mSensorManager.registerListener(mSensorEventListener, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_NORMAL);
}

/**
 * Call on activity onPause()
 */
public void onPause() {
    mSensorManager.unregisterListener(mSensorEventListener);
}

private class Listener implements SensorEventListener {

    @Override
    public void onSensorChanged(SensorEvent event) {
        float x = event.values[0];
        float y = event.values[1];

        if (x<5 && x>-5 && y > 5)
            mOrientation = 0;
        else if (x<-5 && y<5 && y>-5)
            mOrientation = 90;
        else if (x<5 && x>-5 && y<-5)
            mOrientation = 180;
        else if (x>5 && y<5 && y>-5)
            mOrientation = 270;

        //Log.e(TAG,"mOrientation="+mOrientation+"   ["+event.values[0]+","+event.values[1]+","+event.values[2]+"]");
                                                                       }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {

    }

}

public int getOrientation(){
    return mOrientation;
    }
}

Answer 5

Para entrar en que desea establecer en el archivo de manifiesto en esa actividad

android:configChanges="orientation|keyboardHidden"

Luego, cuando el usuario gire el teléfono, entrará en vigor público el método onConfigurationChanged (). También quitar

android:screenOrientation="portrait" 

de la misma actividad.

Answer 6

Si desactiva el cambio de orientación de la pantalla, obviamente, nunca se llamará a onConfigurationChanged ...

Creo que la única forma es usar el sensor del acelerómetro, verifique este enlace .