android.exe, replacement for android.bat on Windows

Change-Id: I7275cfeeec53511b1679c203a149b801e137b921

8 files changed, 1026 insertions, 0 deletions

diff --git a/sdkmanager/Android.mk b/sdkmanager/Android.mk
index 30df7f1..a6c9379 100644
--- a/sdkmanager/Android.mk
+++ b/sdkmanager/Android.mk
@@ -16,3 +16,4 @@
 SDKMANAGER_LOCAL_DIR := $(call my-dir)
 include $(SDKMANAGER_LOCAL_DIR)/app/Android.mk
 include $(SDKMANAGER_LOCAL_DIR)/libs/Android.mk
+include $(SDKMANAGER_LOCAL_DIR)/win_android/Android.mk
diff --git a/sdkmanager/win_android/.gitignore b/sdkmanager/win_android/.gitignore
new file mode 100644
index 0000000..589b106
--- /dev/null
+++ b/sdkmanager/win_android/.gitignore
@@ -0,0 +1 @@
+images/win_android_icon.o
diff --git a/sdkmanager/win_android/Android.mk b/sdkmanager/win_android/Android.mk
new file mode 100644
index 0000000..a50b3c7
--- /dev/null
+++ b/sdkmanager/win_android/Android.mk
@@ -0,0 +1,54 @@
+# Copyright 2011 The Android Open Source Project
+#
+# Android.mk for sdkmanager/win_android
+#
+# This provides "win_android.exe", a replacement for "android.bat" for Windows only.
+
+
+#----- The current C++ sdklauncher -----
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+ifeq ($(HOST_OS),windows)
+
+LOCAL_SRC_FILES := \
+	win_android.cpp
+
+LOCAL_CFLAGS += -Wall -Wno-unused-parameter
+LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE -DSH_HISTORY -DUSE_MINGW
+LOCAL_MODULE := win_android
+
+LOCAL_MODULE_TAGS := optional
+
+# Locate windres executable
+WINDRES := windres
+ifneq ($(USE_MINGW),)
+  # When building the Windows resources under Linux, use the MinGW one
+  WINDRES := i586-mingw32msvc-windres
+endif
+
+# Link the Windows icon file as well into the executable, based on the technique
+# used in external/qemu/Makefile.android.  The variables need to have different
+# names to not interfere with the ones from qemu/Makefile.android.
+#
+INTERMEDIATE         := $(call intermediates-dir-for,EXECUTABLES,$(LOCAL_MODULE),true)
+WIN_ANDROID_ICON_OBJ  := win_android_icon.o
+WIN_ANDROID_ICON_PATH := $(LOCAL_PATH)/images
+$(WIN_ANDROID_ICON_PATH)/$(WIN_ANDROID_ICON_OBJ): $(WIN_ANDROID_ICON_PATH)/android_icon.rc
+	$(WINDRES) $< -I $(WIN_ANDROID_ICON_PATH) -o $@
+
+# seems to be the only way to add an object file that was not generated from
+# a C/C++/Java source file to our build system. and very unfortunately,
+# $(TOPDIR)/$(LOCALPATH) will always be prepended to this value, which forces
+# us to put the object file in the source directory...
+#
+LOCAL_PREBUILT_OBJ_FILES += images/$(WIN_ANDROID_ICON_OBJ)
+
+include $(BUILD_HOST_EXECUTABLE)
+
+$(call dist-for-goals,droid,$(LOCAL_BUILT_MODULE))
+
+endif
+
+
diff --git a/sdkmanager/win_android/NOTICE b/sdkmanager/win_android/NOTICE
new file mode 100644
index 0000000..7317ae2
--- /dev/null
+++ b/sdkmanager/win_android/NOTICE
@@ -0,0 +1,190 @@
+
+   Copyright (c) 2005-2011, The Android Open Source Project
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
diff --git a/sdkmanager/win_android/images/android_icon.ico b/sdkmanager/win_android/images/android_icon.ico
new file mode 100644
index 0000000..bd25179
--- /dev/null
+++ b/sdkmanager/win_android/images/android_icon.ico
diff --git a/sdkmanager/win_android/images/android_icon.rc b/sdkmanager/win_android/images/android_icon.rc
new file mode 100644
index 0000000..42298a9
--- /dev/null
+++ b/sdkmanager/win_android/images/android_icon.rc
@@ -0,0 +1,2 @@
+1 ICON "../images/android_icon.ico"

