46 views

Controleer oriëntatie op Android-telefoon

Hosted by Code Expert
java

Hoe kan ik controleren of de Android-telefoon in Liggend of Staand staat?

Antwoord 1, autoriteit 100%

De huidige configuratie, zoals gebruikt om te bepalen welke bronnen moeten worden opgehaald, is beschikbaar via het Configuration-object van de bronnen:

getResources().getConfiguration().orientation;

U kunt de oriëntatie controleren door naar de waarde te kijken:

int orientation = getResources().getConfiguration().orientation;
if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
    // In landscape
} else {
    // In portrait
}

Meer informatie is te vinden in de Android-ontwikkelaar.

Antwoord 2, autoriteit 23%

Als u getResources().getConfiguration().orientation op sommige apparaten gebruikt, gaat het mis. We gebruikten die aanpak aanvankelijk in http://apphance.com. Dankzij remote logging van Apphance konden we het op verschillende devices zien en zagen we dat fragmentatie hier een rol speelt.
Ik zag rare gevallen: bijvoorbeeld afwisselend portret en vierkant (?!) op HTC Desire HD:

CONDITION[17:37:10.345] screen: rotation: 270 orientation: square
CONDITION[17:37:12.774] screen: rotation: 0 orientation: portrait
CONDITION[17:37:15.898] screen: rotation: 90
CONDITION[17:37:21.451] screen: rotation: 0
CONDITION[17:38:42.120] screen: rotation: 270 orientation: square

of helemaal niet van richting veranderen:

CONDITION[11:34:41.134] screen: rotation: 0
CONDITION[11:35:04.533] screen: rotation: 90
CONDITION[11:35:06.312] screen: rotation: 0
CONDITION[11:35:07.938] screen: rotation: 90
CONDITION[11:35:09.336] screen: rotation: 0

Aan de andere kant zijn width() en height() altijd correct (het wordt gebruikt door window manager, dus het zou beter moeten zijn). Ik zou zeggen dat het beste idee is om de breedte/hoogte ALTIJD te controleren. Als je even nadenkt, is dit precies wat je wilt – weten of de breedte kleiner is dan de hoogte (portret), het tegenovergestelde (landschap) of dat ze hetzelfde zijn (vierkant).

Dan komt het neer op deze simpele code:

public int getScreenOrientation()
{
    Display getOrient = getWindowManager().getDefaultDisplay();
    int orientation = Configuration.ORIENTATION_UNDEFINED;
    if(getOrient.getWidth()==getOrient.getHeight()){
        orientation = Configuration.ORIENTATION_SQUARE;
    } else{ 
        if(getOrient.getWidth() < getOrient.getHeight()){
            orientation = Configuration.ORIENTATION_PORTRAIT;
        }else { 
             orientation = Configuration.ORIENTATION_LANDSCAPE;
        }
    }
    return orientation;
}

Antwoord 3, autoriteit 8%

Een andere manier om dit probleem op te lossen is door niet te vertrouwen op de juiste retourwaarde van het scherm, maar te vertrouwen op de oplossing van Android-bronnen.

Maak het bestand layouts.xmlaan in de mappen res/values-landen res/values-portmet de volgende inhoud:

res/values-land/layouts.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <bool name="is_landscape">true</bool>
</resources>

res/values-port/layouts.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <bool name="is_landscape">false</bool>
</resources>

In je broncode heb je nu als volgt toegang tot de huidige oriëntatie:

context.getResources().getBoolean(R.bool.is_landscape)

Antwoord 4, autoriteit 7%

Een volledige manier om de huidige richting van de telefoon te specificeren:

public String getRotation(Context context) {
    final int rotation = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getOrientation();
    switch (rotation) {
        case Surface.ROTATION_0:
            return "portrait";
        case Surface.ROTATION_90:
            return "landscape";
        case Surface.ROTATION_180:
            return "reverse portrait";
        default:
            return "reverse landscape";
    }
}

Antwoord 5, autoriteit 4%

Hier is een demo van een codefragment voor het verkrijgen van schermoriëntatie, aanbevolen door hackboden Martijn:

❶ Activeren bij verandering van oriëntatie:

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
        int nCurrentOrientation = _getScreenOrientation();
    _doSomeThingWhenChangeOrientation(nCurrentOrientation);
}

❷ Krijg de huidige oriëntatie zoals hackbodaanbeveelt:

private int _getScreenOrientation(){    
    return getResources().getConfiguration().orientation;
}

❸Er zijn alternatieve oplossingen om de huidige schermoriëntatie te krijgen ❷ volg de Martijn-oplossing:

