Help with Libgdx game android audio makes game lag

[Keith Earl]

Hello all,

I've been following a tutorial on youtube on how to make a space invaders type of game using Libgdx. The game works fine and I even added audio on my own, however the audio seems to be a problem with running the game on android. On the PC the game works, but with android it runs very very slow and if I remove or comment out all of the audio then the game runs perfectly fine on android. The problem initially was I had no type of assets manager for the audio, but then I created one and still get the same problem. I'll paste all of my coding here and please forgive me if it isn't the correct etiquette. I'm willing to put all of the classes in pastebin as well if I need to. Excluding the typical Desktop and Android launcher classes, there are 14 classes: MyGdxGame, TextureManager, OrthoCamera, VirtualViewport, Assets, , EntityManager, Entity ->( Enemy, Player, Missile), ScreenManager, Screen -> ( GameScreen, GameOverScreen). the ->() indicates that the classes within the () are extending the previous class, GameScreen extending Screen for example.


MyGdxGame

package com.innermindgames2.game;

import com.badlogic.gdx.ApplicationListener;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.audio.Music;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.innermindgames2.data.Assets;
import com.innermindgames2.screen.GameScreen;
import com.innermindgames2.screen.ScreenManager;

public class MyGdxGame implements ApplicationListener {
	
	private static int width = 480;
	private static int height = 800;
	
	private static Music music;
	
	SpriteBatch batch;
	Texture img;
	
	@Override
	public void create () {
		batch = new SpriteBatch();
		ScreenManager.setScreen(new GameScreen());
		Assets.load();
		Assets.manager.finishLoading();
		music = Assets.manager.get(Assets.backgroundmusic);
		music.setVolume(0.5f);
		music.play();
		music.setLooping(true);
		
	}
	
	
	@Override
	public void render () {
		Gdx.gl.glClearColor(0, 0, 0, 1);
		Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
		
		if(ScreenManager.getCurrentSCreen() != null)
			ScreenManager.getCurrentSCreen().update();
		
		if(ScreenManager.getCurrentSCreen() != null)
			ScreenManager.getCurrentSCreen().render(batch);
	}
	

	@Override
	public void resize(int width, int height) {
		if(ScreenManager.getCurrentSCreen() != null)
			ScreenManager.getCurrentSCreen().resize(width, height);
	}


	@Override
	public void pause() {
		if(ScreenManager.getCurrentSCreen() != null)
			ScreenManager.getCurrentSCreen().pause();
	}


	@Override
	public void resume() {
		if(ScreenManager.getCurrentSCreen() != null)
			ScreenManager.getCurrentSCreen().resume();
	}


	@Override
	public void dispose() {
		if(ScreenManager.getCurrentSCreen() != null)
			ScreenManager.getCurrentSCreen().dispose();
		batch.dispose();
		Assets.dispose();
	}
	
	// My own methods
	public static void stopMusic(){
		music.stop();
		music.dispose();
	}
	
	public static int getWidth(){
		return width;
	}
	
	public static int getHeight(){
		return height;
	}
}

TextureManager

package com.innermindgames2.game;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.Texture;

public class TextureManager {
	
	public static Texture PLAYER = new Texture(Gdx.files.internal("data/texture/player2.png"));
	public static Texture MISSLE = new Texture(Gdx.files.internal("data/texture/bullet.png"));
	public static Texture ENEMY = new Texture(Gdx.files.internal("data/texture/enemy.gif"));
	public static Texture GAME_OVER = new Texture(Gdx.files.internal("data/texture/gameover.png"));
	public static Texture GAME_WON = new Texture(Gdx.files.internal("data/texture/gamewon.png"));
	
}

OrthoCamera

package com.innermindgames2.camera;

import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.math.Matrix4;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.math.Vector3;
import com.innermindgames2.game.MyGdxGame;

public class OrthoCamera extends OrthographicCamera{
	
	Vector3 tmp = new Vector3();
	Vector2 origin = new Vector2();
	VirtualViewport virtualViewport;
	Vector2 pos = new Vector2();

	public OrthoCamera() {
		this(new VirtualViewport(MyGdxGame.getWidth(), MyGdxGame.getHeight()));
	}
	
	public OrthoCamera(VirtualViewport virtualViewport) {
		this(virtualViewport, 0f, 0f);
	}

	public OrthoCamera(VirtualViewport virtualViewport, float cx, float cy) {
		this.virtualViewport = virtualViewport;
		this.origin.set(cx, cy);
	}

