simulator/app/DeviceManager.h

//
// Copyright 2005 The Android Open Source Project
//
// Class that manages the simulated device.
//
#ifndef _SIM_DEVICE_MANAGER_H
#define _SIM_DEVICE_MANAGER_H

#include "UserEvent.h"

#include "Shmem.h"
#include "MessageStream.h"
#include "SimRuntime.h"

#include "ui/PixelFormat.h"
#include "ui/KeycodeLabels.h"

#include <sys/stat.h>

/*
 * Manage the simulated device.  This includes starting/stopping as well
 * as sending messages to it and receiving events from it.
 *
 * The object may span multiple invocations of a specific device.  If
 * the simulator is reconfigured to use a device with different
 * characteristics, the object should be destroyed and recreated (which
 * guarantees that the runtime is restarted).
 */
class DeviceManager {
public:
    DeviceManager(void);
    virtual ~DeviceManager(void);

    /*
     * Initialize the object.  Call this once.
     *
     * "numDisplays" is the number of displays that the simulated hardware
     * supports.  The displays themselves are configured with separate calls.
     *
     * "statusWindow" should be the main frame.  Messages indicating runtime
     * startup/shutdown are sent, as well as error messages that should be
     * displayed in message boxes.
     */
    bool Init(int numDisplays, wxWindow* statusWindow);
    bool IsInitialized(void) const;

    /*
     * Tell the device manager that the windows used to display its output
     * are closing down.
     */
    void WindowsClosing(void);

    /*
     * "displayWindow" is the window to notify when a new frame of graphics
     * data is available.  This can be set independently for each display.
     */
    bool SetDisplayConfig(int displayIndex, wxWindow* window,
        int width, int height, android::PixelFormat format, int refresh);

    /*
     * set the key map
     */
    bool SetKeyboardConfig(const char *keymap);

    /*
     * Return the number of displays we're configured for.
     */
    int GetNumDisplays(void) const { return mNumDisplays; }

    /*
     * Return the shmem key for the Nth display.
     */
    //int GetShmemKey(int displayIndex);

    /*
     * Is the runtime process still running?
     */
    bool IsRunning(void) const {
        if (mThread != NULL)
            return mThread->IsRunning();
        return false;
    }
    bool IsKillable(void) const {
        return true;
    }

    // (Re-)configure the device, e.g. when #of displays changes because
    // a different phone model has been selected.  Call this before doing
    // any display-specific setup.  DO NOT call this if the runtime is active.
//    void Configure(int numDisplays);

    // start the runtime, acting as parent
    bool StartRuntime(void);
    // start the runtime, acting as peer
    bool StartRuntime(android::Pipe* reader, android::Pipe* writer);
    // politely ask the runtime to stop
    bool StopRuntime(void);
    // kill the runtime with extreme prejudice
    void KillRuntime(void);

#if 0
    // Returns if the executable is new
    bool RefreshRuntime(void);
    // Update the time of the current runtime because the user cancelled a
    // refresh
    void UserCancelledRefresh(void);
#endif

    // send a key-up or key-down event to the runtime
    void SendKeyEvent(KeyCode keyCode, bool down);
    // send touch-screen events
    void SendTouchEvent(android::Simulator::TouchMode mode, int x, int y);

    wxBitmap* GetImageData(int displayIndex);
    
    void BroadcastEvent(UserEvent &userEvent);

private:
    /*
     * Threads in wxWidgets use sub-classing to define interfaces and
     * entry points.  We use this to create the thread that interacts
     * with the runtime.
     *
     * The "reader" and "writer" arguments may be NULL.  If they are,
     * we will launch the runtime ourselves.  If not, we will use them
     * to speak with an externally-launched runtime process.  The thread
     * will own the pipes, shutting them down when it exits.
     */
    class DeviceThread : public wxThread {
    public:
        DeviceThread(DeviceManager* pDM, wxWindow* pStatusWindow,
            android::Pipe* reader, android::Pipe* writer)
            : wxThread(wxTHREAD_JOINABLE), mpStatusWindow(pStatusWindow),
              mReader(reader), mWriter(writer),
              mpDeviceManager(pDM), /*mTerminalFollowsChild(false),
              mSlowExit(false), mIsExternal(false), mLastModified(0),*/
              mRuntimeProcessGroup(0)
            {}
        virtual ~DeviceThread(void) {
            delete mReader;
            delete mWriter;
        }

