Android live wallpaper scaling

Question

I'm learning android and java and am trying to learn how to make a live wallpaper I am using the aquarium tutorial, I put it all in one file instead of spreading it but what I am trying to do is get one scale number for everything, I want to get the height of the screen divide that by the background image height (which will always be bigger), this should give me a ratio to use for scaling everything, I tried this in a surfaceView code and it worked perfect, I tried it in livewallpaper and nada. In the surfaceView test I use onSizeChange and got the height that way and it worked no problems. This is what I did for the livewallpaper one This is what I put for the onSurfaceChange

public int screenWidth;
public float rescaler;
public float totalHeight = theTemplate._backgroundImage.getHeight();

@Override
public void onSurfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    //add rescale and width
    screenWidth = width;
    rescaler = (float) (height / totalHeight);
    super.onSurfaceChanged(holder, format, width, height);          
}

The background image comes from an inner class named TheTemplate This is what I did there The variables

private SpriteAnimationActivityEngine theTest;
private Bitmap theBackgroundImage;
private float theScaler = theTest.rescaler;

then I try and rescale it using theScaler

public void initialize(Context context, SurfaceHolder surfaceHolder) {
    this.spriteThread = new SpriteThread(this); 
    this._surfaceHolder = surfaceHolder;        
    this._sprites = new ArrayList<Renderable>();
    this._context = context;
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inPurgeable = true;
    this._backgroundImage = BitmapFactory.decodeResource(context.getResources(),ca.samsstuff.testonepagewallpaper.R.drawable.sky, options);
    this.theBackgroundImage = Bitmap.createScaledBitmap(_backgroundImage,  (int) (theScaler * _backgroundImage.getWidth()),  (int) (theScaler * _backgroundImage.getHeight()), true);
    this.addSprites();
}

Then it passes it to draw the background

private void renderBackGround(Canvas canvas) {
    canvas.drawBitmap(this.theBackgroundImage, 0, 0, null);
}

Which sends it to draw

protected void onDraw(Canvas canvas) {
    this.renderBackGround(canvas);              
    for (Renderable renderable : this._sprites) {
        renderable.render(canvas);
    }
}

I keep getting errors and don't know what I am doing wrong. Like I said I am learning both android and java but this method worked in another test I did but I got the screen height from onSizeChange can I get the height by using onSurfaceChange?

Any help would be appreciated Thanks in advance sam

EDIT I also tried to rescale within the theTemplate class just to see if it would work having everything within its own class and still having issues, I used the DisplayMetrics to get the screen height this time. This might work if I can get it going properly. Here is this attempt

public class TheTemplate {

        private SpriteThread spriteThread;  
        private SurfaceHolder _surfaceHolder;   
        private ArrayList<Renderable> _sprites; 
        public Bitmap _backgroundImage = BitmapFactory.decodeResource(getResources(), R.drawable.sky);;
        private Context _context;

        // add rescale stuff
        private Bitmap theBackgroundImage;
        private float theScaler = initFrameParams() / _backgroundImage.getHeight();
        private Bitmap oneBackImage = Bitmap.createScaledBitmap(_backgroundImage,  (int) (theScaler * _backgroundImage.getWidth()),  (int) (theScaler * _backgroundImage.getHeight()), true);

        int initFrameParams()
        {
                            //get the screen height to use to rescale everything
            DisplayMetrics metrics = new DisplayMetrics();
            Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
            display.getMetrics(metrics);

            int screenHeight = display.getHeight();
            return screenHeight;


        }


        public void render(){
            Canvas canvas = null;
            try{

                canvas = this._surfaceHolder.lockCanvas(null);
                synchronized (this._surfaceHolder) {
                    this.onDraw(canvas);
                }

            }finally{
                if(canvas != null){
                    this._surfaceHolder.unlockCanvasAndPost(canvas);
                }
            }   
        }

        protected void onDraw(Canvas canvas) {
            this.renderBackGround(canvas);              
            for (Renderable renderable : this._sprites) {
                renderable.render(canvas);
            }
        };

        public void start(){
            this.spriteThread.switchOn();
        }