	public void setVirtualViewport(VirtualViewport virtualViewport) {
		this.virtualViewport = virtualViewport;
	}
	
	public void setPosition(float x, float y) {
		position.set(x - viewportWidth * origin.x, y - viewportHeight * origin.y, 0f);
		pos.set(x, y);
	}
	
	public Vector2 getPos() {
		return pos;
	}

	@Override
	public void update() {
		float left = zoom * -viewportWidth / 2 + virtualViewport.getVirtualWidth() * origin.x;
		float right = zoom * viewportWidth / 2 + virtualViewport.getVirtualWidth() * origin.x;
		float top = zoom * viewportHeight / 2 + virtualViewport.getVirtualHeight() * origin.y;
		float bottom = zoom * -viewportHeight / 2 + virtualViewport.getVirtualHeight() * origin.y;

		projection.setToOrtho(left, right, bottom, top, Math.abs(near), Math.abs(far));
		view.setToLookAt(position, tmp.set(position).add(direction), up);
		combined.set(projection);
		Matrix4.mul(combined.val, view.val);
		invProjectionView.set(combined);
		Matrix4.inv(invProjectionView.val);
		frustum.update(invProjectionView);
	}

	/**
	 * This must be called in ApplicationListener.resize() in order to correctly update the camera viewport. 
	 */
	public void updateViewport() {
		setToOrtho(false, virtualViewport.getWidth(), virtualViewport.getHeight());
	}
	
	public Vector2 unprojectCoordinates(float x, float y) {
        Vector3 rawtouch = new Vector3(x, y,0);
        unproject(rawtouch); 
        return new Vector2(rawtouch.x, rawtouch.y);
    }
	
	public void resize() {
		VirtualViewport virtualViewport = new VirtualViewport(MyGdxGame.getWidth(), MyGdxGame.getHeight());  
		setVirtualViewport(virtualViewport);  
		updateViewport();
	}


}

VirtualViewport

package com.innermindgames2.camera;

import com.badlogic.gdx.Gdx;

public class VirtualViewport {
	float virtualWidth;  
    float virtualHeight;  
  
    public float getVirtualWidth() {  
        return virtualWidth;  
    }  
  
    public float getVirtualHeight() {  
        return virtualHeight;  
    }  
  
    public VirtualViewport(float virtualWidth, float virtualHeight) {  
        this(virtualWidth, virtualHeight, false);  
    }  
  
    public VirtualViewport(float virtualWidth, float virtualHeight, boolean shrink) {  
        this.virtualWidth = virtualWidth;  
        this.virtualHeight = virtualHeight;  
    }  
  
    public float getWidth() {  
        return getWidth(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());  
    }  
  
    public float getHeight() {  
        return getHeight(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());  
    }  
  
    /** 
     * Returns the view port width to let all the virtual view port to be shown on the screen. 
     *  
     * @param screenWidth 
     *            The screen width. 
     * @param screenHeight 
     *            The screen Height. 
     */  
    public float getWidth(float screenWidth, float screenHeight) {  
        float virtualAspect = virtualWidth / virtualHeight;  
        float aspect = screenWidth / screenHeight;  
        if (aspect > virtualAspect || (Math.abs(aspect - virtualAspect) < 0.01f)) {  
            return virtualHeight * aspect;  
        } else {  
            return virtualWidth;  
        }  
    }  
  
    /** 
     * Returns the view port height to let all the virtual view port to be shown on the screen. 
     *  
     * @param screenWidth 
     *            The screen width. 
     * @param screenHeight 
     *            The screen Height. 
     */  
    public float getHeight(float screenWidth, float screenHeight) {  
        float virtualAspect = virtualWidth / virtualHeight;  
        float aspect = screenWidth / screenHeight;  
        if (aspect > virtualAspect || (Math.abs(aspect - virtualAspect) < 0.01f)) {  
            return virtualHeight;  
        } else {  
            return virtualWidth / aspect;  
        }  
    }  
}

Assets

package com.innermindgames2.data;

import com.badlogic.gdx.assets.AssetManager;
import com.badlogic.gdx.audio.Music;
import com.badlogic.gdx.audio.Sound;

public class Assets {
	public static final AssetManager manager = new AssetManager();
	
	public static final String backgroundmusic = "data/music/stagemusic2.mp3";
	public static final String gameovermusic = "data/music/gameovermusic.mp3";
	public static final String laser = "data/sound/laserfire.wav";
	public static final String falling = "data/sound/falling.wav";
	public static final String explode = "data/sound/explode.wav";
	