+1 RT_MANIFEST "../win_android.exe.manifest"

diff --git a/sdkmanager/win_android/win_android.cpp b/sdkmanager/win_android/win_android.cpp
new file mode 100644
index 0000000..ed4bb7d
--- /dev/null
+++ b/sdkmanager/win_android/win_android.cpp
@@ -0,0 +1,745 @@
+/*

+ * Copyright (C) 2011 The Android Open Source Project

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *      http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+

+/*

+ * "win_android.exe", for Windows only. Replaces the previous android.bat.

+ * In the final SDK, this is what becomes tools\android.exe and it runs

+ * the UI for the SDK Manager or the AVD Manager.

+ *

+ * Implementation details:

+ * - We don't have access to ATL or MFC.

+ * - We don't want to pull in things like STL.

+ * - No Unicode/MBCS support for now.

+ */

+

+#ifdef _WIN32

+

+#define _CRT_SECURE_NO_WARNINGS 1

+

+#include <direct.h>

+#include <stdio.h>

+#include <stdarg.h>

+#include <string.h>

+#include <windows.h>

+

+// VS vs MINGW specific includes

+#ifdef USE_MINGW

+    #define _ASSERT(x)      // undef

+#else

+    #include <crtdbg.h>     // for _ASSERT

+#endif

+

+// A NULL-terminated list of directory to create in the temp folder.

+static const char * sMkDirList[] = {

+    "lib",

+    "lib\\x86",

+    "lib\\x86_64",

+    NULL,

+};

+

+// A NULL-terminated list of file patterns to copy in the temp folder.

+// The folders must be listed in sMkDirList

+static const char * sFilesToCopy[] = {

+    "lib\\x86\\swt.jar",

+    "lib\\x86_64\\swt.jar",

+    "lib\\androidprefs.jar",

+    "lib\\org.eclipse.*",

+    "lib\\sdk*",

+    "lib\\common.jar",

+    "lib\\commons-compress*",

+    "lib\\swtmenubar.jar",

+    "lib\\commons-logging*",

+    "lib\\commons-codec*",

+    "lib\\httpclient*",

+    "lib\\httpcore*",

+    "lib\\httpmime*",

+    NULL,

+};

+

+static bool gDebug = false;

+

+

+// An array that knows its own size. Not dynamically resizable.

+template <class T> class CArray {

+    T* mPtr;

+    int mSize;

+public:

+    CArray(int size) {

+        mSize = size;

+        mPtr = new T[size];

+    }

+

+    ~CArray() {

+        if (mPtr != NULL) {

+            delete[] mPtr;

+            mPtr = NULL;

+        }

+        mSize = 0;

+    }

+

+    T& operator[](int i) {

+        _ASSERT(i >= 0 && i < mSize);

+        return mPtr[i];

+    }

+

+    int size() {

+        return mSize;

+    }

+};

+

+// A simple string class wrapper.

