Redémarrage d'activité sur rotation Android

StackOverflow https://stackoverflow.com/questions/456211

Question

Dans mon application Android, lorsque je fais pivoter l'appareil (faites glisser le clavier), mon Activity est redémarré (onCreate est appelé). Maintenant, c'est probablement ce qui est supposé être, mais je fais beaucoup de configuration initiale dans la méthode <=>, donc il me faut soit:

  1. Mettez toutes les configurations initiales dans une autre fonction afin qu'elles ne soient pas toutes perdues lors de la rotation des périphériques ou
  2. Faites en sorte que <=> ne soit pas appelé à nouveau et que la disposition soit simplement ajustée ou
  3. Limitez l'application à un simple portrait afin que <=> ne soit pas appelé.
Était-ce utile?

La solution

Utilisation de la classe d'application

En fonction de ce que vous faites lors de votre initialisation, vous pouvez envisager de créer une nouvelle classe qui étend Application et de déplacer votre code d'initialisation vers une méthode onCreate remplacée dans cette classe. 

public class MyApplicationClass extends Application {
  @Override
  public void onCreate() {
    super.onCreate();
    // TODO Put your application initialization code here.
  }
}

La android:configChanges classe d'application n'est appelée que lorsque l'application entière est créée. Par conséquent, l'activité redémarre à la suite d'une modification de l'orientation du clavier ou de la visibilité du clavier.

Il est judicieux d'exposer l'instance de cette classe en tant que singleton et d'exposer les variables d'application que vous initialisez à l'aide de getters et de setters.

REMARQUE: vous devez spécifier le nom de votre nouvelle classe d'application dans le manifeste pour qu'elle soit enregistrée et utilisée: 

<application
    android:name="com.you.yourapp.MyApplicationClass"

Réaction aux modifications de configuration [UPDATE: obsolète depuis l’API 13; voir l'alternative recommandée ]

Vous pouvez également laisser votre application écouter les événements susceptibles de provoquer un redémarrage & # 8211; comme l'orientation et les changements de visibilité du clavier & # 8211; et les gérer dans votre activité.

Commencez par ajouter le nœud onConfigurationChanged au nœud du manifeste de votre activité

. 
 <activity android:name=".MyActivity"
      android:configChanges="orientation|keyboardHidden"
      android:label="@string/app_name">

ou pour Android 3.2 (API niveau 13) et plus récent : 

<activity android:name=".MyActivity"
      android:configChanges="keyboardHidden|orientation|screenSize"
      android:label="@string/app_name">

Dans l'activité, remplacez la méthode setContentView et appelez <=> pour forcer la présentation de l'interface graphique à être refaite dans la nouvelle orientation. 

@Override
public void onConfigurationChanged(Configuration newConfig) {
  super.onConfigurationChanged(newConfig);
  setContentView(R.layout.myLayout);
}

Autres conseils

Mise à jour pour Android 3.2 et versions ultérieures:

  

Attention : depuis Android 3.2 (niveau 13 de l'API), la & taille d'écran " change également lorsque l’appareil bascule entre l’orientation portrait et l’orientation paysage. Ainsi, si vous souhaitez empêcher les redémarrages d'exécution en raison d'un changement d'orientation lors du développement pour l'API de niveau 13 ou supérieur (comme indiqué par les attributs minSdkVersion et targetSdkVersion), vous devez inclure la valeur "screenSize" en plus de la valeur "orientation". C'est-à-dire que vous devez déclarer android:configChanges="orientation|screenSize". Toutefois, si votre application cible une API de niveau 12 ou inférieur, votre activité gère toujours cette modification de configuration elle-même (cette modification de configuration ne redémarre pas votre activité, même sur un périphérique Android 3.2 ou supérieur).

Au lieu d’essayer d’empêcher le onCreate() déclenchement du tir, essayez peut-être de vérifier si Bundle savedInstanceState est passé dans l'événement pour voir s'il est nul ou non.

Par exemple, si une logique doit être exécutée lorsque le Activity est véritablement créé, et non à chaque changement d'orientation, je l'exécute uniquement dans le <=> uniquement si le <=> est nul.

Sinon, je souhaite toujours que la présentation soit correctement redessinée pour l'orientation. 

public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_game_list);

        if(savedInstanceState == null){
            setupCloudMessaging();
        }
}

ne sais pas si c'est la réponse ultime, mais cela fonctionne pour moi.