	public static void load(){
		manager.load(backgroundmusic, Music.class);
		manager.load(gameovermusic, Music.class);
		manager.load(laser, Sound.class);
		manager.load(falling, Sound.class);
		manager.load(explode, Sound.class);
		
	}
	
	public static void dispose(){
		manager.dispose();
	}
}

EntityManager

package com.innermindgames2.entity;

import com.badlogic.gdx.audio.Music;
import com.badlogic.gdx.audio.Sound;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.utils.Array;
import com.innermindgames2.camera.OrthoCamera;
import com.innermindgames2.data.Assets;
import com.innermindgames2.game.MyGdxGame;
import com.innermindgames2.game.TextureManager;
import com.innermindgames2.screen.GameOverScreen;
import com.innermindgames2.screen.ScreenManager;

public class EntityManager {
	private final Array<Entity> entities = new Array<Entity>();
	private final Player player;
	private Sound hit;
	private Music gameovermusic;

	
	public EntityManager(int amount, OrthoCamera camera) {
		player = new Player(new Vector2(230, 15), new Vector2(0, 0), this, camera);
		
		for (int i = 0; i < amount; i++) {
			float x = MathUtils.random(0, MyGdxGame.getWidth() - TextureManager.ENEMY.getWidth());
			float y = MathUtils.random(MyGdxGame.getHeight(), MyGdxGame.getHeight() * 3);
			float speed = MathUtils.random(2, 5);
			addEntity(new Enemy(new Vector2(x, y), new Vector2(0, -speed)));
		}
	}
	
	public void update() {
		Assets.load();
		Assets.manager.finishLoading();
		hit = Assets.manager.get(Assets.explode);
		gameovermusic = Assets.manager.get(Assets.gameovermusic);
		
		for (Entity e : entities)
			e.update();
		for (Missile m : getMissiles())
			if (m.checkEnd())
				entities.removeValue(m, false);
		player.update();
		
		checkCollisions();
	}
	
	public void render(SpriteBatch sb) {
		for (Entity e : entities)
			e.render(sb);
		player.render(sb);
	}
	
	private void checkCollisions() {
		for (Enemy e : getEnemies()) {
			for (Missile m : getMissiles()) {
				if (e.getBounds().overlaps(m.getBounds())) {
					hit.play();
					entities.removeValue(e, false);
					entities.removeValue(m, false);
					if (gameOver()){
						//end game, won
						ScreenManager.setScreen(new GameOverScreen(true));
						if(ScreenManager.getCurrentSCreen() instanceof GameOverScreen){
							MyGdxGame.stopMusic();
							gameovermusic.play();
							
						}
					}
				}
			}
			if (e.getBounds().overlaps(player.getBounds())){
				//end game , lost
				ScreenManager.setScreen(new GameOverScreen(false));
				if(ScreenManager.getCurrentSCreen() instanceof GameOverScreen){
					MyGdxGame.stopMusic();
					gameovermusic.play();
					
				}
			}

		}
	}
	
	public void addEntity(Entity entity) {
		entities.add(entity);
	}
	
	private Array<Enemy> getEnemies() {
		Array<Enemy> ret = new Array<Enemy>();
		for (Entity e : entities)
			if (e instanceof Enemy)
				ret.add((Enemy)e);
		return ret;
	}
	
	private Array<Missile> getMissiles() {
		Array<Missile> ret = new Array<Missile>();
		for (Entity e : entities)
			if (e instanceof Missile)
				ret.add((Missile)e);
		return ret;
	}
	
	public boolean gameOver() {
		return getEnemies().size <= 0;
	}

}

Entity

package com.innermindgames2.entity;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.math.Rectangle;
import com.badlogic.gdx.math.Vector2;

public abstract class Entity {
	
	protected Texture texture;
	protected Vector2 pos, direction;
		
	public Entity(Texture texture, Vector2 pos, Vector2 direction){
		this.texture = texture;
		this.pos = pos;
		this.direction = direction;
	}
	
	public abstract void update();
	
	public void render(SpriteBatch sb){
		sb.draw(texture, pos.x, pos.y);
	}
	
	public Vector2 getPosition(){
		return pos;
	}
	
	public Rectangle getBounds(){
		return new Rectangle(pos.x, pos.y, texture.getWidth(), texture.getHeight());
	}
	
	public void setDirection(float x, float y){
		direction.set(x,y);
		direction.scl(Gdx.graphics.getDeltaTime());
	}
	
}

Enemy

package com.innermindgames2.entity;