+class CString {

+protected:

+    char *mStr;

+public:

+    CString() { mStr = NULL; }

+    CString(const CString &str) { mStr = str.mStr == NULL ? NULL : _strdup(str.mStr); }

+    CString(const char *str) { mStr = NULL; set(str); }

+    CString(const char *start, int length) { mStr = NULL; set(start, length); }

+

+    CString& set(const char *str) {

+        _free();

+        if (str != NULL) {

+            mStr = _strdup(str);

+        }

+        return *this;

+    }

+

+    CString& set(const char *start, int length) {

+        _free();

+        if (start != NULL) {

+            mStr = (char *)malloc(length + 1);

+            strncpy(mStr, start, length);

+            mStr[length] = 0;

+        }

+        return *this;

+    }

+

+    CString& setv(const char *str, va_list ap) {

+        _free();

+        // _vscprintf(str, ap) is only available with the MSVCRT, not MinGW.

+        // Instead we'll iterate till we have enough space to generate the string.

+        int len = strlen(str) + 1024;

+        mStr = (char *)malloc(len);

+        strcpy(mStr, str); // provide a default in case vsnprintf totally fails

+        for (int guard = 0; guard < 10; guard++) {

+            int ret = vsnprintf(mStr, len, str, ap);

+            if (ret == -1) {

+                // Some implementations don't give the proper size needed

+                // so double the space and try again.

+                len *= 2;

+            } else if (ret >= len) {

+                len = ret + 1;

+            } else {

+                // There was enough space to write.

+                break;

+            }

+            mStr = (char *)realloc((void *)mStr, len);

+            strcpy(mStr, str); // provide a default in case vsnprintf totally fails

+        }

+        return *this;

+    }

+

+    CString& setf(const char *str, ...) {

+        _free();

+        va_list ap;

+        va_start(ap, str);

+        setv(str, ap);

+        va_end(ap);

+        return *this;

+    }

+

+    virtual ~CString() { _free(); }

+

+    // Returns the C string owned by this CString. It will be

+    // invalid as soon as this CString is deleted or out of scope.

+    operator const char* () {

+        return mStr;

+    }

+

+    bool isEmpty() {

+        return mStr == NULL || *mStr == 0;

+    }

+

+    int length() {

+        return mStr == NULL ? 0 : strlen(mStr);

+    }

+

+    CString& add(const char *s) {

+        if (mStr == NULL) {

+            set(s);

+        } else {

+            mStr = (char *)realloc((void *)mStr, strlen(mStr) + strlen(s) + 1);

+            strcat((char *)mStr, s);

+        }

+        return *this;

+    }

+

+    CArray<CString> * split(char sep) {

+        if (mStr == NULL) {

+            return new CArray<CString>(0);

+        }

+        const char *last = NULL;

+        int n = 0;

+        for (const char *s = mStr; *s; s++) {

+            if (*s == sep && s != mStr && (last == NULL || s > last+1)) {

+                n++;

+                last = s;

+            }

+        }

+

+        CArray<CString> *result = new CArray<CString>(n);

+        last = NULL;

+        n = 0;

+        for (const char *s = mStr; *s; s++) {

+            if (*s == sep) {

+                if (s != mStr && (last == NULL || s > last+1)) {

+                    const char *start = last ? last : mStr;

+                    (*result)[n++].set(start, s-start);

+                }

+                last = s+1;

+            }

+        }

+

+        return result;

+    }

+

+private:

+    void _free() {

+        if (mStr != NULL) {

+            free((void *)mStr);

+            mStr = NULL;

+        }

+    }

+

+};

+

+// A simple path class wrapper.

