Discussion :

[ptitvincent]

Bonjour !

Je suis en train de développer un jeu pour mobile android, et je suis en train de demander à mes testeurs de.. tester.

L'un d'entre eux possède un Samsung Galaxy note 2, j'ai été voir les stats et j'en ai déduis que c'était un large-hdpi, mais tout le monde sur le net semble dire que c'est en réalité un large-xhdpi.

A coté de cela, j'ai un dossier drawable-xhdpi pour les nouvelles tablette en 2560. Mais du coup les images sont bien trop grosses et font crasher le dit device

j'ai donc ajouté des dossiers drawable ainsi :
drawable-xhdpi
drawable-large-hdpi
drawable-large-xhdpi

Mais voila, c'est la que nait mon incompréhension, son galaxy note 2 va chercher les images dans le dossier drawable-xhdpi

Je me tire les cheveux pour trouver une solution mais je n'y comprend plus rien...

[nicroman]

Ben non, tous les Galaxy Note sont "xhdpi" (avec un écran "normal").

j'ai été voir les stats et j'en ai déduis

Comment ?
La valeur "hdpi"/"xhdpi" est choisie par le constructeur...
(un petit lien vers mon tuto là dessus )


Galaxy Note:
pixels: 800x1280
densité "constructeur": xhdpi (320dpi)
donc taille en "dp": 400x640
donc écran "normal" (il faudrait 480dp x 640dp pour avoir un écran "large")