        /* thread entry point */
        virtual void* Entry(void);

        // wxThread class supplies an IsRunning() method

        /*
         * This kills the runtime process to force this thread to exit.
         * If the thread doesn't exit after a short period of time, it
         * is forcibly terminated.
         */
        void KillChildProcesses(void);

#if 0
        /*
         * Return if the runtime executable is new
         */
        bool IsRuntimeNew(void);

        void UpdateLastModified(void);
#endif

        android::MessageStream* GetStream(void) { return &mStream; }

        static bool LaunchProcess(wxWindow* statusWindow);

    private:
        void WaitForDeath(int delay);
        void ResetProperties(void);

        android::MessageStream  mStream;
        wxWindow*       mpStatusWindow;
        android::Pipe*  mReader;
        android::Pipe*  mWriter;
        DeviceManager*  mpDeviceManager;
        pid_t           mRuntimeProcessGroup;
        //time_t          mLastModified;
        wxString        mRuntimeExe;
    };

    friend class DeviceThread;

    /*
     * We need one of these for each display on the device.  Most devices
     * only have one, but some flip phones have two.
     */
    class Display {
    public:
        Display(void)
            : mDisplayWindow(NULL), mpShmem(NULL), mShmemKey(0),
              mImageData(NULL), mDisplayNum(-1), mWidth(-1), mHeight(-1),
              mFormat(android::PIXEL_FORMAT_UNKNOWN), mRefresh(0)
            {}
        ~Display() {
            delete mpShmem;
            delete[] mImageData;
        }

        /* initialize goodies */
        bool Create(int displayNum, wxWindow* window, int width, int height,
            android::PixelFormat format, int refresh);

        /* call this if we're shutting down soon */
        void Uncreate(void);

        /* copy & convert data from shared memory */
        void CopyFromShared(void);

        /* get image data in the form of a 24bpp bitmap */
        wxBitmap* GetImageData(void);

        /* get a pointer to our display window */
        wxWindow* GetWindow(void) const { return mDisplayWindow; }

        /* get our shared memory key */
        int GetShmemKey(void) const { return mShmemKey; }

        int GetWidth(void) const { return mWidth; }
        int GetHeight(void) const { return mHeight; }
        android::PixelFormat GetFormat(void) const { return mFormat; }
        int GetRefresh(void) const { return mRefresh; }

    private:
        int GenerateKey(int displayNum) {
            return 0x41544d00 | displayNum;
        }

        // control access to image data shared between runtime mgr and UI
        wxMutex         mImageDataLock;
        // we send an event here when we get stuff to display
        wxWindow*       mDisplayWindow;

        // shared memory segment
        android::Shmem* mpShmem;
        int             mShmemKey;

        // local copy of data from shared mem, converted to 24bpp
        unsigned char*  mImageData;

        // mainly for debugging -- which display are we?
        int             mDisplayNum;

        // display characteristics
        int             mWidth;
        int             mHeight;
        android::PixelFormat mFormat;
        int             mRefresh;       // fps
    };

    Display* GetDisplay(int dispNum) { return &mDisplay[dispNum]; }

    const char* GetKeyMap() { return mKeyMap ? mKeyMap : "qwerty"; }

    void ShowFrame(int displayIndex);

    void Vibrate(int vibrateOn);

    // get the message stream from the device thread
    android::MessageStream* GetStream(void);

    // send a request to set the visible layers
    void SendSetVisibleLayers(void);

    // points at the runtime's thread (while it's running)
    DeviceThread*   mThread;

    // array of Displays, one per display on the device
    Display*        mDisplay;
    int             mNumDisplays;

    // the key map
    const char * mKeyMap;

    // which graphics layers are visible?
    int             mVisibleLayers;

    // where to send status messages
    wxWindow*       mpStatusWindow;

};

#endif // _SIM_DEVICE_MANAGER_H