+class CPath : public CString {

+public:

+    CPath()                 : CString()    { }

+    CPath(const CPath &str) : CString(str) { }

+    CPath(const char *str)  : CString(str) { }

+    CPath(const char *start, int length) : CString(start, length) { }

+

+    // Appends a path segment, adding a \ as necessary.

+    CPath& addPath(const char *s) {

+        int n = length();

+        if (n > 0 && mStr[n-1] != '\\') add("\\");

+        add(s);

+        return *this;

+    }

+

+    // Returns true if file exist and is not a directory.

+    // There's no garantee we have rights to access it.

+    bool fileExists() {

+        if (mStr == NULL) return false;

+        DWORD attribs = GetFileAttributesA(mStr);

+        return attribs != INVALID_FILE_ATTRIBUTES &&

+             !(attribs & FILE_ATTRIBUTE_DIRECTORY);

+    }

+

+    // Returns true if file exist and is a directory.

+    // There's no garantee we have rights to access it.

+    bool dirExists() {

+        if (mStr == NULL) return false;

+        DWORD attribs = GetFileAttributesA(mStr);

+        return attribs != INVALID_FILE_ATTRIBUTES &&

+              (attribs & FILE_ATTRIBUTE_DIRECTORY) != 0;

+    }

+

+    // Returns a copy of the directory portion of the path, if any

+    CPath dirName() {

+        CPath result;

+        if (mStr != NULL) {

+            char *pos = strrchr(mStr, '\\');

+            if (pos != NULL) {

+                result.set(mStr, pos - mStr);

+            }

+        }

+        return result;

+    }

+

+    // Returns a pointer to the baseName part of the path.

+    // It becomes invalid if the path changes.

+    const char *baseName() {

+        if (mStr != NULL) {

+            char *pos = strrchr(mStr, '\\');

+            if (pos != NULL) {

+                return pos + 1;

+            }

+        }

+        return NULL;

+    }

+

+    // If the path ends with the given searchName, replace it by the new name

+    void replaceName(const char *searchName, const char* newName) {

+        if (mStr == NULL) return;

+        int n = length();

+        int sn = strlen(searchName);

+        if (n < sn) return;

+        // if mStr ends with searchName

+        if (strcmp(mStr + n - sn, searchName) == 0) {

+            int sn2 = strlen(newName);

+            if (sn2 > sn) {

+                mStr = (char *)realloc((void *)mStr, n + sn2 - sn + 1);

+            }

+            strcpy(mStr + n - sn, newName);

+            mStr[n + sn2 - sn] = 0;

+        }

+    }

+};

+

+// ========= UTILITIES ==============

+

+// Displays a message in an ok+info dialog box.

+static void msgBox(const char* text, ...) {

+    CString formatted;

+    va_list ap;

+    va_start(ap, text);

+    formatted.setv(text, ap);

+    va_end(ap);

+

+    MessageBoxA(NULL, formatted, "Android SDK Manager", MB_OK | MB_ICONINFORMATION);

+}

+

+static void displayLastError(const char *description, ...) {

+    CString formatted;

+    va_list ap;

+    va_start(ap, description);

+    formatted.setv(description, ap);

+    va_end(ap);

+

+    DWORD err = GetLastError();

+    LPSTR errStr;

+    if (FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | /* dwFlags */

+                      FORMAT_MESSAGE_FROM_SYSTEM,

+                      NULL,                             /* lpSource */

+                      err,                              /* dwMessageId */

+                      0,                                /* dwLanguageId */

+                      (LPSTR)&errStr,                   /* lpBuffer */

+                      0,                                /* nSize */

+                      NULL) != 0) {                     /* va_list args */

+        formatted.add("\r\n");

+        formatted.add(errStr);

+        MessageBox(NULL, formatted, "Android SDK Manager - Error", MB_OK | MB_ICONERROR);

+        LocalFree(errStr);

+    }

+}

+

+// Executes the command line. Does not wait for the program to finish.

+// The return code is from CreateProcess (0 means failure), not the running app.

+static int execNoWait(const char *app, const char *params, const char *workDir) {

+    STARTUPINFO           startup;

+    PROCESS_INFORMATION   pinfo;

+

+    ZeroMemory(&pinfo, sizeof(pinfo));

+

+    ZeroMemory(&startup, sizeof(startup));

+    startup.cb          = sizeof(startup);

+    startup.dwFlags     = STARTF_USESHOWWINDOW;

+    startup.wShowWindow = SW_HIDE|SW_MINIMIZE;

+

+    int ret = CreateProcessA(

+            (LPSTR) app,                                /* program path */

+            (LPSTR) params,                             /* command-line */

+            NULL,                  /* process handle is not inheritable */

+            NULL,                   /* thread handle is not inheritable */

+            TRUE,                          /* yes, inherit some handles */

+            CREATE_NO_WINDOW,                /* we don't want a console */

+            NULL,                     /* use parent's environment block */

+            workDir,                 /* use parent's starting directory */

+            &startup,                 /* startup info, i.e. std handles */

+            &pinfo);

+

+    if (ret) {

+        CloseHandle(pinfo.hProcess);

+        CloseHandle(pinfo.hThread);

+    }

+

+    return ret;

+}

