Как рассчитать экран Android? - PullRequest
       41

Как рассчитать экран Android?

0 голосов
/ 08 февраля 2012

Вот изображение получающегося экрана.

Android Screen

То, что я делаю, - это создание вида поверхности в FastRenderView.java, а затем публикация на нем из растрового изображения, созданного вLoadingScreen.java.Конечно, экран загрузки - это один из многих экранов, которые будут использоваться.

Моя проблема заключается в том, что я не рассчитываю правильный размер экрана для экрана загрузки.Вот файлы, которые вам понадобятся, чтобы помочь мне.

Другими словами, я получаю размер экрана из игры для Android.Это отправляется на экран загрузки, а затем составляет растровое изображение всей игры.Это растровое изображение черного цвета с красной полосой загрузки.Затем я отправляю растровое изображение с экрана загрузки в режим быстрого рендеринга, который отправляет его на экран.Однако растровое изображение намного меньше, чем размер экрана.Как это исправить?

FastRenderView.java

package framework.impl;

import android.graphics.Canvas;
import android.graphics.Rect;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import framework.Game;

public class FastRenderView extends SurfaceView implements Runnable {

    Game game;
    Thread renderThread = null;
    SurfaceHolder holder;
    volatile boolean running = false;

    public FastRenderView(AndroidGame game) {
        super(game);
        this.game = game;
        this.holder = getHolder();
    }