private int _getScreenOrientation(){
        Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
        return display.getOrientation();
}

★Opmerking:
Ik probeerde beide te implementeren ❷ & ❸, maar op RealDevice (NexusOne SDK 2.3) Oriëntatie geeft het de verkeerde richting terug.

★Dus ik beveel de gebruikte oplossing aan❷ om de schermoriëntatie te krijgen die meer voordeel heeft: duidelijk, eenvoudig en werkt als een charme.

★Controleer zorgvuldig de terugkeer van de oriëntatie om er zeker van te zijn dat deze correct is zoals verwacht (kan beperkt zijn, afhankelijk van de specificatie van het fysieke apparaat)

Ik hoop dat het helpt,

Antwoord 6, autoriteit 2%

int ot = getResources().getConfiguration().orientation;
switch(ot)
        {
        case  Configuration.ORIENTATION_LANDSCAPE:
            Log.d("my orient" ,"ORIENTATION_LANDSCAPE");
        break;
        case Configuration.ORIENTATION_PORTRAIT:
            Log.d("my orient" ,"ORIENTATION_PORTRAIT");
            break;
        case Configuration.ORIENTATION_SQUARE:
            Log.d("my orient" ,"ORIENTATION_SQUARE");
            break;
        case Configuration.ORIENTATION_UNDEFINED:
            Log.d("my orient" ,"ORIENTATION_UNDEFINED");
            break;
            default:
            Log.d("my orient", "default val");
            break;
        }

7

Ik denk dat het gebruik van getrotationv () niet helpt omdat
http://developer.android.com/reference/android /view/Display.html#getRotation%28%29
getRotation() Retourneert de rotatie van het scherm vanuit zijn “natuurlijke” oriëntatie.

dus tenzij je de “natuurlijke” oriëntatie kent, heeft rotatie geen zin.

ik heb een gemakkelijkere manier gevonden, 

 Display display = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
  Point size = new Point();
  display.getSize(size);
  int width = size.x;
  int height = size.y;
  if(width>height)
    // its landscape

vertel me als er een probleem is met deze persoon?

Antwoord 8

Gewoon een simpele code van twee regels

if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
    // do something in landscape
} else {
    //do in potrait
}

Antwoord 9

Oud bericht ik weet het. Wat de oriëntatie ook is of wordt verwisseld enz. Ik heb deze functie ontworpen die wordt gebruikt om het apparaat in de juiste richting te zetten zonder dat ik hoef te weten hoe de portret- en landschapsfuncties op het apparaat zijn georganiseerd.

  private void initActivityScreenOrientPortrait()
    {
        // Avoid screen rotations (use the manifests android:screenOrientation setting)
        // Set this to nosensor or potrait
        // Set window fullscreen
        this.activity.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
        DisplayMetrics metrics = new DisplayMetrics();
        this.activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
         // Test if it is VISUAL in portrait mode by simply checking it's size
        boolean bIsVisualPortrait = ( metrics.heightPixels >= metrics.widthPixels ); 
        if( !bIsVisualPortrait )
        { 
            // Swap the orientation to match the VISUAL portrait mode
            if( this.activity.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT )
             { this.activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); }
            else { this.activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT ); }
        }
        else { this.activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR); }
    }

Werkt als een tierelier!

Antwoord 10

Op deze manier gebruiken, 

   int orientation = getResources().getConfiguration().orientation;
    String Orintaion = "";
    switch (orientation)
    {
        case Configuration.ORIENTATION_UNDEFINED: Orintaion = "Undefined"; break;
        case Configuration.ORIENTATION_LANDSCAPE: Orintaion = "Landscrape"; break;
        case Configuration.ORIENTATION_PORTRAIT:  Orintaion = "Portrait"; break;
        default: Orintaion = "Square";break;
    }

in de String heb je de Oriantion

Antwoord 11

er zijn veel manieren om dit te doen, dit stukje code werkt voor mij 

if (this.getWindow().getWindowManager().getDefaultDisplay()
                .getOrientation() == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
             // portrait mode
} else if (this.getWindow().getWindowManager().getDefaultDisplay()
                .getOrientation() == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
                      // landscape
        }

Antwoord 12

Eenvoudig en gemakkelijk 🙂

  1. Maak 2 xml-lay-outs (d.w.z. Staand en Liggend)

  2. Schrijf in het java-bestand:

    private int intOrientation;

    bij onCreatemethode en voor setContentViewschrijf:

    intOrientation = getResources().getConfiguration().orientation;
if (intOrientation == Configuration.ORIENTATION_PORTRAIT)
    setContentView(R.layout.activity_main);