+

+

+// Executes command, waits for completion and returns exit code.

+// As indicated in MSDN for CreateProcess, callers should double-quote the program name

+// e.g. cmd="\"c:\program files\myapp.exe\" arg1 arg2";

+static int execWait(const char *cmd) {

+    STARTUPINFO           startup;

+    PROCESS_INFORMATION   pinfo;

+

+    ZeroMemory(&pinfo, sizeof(pinfo));

+

+    ZeroMemory(&startup, sizeof(startup));

+    startup.cb          = sizeof(startup);

+    startup.dwFlags     = STARTF_USESHOWWINDOW;

+    startup.wShowWindow = SW_HIDE|SW_MINIMIZE;

+

+    int ret = CreateProcessA(

+            NULL,                                       /* program path */

+            (LPSTR) cmd,                                /* command-line */

+            NULL,                  /* process handle is not inheritable */

+            NULL,                   /* thread handle is not inheritable */

+            TRUE,                          /* yes, inherit some handles */

+            CREATE_NO_WINDOW,                /* we don't want a console */

+            NULL,                     /* use parent's environment block */

+            NULL,                    /* use parent's starting directory */

+            &startup,                 /* startup info, i.e. std handles */

+            &pinfo);

+

+    int result = -1;

+    if (ret) {

+        WaitForSingleObject(pinfo.hProcess, INFINITE);

+

+        DWORD exitCode;

+        if (GetExitCodeProcess(pinfo.hProcess, &exitCode)) {

+            // this should not return STILL_ACTIVE (259)

+            result = exitCode;

+        }

+        CloseHandle(pinfo.hProcess);

+        CloseHandle(pinfo.hThread);

+    }

+

+    return result;

+}

+

+static bool getModuleDir(CPath *outDir) {

+    CHAR programDir[MAX_PATH];

+    int ret = GetModuleFileName(NULL, programDir, sizeof(programDir));

+    if (ret != 0) {

+        // Remove the last segment to keep only the directory.

+        int pos = ret - 1;

+        while (pos > 0 && programDir[pos] != '\\') {

+            --pos;

+        }

+        outDir->set(programDir, pos);

+        return true;

+    }

+    return false;

+}

+

+// Disable the FS redirection done by WOW64.

+// Because this runs as a 32-bit app, Windows automagically remaps some

+// folder under the hood (e.g. "Programs Files(x86)" is mapped as "Program Files").

+// This prevents the app from correctly searching for java.exe in these folders.

+// The registry is also remapped.

+static PVOID disableWow64FsRedirection() {

+

+    // The call we want to make is the following:

+    //    PVOID oldWow64Value;

+    //    Wow64DisableWow64FsRedirection(&oldWow64Value);

+    // However that method may not exist (e.g. on non-64 systems) so

+    // we must not call it directly.

+

+    PVOID oldWow64Value = 0;

+

+    HMODULE hmod = LoadLibrary("kernel32.dll");

+    if (hmod != NULL) {

+        FARPROC proc = GetProcAddress(hmod, "Wow64DisableWow64FsRedirection");

+        if (proc != NULL) {

+            typedef BOOL (WINAPI *disableWow64FuncType)(PVOID *);

+            disableWow64FuncType funcPtr = (disableWow64FuncType)proc;

+            funcPtr(&oldWow64Value);

+        }

+

+        FreeLibrary(hmod);

+    }

+

+    return oldWow64Value;

+}

+

+//Reverts the redirection disabled in disableWow64FsRedirection.

