Android Bild-Skalierung

Mache ich eine app für 1.6 und ich habe da ein problem mit android, Bild-Skalierung, ich habe ein Bild das ist 480x295.

Auf ein medium dieser Bildschirm wird richtig angezeigt, aber auf einem großen Bildschirm (480x800 oder 480x854) es füllt nicht den Bildschirm, android macht das Bild 1,5 x größer, das ist nur 720x442.

Als 800 ist eigentlich 1,67 und 854 1,78, ich kann natürlich nur große Bilder für den drawable-hdpi Ordner, aber das Bild ist schon 1,5 mb, die größer ist, als die Leute scheinen es zu mögen, und ich kann nicht mit app2sd, wie ich will, zu unterstützen 1.6.

Irgendwelche Vorschläge?

Mir nur drei Optionen:
1) sind die größere Bilder (aber das schränkt die Verkäufe wahrscheinlich, und erhöht natürlich die apk-Größe)

2) Machen Sie 2 Versionen, scheint eine gute Lösung, nur schwerer zu implementieren.

3) Ändern bis 1,5, und behandeln alle meine Skalierung selbst.

BEARBEITEN:
Mehr details:
Ich zeichne mit canvas und surfaceview
Bild laden-code:

backgroundBMP = BitmapFactory.decodeResource(getResources(), R.drawable.background, null);

Und die Zeichnung code:

canvas.drawBitmap(backgroundBMP, 0, 0, null);

Die scaleType hast du verwendet?
Sorry, werde ich mehr details hinzufügen

InformationsquelleAutor Ray Britton | 2011-02-26

android image-scaling

3

Wenn du willst skalieren Sie Ihre Bitmap Sie können tun, dass durch die Verwendung canvas.scale(scaleX, scaleY); vor canvas.drawBitmap(). Sie könnten berechnen Sie das Seitenverhältnis und verwenden Sie Ihre Waage Wert.

Eine wichtige Sache ist, dass Sie können verwenden Sie die "Move to SD-Karte" - Funktion, mit <uses-sdk android:minSdkVersion="3" /> und immer noch unterstützen niedrigeren Android-Versionen angegeben, die von minSdkVersion.
- Danke Viktor, ich hatte angenommen, es würde zu begrenzen die app. Für alle anderen, die entscheidet, dies zu tun, müssen Sie auf set default.Eigenschaften-android-8 und android:targetSdkVersion auf 8, und add android:installLocation="auto" zu manifestieren Abschnitt der manifest-Datei.
InformationsquelleAutor Wroclai
5

Wenn Sie möchten, dass die Skalierung sich selbst, legen Sie eine einzelne Kopie in:
```
res/drawable-nodpi
```
Stellen Sie sicher, dass die Ressource in keinem anderen Ordner.

Laden Sie das bitmap so:
```
Bitmap bitmap = BitmapFactory.decodeResource(

                    context.getResources(),

                    R.drawable.my_image
                );
```
Größe wie dieser:
```
bitmap = Bitmap.createScaledBitmap(bitmap, width, height, true);
```
Dann ziehen Sie es auf Ihre Leinwand:
```
canvas.drawBitmap(bitmap, 0, 0, null);
```
Dass das Mindeste, was Sie wissen müssen, um den job zu erledigen.

Zusätzliche Hinweise

Normalerweise, Android wählt euer Bild aus einem von der res/drawable Ordner basierend auf der aktuellen Bildschirmauflösung.

Meisten Bild-Formate, die nicht Dichte-Informationen, also Android macht Annahmen über die Dichte des bitmap basierend auf der Ordner-es war geladen.

Das bedeutet, dass Sie es tun können, es auf eigene Skalierung entsprechend der Dichte der geladenen bitmap mit der Leinwand Dichte.

Android überprüft und entspricht den dichten einmal beim laden der bitmap und wieder, wenn Sie beim zeichnen der bitmap.

Sind, wenn Sie tun, Ihre eigene Skalierung, die Sie in der Regel wollen, um zu verhindern, dass das Betriebssystem von sich einzumischen. Es gibt mehrere Möglichkeiten, wie Sie es tun können:

1. Verwenden Sie res/drawable-nodpi

Dies ist die Strategie, die ich beschrieben in den quick-Beispiel oben. Wenn Sie wollen, packen Sie Ihr Bild als eine Ressource, und dennoch Steuern Sie die Skalierung sich, es hier, und nur hier:
```
res/drawable-nodpi
```
Wenn Sie unterstützen müssen, Cupcake, legen Sie eine Kopie in jedem dieser Ordner statt:
```
res/drawable-nodpi-v4    
res/drawable
```
Den decoder automatisch mit Optionen, um zu verhindern, Skalierung. Android legt dann das Bild die Dichte entsprechend der Bildschirm, damit es nicht zu skalieren, wenn Sie ziehen Sie es entweder. Der compiler gelten verlustfreie Komprimierung, um Bilder nach res/drawable-xxx Ordner.

2. Verwenden Sie res/raw

Lassen Sie das Bild unberührt von dem compiler, wenn man es in:
```
res/raw
```
Aber dann müssen Sie vorsichtig sein, um zu verhindern, dass die Skalierung zur Laufzeit:
```
BitmapFactory.Options options = new BitmapFactory.Options();    

options.inScaled = false; //Prevents scaling at decode time.

Bitmap bitmap = BitmapFactory.decodeResource(

                    context.getResources(),

                    R.raw.my_image,

                    options
                );

bitmap.setDensity(Bitmap.DENSITY_NONE); //Prevents scaling at draw time.
```
3. Verwenden Sie den Ordner "assets"

Wenn Sie Ihre Bilder in der Vermögenswerte Ordner anstatt in res, die Sie verwenden können, eine echte Ordnerstruktur zu organisieren. Laden Sie ein bitmap-Element wie diesem:
```
Bitmap bitmap = BitmapFactory.decodeStream(

                    context.getAssets().open(

                        "myfolder/my_image.png",

                        AssetManager.ACCESS_BUFFER
                    )
                );
```
Der compiler nicht berührt, es lädt ohne Skalierung, und es ist die Dichte festgelegt, dass der Bildschirm, so dass es nicht skaliert, wenn Sie Sie ziehen entweder.

(LEISTUNG HINWEIS: Bevor Android wird ein Bild geladen, es hat um die Datei zu suchen. Eine Ressource ist schneller zu finden als ein Vermögenswert, so kann es einige performance-Strafe, wenn Sie das Paket Ihrer Bilder als assets).

InformationsquelleAutor SharkAlley
2

Wie vorgeschlagen durch Viktor, können Sie auf einer Leinwand.scale(). Sie konnte auch zeichnen Sie die bitmap mit einem BitmapDrawable (als Sicht-hintergrund) und die Skala wird für Sie erledigt werden.
- Das problem ist, ich mindestens 50 Bilder, die brauchen Skalierung, es ist für ein Spiel, und android ist nicht die Skalierung richtig.
InformationsquelleAutor Romain Guy

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.