android.exe, replacement for android.bat on Windows
Change-Id: I7275cfeeec53511b1679c203a149b801e137b921
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
Binary files differ
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>