| // |
| // Copyright 2005 The Android Open Source Project |
| // |
| // Management of the simulated device. |
| // |
| |
| // For compilers that support precompilation, include "wx/wx.h". |
| #include "wx/wxprec.h" |
| |
| // Otherwise, include all standard headers |
| #ifndef WX_PRECOMP |
| # include "wx/wx.h" |
| #endif |
| #include "wx/image.h" |
| |
| #include "DeviceManager.h" |
| #include "MyApp.h" |
| #include "DeviceWindow.h" |
| #include "LogWindow.h" |
| #include "UserEvent.h" |
| #include "UserEventMessage.h" |
| |
| #include "SimRuntime.h" |
| #include "utils.h" |
| |
| #include <unistd.h> |
| #include <signal.h> |
| #include <errno.h> |
| |
| #if !defined(SIGKILL) // doesn't exist in MinGW |
| # if defined(SIGBREAK) |
| # define SIGKILL SIGBREAK // intended for Ctrl-Break |
| # else |
| # define SIGKILL SIGABRT |
| # endif |
| #endif |
| |
| |
| /* |
| * Constructor. |
| */ |
| DeviceManager::DeviceManager(void) |
| : mThread(NULL), mDisplay(NULL), mNumDisplays(0), mKeyMap(NULL), |
| mpStatusWindow(NULL) |
| { |
| //printf("--- DeviceManager constructor\n"); |
| } |
| |
| /* |
| * Destructor. Snuff the thread if it's still kicking. |
| */ |
| DeviceManager::~DeviceManager(void) |
| { |
| //printf("--- DeviceManager destructor\n"); |
| |
| if (mThread != NULL && mThread->IsRunning()) { |
| mThread->KillChildProcesses(); |
| } |
| if (mThread != NULL) { |
| wxThread::ExitCode code; |
| |
| printf("Sim: Waiting for old runtime thread..."); fflush(stdout); |
| code = mThread->Wait(); // join the old thread |
| printf("done (code=%ld)\n", (long) code); |
| } |
| delete mThread; |
| mThread = NULL; |
| |
| delete[] mDisplay; |
| free((void*)mKeyMap); |
| } |
| |
| /* |
| * Initialize the device configuration. |
| * |
| * "statusWindow" is where message boxes with failure messages go, usually |
| * the main frame. |
| */ |
| bool DeviceManager::Init(int numDisplays, wxWindow* statusWindow) |
| { |
| //if (IsRunning()) { |
| // fprintf(stderr, "ERROR: tried to Configure device while running\n"); |
| // return false; |
| //} |
| assert(mDisplay == NULL); |
| assert(numDisplays > 0); |
| |
| //if (mDisplay != NULL) |
| // delete[] mDisplay; |
| |
| mDisplay = new Display[numDisplays]; |
| mNumDisplays = numDisplays; |
| |
| mpStatusWindow = statusWindow; |
| |
| return true; |
| } |
| |
| /* |
| * Have we been initialized already? |
| */ |
| bool DeviceManager::IsInitialized(void) const |
| { |
| return (mDisplay != NULL); |
| } |
| |
| #if 0 |
| /* |
| * Return the Nth display. |
| */ |
| int DeviceManager::GetShmemKey(int displayIndex) |
| { |
| assert(displayIndex >= 0 && displayIndex < mNumDisplays); |
| return mDisplay[displayIndex].GetShmemKey(); |
| } |
| #endif |
| |
| /* |
| * Define mapping between the device's display and a wxWidgets window. |
| */ |
| bool DeviceManager::SetDisplayConfig(int displayIndex, wxWindow* window, |
| int width, int height, android::PixelFormat format, int refresh) |
| { |
| assert(displayIndex >= 0 && displayIndex < mNumDisplays); |
| |
| if (!mDisplay[displayIndex].Create(displayIndex, window, width, height, |
| format, refresh)) |
| { |
| fprintf(stderr, "Sim: ERROR: unable to configure display %d\n", |
| displayIndex); |
| return false; |
| } else { |
| printf("Sim: configured display %d (w=%d h=%d f=%d re=%d)\n", |
| displayIndex, width, height, format, refresh); |
| return true; |
| } |
| } |
| |
| /* |
| * Define the keyboard |
| */ |
| bool DeviceManager::SetKeyboardConfig(const char *keymap) { |
| free((void*)mKeyMap); |
| mKeyMap = strdup(keymap); |
| return true; |
| } |
| |
| /* |
| * Called before the phone window dialog destroys itself. The goal here |
| * is to prevent the runtime thread from trying to draw after the phone |
| * window has closed for business but before the device manager destructor |
| * gets called. |
| */ |
| void DeviceManager::WindowsClosing(void) |
| { |
| int i; |
| |
| for (i = 0; i < mNumDisplays; i++) |
| mDisplay[i].Uncreate(); |
| } |
| |
| /* |
| * Launch a new runtime process. If there is an existing device manager |
| * thread, we assume that it is in the process of shutting down. |
| */ |
| bool DeviceManager::StartRuntime(void) |
| { |
| return DeviceManager::DeviceThread::LaunchProcess(mpStatusWindow); |
| } |
| |
| /* |
| * Start the runtime management thread when a runtime connects to us. If |
| * there is an existing thread, we assume that it is in the process of |
| * shutting down. |
| */ |
| bool DeviceManager::StartRuntime(android::Pipe* reader, android::Pipe* writer) |
| { |
| if (mThread != NULL) { |
| wxThread::ExitCode code; |
| |
| if (mThread->IsRunning()) { |
| fprintf(stderr, |
| "Sim: ERROR: start requested, but thread running\n"); |
| return false; |
| } |
| |
| // clean up old thread |
| printf("Sim: Waiting for old runtime thread..."); fflush(stdout); |
| code = mThread->Wait(); // join the old thread |
| printf("done (code=%ld)\n", (long) code); |
| |
| delete mThread; |
| mThread = NULL; |
| } |
| |
| assert(mpStatusWindow != NULL); |
| mThread = new DeviceThread(this, mpStatusWindow, reader, writer); |
| if (mThread->Create() != wxTHREAD_NO_ERROR) { |
| fprintf(stderr, "Sim: ERROR: can't create thread\n"); |
| return false; |
| } |
| mThread->Run(); |
| |
| return true; |
| } |
| |
| /* |
| * Get the message stream. Returns NULL if it doesn't exist. |
| */ |
| android::MessageStream* DeviceManager::GetStream(void) |
| { |
| if (!IsRunning()) { |
| fprintf(stderr, "Sim: ERROR: runtime thread not active\n"); |
| return NULL; |
| } |
| |
| assert(mThread != NULL); |
| android::MessageStream* pStream = mThread->GetStream(); |
| assert(pStream != NULL); |
| |
| if (!pStream->isReady()) { |
| fprintf(stderr, "Sim: NOTE: connection to runtime not ready\n"); |
| return NULL; |
| } |
| |
| return pStream; |
| } |
| |
| /* |
| * Stop the runtime, politely. |
| * |
| * We don't clean up the thread here, because it might not exit immediately. |
| */ |
| bool DeviceManager::StopRuntime(void) |
| { |
| android::MessageStream* pStream = GetStream(); |
| if (pStream == NULL) |
| return false; |
| |
| printf("Sim: Sending quit command\n"); |
| |
| android::Message msg; |
| msg.setCommand(android::Simulator::kCommandQuit, 0); |
| pStream->send(&msg); |
| return true; |
| } |
| |
| /* |
| * Kill the runtime as efficiently as possible. |
| */ |
| void DeviceManager::KillRuntime(void) |
| { |
| if (mThread != NULL && mThread->IsRunning()) |
| mThread->KillChildProcesses(); |
| } |
| |
| #if 0 |
| /* |
| * Check if the modified time is newer than mLastModified |
| */ |
| bool DeviceManager::RefreshRuntime(void) |
| { |
| return (IsRunning() && mThread->IsRuntimeNew()); |
| } |
| |
| /* |
| * Tells the device manager that the user does not want to update |
| * the runtime |
| */ |
| void DeviceManager::UserCancelledRefresh(void) |
| { |
| mThread->UpdateLastModified(); |
| } |
| #endif |
| |
| /* |
| * Send an event to the runtime. |
| * |
| * The events are defined in display_device.h. |
| */ |
| void DeviceManager::SendKeyEvent(int32_t keyCode, bool down) |
| { |
| android::MessageStream* pStream = GetStream(); |
| if (pStream == NULL) |
| return; |
| |
| int event = down ? android::Simulator::kCommandKeyDown : |
| android::Simulator::kCommandKeyUp; |
| |
| //printf("Sim: sending key-%s %d\n", down ? "down" : "up", keyCode); |
| |
| android::Message msg; |
| msg.setCommand(event, keyCode); |
| pStream->send(&msg); |
| } |
| |
| /* |
| * Send a "touch screen" event to the runtime. |
| * |
| * "mode" can be "down" (we're pressing), "up" (we're lifting our finger |
| * off) or "drag". |
| */ |
| void DeviceManager::SendTouchEvent(android::Simulator::TouchMode mode, |
| int x, int y) |
| { |
| android::MessageStream* pStream = GetStream(); |
| if (pStream == NULL) |
| return; |
| |
| //printf("Sim: sending touch-%d x=%d y=%d\n", (int) mode, x, y); |
| |
| android::Message msg; |
| msg.setCommandExt(android::Simulator::kCommandTouch, mode, x, y); |
| pStream->send(&msg); |
| } |
| |
| /* |
| * The runtime has sent us a new frame of stuff to display. |
| * |
| * NOTE: we're still in the runtime management thread. We have to pass the |
| * bitmap through AddPendingEvent to get it over to the main thread. |
| * |
| * We have to make a copy of the data from the runtime; the easiest |
| * way to do that is to convert it to a bitmap here. However, X11 gets |
| * all worked up about calls being made from multiple threads, so we're |
| * better off just copying it into a buffer. |
| * |
| * Because we're decoupled from the runtime, there is a chance that we |
| * could drop frames. Buffering them up is probably worse, since it |
| * creates the possibility that we could stall and run out of memory. |
| * We could save a copy by handing the runtime a pointer to our buffer, |
| * but then we'd have to mutex the runtime against the simulator window |
| * Paint function. |
| */ |
| void DeviceManager::ShowFrame(int displayIndex) |
| { |
| assert(displayIndex >= 0 && displayIndex < mNumDisplays); |
| |
| // copy the data to local storage and convert |
| mDisplay[displayIndex].CopyFromShared(); |
| |
| // create a user event and send it to the window |
| UserEvent uev(0, (void*) displayIndex); |
| |
| wxWindow* pEventWindow = mDisplay[displayIndex].GetWindow(); |
| if (pEventWindow != NULL) { |
| //printf("runtime has image, passing up\n"); |
| pEventWindow->AddPendingEvent(uev); |
| } else { |
| fprintf(stderr, "NOTE: runtime has image, display not available\n"); |
| } |
| } |
| |
| void DeviceManager::Vibrate(int vibrateOn) |
| { |
| ((MyApp*)wxTheApp)->Vibrate(vibrateOn); |
| } |
| |
| /* |
| * Get the display data from the specified display. |
| */ |
| wxBitmap* DeviceManager::GetImageData(int displayIndex) |
| { |
| assert(displayIndex >= 0 && displayIndex < mNumDisplays); |
| return mDisplay[displayIndex].GetImageData(); |
| } |
| |
| /* |
| * Send an event to all device windows |
| */ |
| void DeviceManager::BroadcastEvent(UserEvent& userEvent) { |
| int numDisplays = GetNumDisplays(); |
| for (int i = 0; i < numDisplays; i++) { |
| wxWindow* pEventWindow = mDisplay[i].GetWindow(); |
| if (pEventWindow != NULL) { |
| pEventWindow->AddPendingEvent(userEvent); |
| } |
| } |
| } |
| |
| |
| /* |
| * =========================================================================== |
| * DeviceManager::Display |
| * =========================================================================== |
| */ |
| |
| /* |
| * Fill out the various interesting fields based on the parameters. |
| */ |
| bool DeviceManager::Display::Create(int displayNum, wxWindow* window, |
| int width, int height, android::PixelFormat format, int refresh) |
| { |
| //printf("DeviceManager::Display constructor\n"); |
| |
| assert(window != NULL); |
| if (mImageData != NULL) { |
| assert(false); // no re-init |
| return false; |
| } |
| |
| mDisplayNum = displayNum; |
| mDisplayWindow = window; |
| mWidth = width; |
| mHeight = height; |
| mFormat = format; |
| mRefresh = refresh; |
| |
| // use a fixed key for now |
| mShmemKey = GenerateKey(displayNum); |
| // allocate 24bpp for now |
| mpShmem = new android::Shmem; |
| if (!mpShmem->create(mShmemKey, width * height * 3, true)) |
| return false; |
| //printf("--- CREATED shmem, key=0x%08x addr=%p\n", |
| // mShmemKey, mpShmem->getAddr()); |
| |
| mImageData = new unsigned char[width * height * 3]; |
| if (mImageData == NULL) |
| return false; |
| |
| return true; |
| } |
| |
| /* |
| * The UI components are starting to shut down. We need to do away with |
| * our wxWindow pointer so that the runtime management thread doesn't try |
| * to send it display update events. |
| * |
| * We also need to let go of our side of the shared memory, because a |
| * new DeviceManager may get started up before our destructor gets called, |
| * and we may be re-using the key. |
| */ |
| void DeviceManager::Display::Uncreate(void) |
| { |
| wxMutexLocker locker(mImageDataLock); |
| |
| //printf("--- Uncreate\n"); |
| |
| mDisplayWindow = NULL; |
| |
| // the "locker" mutex keeps this from hosing CopyFromShared() |
| if (mpShmem != NULL) { |
| //printf("--- DELETING shmem, addr=%p\n", mpShmem->getAddr()); |
| delete mpShmem; |
| mpShmem = NULL; |
| } |
| } |
| |
| /* |
| * Make a local copy of the image data. The UI grabs this data from a |
| * different thread, so we have to mutex it. |
| */ |
| void DeviceManager::Display::CopyFromShared(void) |
| { |
| wxMutexLocker locker(mImageDataLock); |
| |
| if (mpShmem == NULL) { |
| //printf("Sim: SKIP CopyFromShared\n"); |
| return; |
| } |
| |
| //printf("Display %d: copying data from %p to %p\n", |
| // mDisplayNum, mpShmem->getAddr(), mImageData); |
| |
| /* data is always 24bpp RGB */ |
| mpShmem->lock(); // avoid tearing |
| memcpy(mImageData, mpShmem->getAddr(), mWidth * mHeight * 3); |
| mpShmem->unlock(); |
| } |
| |
| /* |
| * Get the image data in the form of a newly-allocated bitmap. |
| * |
| * This MUST be called from the UI thread. Creating wxBitmaps in the |
| * runtime management thread will cause X11 failures (e.g. |
| * "Xlib: unexpected async reply"). |
| */ |
| wxBitmap* DeviceManager::Display::GetImageData(void) |
| { |
| wxMutexLocker locker(mImageDataLock); |
| |
| assert(mImageData != NULL); |
| |
| //printf("HEY: creating tmpImage, w=%d h=%d data=%p\n", |
| // mWidth, mHeight, mImageData); |
| |
| /* create a temporary wxImage; it does not own the data */ |
| wxImage tmpImage(mWidth, mHeight, (unsigned char*) mImageData, true); |
| |
| /* return a new bitmap with the converted-for-display data */ |
| return new wxBitmap(tmpImage); |
| } |
| |
| |
| /* |
| * =========================================================================== |
| * DeviceManager::DeviceThread |
| * =========================================================================== |
| */ |
| |
| /* |
| * Some notes on process management under Linux/Mac OS X: |
| * |
| * We want to put the runtime into its own process group. That way we |
| * can send SIGKILL to the entire group to guarantee that we kill it and |
| * all of its children. Simply killing the sim's direct descendant doesn't |
| * do what we want. If it's a debugger, we will just orphan the runtime |
| * without killing it. Even if the runtime is our child, the children of |
| * the runtime might outlive it. |
| * |
| * We want to be able to run the child under GDB or Valgrind, both |
| * of which take input from the tty. They need to be in the "foreground" |
| * process group. We might be debugging or valgrinding the simulator, |
| * or operating in a command-line-only "headless" mode, so in that case |
| * the sim front-end should actually be in the foreground group. |
| * |
| * Putting the runtime in the background group means it can't read input |
| * from the tty (not an issue) and will generate SIGTTOU signals when it |
| * writes output to the tty (easy to ignore). The trick, then, is to |
| * have the simulator and gdb/valgrind in the foreground pgrp while the |
| * runtime itself is in a different group. This group needs to be known |
| * to the simulator so that it can send signals to the appropriate place. |
| * |
| * The solution is to have the runtime process change its process group |
| * after it starts but before it creates any new processes, and then send |
| * the process group ID back to the simulator. The sim can then send |
| * signals to the pgrp to ensure that we don't end up with zombies. Any |
| * "pre-launch" processes, like GDB, stay in the sim's pgrp. This also |
| * allows a consistent API for platforms that don't have fork/exec |
| * (e.g. MinGW). |
| * |
| * This doesn't help us with interactive valgrind (e.g. --db-attach=yes), |
| * because valgrind is an LD_PRELOAD shared library rather than a |
| * separate process. For that, we actually need to use termios(3) to |
| * change the terminal's pgrp, or the interactive stuff just doesn't work. |
| * We don't want to do that every time or attempting to debug the simulator |
| * front-end will have difficulties. |
| * |
| * Making this even more entertaining is the fact that the simulator |
| * front-end could itself be launched in the background. It's essential |
| * that we be careful about assigning a process group to the foreground, |
| * and that we don't restore ourselves unless we were in the foreground to |
| * begin with. |
| * |
| * |
| * Some notes on process management under Windows (Cygwin, MinGW): |
| * |
| * Signals cannot be caught or ignored under MinGW. All signals are fatal. |
| * |
| * Signals can be ignored under Cygwin, but not caught. |
| * |
| * Windows has some process group stuff (e.g. CREATE_NEW_PROCESS_GROUP flag |
| * and GenerateConsoleCtrlEvent()). Need to explore. |
| * |
| * |
| * UPDATE: we've abandoned Mac OS and MinGW, so we now launch the runtime in |
| * a separate xterm. This avoids all tty work on our side. We still need |
| * to learn the pgrp from the child during the initial communication |
| * handshake so we can do necessary cleanup. |
| */ |
| |
| |
| /* |
| * Convert a space-delimited string into an argument vector. |
| * |
| * "arg" is the current arg offset. |
| */ |
| static int stringToArgv(char* mangle, const char** argv, int arg, int maxArgs) |
| { |
| bool first = true; |
| |
| while (*mangle != '\0') { |
| assert(arg < maxArgs); |
| if (first) { |
| argv[arg++] = mangle; |
| first = false; |
| } |
| if (*mangle == ' ') { |
| *mangle = '\0'; |
| first = true; |
| } |
| mangle++; |
| } |
| |
| return arg; |
| } |
| |
| /* |
| * Launch the runtime process in its own terminal window. Start by setting |
| * up the argument vector to the runtime process. |
| * |
| * The last entry in the vector will be a NULL pointer. |
| * |
| * This is awkward and annoying because the wxWidgets strings are current |
| * configured for UNICODE. |
| */ |
| /*static*/ bool DeviceManager::DeviceThread::LaunchProcess(wxWindow* statusWindow) |
| { |
| static const char* kLaunchWrapper = "launch-wrapper"; |
| const int kMaxArgs = 64; |
| Preferences* pPrefs; |
| wxString errMsg; |
| wxString runtimeExe; |
| wxString debuggerExe; |
| wxString debuggerScript; |
| wxString valgrinderExe; |
| wxString launchWrapperExe; |
| wxString launchWrapperArgs; |
| wxString javaAppName; |
| wxString termCmd; |
| wxString tmpStr; |
| char gammaVal[8]; |
| //bool bval; |
| double dval; |
| bool result = false; |
| bool doDebug, doValgrind, doCheckJni, doEnableSound, doEnableFakeCamera; |
| const char** argv = NULL; |
| int arg; |
| wxCharBuffer runtimeExeTmp; |
| wxCharBuffer debuggerExeTmp; |
| wxCharBuffer debuggerScriptTmp; |
| wxCharBuffer javaAppNameTmp; |
| wxCharBuffer valgrinderExeTmp; |
| wxCharBuffer termCmdTmp; |
| wxCharBuffer launchWrapperExeTmp; |
| wxCharBuffer launchWrapperArgsTmp; |
| |
| pPrefs = ((MyApp*)wxTheApp)->GetPrefs(); |
| if (pPrefs == NULL) { |
| errMsg = wxT("Preferences were not loaded."); |
| goto bail; |
| } |
| |
| /* |
| * Set environment variables. This stuff should be passed through as |
| * arguments, but the runtime binary currently has a disconnect |
| * between main() and the VM initilization. |
| * |
| * TODO: remove this in favor of system properties |
| */ |
| #if 0 |
| // TODO: restore this |
| doCheckJni = false; |
| pPrefs->GetBool("check-jni", &doCheckJni); |
| #endif |
| |
| tmpStr.Empty(); |
| pPrefs->GetString("ld-assume-kernel", /*ref*/ tmpStr); |
| if (tmpStr.IsEmpty()) { |
| unsetenv("LD_ASSUME_KERNEL"); |
| } else { |
| setenv("LD_ASSUME_KERNEL", tmpStr.ToAscii(), 1); |
| } |
| |
| doEnableSound = false; |
| pPrefs->GetBool("enable-sound", &doEnableSound); |
| if (doEnableSound) |
| setenv("ANDROIDSOUND", "1", 1); |
| |
| doEnableFakeCamera = false; |
| pPrefs->GetBool("enable-fake-camera", &doEnableFakeCamera); |
| if (doEnableFakeCamera) |
| setenv("ANDROIDFAKECAMERA", "1", 1); |
| |
| /* |
| * Set the Dalvik bootstrap class path. Normally this is set by "init". |
| */ |
| setenv("BOOTCLASSPATH", |
| "/system/framework/core.jar:/system/framework/ext.jar:/system/framework/framework.jar:/system/framework/android.policy.jar:/system/framework/services.jar", |
| 1); |
| |
| /* |
| * Figure out where the "runtime" binary lives. |
| */ |
| runtimeExe = ((MyApp*)wxTheApp)->GetRuntimeExe(); |
| assert(!runtimeExe.IsEmpty()); |
| |
| //UpdateLastModified(); |
| |
| /* |
| * Initialize argv. |
| */ |
| argv = new const char*[kMaxArgs]; |
| if (argv == NULL) |
| goto bail; |
| arg = 0; |
| |
| /* |
| * We want to launch the runtime in its own terminal window so we don't |
| * have to fight over who gets access to the controlling tty. We allow |
| * the user to specify the command they want to use to perform the |
| * launch. Here we cut it into pieces for argv. |
| * |
| * To make life easier here, we require that the launch command be |
| * all one piece, i.e. it's not "xterm -e <stuff> -geom blah" with our |
| * stuff in the middle. |
| */ |
| termCmd.Empty(); |
| pPrefs->GetString("launch-command", /*ref*/ termCmd); |
| if (termCmd.IsEmpty()) { |
| fprintf(stderr, "Sim: WARNING: launch-command is empty\n"); |
| } else { |
| termCmdTmp = termCmd.ToAscii(); |
| char* mangle = strdup(termCmdTmp); |
| arg = stringToArgv(mangle, argv, arg, kMaxArgs); |
| } |
| |
| /* |
| * The "launch-wrapper" binary lives in the same place as the runtime. |
| * This sets up LD_PRELOAD and some other environment variables. |
| */ |
| int charIdx; |
| |
| charIdx = runtimeExe.Find('/', true); |
| if (charIdx == -1) { |
| launchWrapperExe = wxString::FromAscii(kLaunchWrapper); |
| } else { |
| launchWrapperExe = runtimeExe.Mid(0, charIdx+1); |
| launchWrapperExe.Append(wxString::FromAscii(kLaunchWrapper)); |
| } |
| printf("Sim launch wrapper: %s\n", (const char*)launchWrapperExe.ToAscii()); |
| |
| argv[arg++] = launchWrapperExeTmp = launchWrapperExe.ToAscii(); |
| |
| launchWrapperArgs.Empty(); |
| pPrefs->GetString("launch-wrapper-args", /*ref*/ launchWrapperArgs); |
| if (!launchWrapperArgs.IsEmpty()) { |
| launchWrapperArgsTmp = launchWrapperArgs.ToAscii(); |
| char* mangle = strdup(launchWrapperArgsTmp); |
| arg = stringToArgv(mangle, argv, arg, kMaxArgs); |
| } |
| |
| /* |
| * If we're launching under GDB or valgrind, set that up. |
| */ |
| doDebug = doValgrind = false; |
| pPrefs->GetBool("debug", &doDebug); |
| if (((MyApp*)wxTheApp)->GetDebuggerOption()) { |
| doDebug = true; |
| } |
| debuggerScript = ((MyApp*)wxTheApp)->GetDebuggerScript(); |
| |
| pPrefs->GetBool("valgrind", &doValgrind); |
| if (doDebug || doValgrind) { |
| |
| pPrefs->GetString("debugger", /*ref*/ debuggerExe); |
| pPrefs->GetString("valgrinder", /*ref*/ valgrinderExe); |
| |
| // check for empty or undefined preferences |
| if (doDebug && debuggerExe.IsEmpty()) { |
| errMsg = wxT("Debugger not defined."); |
| goto bail; |
| } |
| if (doValgrind && valgrinderExe.IsEmpty()) { |
| errMsg = wxT("Valgrinder not defined."); |
| goto bail; |
| } |
| |
| if (doValgrind) { |
| argv[arg++] = valgrinderExeTmp = valgrinderExe.ToAscii(); |
| //argv[arg++] = "--tool=callgrind"; |
| argv[arg++] = "--tool=memcheck"; |
| argv[arg++] = "--leak-check=yes"; // check for leaks too |
| argv[arg++] = "--leak-resolution=med"; // increase from 2 to 4 |
| argv[arg++] = "--num-callers=8"; // reduce from 12 to 8 |
| //argv[arg++] = "--show-reachable=yes"; // show still-reachable |
| if (doDebug) { |
| //mTerminalFollowsChild = true; // interactive |
| argv[arg++] = "--db-attach=yes"; |
| } |
| //mSlowExit = true; |
| } else /*doDebug*/ { |
| argv[arg++] = debuggerExeTmp = debuggerExe.ToAscii(); |
| if (!debuggerScript.IsEmpty()) { |
| argv[arg++] = "-x"; |
| argv[arg++] = debuggerScriptTmp = debuggerScript.ToAscii(); |
| } |
| argv[arg++] = runtimeExeTmp = runtimeExe.ToAscii(); |
| argv[arg++] = "--args"; |
| } |
| } |
| |
| /* |
| * Get runtime args. |
| */ |
| |
| argv[arg++] = runtimeExeTmp = (const char*) runtimeExe.ToAscii(); |
| |
| javaAppName = ((MyApp*)wxTheApp)->GetAutoRunApp(); |
| if (javaAppName.IsEmpty()) { |
| if (!pPrefs->GetString("java-app-name", /*ref*/ javaAppName)) { |
| javaAppName = wxT(""); |
| } |
| } |
| |
| if (!javaAppName.IsEmpty()) |
| { |
| argv[arg++] = "-j"; |
| argv[arg++] = javaAppNameTmp = (const char*) javaAppName.ToAscii(); |
| } |
| |
| if (pPrefs->GetDouble("gamma", &dval) && dval != 1.0) { |
| snprintf(gammaVal, sizeof(gammaVal), "%.3f", dval); |
| argv[arg++] = "-g"; |
| argv[arg++] = gammaVal; |
| } |
| |
| /* finish arg set */ |
| argv[arg++] = NULL; |
| |
| assert(arg <= kMaxArgs); |
| |
| #if 1 |
| printf("ARGS:\n"); |
| for (int i = 0; i < arg; i++) |
| printf(" %d: '%s'\n", i, argv[i]); |
| #endif |
| |
| if (fork() == 0) { |
| execvp(argv[0], (char* const*) argv); |
| fprintf(stderr, "execvp '%s' failed: %s\n", argv[0], strerror(errno)); |
| exit(1); |
| } |
| |
| /* |
| * We assume success; if it didn't succeed we'll just sort of hang |
| * out waiting for a connection. There are ways to fix this (create |
| * a non-close-on-exec pipe and watch to see if the other side closes), |
| * but at this stage it's not worthwhile. |
| */ |
| result = true; |
| |
| tmpStr = wxT("=== launched "); |
| tmpStr += runtimeExe; |
| LogWindow::PostLogMsg(tmpStr); |
| |
| assert(errMsg.IsEmpty()); |
| |
| bail: |
| if (!errMsg.IsEmpty()) { |
| assert(result == false); |
| |
| UserEventMessage* pUem = new UserEventMessage; |
| pUem->CreateErrorMessage(errMsg); |
| |
| UserEvent uev(0, (void*) pUem); |
| |
| assert(statusWindow != NULL); |
| statusWindow->AddPendingEvent(uev); |
| } |
| delete[] argv; |
| return result; |
| } |
| |
| /* |
| * This is the entry point for the device thread. The thread launches the |
| * runtime process and monitors it. When the runtime exits, the thread |
| * exits. |
| * |
| * Because this isn't running in the UI thread, any user interaction has |
| * to be channeled through "user events" to the appropriate window. |
| */ |
| void* DeviceManager::DeviceThread::Entry(void) |
| { |
| //android::MessageStream stream; |
| android::Message msg; |
| wxString errMsg; |
| char statusBuf[64] = "(no status)"; |
| int result = 1; |
| |
| /* print this so we can make sense of log messages */ |
| LOG(LOG_DEBUG, "", "Sim: device management thread starting (pid=%d)\n", |
| getpid()); |
| |
| assert(mReader != NULL && mWriter != NULL); |
| |
| /* |
| * Tell the main thread that we're running. If something fails here, |
| * we'll send them a "stopped running" immediately afterward. |
| */ |
| { |
| UserEventMessage* pUem = new UserEventMessage; |
| pUem->CreateRuntimeStarted(); |
| |
| UserEvent uev(0, (void*) pUem); |
| |
| assert(mpStatusWindow != NULL); |
| mpStatusWindow->AddPendingEvent(uev); |
| } |
| LogWindow::PostLogMsg( |
| "=============================================================="); |
| LogWindow::PostLogMsg("=== runtime starting"); |
| |
| /* |
| * Establish contact with runtime. |
| */ |
| if (!mStream.init(mReader, mWriter, true)) { |
| errMsg = wxT("ERROR: Unable to establish communication with runtime.\n"); |
| goto bail; |
| } |
| |
| /* |
| * Tell the runtime to put itself into a new process group and set |
| * itself up as the foreground process. The latter is only really |
| * necessary to make valgrind+gdb work. |
| */ |
| msg.setCommand(android::Simulator::kCommandNewPGroup, true); |
| mStream.send(&msg); |
| |
| printf("Sim: Sending hardware configuration\n"); |
| |
| /* |
| * Send display config. |
| * |
| * Right now we're just shipping a big binary blob over. |
| */ |
| assert(android::Simulator::kValuesPerDisplay >= 5); |
| int buf[1 + 1 + mpDeviceManager->GetNumDisplays() * |
| android::Simulator::kValuesPerDisplay]; |
| buf[0] = android::Simulator::kDisplayConfigMagic; |
| buf[1] = mpDeviceManager->GetNumDisplays(); |
| for (int i = 0; i < mpDeviceManager->GetNumDisplays(); i++) { |
| DeviceManager::Display* pDisplay = mpDeviceManager->GetDisplay(i); |
| int* pBuf = &buf[2 + android::Simulator::kValuesPerDisplay * i]; |
| |
| pBuf[0] = pDisplay->GetWidth(); |
| pBuf[1] = pDisplay->GetHeight(); |
| pBuf[2] = pDisplay->GetFormat(); |
| pBuf[3] = pDisplay->GetRefresh(); |
| pBuf[4] = pDisplay->GetShmemKey(); |
| } |
| msg.setRaw((const unsigned char*)buf, sizeof(buf), |
| android::Message::kCleanupNoDelete); |
| mStream.send(&msg); |
| |
| /* |
| * Send other hardware config. |
| * |
| * Examples: |
| * - Available input devices. |
| * - Set of buttons on device. |
| * - External devices (Bluetooth, etc). |
| * - Initial mode (e.g. "flipped open" vs. "flipped closed"). |
| */ |
| |
| msg.setConfig("keycharmap", mpDeviceManager->GetKeyMap()); |
| mStream.send(&msg); |
| |
| /* |
| * Done with config. |
| */ |
| msg.setCommand(android::Simulator::kCommandConfigDone, 0); |
| mStream.send(&msg); |
| |
| /* |
| * Sit forever, waiting for messages from the runtime process. |
| */ |
| while (1) { |
| if (!mStream.recv(&msg, true)) { |
| /* |
| * The read failed. This usually means the child has died. |
| */ |
| printf("Sim: runtime process has probably died\n"); |
| break; |
| } |
| |
| if (msg.getType() == android::Message::kTypeCommand) { |
| int cmd, arg; |
| |
| if (!msg.getCommand(&cmd, &arg)) { |
| fprintf(stderr, "Sim: Warning: failed unpacking command\n"); |
| /* keep going? */ |
| } else { |
| switch (cmd) { |
| case android::Simulator::kCommandNewPGroupCreated: |
| // runtime has moved into a separate process group |
| // (not expected for external) |
| printf("Sim: child says it's now in pgrp %d\n", arg); |
| mRuntimeProcessGroup = arg; |
| break; |
| case android::Simulator::kCommandRuntimeReady: |
| // sim is up and running, do late init |
| break; |
| case android::Simulator::kCommandUpdateDisplay: |
| // new frame of graphics is ready |
| //printf("RCVD display update %d\n", arg); |
| mpDeviceManager->ShowFrame(arg); |
| break; |
| case android::Simulator::kCommandVibrate: |
| // vibrator on or off |
| //printf("RCVD vibrator update %d\n", arg); |
| mpDeviceManager->Vibrate(arg); |
| break; |
| default: |
| printf("Sim: got unknown command %d/%d\n", cmd, arg); |
| break; |
| } |
| } |
| } else if (msg.getType() == android::Message::kTypeLogBundle) { |
| android_LogBundle bundle; |
| |
| if (!msg.getLogBundle(&bundle)) { |
| fprintf(stderr, "Sim: Warning: failed unpacking logBundle\n"); |
| /* keep going? */ |
| } else { |
| LogWindow::PostLogMsg(&bundle); |
| } |
| } else { |
| printf("Sim: got unknown message type=%d\n", msg.getType()); |
| } |
| } |
| |
| result = 0; |
| |
| bail: |
| printf("Sim: DeviceManager thread preparing to exit\n"); |
| |
| /* kill the comm channel; should encourage runtime to die */ |
| mStream.close(); |
| delete mReader; |
| delete mWriter; |
| mReader = mWriter = NULL; |
| |
| /* |
| * We never really did get a "friendly death" working, so just slam |
| * the thing if we have the process group. |
| */ |
| if (mRuntimeProcessGroup != 0) { |
| /* kill the group, not our immediate child */ |
| printf("Sim: killing pgrp %d\n", (int) mRuntimeProcessGroup); |
| kill(-mRuntimeProcessGroup, 9); |
| } |
| |
| if (!errMsg.IsEmpty()) { |
| UserEventMessage* pUem = new UserEventMessage; |
| pUem->CreateErrorMessage(errMsg); |
| |
| UserEvent uev(0, (void*) pUem); |
| mpStatusWindow->AddPendingEvent(uev); |
| } |
| |
| /* notify the main window that the runtime has stopped */ |
| { |
| UserEventMessage* pUem = new UserEventMessage; |
| pUem->CreateRuntimeStopped(); |
| |
| UserEvent uev(0, (void*) pUem); |
| mpStatusWindow->AddPendingEvent(uev); |
| } |
| |
| /* show exit status in log file */ |
| wxString exitMsg; |
| exitMsg.Printf(wxT("=== runtime exiting - %s"), statusBuf); |
| LogWindow::PostLogMsg(exitMsg); |
| LogWindow::PostLogMsg( |
| "==============================================================\n"); |
| |
| /* |
| * Reset system properties for future runs. |
| */ |
| ResetProperties(); |
| |
| return (void*) result; |
| } |
| |
| |
| /* |
| * Wait for a little bit to see if the thread will exit. |
| * |
| * "delay" is in 0.1s increments. |
| */ |
| void DeviceManager::DeviceThread::WaitForDeath(int delay) |
| { |
| const int kDelayUnit = 100000; |
| int i; |
| |
| for (i = 0; i < delay; i++) { |
| if (!IsRunning()) |
| return; |
| usleep(kDelayUnit); |
| } |
| } |
| |
| |
| /* |
| * Kill the runtime process. The goal is to cause our local runtime |
| * management thread to exit. If it doesn't, this will kill the thread |
| * before it returns. |
| */ |
| void DeviceManager::DeviceThread::KillChildProcesses(void) |
| { |
| if (!this->IsRunning()) |
| return; |
| |
| /* clear "slow exit" flag -- we're forcefully killing this thing */ |
| //this->mSlowExit = false; |
| |
| /* |
| * Use the ChildProcess object in the thread to send signals. There's |
| * a risk that the DeviceThread will exit and destroy the object while |
| * we're using it. Using a mutex here gets a little awkward because |
| * we can't put it in DeviceThread. It's easier to make a copy of |
| * ChildProcess and operate on the copy, but we have to do that very |
| * carefully to avoid interfering with the communcation pipes. |
| * |
| * For now, we just hope for the best. FIX this someday. |
| * |
| * We broadcast to the process group, which will ordinarily kill |
| * everything. If we're running with valgrind+GDB everything is in our |
| * pgrp and we can't do the broadcast; if GDB alone, then only GDB is |
| * in our pgrp, so the broadcast will hit everything except it. We |
| * hit the group and then hit our child for good measure. |
| */ |
| if (mRuntimeProcessGroup != 0) { |
| /* kill the group, not our immediate child */ |
| printf("Sim: killing pgrp %d\n", (int) mRuntimeProcessGroup); |
| kill(-mRuntimeProcessGroup, 9); |
| WaitForDeath(15); |
| } |
| |
| /* |
| * Close the communication channel. This should cause our thread |
| * to snap out of its blocking read and the runtime thread to bail |
| * out the next time it tries to interact with us. We should only |
| * get here if somebody other than our direct descendant has the |
| * comm channel open and our broadcast didn't work, which should |
| * no longer be possible. |
| */ |
| if (this->IsRunning()) { |
| printf("Sim: killing comm channel\n"); |
| mStream.close(); |
| delete mReader; |
| delete mWriter; |
| mReader = mWriter = NULL; |
| WaitForDeath(15); |
| } |
| |
| /* |
| * At this point it's possible that our DeviceThread is just wedged. |
| * Kill it. |
| * |
| * Using the thread Kill() function can orphan resources, including |
| * locks and semaphores. There is some risk that the simulator will |
| * be hosed after this. |
| */ |
| if (this->IsRunning()) { |
| fprintf(stderr, "Sim: WARNING: killing runtime thread (%ld)\n", |
| (long) GetId()); |
| this->Kill(); |
| WaitForDeath(15); |
| } |
| |
| /* |
| * Now I'm scared. |
| */ |
| if (this->IsRunning()) { |
| fprintf(stderr, "Sim: thread won't die!\n"); |
| } |
| } |
| |
| |
| /* |
| * Configure system properties for the simulated device. |
| * |
| * Property requests can arrive *before* the full connection to the |
| * simulator is established, so we want to reset these during cleanup. |
| */ |
| void DeviceManager::DeviceThread::ResetProperties(void) |
| { |
| wxWindow* mainFrame = ((MyApp*)wxTheApp)->GetMainFrame(); |
| PropertyServer* props = ((MainFrame*)mainFrame)->GetPropertyServer(); |
| |
| props->ClearProperties(); |
| props->SetDefaultProperties(); |
| } |
| |
| |
| #if 0 |
| /* |
| * Return true if the executable found is newer than |
| * what is currently running |
| */ |
| bool DeviceManager::DeviceThread::IsRuntimeNew(void) |
| { |
| if (mLastModified == 0) { |
| /* |
| * Haven't called UpdateLastModified yet, or called it but |
| * couldn't stat() the executable. |
| */ |
| return false; |
| } |
| |
| struct stat status; |
| if (stat(mRuntimeExe.ToAscii(), &status) == 0) { |
| return (status.st_mtime > mLastModified); |
| } else { |
| // doesn't exist, so it can't be newer |
| fprintf(stderr, "Sim: unable to stat '%s': %s\n", |
| (const char*) mRuntimeExe.ToAscii(), strerror(errno)); |
| return false; |
| } |
| } |
| |
| /* |
| * Updates mLastModified to reflect the current executables mtime |
| */ |
| void DeviceManager::DeviceThread::UpdateLastModified(void) |
| { |
| struct stat status; |
| if (stat(mRuntimeExe.ToAscii(), &status) == 0) { |
| mLastModified = status.st_mtime; |
| } else { |
| fprintf(stderr, "Sim: unable to stat '%s': %s\n", |
| (const char*) mRuntimeExe.ToAscii(), strerror(errno)); |
| mLastModified = 0; |
| } |
| } |
| #endif |
| |