    @Override
    public void run() {
        Rect dstRect = new Rect();
        long startTime = System.nanoTime();
        while(running) {
            if(!holder.getSurface().isValid()) {
                continue;
            }

            float deltaTime = (System.nanoTime() - startTime) / 1000000000.0f;
            startTime = System.nanoTime();

            game.getScreen().update(deltaTime);
            game.getScreen().present(deltaTime);

            // Method 1 //
            //this.game.getScreen().setCanvas(this.holder.lockCanvas());
            //this.holder.unlockCanvasAndPost(this.game.getScreen().getCurrentCanvas());

            // Method 2 //
            Canvas canvas = this.holder.lockCanvas();
            canvas.drawARGB(255, 150, 150, 10);
            canvas.drawBitmap(this.game.getScreen().getCurrentScreen(), 0, 0, null);
            holder.unlockCanvasAndPost(canvas);

            try {
                Thread.sleep(100);
            } catch(Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void resume() {
        running = true;
        renderThread = new Thread(this);
        renderThread.start();
    }

    public void pause() {
        running = false;
        while(true) {
            try {
                renderThread.join();
                break;
            } catch(Exception e) {
                // retry
            }
        }
    }
}

LoadingScreen.java

import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import framework.Game;
import framework.Screen;

public class LoadingScreen extends Screen {

    private int loadingPercent;
    Canvas currentCanvas;
    Bitmap currentScreen;
    Paint paint;

    public LoadingScreen(Game game) {
        super(game);
        this.currentScreen = Bitmap.createBitmap(this.game.getFrameWidth(), this.game.getFrameHeight(), Config.RGB_565);
        this.game.getFastRenderView().run();
    }

    @Override
    public void update(float deltaTime) {
        this.loadingPercent = 0;
        Assets assets = game.getAssetsClass();
        this.loadingPercent = 33;
        assets.plane = assets.fetchImage("image.png");
        this.loadingPercent = 66;
        assets.plane_full = assets.fetchImage("image2.png");
        this.loadingPercent = 99;
        //this.game.setScreen(new MainMenuScreen(this.game));
    }

    @Override
    public void present(float deltaTime) {
        Bitmap picture = Bitmap.createBitmap(this.game.getFrameWidth(), this.game.getFrameHeight(), Config.RGB_565);
        Canvas canvas = new Canvas(picture);
        paint = new Paint();
        paint.setColor(Color.RED);
        Rect darkRed = new Rect(10, 10, 4 * this.loadingPercent, 40);
        canvas.drawRect(darkRed, paint);
        this.currentCanvas = canvas;
        this.currentScreen = picture;
    }

    @Override
    public Bitmap getCurrentScreen() {
        return this.currentScreen;
    }

    @Override
    public void setCanvas(Canvas canvas) {
        this.currentCanvas = canvas;
    }

    @Override
    public Canvas getCurrentCanvas() {
        return this.currentCanvas;
    }

    @Override
    public void pause() {

    }

    @Override
    public void resume() {

    }

    @Override
    public void dispose() {

    }
}

AndroidGame.java

package framework.impl;

import android.app.Activity;
import android.content.Context;
import android.content.res.Configuration;
import android.os.Bundle;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.util.Log;
import android.view.Window;
import android.view.WindowManager;
import framework.Audio;
import framework.Game;
import framework.Input;
import framework.Screen;
import tiny.bomber.Assets;

public abstract class AndroidGame extends Activity implements Game {

    FastRenderView renderView;
    int frameWidth;
    int frameHeight;
    Input input;
    Audio audio;
    Screen screen;
    Assets assets;
    WakeLock wakeLock;

    @Override
    public void onCreate(Bundle savedInstaneState) {
        super.onCreate(savedInstaneState);

        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);

        boolean isLandscape = getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE;
        frameWidth = isLandscape ? 480 : 320;
        frameHeight = isLandscape ? 320 : 480;

        float scaleX = (float) frameWidth / getWindowManager().getDefaultDisplay().getWidth();
        float scaleY = (float) frameHeight / getWindowManager().getDefaultDisplay().getHeight();

        // Setup Globabl Variables //
        renderView = new FastRenderView(this);
        this.assets = new Assets(this.getAssets(), this.getResources());
        //input = new Input();
        //audio = new Audio();
        setContentView(renderView);

        PowerManager powerManager = (PowerManager) getSystemService(Context.POWER_SERVICE);
        wakeLock = powerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK, "TinyBmoberGame");

        this.screen = this.getStartScreen();
    }

    @Override
    public void onResume() {
        super.onResume();
        wakeLock.acquire();
        screen.resume();
        renderView.resume();
    }

    @Override
    public void onPause() {
        super.onPause();
        wakeLock.release();
        renderView.pause();
        screen.pause();
    }

    @Override
    public void setScreen(Screen screen) {
        this.screen = screen;
    }

    @Override
    public Input getInput() {
        return this.input;
    }

    @Override
    public Audio getAudio() {
        return this.audio;
    }

    @Override
    public Screen getScreen() {
        return this.screen;
    }

    @Override
    public Assets getAssetsClass() {
        return this.assets;
    }

    @Override
    public FastRenderView getFastRenderView() {
        return this.renderView;
    }

    @Override
    public int getFrameWidth() {
        return this.frameWidth;
    }

    @Override
    public int getFrameHeight() {
        return this.frameHeight;
    }

    public WakeLock getWakeLock() {
        return this.wakeLock;
    }
}

Ответы [ 2 ]

1 голос
/ 08 февраля 2012

Вы можете использовать

// display width
int width = getResources().getDisplayMetrics().widthPixels

// display height
int height = getResources().getDisplayMetrics().heightPixels

или вы можете создать экземпляр объекта DisplayMetrics:

DisplayMetrics dm = new DisplayMetrics();
int width = dm.widthPixels;
int height = dm.heightPixels;

Кстати: на некоторых устройствах вы не можете установить «настоящий» полноэкранный режим из-за аппаратных ограничений

0 голосов
/ 09 февраля 2012

Андреас Bf ответил на часть вопроса, поэтому +1 за это.

Я использовал этот метод для загрузки экрана для масштабирования изображения.

private Bitmap scaleImage(Bitmap picture) {
        Matrix matrix = new Matrix();
        matrix.postScale(this.game.getScaleX(), this.game.getScaleY());
        Bitmap resizedPicture = Bitmap.createBitmap(picture, 0, 0, picture.getWidth(), picture.getHeight(), matrix, true);
        return resizedPicture;
    }

Мне пришлось добавить следующее в AndroidGame, чтобы получить ScaleX и ScaleY.

@Override
public float getScaleX() {
    return this.scaleX;
}

@Override
public float getScaleY() {
    return this.scaleY;
}

Затем в Android Game я изменил следующее, чтобы оно корректно масштабировалось.

boolean isLandscape = getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE;
        frameWidth = isLandscape ? 480 : 320; // Based on my standard
        frameHeight = isLandscape ? 320 : 480;

        scaleX = (float) frameWidth / getWindowManager().getDefaultDisplay().getWidth();
        scaleY = (float) frameHeight / getWindowManager().getDefaultDisplay().getHeight();
        if(scaleX < 1 || scaleY < 1) {
            scaleX = (float) getWindowManager().getDefaultDisplay().getWidth() / frameWidth;
            scaleY = (float) getWindowManager().getDefaultDisplay().getHeight() / frameHeight;
        }

Наконец, на экране загрузки я изменил представленный метод следующим образом.

@Override
    public void present(float deltaTime) {
        Bitmap picture = Bitmap.createBitmap(this.game.getFrameWidth(), this.game.getFrameHeight(), Config.RGB_565);
        Canvas canvas = new Canvas(picture);
        Log.i("Canvas", "Canvas Size: " + canvas.getWidth() + ", " + canvas.getHeight());
        paint = new Paint();
        paint.setColor(Color.RED);
        Rect darkRed = new Rect((int) (480 * 0.02), (320 / 2), (int) (((480 - (480 * 0.02)) / 100) * this.loadingPercent), 50);
        canvas.drawRect(darkRed, paint);
        this.currentCanvas = canvas;
        picture = this.scaleImage(picture);
        this.currentScreen = picture;
    }

Теперь все работает правильно !!! :)

...