ce que j'ai fait ...

dans le manifeste, dans la section Activité, a ajouté: 

android:configChanges="keyboardHidden|orientation"

dans le code de l'activité, implémenté: 

//used in onCreate() and onConfigurationChanged() to set up the UI elements
public void InitializeUI()
{
    //get views from ID's
    this.textViewHeaderMainMessage = (TextView) this.findViewById(R.id.TextViewHeaderMainMessage);

    //etc... hook up click listeners, whatever you need from the Views
}

//Called when the activity is first created.
@Override
public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    InitializeUI();
}

//this is called when the screen rotates.
// (onCreate is no longer called when screen rotates due to manifest, see: android:configChanges)
@Override
public void onConfigurationChanged(Configuration newConfig)
{
    super.onConfigurationChanged(newConfig);
    setContentView(R.layout.main);

    InitializeUI();
}

Ce que vous décrivez est le comportement par défaut. Vous devez détecter et gérer ces événements vous-même en ajoutant: 

android:configChanges

à votre manifeste, puis aux modifications que vous souhaitez gérer. Donc, pour l’orientation, vous utiliseriez: 

android:configChanges="orientation"

et pour le clavier ouvert ou fermé, vous utiliseriez: 

android:configChanges="keyboardHidden"

Si vous voulez gérer les deux, vous pouvez simplement les séparer avec la commande pipe comme: 

android:configChanges="keyboardHidden|orientation"

Ceci déclenchera la méthode onConfigurationChanged dans l’activité que vous appelez. Si vous substituez la méthode, vous pouvez transmettre les nouvelles valeurs.

J'espère que cela vous aidera.

Je viens de découvrir cette tradition:

Pour maintenir l'activité en vie lors d'un changement d'orientation et pour la gérer via onConfigurationChanged, la documentation et l'exemple de code ci-dessus le suggère dans le fichier manifeste: 

<activity android:name=".MyActivity"
      android:configChanges="orientation|keyboardHidden"
      android:label="@string/app_name">

qui présente l'avantage supplémentaire de toujours fonctionner.

Le bonus est que l'omission de keyboardHidden peut sembler logique, mais cela provoque des échecs dans l'émulateur (du moins pour Android 2.1): spécifier uniquement orientation fera appeler l'émulateur à la fois OnCreate et <=>. parfois, et seulement <=> d'autres fois.

Je n'ai pas vu l'échec sur un périphérique, mais j'ai entendu parler de l'échec de l'émulateur pour d'autres. Il est donc utile de documenter.

Vous pouvez également envisager d'utiliser la méthode utilisée par la plateforme Android pour conserver les données malgré les modifications d'orientation: onRetainNonConfigurationInstance () et getLastNonConfigurationInstance () .

Cela vous permet de conserver les données lors des modifications de configuration, telles que les informations que vous avez peut-être obtenues lors d'une extraction de serveur ou autre chose calculée dans onCreate ou depuis, tout en permettant à Android de procéder à une nouvelle présentation votre Activité en utilisant le fichier XML pour l'orientation actuellement utilisée.

Voir ici ou ici .

Il convient de noter que ces méthodes sont désormais obsolètes (bien que plus souples encore que la gestion de l'orientation vous-même, comme le suggèrent la plupart des solutions ci-dessus), il est recommandé à tout le monde de passer à Fragments et d'utiliser plutôt < code> setRetainInstance (true) sur chaque fragment que vous souhaitez conserver.

L’approche est utile mais incomplète lors de l’utilisation de fragments.

Les fragments sont généralement recréés lors d'un changement de configuration. Si vous ne le souhaitez pas, utilisez

setRetainInstance (true); dans le ou les constructeurs du fragment

Cela entraînera la rétention des fragments lors du changement de configuration.

http://developer.android.com/ reference / android / app / Fragment.html # setRetainInstance (boolean)

J'ai simplement ajouté 

     android:configChanges="keyboard|keyboardHidden|orientation"

dans le fichier manifeste et n'ajouté aucune méthode onConfigurationChanged dans mon activité.

Chaque fois que le clavier glisse ou que rien ne se produit .

La méthode onCreate est toujours appelée même lorsque vous modifiez l'orientation de d'android. Donc, déplacer toutes les fonctionnalités lourdes de cette méthode ne va pas vous aider

C’est très simple, procédez comme suit: 

<activity
    android:name=".Test"
    android:configChanges="orientation|screenSize"
    android:screenOrientation="landscape" >
</activity>

Cela fonctionne pour moi:

Remarque: l'orientation dépend de votre demande

Placez le code ci-dessous dans votre balise < activité > dans Manifest.xml : 

android:configChanges="screenLayout|screenSize|orientation"

 onConfigurationChanged is called when the screen rotates. 
 (onCreate is no longer called when screen rotates due to manifest, see:  
 android:configChanges)

Quelle partie du manifeste l'indique "N'appelez pas onCreate () "?

Aussi, Les docs de Google disent d'éviter d'utiliser android: configChanges (sauf en dernier recours) .... Mais les méthodes alternatives suggèrent qu'ils DO utilisent android: configChanges .

D'après mon expérience, l'émulateur appelle TOUJOURS onCreate () lors de la rotation.
Mais les 1-2 appareils sur lesquels je lance le même code ne le font pas. (Vous ne savez pas pourquoi il y aurait une différence.)

Ajoutez cette ligne à votre manifeste: - 

android:configChanges="orientation|keyboard|keyboardHidden|screenSize|screenLayout|uiMode"

et cet extrait de l'activité: - 

@Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
    }