import com.badlogic.gdx.audio.Sound;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Vector2;
import com.innermindgames2.data.Assets;
import com.innermindgames2.game.MyGdxGame;
import com.innermindgames2.game.TextureManager;

public class Enemy extends Entity{
	
	private Sound spawn;
	
	public Enemy(Vector2 pos, Vector2 direction) {
		super(TextureManager.ENEMY, pos, direction);
	}

	@Override
	public void update() {
		Assets.load();
		Assets.manager.finishLoading();
		
		pos.add(direction);
		if(pos.y <= -TextureManager.ENEMY.getHeight()){
			float x = MathUtils.random(0, MyGdxGame.getWidth() - TextureManager.ENEMY.getWidth());
			pos.set(x, MyGdxGame.getHeight());
			spawn = Assets.manager.get(Assets.falling);
			long id = spawn.play();
			spawn.setVolume(id, 3.0f);
			
		}
	}
}

Player

package com.innermindgames2.entity;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input.Buttons;
import com.badlogic.gdx.Input.Keys;
import com.badlogic.gdx.audio.Sound;
import com.badlogic.gdx.math.Vector2;
import com.innermindgames2.camera.OrthoCamera;
import com.innermindgames2.data.Assets;
import com.innermindgames2.game.MyGdxGame;
import com.innermindgames2.game.TextureManager;


public class Player extends Entity{

	private final EntityManager entityManager;
	private final OrthoCamera camera;
	private long lastFire;
	private Sound laser;
	
	public Player(Vector2 pos, Vector2 direction, EntityManager entityManager, OrthoCamera camera) {
		super(TextureManager.PLAYER, pos, direction);
		this.entityManager = entityManager;
		this.camera = camera;
	}

	@Override
	public void update() {
		pos.add(direction);
		
		Assets.load();
		Assets.manager.finishLoading();
		
		int dir = 0;
		
		if(Gdx.input.isTouched()){
			Vector2 touch = camera.unprojectCoordinates(Gdx.input.getX(), Gdx.input.getY());
			if(touch.x > MyGdxGame.getWidth() / 2)
				dir = 2;
			else
				dir = 1;
		}
		
		if(Gdx.input.isKeyPressed(Keys.A) || dir == 1) // Left
			setDirection(-350,0);
		else if(Gdx.input.isKeyPressed(Keys.D) || dir == 2) // right
			setDirection(350,0);
		else
			setDirection(0,0);
		if(Gdx.input.isButtonPressed(Buttons.LEFT) || Gdx.input.isKeyPressed(Keys.SPACE)){
			if(System.currentTimeMillis() - lastFire >= 200){
			laser = Assets.manager.get(Assets.laser);
			laser.play();
			entityManager.addEntity(new Missile(pos.cpy().add(25, TextureManager.PLAYER.getHeight())));
			lastFire = System.currentTimeMillis();
			}

		}
		
	}

}

Missile

package com.innermindgames2.entity;

import com.badlogic.gdx.math.Vector2;
import com.innermindgames2.game.MyGdxGame;
import com.innermindgames2.game.TextureManager;

public class Missile extends Entity{

	public Missile(Vector2 pos) {
		super(TextureManager.MISSLE, pos, new Vector2(0,5));
			
	}

	@Override
	public void update() {
		pos.add(direction);
	}
	
	public boolean checkEnd(){
		return pos.y >= MyGdxGame.getHeight();
	}

}

ScreenManager

package com.innermindgames2.screen;

public class ScreenManager {
	
	private static Screen currentScreen;
	
	public static void setScreen(Screen screen){
		if (currentScreen != null)
			currentScreen.dispose();
		currentScreen = screen;
		currentScreen.create();
	}
	
	public static Screen getCurrentSCreen(){
		return currentScreen;
	}
	
}

Screen

package com.innermindgames2.screen;

import com.badlogic.gdx.graphics.g2d.SpriteBatch;

public abstract class Screen {
	
	public abstract void create();
	
	public abstract void update();
	
	public abstract void render(SpriteBatch sb);
	
	public abstract void resize(int width, int height);
	
	public abstract void dispose();
	
	public abstract void hide();
		
	public abstract void pause();
	
	public abstract void resume();
}

GameScreen

package com.innermindgames2.screen;

import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.innermindgames2.camera.OrthoCamera;
import com.innermindgames2.data.Assets;
import com.innermindgames2.entity.EntityManager;

public class GameScreen extends Screen{
	
	private OrthoCamera camera;
	private EntityManager entityManager;

	
	