+static void revertWow64FsRedirection(PVOID oldWow64Value) {

+

+    // The call we want to make is the following:

+    //    Wow64RevertWow64FsRedirection(oldWow64Value);

+    // However that method may not exist (e.g. on non-64 systems) so

+    // we must not call it directly.

+

+    HMODULE hmod = LoadLibrary("kernel32.dll");

+    if (hmod != NULL) {

+        FARPROC proc = GetProcAddress(hmod, "Wow64RevertWow64FsRedirection");

+        if (proc != NULL) {

+            typedef BOOL (WINAPI *revertWow64FuncType)(PVOID);

+            revertWow64FuncType funcPtr = (revertWow64FuncType)proc;

+            funcPtr(oldWow64Value);

+        }

+

+        FreeLibrary(hmod);

+    }

+}

+

+

+// =============================

+

+// Search java.exe in the path

+static bool findJavaInEnvPath(CPath *outJavaPath) {

+    SetLastError(0);

+    const char* envPath = getenv("PATH");

+    if (!envPath) return false;

+

+    CArray<CString> *paths = CString(envPath).split(';');

+    for(int i = 0; i < paths->size(); i++) {

+        CPath p((*paths)[i]);

+        p.addPath("java.exe");

+        if (p.fileExists()) {

+            // Make sure we can actually run "java -version".

+            CString cmd;

+            cmd.setf("\"%s\" -version", (const char*)p);

+            int code = execWait(cmd);

+            if (code == 0) {

+                if (gDebug) msgBox("Java found via env path: %s", (const char *)p);

+                outJavaPath->set(p);

+                delete paths;

+                return true;

+            }

+        }

+    }

+

+    delete paths;

+    return false;

+}

+

+static bool findJavaInRegistry(CPath *outJavaPath) {

+    // TODO

+    return false;

+}

+

+static bool findJavaInProgramFiles(CPath *outJavaPath) {

+    // TODO

+    return false;

+}

+

+// Creates a directory named dirLeafName in the TEMP directory.

+// Returns the path in outDir on success.

+static bool mkTempDir(const char *dirLeafName, CPath *outDir) {

+    SetLastError(0);

+    char tempPath[MAX_PATH + 1] = "";

+    DWORD len = GetTempPathA(MAX_PATH, tempPath);

+    if (len > 0 && len <= MAX_PATH) {

+        _ASSERT(tempPath[len-1] == '\\');

+        _ASSERT(len + strlen(dirLeafName) < MAX_PATH);

+        if (len + strlen(dirLeafName) >= MAX_PATH) {

+            displayLastError("TEMP path too long to create a temporary directory: %s", tempPath);

+            return false;

+        }

+        strcat(tempPath, dirLeafName);

+        outDir->set(tempPath);

+

+        if (outDir->dirExists() ||

+            CreateDirectoryA(tempPath, NULL /*lpSecurityAttributes*/) != 0) {

+            return true;

+        }

+    }

+    displayLastError("Failed to create a temporary directory: %s", tempPath);

+    return false;

+}

+

+// Creates all the directories from sMkDirList in the specified base tmpDir.

+static bool mkDirs(const char *tmpDir, const char * dirList[]) {

+    SetLastError(0);

+    for (const char **dir = dirList; *dir != NULL; dir++) {

+        CPath path(tmpDir);

+        path.addPath(*dir);

+        if (!path.dirExists()) {

+            if (!CreateDirectoryA(path, NULL /*lpSecurityAttributes*/)) {

+                displayLastError("Failed to create directory: %s", (const char *)path);

+                return false;

+            }

+        }

+    }

+    return true;

+}

+