Les modifications à apporter au manifeste Android sont les suivantes: 

android:configChanges="keyboardHidden|orientation"

Les ajouts à faire dans l’activité sont: 

public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);

    // Checks the orientation of the screen
    if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
        Toast.makeText(this, "landscape", Toast.LENGTH_SHORT).show();
    } else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT) {
        Toast.makeText(this, "portrait", Toast.LENGTH_SHORT).show();
    }
}

Il existe plusieurs façons de procéder:

Enregistrer l'état d'activité

Vous pouvez enregistrer l'état d'activité dans onSaveInstanceState . 

@Override
public void onSaveInstanceState(Bundle outState) {
    /*Save your data to be restored here
    Example : outState.putLong("time_state", time); , time is a long variable*/
    super.onSaveInstanceState(outState);
}

puis utilisez le bundle pour restaurer l'état. 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    if(savedInstanceState!= null){
       /*When rotation occurs
        Example : time = savedInstanceState.getLong("time_state", 0); */
    } else {
      //When onCreate is called for the first time
    }
}

Gérez vous-même les changements d'orientation

Une autre solution consiste à gérer vous-même les changements d’orientation. Mais cela n’est pas considéré comme une bonne pratique.

Ajoutez ceci à votre fichier manifeste. 

android:configChanges="keyboardHidden|orientation"

pour Android 3.2 et versions ultérieures: 

android:configChanges="keyboardHidden|orientation|screenSize"

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

if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT) {
        //Handle rotation from landscape to portarit mode here
    } else if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE){
        //Handle rotation from portrait to landscape mode here
    }
}

Restreindre la rotation

Vous pouvez également limiter votre activité au mode portrait ou paysage pour éviter la rotation.

Ajoutez ceci à la balise d'activité de votre fichier manifeste: 

        android:screenOrientation="portrait"

Ou implémentez-le par programme dans votre activité: 

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}

Pour ce faire, utilisez les événements onRestoreInstanceState et onSaveInstanceState pour enregistrer quelque chose dans le Bundle (même si vous n’a pas besoin de variables sauvegardées, il suffit d’y mettre quelque chose pour que le Bundle ne soit pas vide). Ensuite, avec la méthode onCreate , vérifiez si le Bundle est vide et si c'est le cas, effectuez l'initialisation, si ce n'est pas le cas, puis exécutez-le.

Même s'il ne s'agit pas de la "façon Android" J'ai obtenu de très bons résultats en gérant moi-même les changements d'orientation et en repositionnant simplement les widgets dans une vue pour prendre en compte l'orientation modifiée. Ceci est plus rapide que toute autre approche, car vos vues ne doivent pas nécessairement être enregistrées et restaurées. Il offre également une expérience plus transparente à l'utilisateur, car les widgets repositionnés sont exactement les mêmes, juste déplacés et / ou redimensionnés. Ainsi, non seulement l’état du modèle, mais également l’état de la vue peuvent être préservés.