	@Override
	public void create() {
		camera = new OrthoCamera();
		entityManager = new EntityManager(20, camera);

	}

	@Override
	public void update() {
		camera.update();
		entityManager.update();
	}
	
	@Override
	public void render(SpriteBatch sb) {
		sb.setProjectionMatrix(camera.combined);
		sb.begin();
		entityManager.render(sb);
		sb.end();
	}

	@Override
	public void resize(int width, int height) {
		camera.resize();
	}

	@Override
	public void dispose() {
		Assets.dispose();
	}

	@Override
	public void hide() {
		
	}

	@Override
	public void pause() {
		
	}

	@Override
	public void resume() {
		
	}
}

GameOverScreen

package com.innermindgames2.screen;

import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.innermindgames2.camera.OrthoCamera;
import com.innermindgames2.game.MyGdxGame;
import com.innermindgames2.game.TextureManager;

public class GameOverScreen extends Screen{
	
	private OrthoCamera camera;
	private Texture texture;
	
	public GameOverScreen(boolean won){
		if(won)
			texture = TextureManager.GAME_WON;
		else
			texture = TextureManager.GAME_OVER;
		
	}
	
	@Override
	public void create() {
		camera = new OrthoCamera();
		camera.resize();

		
		
	}

	@Override
	public void update() {
		camera.update();

		
	}

	@Override
	public void render(SpriteBatch sb) {
		sb.setProjectionMatrix(camera.combined);
		sb.begin();
		sb.draw(texture, MyGdxGame.getWidth() / 2 - texture.getWidth() / 2, MyGdxGame.getHeight() / 2 - texture.getHeight() / 2);
		sb.end();
	}

	@Override
	public void resize(int width, int height) {
		camera.resize();
	}

	@Override
	public void dispose() {
		
	}

	@Override
	public void hide() {
		
	}

	@Override
	public void pause() {
		
	}

	@Override
	public void resume() {
		
	}

}

That's all there is to it sans the launcher classes. Am I going about the assetmanager the wrong way? Again it works perfectly fine on PC, but I would assume that's because it's got better graphics and processing power than my phone hence why it doesn't lag

[Guillermo Ishi]

I guess I would uncomment the audio line by line until I found a call that looked like it might be causing the lag, and then take it from there.

This may not be your problem but I can tell you that Android audio itself is infamously laggy. You can't get below about 1/10 sec between input and playback, in my experience, in other words no real-time monitoring. Other people reporting other show stoppers. I think I read that 5.x fixes some of it but of course it will still be lousy. Everything about Android is great, except the flat out suckaxx audio.

https://code.google.com/p/android/issues/detail?id=3434

[Keith Earl]

Guillermo Ishi wrote:I guess I would uncomment the audio line by line until I found a call that looked like it might be causing the lag, and then take it from there.

This may not be your problem but I can tell you that Android audio itself is infamously laggy. You can't get below about 1/10 sec between input and playback, in my experience, in other words no real-time monitoring. Other people reporting other show stoppers. I think I read that 5.x fixes some of it but of course it will still be lousy. Everything about Android is great, except the flat out suckaxx audio.

https://code.google.com/p/android/issues/detail?id=3434

Yeah I pretty much did that with the audio, as I built the asset manager I would test it and each time it ran slow on android but fine on pc. I guess I'll just have have to look at more audio tutorials for libgdx and see how others did with it. The tutorial I watched on making this game didn't show how to put any sort of sound or audio into it, so I probably have to look further into that to understand it better. I'm sure something's not being disposed properly with the audio and causing the game to lag since that's the only time it does lag when there is audio in the game. Thank you for giving me that link

[Keith Earl]

I think the problem maybe (in a way) fixed itself. When I was testing the game out on android, I was doing so through usb debugging. When I would have the cable still attached while the game was running, that's when it goes slow, but unplugging it makes it run fine. So apparently that was the problem all along. I guess some good came out of it though because I did implement another manager into the game which was good practice. By the way, if anyone wants to test out what I have so far, here is the link to the executable jar.

Source

All of the sound effects were created with a small application called Sfxr, the music came from a game called Gradius, and the sprites are from Galaga and Space Invaders.

I still need to add bounding so the ship doesn't go outside of the screen, but other than that I'm pretty proud of it so far and want to make more changes to it, possibly more stages and stage bosses.

[Guillermo Ishi]

Nice. I've never been able to get usb working on mine, so I wouldn't know. I develop on an emulator then use dropbox or something to get the apk in my phone.