In der letzten Lektion haben wir ein Interface für unser Android Spiel erstellt. In dieser Lektion werden wir nun zum zweiten Schritt übergehen: Die Implementierung.
Wenn wir nun das Skelett der letzten Lektion nehmen, werden wir nun die Brücke zwischen Android Code und unserem Spiel schließen.
Was ist Implementierung?
Wir werden wörtlich genommen die Interfaces implementieren, mit dem eingebauten Word implements. Wir werden also einige Android Klassen importieren und einige Android Methoden aufrufen.
Dies ist eine der wichtigsten Lektionen bisher, also nehmt euch Zeit.
Dieser Code steht unter der Apache 2.0 Lizenz: http://www.apache.org/licenses/LICENSE-2.0.txt
Erstellen der Implementierung
Erstellen des Pakets
In dem src Ordner erstellen wir ein neues Paket, wie folgt.
Alle Implementierungen werden wir nun hier abspeichern.
Bedenkt das dieser Code für com.basteldroid.framework.implementation geschrieben wurde. Wenn ihr euren eigenen Code verwendet, müsst ihr dies anpassen.
Die AndroidGame Klasse
Unter dem neuen Paket erstellt ihr eine neue Klasse mit dem Namen AndroidGame. Diese Klasse ist das Rückgrat von eurem Spiel.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 |
package com.basteldroid.framework.implementation; import android.app.Activity; import android.content.Context; import android.content.res.Configuration; import android.graphics.Bitmap; import android.graphics.Bitmap.Config; import android.os.Bundle; import android.os.PowerManager; import android.os.PowerManager.WakeLock; import android.view.Window; import android.view.WindowManager; import com.basteldroid.framework.Audio; import com.basteldroid.framework.FileIO; import com.basteldroid.framework.Game; import com.basteldroid.framework.Graphics; import com.basteldroid.framework.Input; import com.basteldroid.framework.Screen; public abstract class AndroidGame extends Activity implements Game { AndroidFastRenderView renderView; Graphics graphics; Audio audio; Input input; FileIO fileIO; Screen screen; WakeLock wakeLock; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE); getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); boolean isPortrait = getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT; int frameBufferWidth = isPortrait ? 800: 1280; int frameBufferHeight = isPortrait ? 1280: 800; Bitmap frameBuffer = Bitmap.createBitmap(frameBufferWidth, frameBufferHeight, Config.RGB_565); float scaleX = (float) frameBufferWidth / getWindowManager().getDefaultDisplay().getWidth(); float scaleY = (float) frameBufferHeight / getWindowManager().getDefaultDisplay().getHeight(); renderView = new AndroidFastRenderView(this, frameBuffer); graphics = new AndroidGraphics(getAssets(), frameBuffer); fileIO = new AndroidFileIO(this); audio = new AndroidAudio(this); input = new AndroidInput(this, renderView, scaleX, scaleY); screen = getInitScreen(); setContentView(renderView); PowerManager powerManager = (PowerManager) getSystemService(Context.POWER_SERVICE); wakeLock = powerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK, "MyGame"); } @Override public void onResume() { super.onResume(); wakeLock.acquire(); screen.resume(); renderView.resume(); } @Override public void onPause() { super.onPause(); wakeLock.release(); renderView.pause(); screen.pause(); if (isFinishing()) screen.dispose(); } @Override public Input getInput() { return input; } @Override public FileIO getFileIO() { return fileIO; } @Override public Graphics getGraphics() { return graphics; } @Override public Audio getAudio() { return audio; } @Override public void setScreen(Screen screen) { if (screen == null) throw new IllegalArgumentException("Screen must not be null"); this.screen.pause(); this.screen.dispose(); screen.resume(); screen.update(0); this.screen = screen; } public Screen getCurrentScreen() { return screen; } } |
Wenn ihr diese Klasse erstellt, werden viele Fehler auftreten. Bitte Ignoriert diese, wir werden alle nach und nach beheben.
Bevor wir die weiteren Implementierungen programmieren, schauen wir uns diesen Code genauer an.
1. Android Libraries – Android Büchereien – die ersten 10 importier Statements fangen alle mit Android an. Das bedeutet, wir arbeiten hier mit Android Klassen, die in der SDK Platform gespeichert sind.
Ein paar dieser Klassen werden wir hier näher betrachten, die restlichen sind hier beschrieben: http://developer.android.com/reference
Ein Activity – Eine Aktivität ist normalerweise ein interaktives Window/Fenster. Innerhalb einer normalen App sehen wir dies häufig. So sehen wir meistens eine Login Seite, eine separate Einstellungsseite und so weiter.
Activities sind für Views/Ansichten erstellt wurden, so wie Bilder oder Text.
Bundle lässt uns Informationen zwischen einzelnen Aktivitäten austauschen. Wenn wir uns also auf der Login Seite einloggen, überprüft die nächste Aktivität ob diese Daten auch wirklich stimmen.
PowerManager.WackeLock hilft uns, dass Smartphone an zu lassen, so lange das Spiel läuft.
2. In dem zweiten Teil importieren wir unsere Interfaces. Dabei erstellen wir Objekte bei den Variablen. Des Weiteren erweitern wir AndroidGame extends Activity implements Game, damit implementieren wir unser Spiel Interface.
3. In unserem Code erstellen wir als erstes eine onCreate()-Methode. Um das genau zu verstehen, müssen wir als erstes das Android Activity Lifecycle – Android Aktivitäten Lebenszyklus – verstehen.
Android ist eine Mobile Plattform, daher kann der momentane Stand unserer Aktivität pausiert oder fortgesetzt werden, erstellt gestoppt, zerstört oder neu gestartet werden. Wenn wir zum Beispiel ein Anruf erhalten, wir die App die wir in diesem Moment ausführen gestoppt. Genau das selbe passiert, wenn wir den Home Button drücken. Wenn wir die App danach wieder öffnen, wird diese fortgesetzt.
Deshalb benötigt unsere App diese Methoden um diese Übergangsphasen ohne Fehler, Abstürze oder Ähnliches zu überstehen.
Die onCreate()-Methode wird aufgerufen, wenn die App das erste mal startet. Da dort @Override steht, können wir erkennen, dass diese Methode zu einer Super Klasse gehört.
Normalerweise kann man in der onCreate()-Methode das Layout der Aktivität erkennen. In jedem Punkt des Activity Lifecycle rufen wir als erstes die Super Methode auf, das ist die Standart onCreat()-Methode. Normalerweise haben Apps eine Leiste Oben, wo der Name der App angezeigt wird. Wir schreiben als erstes, dass unsere App im Full Screen Modus ausgeführt werden soll.
4. Als nächstes überprüfen wir die momentane Display Ausrichtung des Gerätes und setzen die Höhe und Breite unseres Spiels. Als nächsten nutzen wir folgenden Code: int frameBufferWidth = isPortrait ? 800: 1280;
Das ? ist eine Art Auswertung einer boolean. Wenn der boolean isPortait wahr ist, dann nimmt der frameBufferWidth 800 an. Ist er Falsch wird der Wert 1280 angenommen.
Hier können wir die Auflösung unseres Spiels einstellen. Wir werden 800×480 verwenden um auch schwächere Geräte zu unterstützen. Wir könnten hier auch mit IF Statements arbeiten um auf höher auflösenden Bildschirmen mit besserer Grafik zu arbeiten. In dieser Anleitung werden wir einen eine Größe passt allen Weg einschlagen.
5. Die App passt sich also automatisch an kleine und große Bildschirme an, was wir im nächsten Schritt programmieren.
6. Danach definieren wir jedes Interface, dazu erstellen wir neue Instanzen der Implementierungsklassen, welche wir noch erstellen.
7. Wir verwenden den PowerManager um die WakeLocks Variablen zu definieren. Wir erwerben und geben diese frei in der onResume und onPause Methode. Warum? Schaut euch nochmals genau den Android Activity Lifecycle an.
8. Der Rest der AndroidGame Klasse definiert viele zusätzliche Methoden um zu den verschiedensten Interfaces zurückzukehren. Des Weiteren definieren wir die setScreen und die getCurrentScreen Methode des Spiele Interfaces.
Ich hoffe ihr habt nun den Aufbau und das verhalten einer Android Activity verstanden? Versucht dies erst komplett zu verstehen wie AndroidGame Implementation und das Game Interface miteinander zusammenarbeiten. Habe ich eventuell etwas nicht vollkommen klar Erläutert oder eurer Meinung nach falsch, dann bitte berichtigt mich. Dies ist ein wichtiger Schritt hin zur Android Entwicklung.
Die AndroidGraphics Klasse
Hier werden wir einige abstrakte Methoden implementieren, welche wir in dem Graphics Interface erstellt haben.
Denkt daran den Paket Namen zu ändern, falls ihr euren eigenen benutzt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 |
package com.basteldroid.framework.implementation; import java.io.IOException; import java.io.InputStream; import android.content.res.AssetManager; import android.graphics.Bitmap; import android.graphics.Bitmap.Config; import android.graphics.BitmapFactory; import android.graphics.BitmapFactory.Options; import android.graphics.Canvas; import android.graphics.Paint; import android.graphics.Paint.Style; import android.graphics.Rect; import com.basteldroid.framework.Graphics; import com.basteldroid.framework.Image; public class AndroidGraphics implements Graphics { AssetManager assets; Bitmap frameBuffer; Canvas canvas; Paint paint; Rect srcRect = new Rect(); Rect dstRect = new Rect(); public AndroidGraphics(AssetManager assets, Bitmap frameBuffer) { this.assets = assets; this.frameBuffer = frameBuffer; this.canvas = new Canvas(frameBuffer); this.paint = new Paint(); } @Override public Image newImage(String fileName, ImageFormat format) { Config config = null; if (format == ImageFormat.RGB565) config = Config.RGB_565; else if (format == ImageFormat.ARGB4444) config = Config.ARGB_4444; else config = Config.ARGB_8888; Options options = new Options(); options.inPreferredConfig = config; InputStream in = null; Bitmap bitmap = null; try { in = assets.open(fileName); bitmap = BitmapFactory.decodeStream(in, null, options); if (bitmap == null) throw new RuntimeException("Couldn't load bitmap from asset '" + fileName + "'"); } catch (IOException e) { throw new RuntimeException("Couldn't load bitmap from asset '" + fileName + "'"); } finally { if (in != null) { try { in.close(); } catch (IOException e) { } } } if (bitmap.getConfig() == Config.RGB_565) format = ImageFormat.RGB565; else if (bitmap.getConfig() == Config.ARGB_4444) format = ImageFormat.ARGB4444; else format = ImageFormat.ARGB8888; return new AndroidImage(bitmap, format); } @Override public void clearScreen(int color) { canvas.drawRGB((color & 0xff0000) >> 16, (color & 0xff00) >> 8, (color & 0xff)); } @Override public void drawLine(int x, int y, int x2, int y2, int color) { paint.setColor(color); canvas.drawLine(x, y, x2, y2, paint); } @Override public void drawRect(int x, int y, int width, int height, int color) { paint.setColor(color); paint.setStyle(Style.FILL); canvas.drawRect(x, y, x + width - 1, y + height - 1, paint); } @Override public void drawARGB(int a, int r, int g, int b) { paint.setStyle(Style.FILL); canvas.drawARGB(a, r, g, b); } @Override public void drawString(String text, int x, int y, Paint paint){ canvas.drawText(text, x, y, paint); } public void drawImage(Image Image, int x, int y, int srcX, int srcY, int srcWidth, int srcHeight) { srcRect.left = srcX; srcRect.top = srcY; srcRect.right = srcX + srcWidth; srcRect.bottom = srcY + srcHeight; dstRect.left = x; dstRect.top = y; dstRect.right = x + srcWidth; dstRect.bottom = y + srcHeight; canvas.drawBitmap(((AndroidImage) Image).bitmap, srcRect, dstRect, null); } @Override public void drawImage(Image Image, int x, int y) { canvas.drawBitmap(((AndroidImage)Image).bitmap, x, y, null); } public void drawScaledImage(Image Image, int x, int y, int width, int height, int srcX, int srcY, int srcWidth, int srcHeight){ srcRect.left = srcX; srcRect.top = srcY; srcRect.right = srcX + srcWidth; srcRect.bottom = srcY + srcHeight; dstRect.left = x; dstRect.top = y; dstRect.right = x + width; dstRect.bottom = y + height; canvas.drawBitmap(((AndroidImage) Image).bitmap, srcRect, dstRect, null); } @Override public int getWidth() { return frameBuffer.getWidth(); } @Override public int getHeight() { return frameBuffer.getHeight(); } } |
In der Graphics Klasse erläutert sich das meiste von selbst.
1. Bitmap erlaubt uns ein Bild Objekt zu erstellen.
2. Canvas ist die Leinwand unserer Bilder. Wir zeichnen Bilder auf diese Leinwand, welche dann auf dem Bildschirm gezeigt werden.
3. Paint wird dazu verwendet, dass was wir auf den Bildschirm wieder geben zu zeichnen.
Wenn wir ein Bild auf dem Bildschirm anzeigen lassen, wird dieses als erstes im Arbeitsspeicher gespeichert. Jedes mal, wenn wir nun dieses Bild aufrufen, wird es aus dem Speicher aufgerufen. Es ist dabei egal wie viel Arbeitsspeicher ein Gerät hat, jeder App steht nur der sogenannte „Heap“ zu. Das kann bei einigen Geräten nur 16MB sein. Daher muss man mit der Speicherbelastung sehr kritisch umgehen.
Aus diesem Grund müssen wir ein paar Erfahrungen mit ImageFormats sammeln. Ein Pixel eines Bildes verbraucht 1 Bit, was 1/8 Byte entspricht. Nun können wir die Größe eines Bildes berechnen, indem wir einfach Länge mal Breite nehmen. Es gibt aber einen weiteren Faktor, die Bildtiefe und genau hier kommt ImageFormats ins Spiel.
In dem Graphics Interface haben wir die folgenden 3 ImageFormats programmiert. Diese 3 kann man verwenden, wenn wir Bilder im Arbeitsspeicher hinterlegen.
Das erste ist RGB565, dies benötigt den geringsten Speicher, normalerweise. Rot, Grün und Blau haben eine Tiefe von 5, 6 und 5. Hierbei können wir aber keinen Transparenten Wert festlegen.
ARGB4444 ist unser zweites Format mit einer Tiefe von 16. Dieses sollte man verwenden, wenn man ein transparentes Bild benötigt.
ARGB8888 ist das Format mit der größten Tiefe von 32. Wenn es möglich ist, sollte man darauf verzichten. ARGB4444 sollte ausreichen.
Je Höher wir die Tiefe eines Bildes wählen desto mehr Qualität haben wir. Wollen wir für etwas schwächere Geräte entwickeln, können wir dadurch schnell an den Heap stoßen. Ein Bild mit 1000×1000 hat bei einer Tiefe von 32 genau 32.000.000 Bits Arbeitsspeicher belegt, das sind rund 4MB. Wenn wir also 4 solcher Bilder haben, ist unser Gerät mit 16MB Heap überlastet und wir bekommen einen Out of Memory Exception und unser Spiel funktioniert nicht mehr. Das würde bedeuten, dass wir sonst nichts anderes im Speicher haben, was nicht möglich ist.
In der AndroidGraphics Klasse finden wir eine menge Methoden, die das Zeichnen für uns übernehmen. Hier sind auch viele Try, Catch und Finally Statements untergebracht. Macht euch darüber keine Gedanken, diese erledigen für uns die Arbeit.
Die AndroidFileIO Implementation
Hier werden wir einige abstrakte Methoden implementieren, welche wir in dem FileIO Interface erstellt haben.
Denkt daran den Paket Namen zu ändern, falls ihr euren eigenen benutzt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
package com.basteldroid.framework.implementation; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import android.content.Context; import android.content.SharedPreferences; import android.content.res.AssetManager; import android.os.Environment; import android.preference.PreferenceManager; import com.basteldroid.framework.FileIO; public class AndroidFileIO implements FileIO { Context context; AssetManager assets; String externalStoragePath; public AndroidFileIO(Context context) { this.context = context; this.assets = context.getAssets(); this.externalStoragePath = Environment.getExternalStorageDirectory() .getAbsolutePath() + File.separator; } @Override public InputStream readAsset(String file) throws IOException { return assets.open(file); } @Override public InputStream readFile(String file) throws IOException { return new FileInputStream(externalStoragePath + file); } @Override public OutputStream writeFile(String file) throws IOException { return new FileOutputStream(externalStoragePath + file); } public SharedPreferences getSharedPref() { return PreferenceManager.getDefaultSharedPreferences(context); } } |
Hier ergeben sich einige Fehler, wenn wir aber fertig sind mit dieser Lektion, werden alle verschwunden sein. Da die Klasse sich von selbst erklärt, vorausgesetzt ihr habt alle Kapitel durchgearbeitet, werde ich diese nicht weiter erläutern. Falls ihr dennoch etwas Hilfe benötigt, könnt ihr diese hier finden: http://developer.android.com/reference
Die AndroidAudio Implementation
Hier werden wir einige abstrakte Methoden implementieren, welche wir in dem Audio Interface erstellt haben.
Denkt daran den Paket Namen zu ändern, falls ihr euren eigenen benutzt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
package com.basteldroid.framework.implementation; import java.io.IOException; import android.app.Activity; import android.content.res.AssetFileDescriptor; import android.content.res.AssetManager; import android.media.AudioManager; import android.media.SoundPool; import com.basteldroid.framework.Audio; import com.basteldroid.framework.Music; import com.basteldroid.framework.Sound; public class AndroidAudio implements Audio { AssetManager assets; SoundPool soundPool; public AndroidAudio(Activity activity) { activity.setVolumeControlStream(AudioManager.STREAM_MUSIC); this.assets = activity.getAssets(); this.soundPool = new SoundPool(20, AudioManager.STREAM_MUSIC, 0); } @Override public Music createMusic(String filename) { try { AssetFileDescriptor assetDescriptor = assets.openFd(filename); return new AndroidMusic(assetDescriptor); } catch (IOException e) { throw new RuntimeException("Couldn't load music '" + filename + "'"); } } @Override public Sound createSound(String filename) { try { AssetFileDescriptor assetDescriptor = assets.openFd(filename); int soundId = soundPool.load(assetDescriptor, 0); return new AndroidSound(soundPool, soundId); } catch (IOException e) { throw new RuntimeException("Couldn't load sound '" + filename + "'"); } } } |
SoundPool ist die Klasse, die die Handhabung der Musik vom Arbeitsspeicher oder aus dem Dateisystem bewerkstelligt.
Kurze Musik die immer und immer wieder auftauchen, können wir im Arbeitsspeicher hinterlegen, dies nimmt viel Arbeit vom Prozessor. Lange Musikstücke die den Arbeitsspeicher voll schreiben würden, können wir direkt vom Dateisystem abgespielt werden.
Daher benötigen wir die nächsten 2 Implementations-: Sound und Music.
Die AndroidSound Interface
Hier werden wir einige abstrakte Methoden implementieren, welche wir in dem Sound Interface erstellt haben.
Denkt daran den Paket Namen zu ändern, falls ihr euren eigenen benutzt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
package com.basteldroid.framework.implementation; import android.media.SoundPool; import com.basteldroid.framework.Sound; public class AndroidSound implements Sound { int soundId; SoundPool soundPool; public AndroidSound(SoundPool soundPool, int soundId) { this.soundId = soundId; this.soundPool = soundPool; } @Override public void play(float volume) { soundPool.play(soundId, volume, volume, 0, 0, 1); } @Override public void dispose() { soundPool.unload(soundId); } } |
Hier werden die kurzen Sounds gemanagt, abgespielt und aus dem Arbeitsspeicher wieder entfernt.
Die AndroidMusic Implementation
Hier werden wir einige abstrakte Methoden implementieren, welche wir in dem Music Interface erstellt haben.
Denkt daran den Paket Namen zu ändern, falls ihr euren eigenen benutzt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 |
package com.basteldroid.framework.implementation; import java.io.IOException; import android.content.res.AssetFileDescriptor; import android.media.MediaPlayer; import android.media.MediaPlayer.OnCompletionListener; import android.media.MediaPlayer.OnPreparedListener; import android.media.MediaPlayer.OnSeekCompleteListener; import android.media.MediaPlayer.OnVideoSizeChangedListener; import com.basteldroid.framework.Music; public class AndroidMusic implements Music, OnCompletionListener, OnSeekCompleteListener, OnPreparedListener, OnVideoSizeChangedListener { MediaPlayer mediaPlayer; boolean isPrepared = false; public AndroidMusic(AssetFileDescriptor assetDescriptor) { mediaPlayer = new MediaPlayer(); try { mediaPlayer.setDataSource(assetDescriptor.getFileDescriptor(), assetDescriptor.getStartOffset(), assetDescriptor.getLength()); mediaPlayer.prepare(); isPrepared = true; mediaPlayer.setOnCompletionListener(this); mediaPlayer.setOnSeekCompleteListener(this); mediaPlayer.setOnPreparedListener(this); mediaPlayer.setOnVideoSizeChangedListener(this); } catch (Exception e) { throw new RuntimeException("Couldn't load music"); } } @Override public void dispose() { if (this.mediaPlayer.isPlaying()){ this.mediaPlayer.stop(); } this.mediaPlayer.release(); } @Override public boolean isLooping() { return mediaPlayer.isLooping(); } @Override public boolean isPlaying() { return this.mediaPlayer.isPlaying(); } @Override public boolean isStopped() { return !isPrepared; } @Override public void pause() { if (this.mediaPlayer.isPlaying()) mediaPlayer.pause(); } @Override public void play() { if (this.mediaPlayer.isPlaying()) return; try { synchronized (this) { if (!isPrepared) mediaPlayer.prepare(); mediaPlayer.start(); } } catch (IllegalStateException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } @Override public void setLooping(boolean isLooping) { mediaPlayer.setLooping(isLooping); } @Override public void setVolume(float volume) { mediaPlayer.setVolume(volume, volume); } @Override public void stop() { if (this.mediaPlayer.isPlaying() == true){ this.mediaPlayer.stop(); synchronized (this) { isPrepared = false; }} } @Override public void onCompletion(MediaPlayer player) { synchronized (this) { isPrepared = false; } } @Override public void seekBegin() { mediaPlayer.seekTo(0); } @Override public void onPrepared(MediaPlayer player) { // TODO Auto-generated method stub synchronized (this) { isPrepared = true; } } @Override public void onSeekComplete(MediaPlayer player) { // TODO Auto-generated method stub } @Override public void onVideoSizeChanged(MediaPlayer player, int width, int height) { // TODO Auto-generated method stub } } |
Hier werden einige Methoden definiert, die zum Abspielen von Musik notwendig sind.
Das wichtigste Objekt ist der MediaPlayer, hier werden Audio und Video Abspielung kontrolliert. Des Weiteren finden wir auch einige Listeners, welche den momentanen Stand der Abspielung überprüfen. Diese kann man mit den KeyListeners aus Kapitel 2 und 3 vergleichen.
Die AndroidFastRenderView Klasse
Denkt daran den Paket Namen zu ändern, falls ihr euren eigenen benutzt.
Weiter oben haben wir uns mit Aktivitäten auseinandergesetzt. Dabei habe ich von einem Window gesprochen, hier wiird eine Klasse SurfaceView erstellt. Diese können wir dazu verwenden grafisch basierende Benutzerumgebung zu programmieren, die sehr schnell sich aktuallisiert.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 |
package com.basteldroid.framework.implementation; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Rect; import android.view.SurfaceHolder; import android.view.SurfaceView; public class AndroidFastRenderView extends SurfaceView implements Runnable { AndroidGame game; Bitmap framebuffer; Thread renderThread = null; SurfaceHolder holder; volatile boolean running = false; public AndroidFastRenderView(AndroidGame game, Bitmap framebuffer) { super(game); this.game = game; this.framebuffer = framebuffer; this.holder = getHolder(); } public void resume() { running = true; renderThread = new Thread(this); renderThread.start(); } public void run() { Rect dstRect = new Rect(); long startTime = System.nanoTime(); while(running) { if(!holder.getSurface().isValid()) continue; float deltaTime = (System.nanoTime() - startTime) / 10000000.000f; startTime = System.nanoTime(); if (deltaTime > 3.15){ deltaTime = (float) 3.15; } game.getCurrentScreen().update(deltaTime); game.getCurrentScreen().paint(deltaTime); Canvas canvas = holder.lockCanvas(); canvas.getClipBounds(dstRect); canvas.drawBitmap(framebuffer, null, dstRect, null); holder.unlockCanvasAndPost(canvas); } } public void pause() { running = false; while(true) { try { renderThread.join(); break; } catch (InterruptedException e) { // retry } } } } |
Diese Klasse gibt unser Spiel auf dem Bildschirm wieder. Hier finden sich die update() und paint()-Methode wieder. Auch deltaTime können wir hier finden.
Bildfrequenz unabhängige Bewegung
In unserem Spiel aus Kapitel 2 und 3 hatten wir eine Bewegung des Roboters, welche von der Bildfrequenz abhängig war. Wir haben sie erst einmal auf 60 gesetzt. Wenn nun der Computer stark ausgelastet war, hätte sich dadurch die Frequenz verringern können. Gehen wir davon aus, dass durch eine hohe Auslastung der CPU unsere Bildfrequenz sich halbiert hätte auf 30. Das würde auch bedeuten, unser Roboter bewegt sich nur noch halb so schnell. All das macht unseren Computer aber eigentlich nichts aus und wird so bei unserem Spiel auch nicht passieren.
Aber wir wollen für Android entwickeln und da gibt es sehr große Unterschiede zwischen den einzelnen Geräten. Des Weiteren bekommen die Geräte beim spielen Nachrichten, E-Mails und noch viel mehr. All dies belastet die CPU und die meisten Geräte sind auch nicht dafür ausgelegt 60 Bilder die Sekunde darzustellen, daher haben wir eine sehr stark schwankende Bildfrequenz.
Um uns von der Bildfrequenz unabhängig zu machen, benutzen wir die Variable deltaTime. Diese überprüft, wie viel Zeit seit dem letzten Update vergangen ist. Wenn also nun doppelt soviel Zeit vergangen ist seit dem letzten Update, verdoppelt sich unsere deltaTime. Wir unterziehen deltaTime durch unsere update-Methode immer wieder der Überprüfung, so das unsere Spielfigur immer den selben Weg zurücklegt in der selben Zeit.
Natürlich kann das zu vielen Problemen führen. Wir können von 1 Pixel pro Sekunde auf bis zu 10 kommen. Dies würde unsere Kollision Methoden komplett überfordern und dazu führen, dass unser Spiel nicht spielbar ist. Aus diesem Grund ist deltaTime nach oben nicht offen und ist bei 3,15 gedeckt. Falls also unser Spiel erheblich langsamer wird, benutzen wir wieder eine Bildfrequenz, so dass nicht unser Spiel abstürzt. Dies ist die Priorisieren bei der Arbeit.
Damit kommen wir nun zur Eingabe.
Die AndroidInput Implementation
Hier werden viele der abstrakten Methoden verwendet, welche wir in dem Input Interface erstellt haben.
Denkt daran den Paket Namen zu ändern, falls ihr euren eigenen benutzt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
package com.basteldroid.framework.implementation; import java.util.List; import android.content.Context; import android.os.Build.VERSION; import android.view.View; import com.basteldroid.framework.Input; public class AndroidInput implements Input { TouchHandler touchHandler; public AndroidInput(Context context, View view, float scaleX, float scaleY) { if(Integer.parseInt(VERSION.SDK) < 5) touchHandler = new SingleTouchHandler(view, scaleX, scaleY); else touchHandler = new MultiTouchHandler(view, scaleX, scaleY); } @Override public boolean isTouchDown(int pointer) { return touchHandler.isTouchDown(pointer); } @Override public int getTouchX(int pointer) { return touchHandler.getTouchX(pointer); } @Override public int getTouchY(int pointer) { return touchHandler.getTouchY(pointer); } @Override public List getTouchEvents() { return touchHandler.getTouchEvents(); } } |
Diese Implementierung benötigt 3 andere Klassen, welche wir gleich erstellen werden. Kurze Info nebenbei:
In Android 2.0 wurde Multi-Touch eingeführt. In dieser Implementierung überprüfen wir die SDK Build Version und implementieren den erforderlichen Touch Handler. SDK Version 5 ist Android 2.0.
Die TouchHandler Klasse
Denkt daran den Paket Namen zu ändern, falls ihr euren eigenen benutzt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
package com.basteldroid.framework.implementation; import java.util.List; import android.view.View.OnTouchListener; import com.basteldroid.framework.Input.TouchEvent; public interface TouchHandler extends OnTouchListener { public boolean isTouchDown(int pointer); public int getTouchX(int pointer); public int getTouchY(int pointer); public List getTouchEvents(); } |
Diese einfache Klasse übernimmt das Touch geschehen, es überprüft für touchDown die X und Y Koordinaten.
Die SingleTouchHandler Klasse
Denkt daran den Paket Namen zu ändern, falls ihr euren eigenen benutzt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 |
package com.basteldroid.framework.implementation; import java.util.ArrayList; import java.util.List; import android.view.MotionEvent; import android.view.View; import com.basteldroid.framework.Pool; import com.basteldroid.framework.Input.TouchEvent; import com.basteldroid.framework.Pool.PoolObjectFactory; public class SingleTouchHandler implements TouchHandler { boolean isTouched; int touchX; int touchY; Pool touchEventPool; List touchEvents = new ArrayList(); List touchEventsBuffer = new ArrayList(); float scaleX; float scaleY; public SingleTouchHandler(View view, float scaleX, float scaleY) { PoolObjectFactory factory = new PoolObjectFactory() { @Override public TouchEvent createObject() { return new TouchEvent(); } }; touchEventPool = new Pool(factory, 100); view.setOnTouchListener(this); this.scaleX = scaleX; this.scaleY = scaleY; } @Override public boolean onTouch(View v, MotionEvent event) { synchronized(this) { TouchEvent touchEvent = touchEventPool.newObject(); switch (event.getAction()) { case MotionEvent.ACTION_DOWN: touchEvent.type = TouchEvent.TOUCH_DOWN; isTouched = true; break; case MotionEvent.ACTION_MOVE: touchEvent.type = TouchEvent.TOUCH_DRAGGED; isTouched = true; break; case MotionEvent.ACTION_CANCEL: case MotionEvent.ACTION_UP: touchEvent.type = TouchEvent.TOUCH_UP; isTouched = false; break; } touchEvent.x = touchX = (int)(event.getX() * scaleX); touchEvent.y = touchY = (int)(event.getY() * scaleY); touchEventsBuffer.add(touchEvent); return true; } } @Override public boolean isTouchDown(int pointer) { synchronized(this) { if(pointer == 0) return isTouched; else return false; } } @Override public int getTouchX(int pointer) { synchronized(this) { return touchX; } } @Override public int getTouchY(int pointer) { synchronized(this) { return touchY; } } @Override public List getTouchEvents() { synchronized(this) { int len = touchEvents.size(); for( int i = 0; i < len; i++ ) touchEventPool.free(touchEvents.get(i)); touchEvents.clear(); touchEvents.addAll(touchEventsBuffer); touchEventsBuffer.clear(); return touchEvents; } } } |
Die MultiTouchHandler Klasse
Denkt daran den Paket Namen zu ändern, falls ihr euren eigenen benutzt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 |
package com.basteldroid.framework.implementation; import java.util.ArrayList; import java.util.List; import android.view.MotionEvent; import android.view.View; import com.basteldroid.framework.Pool; import com.basteldroid.framework.Input.TouchEvent; import com.basteldroid.framework.Pool.PoolObjectFactory; public class MultiTouchHandler implements TouchHandler { private static final int MAX_TOUCHPOINTS = 10; boolean[] isTouched = new boolean[MAX_TOUCHPOINTS]; int[] touchX = new int[MAX_TOUCHPOINTS]; int[] touchY = new int[MAX_TOUCHPOINTS]; int[] id = new int[MAX_TOUCHPOINTS]; Pool touchEventPool; List touchEvents = new ArrayList(); List touchEventsBuffer = new ArrayList(); float scaleX; float scaleY; public MultiTouchHandler(View view, float scaleX, float scaleY) { PoolObjectFactory factory = new PoolObjectFactory() { @Override public TouchEvent createObject() { return new TouchEvent(); } }; touchEventPool = new Pool(factory, 100); view.setOnTouchListener(this); this.scaleX = scaleX; this.scaleY = scaleY; } @Override public boolean onTouch(View v, MotionEvent event) { synchronized (this) { int action = event.getAction() & MotionEvent.ACTION_MASK; int pointerIndex = (event.getAction() & MotionEvent.ACTION_POINTER_ID_MASK) >> MotionEvent.ACTION_POINTER_ID_SHIFT; int pointerCount = event.getPointerCount(); TouchEvent touchEvent; for (int i = 0; i < MAX_TOUCHPOINTS; i++) { if (i >= pointerCount) { isTouched[i] = false; id[i] = -1; continue; } int pointerId = event.getPointerId(i); if (event.getAction() != MotionEvent.ACTION_MOVE && i != pointerIndex) { // if it's an up/down/cancel/out event, mask the id to see if we should process it for this touch // point continue; } switch (action) { case MotionEvent.ACTION_DOWN: case MotionEvent.ACTION_POINTER_DOWN: touchEvent = touchEventPool.newObject(); touchEvent.type = TouchEvent.TOUCH_DOWN; touchEvent.pointer = pointerId; touchEvent.x = touchX[i] = (int) (event.getX(i) * scaleX); touchEvent.y = touchY[i] = (int) (event.getY(i) * scaleY); isTouched[i] = true; id[i] = pointerId; touchEventsBuffer.add(touchEvent); break; case MotionEvent.ACTION_UP: case MotionEvent.ACTION_POINTER_UP: case MotionEvent.ACTION_CANCEL: touchEvent = touchEventPool.newObject(); touchEvent.type = TouchEvent.TOUCH_UP; touchEvent.pointer = pointerId; touchEvent.x = touchX[i] = (int) (event.getX(i) * scaleX); touchEvent.y = touchY[i] = (int) (event.getY(i) * scaleY); isTouched[i] = false; id[i] = -1; touchEventsBuffer.add(touchEvent); break; case MotionEvent.ACTION_MOVE: touchEvent = touchEventPool.newObject(); touchEvent.type = TouchEvent.TOUCH_DRAGGED; touchEvent.pointer = pointerId; touchEvent.x = touchX[i] = (int) (event.getX(i) * scaleX); touchEvent.y = touchY[i] = (int) (event.getY(i) * scaleY); isTouched[i] = true; id[i] = pointerId; touchEventsBuffer.add(touchEvent); break; } } return true; } } @Override public boolean isTouchDown(int pointer) { synchronized (this) { int index = getIndex(pointer); if (index < 0 || index >= MAX_TOUCHPOINTS) return false; else return isTouched[index]; } } @Override public int getTouchX(int pointer) { synchronized (this) { int index = getIndex(pointer); if (index < 0 || index >= MAX_TOUCHPOINTS) return 0; else return touchX[index]; } } @Override public int getTouchY(int pointer) { synchronized (this) { int index = getIndex(pointer); if (index < 0 || index >= MAX_TOUCHPOINTS) return 0; else return touchY[index]; } } @Override public List getTouchEvents() { synchronized (this) { int len = touchEvents.size(); for (int i = 0; i < len; i++) touchEventPool.free(touchEvents.get(i)); touchEvents.clear(); touchEvents.addAll(touchEventsBuffer); touchEventsBuffer.clear(); return touchEvents; } } // returns the index for a given pointerId or -1 if no index. private int getIndex(int pointerId) { for (int i = 0; i < MAX_TOUCHPOINTS; i++) { if (id[i] == pointerId) { return i; } } return -1; } } |
Die letzten beiden Klassen haben sehr oft auf die Pool Klasse zugegriffen. Da wir mit dieser Klasse nichts viel anfangen können, spare ich aus Zeitgründen eine Erleuterung.
Die AndroidImage Implementation
Dies ist die letzte Klasse die wir erstellen. Hier werden wir einige der abstrakten Methoden implementieren, welche wir im Image Interface erstellt haben.
Denkt daran den Paket Namen zu ändern, falls ihr euren eigenen benutzt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
package com.basteldroid.framework.implementation; import android.graphics.Bitmap; import com.basteldroid.framework.Image; import com.basteldroid.framework.Graphics.ImageFormat; public class AndroidImage implements Image { Bitmap bitmap; ImageFormat format; public AndroidImage(Bitmap bitmap, ImageFormat format) { this.bitmap = bitmap; this.format = format; } @Override public int getWidth() { return bitmap.getWidth(); } @Override public int getHeight() { return bitmap.getHeight(); } @Override public ImageFormat getFormat() { return format; } @Override public void dispose() { bitmap.recycle(); } } |
Das ist auch unsere letzte Klasse, diese Klasse erklärt sich von alleine, oder?
Damit haben wir das Grundgerüst abgeschlossen und wir sind bereit unser erstes Spiel zu programmieren.
Falls ihr Fragen habt, immer raus damit, ich helfe euch sehr gerne. Hinterlasst bitte einfach einen Kommentar.
Teilt diese Seite mit euren Freunden und besucht uns mal auf Facebook und auf Google+, dass würde dieser Seite wirklich weiterhelfen, Danke sehr. Oder ein Klick auf die Werbung, hilft dabei diese Seite am laufen zu halten.
Source Code
Falls einer hier einsteigen möchte oder nicht den ganzen Code abtippen möchte, habe ich hier das Projekt exportiert und ihr könnt diesen bei euch einfügen. Unter der Kategorie Eclipse und Import und Export habe ich erläutert wie ihr dies macht.
Quelle: Original Anleitung auf englisch von Kilobolt Studios
Lektion 5 – Grundgerüst eines Android Spiels Teil 1 Lektion 7 - Erstellen eines Spiels von a bis z