        public void stop(){
            boolean retry = true;
            this.spriteThread.switchOff();
            while (retry) {
                try {
                 this.spriteThread.join();
                    retry = false;
                } catch (InterruptedException e) {
                    // we will try it again and again...
                }
            }
        }

        public int getLeft() {      
            return 0;
        }


        public int getRight() {
            return this.theBackgroundImage.getWidth();
        }

        public void initialize(Context context, SurfaceHolder surfaceHolder) {
            this.spriteThread = new SpriteThread(this); 
            this._surfaceHolder = surfaceHolder;        
            this._sprites = new ArrayList<Renderable>();
            this._context = context;
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inPurgeable = true;
            this.theBackgroundImage = oneBackImage;
            this.addSprites();
        }


        private void addSprites() {     
            Point startPoint = new Point(100, 100);
            this._sprites.add(new SpriteOne(this._context, this, startPoint, 90));
            Point startPoint1 = new Point(100, 300);
            this._sprites.add(new SpriteOne(this._context, this, startPoint1, 50));

            Point startPoint2 = new Point(200, 200);
            this._sprites.add(new SpriteOne(this._context, this, startPoint2, 15));
        }

        private void renderBackGround(Canvas canvas)
        {
            canvas.drawBitmap(this.theBackgroundImage, 0, 0, null);
        }
    }

As I stated before any help would be appreciated. Thanks again in advance Sam

Edit SOLVED Here is an answer I came up with, The rescale code is where the comments are Hope this helps someone out.

public class TheTemplate {  

            private SpriteThread spriteThread;    
            private SurfaceHolder _surfaceHolder;     
            private ArrayList<Renderable> _sprites;     
            public Bitmap _backgroundImage = BitmapFactory.decodeResource(getResources(), R.drawable.sky);;  
            private Context _context;  

            // add rescale stuff  
            //private SpriteAnimationActivityEngine theTest;  
            private Bitmap theBackgroundImage;  
            private float totalHeight = _backgroundImage.getHeight();  
            private int screenSized = initFrameParams();  
            private float theScaler = (float) (screenSized / totalHeight);  

            private Bitmap oneBackImage = Bitmap.createScaledBitmap(_backgroundImage,  (int) (theScaler * _backgroundImage.getWidth()),  (int) (theScaler * _backgroundImage.getHeight()), true);  


            int initFrameParams()  
            {  
                DisplayMetrics metrics = new DisplayMetrics();  
                Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();  
                display.getMetrics(metrics);  

                int screenHeight = display.getHeight();  
                return screenHeight;  
            }  


            public void render(){  
                Canvas canvas = null;  
                try{  

                    canvas = this._surfaceHolder.lockCanvas(null);  
                    synchronized (this._surfaceHolder) {  
                        this.onDraw(canvas);  
                    }  

                }finally{  
                    if(canvas != null){  
                        this._surfaceHolder.unlockCanvasAndPost(canvas);  
                    }  
                }     
            }  

            protected void onDraw(Canvas canvas) {  
                this.renderBackGround(canvas);                
                for (Renderable renderable : this._sprites) {  
                    renderable.render(canvas);  
                }  
            };  

            public void start(){  
                this.spriteThread.switchOn();  
            }  

            public void stop(){  
                boolean retry = true;  
                this.spriteThread.switchOff();  
                while (retry) {  
                    try {  
                     this.spriteThread.join();  
                        retry = false;  
                    } catch (InterruptedException e) {  
                        // we will try it again and again...  
                    }  
                }  
            }  

            public int getLeft() {        
                return 0;  
            }  


            public int getRight() {  
                return this.theBackgroundImage.getWidth();  
            }  

            public void initialize(Context context, SurfaceHolder surfaceHolder) {  
                this.spriteThread = new SpriteThread(this);   
                this._surfaceHolder = surfaceHolder;          
                this._sprites = new ArrayList<Renderable>();  
                this._context = context;  
                BitmapFactory.Options options = new BitmapFactory.Options();  
                options.inPurgeable = true;  
                this.theBackgroundImage = oneBackImage;  
                this.addSprites();  
            }  