Galaxy Note 2:
pixels: 720 x 1280 (si si c'est moins que le Note I)
densité "constructeur": xhdpi (320dpi)
donc taille en "dp": 360x640
donc écran "normal"

Galaxy Note 3:
pixels: 1080 x 1920
densité "constructeur": xxhdpi (480dpi)
donc taille en "dp": 360x640
donc écran "normal"

De toute manière cela n'a aucun intérêt pour une image... Le système se charge pour coller l'image qui va bien (du bon dossier drawable) pour la taille voulue (indiquée en "dp" dans l'interface).

Une image donnée a une taille en "dp"... disons 120dp...

C'est la même pour tous les écrans quels qu'ils soient.

Pour éviter qu'elle n'apparaisse pixelisée sur certains écrans (ou qu'elle demande trop de mémoire sur d'autres), on fournit une version ldpi, mdpi, hdpi, xhdpi et xxhdpi de l'image

ldpi = dp * 3 /4 (90 pixels pour notre image)
mdpi = dp (120 pixels pour notre image)
hdpi = dp * 3 / 2 (180 pixels pour notre image)
xhdpi = dp * 2 (240 pixels pour notre image)
xxhdpi = dp * 3 (360 pixels pour notre image)
xxxhdpi = dp * 4 (480 pixels pour notre image) <= Android 4.4 only.

[ptitvincent]

donc taille en "dp": 400x640
donc écran "normal" (il faudrait 480dp x 640dp pour avoir un écran "large")

Oui je veux bien, mais pourquoi dans la doc de google (http://developer.android.com/guide/p...s_support.html) ils expliquent que leur param large xlarge normal etc est calculé d'après la diagonale, et plus bas ils montrent un schema représentant la mesure en pouce ?

Screen size
Actual physical size, measured as the screen's diagonal.
For simplicity, Android groups all actual screen sizes into four generalized sizes: small, normal, large, and extra large.

Si j'ai simplement des dossier avec comme selecteur la densité comme tu me le propose, je vais avoir un soucis car la nouvelle tablette de google fait 2560 x 1600 et le galaxy note 2 1280 x 720 :o si il essaye de charger un background de 2560px il se tape un outofmemory (c'est exactement ce qu'il se passe) c'est pour cette raison que j'ai voulu faire des dossiers plus spécifique

[nicroman]

As you design your UI for different screen sizes, you'll discover that each design requires a minimum amount of space. So, each generalized screen size above has an associated minimum resolution that's defined by the system. These minimum sizes are in "dp" units—the same units you should use when defining your layouts—which allows the system to avoid worrying about changes in screen density.

xlarge screens are at least 960dp x 720dp
large screens are at least 640dp x 480dp
normal screens are at least 470dp x 320dp
small screens are at least 426dp x 320dp

Non mais pour un background tu ne vas pas charger une image de 2560x1600 même sur un écran de 2560x1600 de toute manière... 16Mo rien que pour un background c'est un peu lourd !
Puisqu'on parle de ressource selector, on est en Java, donc l'appli est limitée à 16Mo de RAM (voir 32Mo au mieux) ce n'est pas vraiment tenable.
Une image de 1280x800 suffirait.

En fait la taille de l'écran décide de la taille (en dp) de l'image à mettre en background.... (donc c'est coté layout que ça se passe).
Puis le système choisi la bonne taille en pixel pour cette taille en dps (en fonction de la résolution).

Une tablette de 2560x1600 xxhdpi tombe dans les écrans "large"... un note 3 xxhdpi tombe dans les écrans "normal"...

[ptitvincent]

Une image de 1280x800 suffirait.

Oui mais comment faire du vrai hd dans ce cas :o
pourquoi avoir fait une résolution si forte si on ne peut la remplir qu'avec du matos downscale ? c'est triste lol

En fait la taille de l'écran décide de la taille (en dp) de l'image à mettre en background.... (donc c'est coté layout que ça se passe).
Puis le système choisi la bonne taille en pixel pour cette taille en dps (en fonction de la résolution).

Ok, j'ai suivis ton conseil et ca semble fonctionner, mais sur la tablette le 1280 est étiré, ça ne se voit pas trop.

En tout cas, merci beaucoup pour tes réponses et ton tuto

[nicroman]

Haaa c'est la plaie les background image quand on veut être portables.... A éviter si possible...

Surtout que entre 4:3, 16:9, 16:10, 3:2 ... les formes sont variées... comment fais tu quand l'écran ne correspond pas aux proportions ?


Mais tu peux utiliser de grosses densités quand même... (même si un background par définition n'a pas besoin de haute résolution).

Par exemple, tu choisis une image en fonction de la taille de l'écran:

small/normal => "background"
large => "backgroundlarge"
xlarge => "backgroundhuge"

"background" est une image de 360dp de haut.
"backgroundlarge" est une image de 540dp de haut.
"backgroundhuge" est une image de 720dp de haut.

Chaque image a ses résolutions:
background en ldpi: 270 pixels
background en mdpi: 360 pixels
background en hdpi: 540 pixels
background en xhdpi: 720 pixels => nickel pour le S3/Note2
background en xxhdpi: 1080 pixels => nickel pour le S4/Note3

backgroundlarge en ldpi: 405 pixels
backgroundlarge en mdpi: 540 pixels
backgroundlarge en hdpi: 810 pixels
backgroundlarge en xhdpi: 1080 pixels
backgroundlarge en xxhdpi: 1620 pixels

backgroundhuge en ldpi: 540 pixels
backgroundhuge en mdpi: 720 pixels
backgroundhuge en hdpi: 1080 pixels
backgroundhuge en xhdpi: 1440 pixels
backgroundhuge en xxhdpi: 2160 pixels.


Avec le truchement des alias de ressources... on s'en sort s'en "trop" de bitmaps... (si on "oublie" ldpi par exemple on a juste les versions: 360,540,720,810,1080,1440,1620,2160)

Remarque.. du coup tu peux aussi le faire avec -{screensize}-{dpi} pour la bitmap... sachant que le note 2 tape dans "-normal-xhdpi", le note 3 dans "-normal-xxhdpi" et la Nexus10 dans le "xlarge-xxhdpi"

[ptitvincent]

Oui ok, et je choisis du coup le drawable en fonction du layout ? ou je fais un dossier drawable par bg ?

Sinon il y a une méthode, je dis ça pour les non-graphistes et les graphistes qui ne connaissent pas, c'est de faire un fond détaché, par exemple en utilisant un blur, des brush moins "net" etc. comme ça, quand on upscale l'image, le coter flou assumé empêche complètement à un humain normalement constitué de voir que ça n'est pas du hd :p

Encore merci Nicroman de prendre le temps de m'éduquer sur la question parce que ça n'est pas une mince affaire j'en suis conscient XD