+static bool copyFiles(const char *toolsDir, const char *tmpDir, const char *globList[]) {

+    SetLastError(0);

+    WIN32_FIND_DATAA srcFindData;

+    WIN32_FIND_DATAA destFindData;

+    for (const char **glob = globList; *glob != NULL; glob++) {

+        CPath globDir = CPath(*glob).dirName();

+

+        CPath fullGlob(toolsDir);

+        fullGlob.addPath(*glob);

+

+        HANDLE srcH = FindFirstFileA(fullGlob, &srcFindData);

+        if (srcH == INVALID_HANDLE_VALUE) {

+            displayLastError("Failed to list files: %s", *glob);

+            return false;

+        }

+        do {

+            // Skip directories

+            if ((srcFindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {

+                continue;

+            }

+            CPath srcPath(toolsDir);

+            srcPath.addPath(globDir).addPath(srcFindData.cFileName);

+

+            CPath destPath(tmpDir);

+            destPath.addPath(globDir).addPath(srcFindData.cFileName);

+

+            // Skip copy if files are likely to not have changed.

+            HANDLE destH = FindFirstFileA(destPath, &destFindData);

+            if (destH != INVALID_HANDLE_VALUE) {

+                // Size must be same for us to skip it.

+                if (srcFindData.nFileSizeHigh == destFindData.nFileSizeHigh &&

+                    srcFindData.nFileSizeLow  == destFindData.nFileSizeLow) {

+                    // Creation & access times can differ. However if the dest write time

+                    // is >= than the source write time, it should be the same file.

+                    LARGE_INTEGER srcWriteTime;

+                    LARGE_INTEGER dstWriteTime;

+                    srcWriteTime.HighPart = srcFindData.ftLastWriteTime.dwHighDateTime;

+                    srcWriteTime.LowPart  = srcFindData.ftLastWriteTime.dwLowDateTime;

+                    dstWriteTime.HighPart = destFindData.ftLastWriteTime.dwHighDateTime;

+                    dstWriteTime.LowPart  = destFindData.ftLastWriteTime.dwLowDateTime;

+                    if (dstWriteTime.QuadPart >= srcWriteTime.QuadPart) {

+                        FindClose(destH);

+                        continue;

+                    }

+                }

+

+                FindClose(destH);

+

+                // CopyFile copies some attributes. It's common for tools to be unzipped

+                // as read-only so we need to remove any r-o attribute on existing

+                // files if we want a recopy to succeed.

+                if ((destFindData.dwFileAttributes && FILE_ATTRIBUTE_READONLY) != 0) {

+                    SetFileAttributes(destPath,

+                        destFindData.dwFileAttributes ^ FILE_ATTRIBUTE_READONLY);

+                }

+            }

+

+            if (!CopyFileA(srcPath, destPath, false /*bFailIfExists*/)) {

+                FindClose(srcH);

+                displayLastError("Failed to copy file: %s", (const char*)destPath);

+                return false;

+            }

+        } while (FindNextFileA(srcH, &srcFindData) != 0);

+        FindClose(srcH);

+    }

+    return true;

+}

+

+static bool execSdkManager(const char *javaPath,

+                           const char *toolsDir,

+                           const char *tmpDir,

+                           const char *lpCmdLine) {

+    SetLastError(0);

+

+    CPath javawPath(javaPath);

+    javawPath.replaceName("java.exe", "javaw.exe");

+    // Only accept it if we can actually find the exec

+    PVOID oldWow64Value = disableWow64FsRedirection();

+    if (!javawPath.fileExists()) {

+        javawPath.set(javaPath);

+    }

+    revertWow64FsRedirection(&oldWow64Value);

+

+    // Check whether the underlying system is x86 or x86_64.

+    // We use GetSystemInfo which will see the one masqueraded by Wow64.

+    // (to get the real info, we would use GetNativeSystemInfo instead.)

+    SYSTEM_INFO sysInfo;

+    GetSystemInfo(&sysInfo);

+

+    CString arch("x86");

+    if (sysInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {

+        arch.set("x86_64");

+    } else if (sysInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) {

+        // Skip this. We'll just assume x86 and let it fail later.

+        // displayLastError("Unknown Processor Architecture: %d", sysInfo.wProcessorArchitecture);

+        // return false;

+    }

+

+    // Now build the command line.

+    // Note that we pass the absolute javawPath to execNoWait

+    // and the first parameter is just for the show.

+    // Important: for the classpath to be able to contain "lib\\sdkmanager.jar", etc.,

+    // we need to set the toolsDir as the *temp* directory in execNoWait.

+    // It's important to not use toolsDir otherwise it would lock that diretory.

+

+    // Tip: to connect the Java debugging to a running process, add this to the Java command line:

+    // "-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000"

+

+    CString cmdLine;

+    cmdLine.setf("\"%s\" "                                   // javaPath

+                 "-Dcom.android.sdkmanager.toolsdir=\"%s\" " // toolsDir

+                 "-Dcom.android.sdkmanager.workdir=\"%s\" "  // workDir==toolsdir

+                 "-classpath \"lib\\sdkmanager.jar;lib\\swtmenubar.jar;lib\\%s\\swt.jar\" " // arch

+                 "com.android.sdkmanager.Main "

+                 "%s",                                       // extra parameters

+        javawPath.baseName(), toolsDir, tmpDir, (const char *)arch, lpCmdLine);

+

+    if (gDebug) msgBox("Executing: %s", (const char *)cmdLine);

+

+    if (!execNoWait(javawPath, cmdLine, tmpDir)) {

+        displayLastError("Failed to run %s", (const char *)cmdLine);

+        return false;

+    }

+

+    return true;

+}

+

+int APIENTRY WinMain(HINSTANCE hInstance,

+                     HINSTANCE hPrevInstance,

+                     LPTSTR    lpCmdLine,

+                     int       nCmdShow) {

+

+    gDebug = (getenv("ANDROID_SDKMAN_DEBUG") != NULL);

+

+    PVOID oldWow64Value = disableWow64FsRedirection();

+

+    CPath javaPath;

+    if (!findJavaInEnvPath(&javaPath) &&

+        !findJavaInRegistry(&javaPath) &&

+        !findJavaInProgramFiles(&javaPath)) {

+        msgBox("Failed to find Java on your system. Please reinstall it.");

+        return 2;

+    }

+    _ASSERT(!javaPath.isEmpty());

+

+    revertWow64FsRedirection(oldWow64Value);

+

+    // For debugging it's more convenient to be able to override the tools directory location

+    CPath toolsDir(getenv("ANDROID_SDKMAN_TOOLS_DIR"));

+    if (toolsDir.isEmpty()) {

+        if (!getModuleDir(&toolsDir)) {

+            displayLastError("Failed to get program's filename: ");

+            return 1;

+        }

+    }

+    _ASSERT(!toolsDir.isEmpty());

+

+    CPath tmpDir;

+    if (!mkTempDir("temp-android-tool", &tmpDir)) {

+        return 1;

+    }

+    _ASSERT(!tmpDir.isEmpty());

+

+    if (!mkDirs(tmpDir, sMkDirList)) {

+        return 1;

+    }

+

+    if (!copyFiles(toolsDir, tmpDir, sFilesToCopy)) {

+        return 1;

+    }

+

+    if (!execSdkManager(javaPath, toolsDir, tmpDir, lpCmdLine)) {

+        displayLastError("Failed to start SDK Manager: ");

+        return 1;

+    }

+

+    return 0;

+}

+#endif /* _WIN32 */

diff --git a/sdkmanager/win_android/win_android.exe.manifest b/sdkmanager/win_android/win_android.exe.manifest
new file mode 100755
index 0000000..fd6c264
--- /dev/null
+++ b/sdkmanager/win_android/win_android.exe.manifest
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

+

+<!--

+  For details on the Assembly Manifest, please look here:

+  http://msdn.microsoft.com/en-us/library/aa374191(VS.85).aspx

+-->

+

+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">

+

+    <application>

+        <!--The ID below indicates application support for Windows Vista -->

+        <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" />

+        <!--The ID below indicates application support for Windows 7 -->

+        <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />

+    </application>

+

+    <assemblyIdentity version="1.0.0.0"

+        processorArchitecture="x86"

+        name="Android.SDK.AndroidTool"

+        type="win32"

+        />

+

+    <description>Wrapper to start the command-line "android" tool or the Android SDK Manager user interface.</description>

+

+    <!-- Identify the application security requirements. -->

+    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">

+        <security>

+            <requestedPrivileges>

+                <requestedExecutionLevel level="asInvoker" uiAccess="false" />

+            </requestedPrivileges>

+        </security>

+    </trustInfo>

+</assembly>