else
    setContentView(R.layout.layout_land);   // I tested it and it works fine.

Antwoord 13

Ik denk dat deze oplossing makkelijk is

if (context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT){
  user_todat_latout = true;
} else {
  user_todat_latout = false;
}

Antwoord 14

Het is ook vermeldenswaard dat er tegenwoordig minder goede redenen zijn om te controleren op expliciete oriëntatie met getResources().getConfiguration().orientationals je dit doet om lay-outredenen, zoals Multi-Window-ondersteuninggeïntroduceerd in Android 7 / API 24+ kan knoeien met uw lay-outs nogal wat in beide richtingen. Overweeg het gebruik van <ConstraintLayout>en alternatief lay-outs afhankelijk van beschikbare breedte of hoogte, samen met andere trucs om te bepalen welke lay-out wordt gebruikt, bijv de aanwezigheid of niet van bepaalde fragmenten die aan uw activiteit zijn gekoppeld.

Antwoord 15

U kunt dit gebruiken (op basis van hier) :

public static boolean isPortrait(Activity activity) {
    final int currentOrientation = getCurrentOrientation(activity);
    return currentOrientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT || currentOrientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
}
public static int getCurrentOrientation(Activity activity) {
    //code based on https://www.captechconsulting.com/blog/eric-miles/programmatically-locking-android-screen-orientation
    final Display display = activity.getWindowManager().getDefaultDisplay();
    final int rotation = display.getRotation();
    final Point size = new Point();
    display.getSize(size);
    int result;
    if (rotation == Surface.ROTATION_0
            || rotation == Surface.ROTATION_180) {
        // if rotation is 0 or 180 and width is greater than height, we have
        // a tablet
        if (size.x > size.y) {
            if (rotation == Surface.ROTATION_0) {
                result = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
            }
        } else {
            // we have a phone
            if (rotation == Surface.ROTATION_0) {
                result = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
            }
        }
    } else {
        // if rotation is 90 or 270 and width is greater than height, we
        // have a phone
        if (size.x > size.y) {
            if (rotation == Surface.ROTATION_90) {
                result = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
            }
        } else {
            // we have a tablet
            if (rotation == Surface.ROTATION_90) {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
            }
        }
    }
    return result;
}
Previous articleDe juiste manier om IXmlSerializable te implementeren?
Next articleEen @Bean-geannoteerde methode aanroepen in Spring Java-configuratie

Other episodes

tomcat-dbcp vs commons-dbcp

java Code Expert - 0
Het lijkt erop dat er veel verwarring bestaat tussen deze twee bibliotheken voor het poolen van verbindingen. Wat ik wil weten is welke beter...
Read more

Hoe automatisch N “verschillende” kleuren genereren?

java Code Expert - 0
Ik heb de twee onderstaande methoden geschreven om automatisch N verschillende kleuren te selecteren. Het werkt door een stuksgewijs lineaire functie op de RGB-kubus...
Read more

Wat is het doel van @SmallTest-, @MediumTest- en @LargeTest-annotaties in Android?

java Code Expert - 0
Ik ben nieuw bij Android en ik heb voorbeeldcode gezien met deze annotaties. Bijvoorbeeld: @SmallTest public void testStuff() { TouchUtils.tapView(this, anEditTextView); ...
Read more

Hoe de hoofdklasse van de Spring-boot-toepassing te testen

java Code Expert - 0
Ik heb een spring-bootapplicatie waar mijn @SpringBootApplicationstartersklasse eruitziet als een standaard. Dus ik heb veel tests gemaakt voor al mijn functionaliteiten en de samenvatting...
Read more

Firebase Cloud Firestore: ongeldige verzamelingsreferentie. Collectiereferenties moeten een oneven aantal segmenten hebben

java Code Expert - 0
Ik heb de volgende code en krijg een foutmelding: Invalid collection reference. Collection references must have an odd number of segments En de code : private...
Read more

Java 9 + maven + junit: heeft testcode zijn eigen module-info.java nodig en waar moet deze worden geplaatst?

java Code Expert - 0
Stel dat ik een Java-project heb met Maven 3 en junit. Er zijn mappen src/main/javaen src/test/javadie respectievelijk hoofdbronnen en testbronnen bevatten (alles is standaard). Nu...
Read more

Verschil tussen veranderlijke objecten en onveranderlijke objecten

java Code Expert - 0
Iedereen, geef het verschil tussen veranderlijke objecten en onveranderlijke objecten met een voorbeeld. Antwoord 1, autoriteit 100% Veranderlijke objecten hebben velden die kunnen worden gewijzigd, onveranderlijke...
Read more

© Copyright - Code Expert 2021