screenengine.java

Sony Ericsson手机上的Facebook客户端全套代码

// Decompiled by Jad v1.5.7g. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   ScreenEngine.java

package se.southend.drops.screen;

import com.sonyericsson.homescreen.Homescreen;
import java.util.Vector;
import javax.microedition.lcdui.*;
import se.southend.drops.integeraffector.AffectorHandler;
import se.southend.drops.scene.Node;
import se.southend.drops.scene.World;

// Referenced classes of package se.southend.drops.screen:
//            Layer, CanvasListener, ScreenCanvas, KeyHandler, 
//            ScreenMidletHS, ScreenMidlet, Log

public class ScreenEngine
    implements Runnable
{

    private ScreenEngine()
    {
        _homeScreenInStandby = true;
        frameCount = 0;
        init();
    }

    public static ScreenEngine getInstance()
    {
        if(instance == null)
            instance = new ScreenEngine();
        return instance;
    }

    public void init()
    {
        canvas = ScreenCanvas.getInstance();
        setScreenProperties();
        keyHandler = KeyHandler.getInstance();
        keyHandler.setCanvas(canvas);
        flushGraphics = true;
        frameSleep = 1;
        gametime = System.currentTimeMillis();
        homescreen = null;
    }

    public ScreenCanvas getCanvas()
    {
        return canvas;
    }

    public void keyPressed(int keyCode)
    {
        keyHandler.keyPressed(keyCode);
    }

    public void keyReleased(int keyCode)
    {
        keyHandler.keyReleased(keyCode);
    }

    public KeyHandler getKeyHandler()
    {
        return keyHandler;
    }

    public int getFrameSleep()
    {
        return frameSleep;
    }

    public void setGraphics(Graphics graphics)
    {
        this.graphics = graphics;
    }

    public Graphics getDefaultGraphics()
    {
        return defaultGraphics;
    }

    public void setFlushGraphics(boolean flushGraphics)
    {
        this.flushGraphics = flushGraphics;
    }

    public void setFlushAreas(int flushAreas[][])
    {
        this.flushAreas = flushAreas;
    }

    public void setFrameSleep(int milliseconds)
    {
        frameSleep = milliseconds;
    }

    public void exit()
    {
        destroy();
        if(isRunningOnHomescreen())
            ScreenMidletHS.getInstance().die();
        else
            ScreenMidlet.getInstance().die();
    }

    public void pause()
    {
        if(pausetime == 0L)
            pausetime = System.currentTimeMillis();
    }

    public void resume()
    {
        timeshift += System.currentTimeMillis() - pausetime;
        pausetime = 0L;
    }

    public synchronized void destroy()
    {
        Log.println("destroy()");
        stopping = true;
        starting = false;
        running = true;
    }

    public synchronized void stop()
    {
        Log.println("stop()");
        stopping = true;
    }

    public synchronized void start()
    {
        Log.println("start()");
        if(running)
        {
            starting = true;
        } else
        {
            running = true;
            (new Thread(this)).start();
        }
    }

    public void run()
    {
        int FRAMES_TO_COUNT = 30;
        int counter = 0;
        start = System.currentTimeMillis();
        timeshift = start - gametime;
        while(!stopping) 
            try
            {
                step();
                if(frameSleep > 0)
                {
                    if(flushGraphics)
                        if(flushAreas == null)
                        {
                            canvas.repaint();
                            canvas.serviceRepaints();
                        } else
                        {
                            for(int i = 0; i < flushAreas.length; i++)
                            {
                                canvas.repaint(flushAreas[i][0], flushAreas[i][1], flushAreas[i][2], flushAreas[i][3]);
                                canvas.serviceRepaints();
                            }

                        }
                    try
                    {
                        Thread.sleep(frameSleep);
                    }
                    catch(Exception e) { }
                } else
                {
                    try
                    {
                        Thread.sleep(100L);
                    }
                    catch(Exception e) { }
                }
            }
            catch(Throwable e)
            {
                e.printStackTrace();
            }
        System.gc();
        stopping = false;
        if(starting)
        {
            starting = false;
            (new Thread(this)).start();
        } else
        {
            running = false;
        }
    }

    public void step()
    {
        for(long realtime = System.currentTimeMillis() - timeshift; running && gametime <= realtime; gametime += 20L)
        {
            input(keyHandler);
            keyHandler.updateKeys();
            process();
        }

    }

    public void process()
    {
        AffectorHandler.getInstance().process(gametime);
        Vector layers = Layer.layersByProcessingOrder();
        int nbrLayers = layers != null ? layers.size() : 0;
        for(int i = 0; i < nbrLayers; i++)
        {
            Layer layer = (Layer)layers.elementAt(i);
            layer.process();
        }

    }

    public void render(Graphics graphics)
    {
        Vector layers = Layer.layersByVisibilityOrder();
        int nbrLayers = layers != null ? layers.size() : 0;
        for(int i = 0; i < nbrLayers; i++)
        {
            Layer layer = (Layer)layers.elementAt(i);
            if(layer.isVisible())
                layer.paint(graphics);
        }

    }

    public void input(KeyHandler keyHandler)
    {
        Vector layers = Layer.layersByProcessingOrder();
        for(int nbrLayers = layers != null ? layers.size() - 1 : 0; nbrLayers >= 0; nbrLayers = Math.min(nbrLayers - 1, layers.size() - 1))
        {
            Layer layer = (Layer)layers.elementAt(nbrLayers);
            if(layer.isVisible() && layer.isInputEnabled())
                layer.input(keyHandler);
        }

    }

    public long getTime()
    {
        return gametime;
    }

    public long getStartTime()
    {
        return start;
    }

    public void syncTime()
    {
        gametime = System.currentTimeMillis();
    }

    public void notifyListeners(int event)
    {
        int nbrCanvasListeners = canvasListeners == null ? 0 : canvasListeners.size();
        for(int i = 0; i < nbrCanvasListeners; i++)
        {
            CanvasListener listener = (CanvasListener)canvasListeners.elementAt(i);
            listener.processEvent(event);
        }

    }

    public void addListener(CanvasListener listener)
    {
        if(canvasListeners == null)
            canvasListeners = new Vector();
        canvasListeners.addElement(listener);
    }

    public void removeListener(CanvasListener listener)
    {
        if(canvasListeners != null)
            canvasListeners.removeElement(listener);
    }

    public void removeAllListeners()
    {
        if(canvasListeners != null)
            canvasListeners.removeAllElements();
    }

    public void showNotify()
    {
        try
        {
            Thread.sleep(100L);
        }
        catch(Exception e) { }
        show();
    }

    public void hideNotify()
    {
        Log.println("hideNotify()");
        hide();
    }

    private synchronized void show()
    {
        if(!visible)
        {
            visible = true;
            Log.println("starting", Log.INFO);
            notifyListeners(1);
            start();
        }
    }

    private synchronized void hide()
    {
        if(visible)
        {
            visible = false;
            Log.println("stopping");
            notifyListeners(0);
            stop();
        }
    }

    public void paint(Graphics g)
    {
        setGraphics(g);
        render(g);
    }

    public void setFullScreenMode(boolean fullScreenMode)
    {
        canvas.setFullScreenMode(fullScreenMode);
        setScreenProperties();
    }

    public void setScreenProperties()
    {
        Node.SCREEN_WIDTH = canvas.getWidth();
        Node.SCREEN_HEIGHT = canvas.getHeight();
        if(Node.SCREEN_WIDTH > Node.SCREEN_HEIGHT)
        {
            int tmp = Node.SCREEN_HEIGHT;
            Node.SCREEN_HEIGHT = Node.SCREEN_WIDTH;
            Node.SCREEN_WIDTH = tmp;
        }
        Node.SCREEN_HALF_WIDTH = Node.SCREEN_WIDTH / 2;
        Node.SCREEN_HALF_HEIGHT = Node.SCREEN_HEIGHT / 2;
        Node.SCREEN_TOP = -Node.SCREEN_HEIGHT / 2;
        Node.SCREEN_BOTTOM = Node.SCREEN_HEIGHT / 2;
        Node.SCREEN_LEFT = -Node.SCREEN_WIDTH / 2;
        Node.SCREEN_RIGHT = Node.SCREEN_WIDTH / 2;
        Log.println("Setting screen size: " + Node.SCREEN_WIDTH + " * " + Node.SCREEN_HEIGHT);
    }

    public void setHomescreen(Homescreen homescreen)
    {
        this.homescreen = homescreen;
        if(homescreen != null)
            canvas.setPaintMode(false);
    }

    public boolean isRunningOnHomescreen()
    {
        return homescreen != null;
    }

    public Homescreen getHomescreen()
    {
        return homescreen;
    }

    public void setHomescreenInStandby(boolean standBy)
    {
        if(standBy)
            homescreen.enterStandby();
        else
            homescreen.leaveStandby();
        _homeScreenInStandby = standBy;
    }

    public boolean isHomescreenInStandby()
    {
        return _homeScreenInStandby;
    }

    public static final int INTERNAL_FPS = 50;
    public static final int PERIOD = 20;
    private boolean starting;
    private boolean stopping;
    private boolean running;
    private boolean showFps;
    private long gametime;
    private long timeshift;
    private int frameSleep;
    private boolean flushGraphics;
    private int flushAreas[][];
    private KeyHandler keyHandler;
    private Vector canvasListeners;
    private ScreenCanvas canvas;
    private Graphics defaultGraphics;
    private Graphics graphics;
    private boolean visible;
    private Homescreen homescreen;
    private boolean _homeScreenInStandby;
    private static ScreenEngine instance;
    private long pausetime;
    private String fpsString;
    private static String fpsLabel = "FPS: ";
    private static String fpsDot = ".";
    long start;
    private int frameCount;

}