RelativeLayout peut parfois être un bon choix pour une vue qui doit se réorienter de temps en temps. Vous venez de fournir un ensemble de paramètres de disposition portrait et un ensemble de paramètres de disposition paysagers, avec différentes règles de positionnement relatif pour chaque widget enfant. Ensuite, dans votre méthode onConfigurationChanged () , vous transmettez celui qui convient à un appel setLayoutParams () sur chaque enfant. Si un contrôle enfant lui-même doit être réorienté en interne , vous appelez simplement une méthode sur cet enfant pour effectuer la réorientation. Cet enfant appelle de la même manière des méthodes sur ses contrôles enfants qui nécessitent une réorientation interne, etc. ".

Chaque fois que l'écran est pivoté, l'activité ouverte est terminée et onCreate () est appelé à nouveau.

1. Vous pouvez faire une chose en sauvegardant l’état de l’activité lorsque l’écran est pivoté afin que vous puissiez récupérer tous les éléments anciens lorsque l’activité onCreate () est appelée à nouveau.     Consultez le lien vers ce lien

.

2. Si vous souhaitez empêcher le redémarrage de l'activité, placez simplement les lignes suivantes dans votre fichier manifest.xml. 

  <activity android:name=".Youractivity"
  android:configChanges="orientation|screenSize"/>

Remarque: Je publie cette réponse si, dans le futur, quelqu'un rencontre le même problème que moi. Pour moi, la ligne suivante n'a pas été suffisante: 

android:configChanges="orientation"

