simulator/app/DeviceManager.h - fp2-dev/platform/development - Gitiles

 //
 // 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
	//
	// 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