            private void addSprites() {       
                Point startPoint = new Point(100, 100);  
                this._sprites.add(new SpriteOne(this._context, this, startPoint, 90));  
                Point startPoint1 = new Point(100, 300);  
                this._sprites.add(new SpriteOne(this._context, this, startPoint1, 50));  

                Point startPoint2 = new Point(200, 200);  
                this._sprites.add(new SpriteOne(this._context, this, startPoint2, 15));  
            }  

            private void renderBackGround(Canvas canvas)  
            {  
                canvas.drawBitmap(this.theBackgroundImage, 0, 0, null);  
            }  
        }  

Answer 1

I added the answer to the original post, hope this helps someone. Sam Sorry about that folks, new to this method of using a forum Here is the answer, I added comments in the code where I made the changes for scaling images. This method can also be used for positioning also. Here is the answer.

 public class TheTemplate {  

        private SpriteThread spriteThread;    
        private SurfaceHolder _surfaceHolder;     
        private ArrayList<Renderable> _sprites;     
        public Bitmap _backgroundImage = BitmapFactory.decodeResource(getResources(), R.drawable.sky);;  
        private Context _context;  

        // add rescale stuff  
        //private SpriteAnimationActivityEngine theTest;  
        private Bitmap theBackgroundImage;  
        private float totalHeight = _backgroundImage.getHeight();  
        private int screenSized = initFrameParams();  
        private float theScaler = (float) (screenSized / totalHeight);  

        private Bitmap oneBackImage = Bitmap.createScaledBitmap(_backgroundImage,  (int) (theScaler * _backgroundImage.getWidth()),  (int) (theScaler * _backgroundImage.getHeight()), true);  


        int initFrameParams()  
        {  
            DisplayMetrics metrics = new DisplayMetrics();  
            Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();  
            display.getMetrics(metrics);  

            int screenHeight = display.getHeight();  
            return screenHeight;  
        }  


        public void render(){  
            Canvas canvas = null;  
            try{  

                canvas = this._surfaceHolder.lockCanvas(null);  
                synchronized (this._surfaceHolder) {  
                    this.onDraw(canvas);  
                }  

            }finally{  
                if(canvas != null){  
                    this._surfaceHolder.unlockCanvasAndPost(canvas);  
                }  
            }     
        }  

        protected void onDraw(Canvas canvas) {  
            this.renderBackGround(canvas);                
            for (Renderable renderable : this._sprites) {  
                renderable.render(canvas);  
            }  
        };  

        public void start(){  
            this.spriteThread.switchOn();  
        }  

        public void stop(){  
            boolean retry = true;  
            this.spriteThread.switchOff();  
            while (retry) {  
                try {  
                 this.spriteThread.join();  
                    retry = false;  
                } catch (InterruptedException e) {  
                    // we will try it again and again...  
                }  
            }  
        }  

        public int getLeft() {        
            return 0;  
        }  


        public int getRight() {  
            return this.theBackgroundImage.getWidth();  
        }  

        public void initialize(Context context, SurfaceHolder surfaceHolder) {  
            this.spriteThread = new SpriteThread(this);   
            this._surfaceHolder = surfaceHolder;          
            this._sprites = new ArrayList<Renderable>();  
            this._context = context;  
            BitmapFactory.Options options = new BitmapFactory.Options();  
            options.inPurgeable = true;  
            this.theBackgroundImage = oneBackImage;  
            this.addSprites();  
        }  


        private void addSprites() {       
            Point startPoint = new Point(100, 100);  
            this._sprites.add(new SpriteOne(this._context, this, startPoint, 90));  
            Point startPoint1 = new Point(100, 300);  
            this._sprites.add(new SpriteOne(this._context, this, startPoint1, 50));  

            Point startPoint2 = new Point(200, 200);  
            this._sprites.add(new SpriteOne(this._context, this, startPoint2, 15));  
        }  

        private void renderBackGround(Canvas canvas)  
        {  
            canvas.drawBitmap(this.theBackgroundImage, 0, 0, null);  
        }  
    }