Lorsque j'ai pivoté l'écran, la méthode `onConfigurationChanged (Configuration newConfig) n'a pas été appelée.

Solution: , je devais également ajouter "screenSize". même si le problème avait à voir avec l'orientation. Donc, dans le fichier AndroidManifest.xml, ajoutez ceci: 

android:configChanges="keyboardHidden|orientation|screenSize"

Ensuite, implémentez la méthode onConfigurationChanged (Configuration newConfig)

vous devez utiliser la méthode onSavedInstanceState pour stocker toute la valeur de son paramètre est a bundle 

@Override
    public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
        super.onSaveInstanceState(outState, outPersistentState);
        outPersistentState.putBoolean("key",value);
    }

et utiliser 

@Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        savedInstanceState.getBoolean("key");
    }

pour récupérer et définir la valeur pour afficher les objets il gérera les rotations d'écran

Dans la section activité du manifeste , ajoutez: 

android:configChanges="keyboardHidden|orientation"

Ajoutez cette ligne dans le manifeste: android: configChanges = "orientation | screenSize"

Les gens disent que vous devriez utiliser 

android:configChanges="keyboardHidden|orientation"

Mais la meilleure et la plus professionnelle des manipulations de rotation dans Android consiste à utiliser la classe Loader. Ce n'est pas une classe célèbre (je ne sais pas pourquoi), mais c'est bien mieux que l'AsyncTask. Pour plus d'informations, vous pouvez lire les tutoriels Android trouvés dans les cours Android d'Udacity.

Bien entendu, vous pouvez également stocker les valeurs ou les vues avec onSaveInstanceState et les lire avec onRestoreInstanceState. C'est à vous de décider.

Après quelques essais et erreurs, j'ai trouvé une solution qui répond à mes besoins dans la plupart des situations. Voici le code:

Configuration du manifeste: 

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.pepperonas.myapplication">

    <application
        android:name=".App"
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity
            android:name=".MainActivity"
            android:configChanges="orientation|keyboardHidden|screenSize">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>

                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
    </application>

</manifest>

MainActivity: 

import android.content.res.Configuration;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private static final String TAG = "MainActivity";

    private Fragment mFragment;

    private int mSelected = -1;


    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "onCreate  " + "");

        // null check not realy needed - but just in case...
        if (savedInstanceState == null) {

            initUi();

            // get an instance of FragmentTransaction from your Activity
            FragmentManager fragmentManager = getSupportFragmentManager();
            FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

            /*IMPORTANT: Do the INITIAL(!) transaction only once!
            * If we call this everytime the layout changes orientation,
            * we will end with a messy, half-working UI.
            * */
            mFragment = FragmentOne.newInstance(mSelected = 0);
            fragmentTransaction.add(R.id.frame, mFragment);
            fragmentTransaction.commit();
        }
    }


    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        Log.d(TAG, "onConfigurationChanged  " +
                   (newConfig.orientation
                    == Configuration.ORIENTATION_LANDSCAPE
                    ? "landscape" : "portrait"));

        initUi();

        Log.i(TAG, "onConfigurationChanged - last selected: " + mSelected);
        makeFragmentTransaction(mSelected);
    }


    /**
     * Called from {@link #onCreate} and {@link #onConfigurationChanged}
     */
    private void initUi() {
        setContentView(R.layout.activity_main);
        Log.d(TAG, "onCreate  instanceState == null / reinitializing..." + "");
        Button btnFragmentOne = (Button) findViewById(R.id.btn_fragment_one);
        Button btnFragmentTwo = (Button) findViewById(R.id.btn_fragment_two);
        btnFragmentOne.setOnClickListener(this);
        btnFragmentTwo.setOnClickListener(this);
    }


    /**
     * Not invoked (just for testing)...
     */
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        Log.d(TAG, "onSaveInstanceState  " + "YOU WON'T SEE ME!!!");
    }


    /**
     * Not invoked (just for testing)...
     */
    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        Log.d(TAG, "onSaveInstanceState  " + "YOU WON'T SEE ME, AS WELL!!!");
    }


    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume  " + "");
    }


    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "onPause  " + "");
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy  " + "");
    }


    @Override
    public void onClick(View v) {

        switch (v.getId()) {
            case R.id.btn_fragment_one:
                Log.d(TAG, "onClick btn_fragment_one " + "");
                makeFragmentTransaction(0);
                break;

            case R.id.btn_fragment_two:
                Log.d(TAG, "onClick btn_fragment_two " + "");
                makeFragmentTransaction(1);
                break;

            default:
                Log.d(TAG, "onClick  null - wtf?!" + "");
        }
    }


    /**
     * We replace the current Fragment with the selected one.
     * Note: It's called from {@link #onConfigurationChanged} as well.
     */
    private void makeFragmentTransaction(int selection) {

        switch (selection) {
            case 0:
                mFragment = FragmentOne.newInstance(mSelected = 0);
                break;
            case 1:
                mFragment = FragmentTwo.newInstance(mSelected = 1);
                break;
        }

        // Create new transaction
        FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();

        // Replace whatever is in the fragment_container view with this fragment,
        // and add the transaction to the back stack
        transaction.replace(R.id.frame, mFragment);

        /*This would add the Fragment to the backstack...
        * But right now we comment it out.*/
        //        transaction.addToBackStack(null);

        // Commit the transaction
        transaction.commit();
    }

}

Et fragment d'échantillon: 

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

/**
 * @author Martin Pfeffer (pepperonas)
 */
public class FragmentOne extends Fragment {

    private static final String TAG = "FragmentOne";


    public static Fragment newInstance(int i) {
        Fragment fragment = new FragmentOne();
        Bundle args = new Bundle();
        args.putInt("the_id", i);
        fragment.setArguments(args);
        return fragment;
    }


    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        Log.d(TAG, "onCreateView  " + "");
        return inflater.inflate(R.layout.fragment_one, container, false);
    }

}

Peut être trouvé sur github .

Utilisez le programme d'écoute orientation pour effectuer différentes tâches selon une orientation différente. 

@Override
public void onConfigurationChanged(Configuration myConfig) 
{
    super.onConfigurationChanged(myConfig);
    int orient = getResources().getConfiguration().orientation; 
    switch(orient) 
    {
       case Configuration.ORIENTATION_LANDSCAPE:
          setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
                    break;
       case Configuration.ORIENTATION_PORTRAIT:
          setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
                    break;
       default:
          setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
    }
}

Mettez le code ci-dessous dans votre Activité dans le Manifeste Android . 

android:configChanges="orientation"

Cela ne redémarrera pas votre activité lorsque vous changeriez d'orientation.

Correction de l'orientation de l'écran (paysage ou portrait) dans AndroidManifest.xml

android: screenOrientation = "portrait" ou android: screenOrientation = "paysage"

Pour cela, votre méthode onResume () n'est pas appelée.

L’un des meilleurs composants d’Android architechure introduit par Google répondra à toutes vos exigences, à savoir ViewModel.

Conçu pour stocker et gérer les données liées à l'interface utilisateur de manière cycle de vie, il permet également aux données de survivre lorsque l'écran tourne. 

class MyViewModel : ViewModel() {

Veuillez vous référer à: https://developer.android.com/topic/libraries / architecture / viewmodel

Vous pouvez verrouiller l'orientation actuelle de l'écran à l'aide de ce code ... 

int currentOrientation =context.getResources().getConfiguration().orientation;
        if (currentOrientation == Configuration.ORIENTATION_PORTRAIT) {
            ((Activity) context).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        } else {
            ((Activity) context). setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        }
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top