androidDeployer.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
/*
 
                                  #############################################################
                                  ## ======================================================= ##
                                  ################### ]   A N D R O I D   [ ###################
                                  ################### ]   DEPLOYER 1.4c   [ ###################
                                  ## ======================================================= ##
                                  ##        ------------------------------------------       ##
                                  ##                        Crafted by                       ##
                                  ########### ]        BRAIN SANDWICH, 2015       [ ###########
                                  ##                   I-MAGINER LTD. CORP.                  ##
                                  ##                                                         ##
                                  ##        -------         since 1997         -------       ##
                                  ##                                                         ##
                                  ## ======================================================= ##
                                  ##                                                         ##
                                  ##   * Turbo APK generation                                ##
                                  ##   * Scol Quad Nitro SSE Zipping                         ##
                                  ##   * Android full throttle integration                   ##
                                  ##                                                         ##
                                  ## ======================================================= ##
                                  #############################################################
 
*/
 
#include <stdlib.h>
#include <vector>
#include <map>
#include <zip.h>
#include "androidDeployer.h"
 
//process with return content 
HANDLE g_hChildStd_OUT_Rd = NULL;
HANDLE g_hChildStd_OUT_Wr = NULL;
HANDLE g_hChildStd_ERR_Rd = NULL;
HANDLE g_hChildStd_ERR_Wr = NULL;
 
#define EXECBUFSIZE 4096
 
PROCESS_INFORMATION CreateExecChildProcess(std::string, BOOL&); 
void ReadExecFromPipe(PROCESS_INFORMATION, std::string&, std::string&); 
 
bool execProcess(std::string cmd, std::string &output)
{ 
  SECURITY_ATTRIBUTES sa;
  std::string err;
 
  // Set the bInheritHandle flag so pipe handles are inherited. 
  sa.nLength = sizeof(SECURITY_ATTRIBUTES); 
  sa.bInheritHandle = TRUE; 
  sa.lpSecurityDescriptor = NULL; 
 
  // Create a pipe for the child process's STDERR. 
  if (!CreatePipe(&g_hChildStd_ERR_Rd, &g_hChildStd_ERR_Wr, &sa, 0))
  {
    return false;
  }
 
  // Ensure the read handle to the pipe for STDERR is not inherited.
  if (!SetHandleInformation(g_hChildStd_ERR_Rd, HANDLE_FLAG_INHERIT, 0))
  {
    return false;
  }
 
  // Create a pipe for the child process's STDOUT. 
  if (!CreatePipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &sa, 0))
  {
    return false;
  }
 
  // Ensure the read handle to the pipe for STDOUT is not inherited
  if (!SetHandleInformation(g_hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0))
  {
    return false;
  }
 
  // Create the child process. 
  BOOL bSuccess = FALSE;
  PROCESS_INFORMATION piProcInfo = CreateExecChildProcess(cmd, bSuccess);
 
  if (!bSuccess)
    return false;
 
  ReadExecFromPipe(piProcInfo, output, err);
 
  //close handles explicitly.
  // Close the handles.
  CloseHandle(piProcInfo.hProcess);
  CloseHandle(piProcInfo.hThread);
 
  if (output.empty())
    output = err;
 
  return true; 
} 
 
// Create a child process that uses the previously created pipes
//  for STDERR and STDOUT.
PROCESS_INFORMATION CreateExecChildProcess(std::string cmd, BOOL &bSuccess)
{
  PROCESS_INFORMATION piProcInfo; 
  STARTUPINFO siStartInfo; 
 
  // Set up members of the PROCESS_INFORMATION structure. 
  ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));
 
  // Set up members of the STARTUPINFO structure. 
  // This structure specifies the STDERR and STDOUT handles for redirection.
  ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
  siStartInfo.cb = sizeof(STARTUPINFO); 
  siStartInfo.hStdError = g_hChildStd_ERR_Wr;
  siStartInfo.hStdOutput = g_hChildStd_OUT_Wr;
  siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
 
  // Create the child process. 
  bSuccess = CreateProcess(NULL, 
      (LPSTR)cmd.c_str(),     // command line 
      NULL,          // process security attributes 
      NULL,          // primary thread security attributes 
      TRUE,          // handles are inherited 
      NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW,             // creation flags 
      NULL,          // use parent's environment 
      NULL,          // use parent's current directory 
      &siStartInfo,  // STARTUPINFO pointer 
      &piProcInfo);  // receives PROCESS_INFORMATION
  CloseHandle(g_hChildStd_ERR_Wr);
  CloseHandle(g_hChildStd_OUT_Wr);
 
  return piProcInfo;
}
 
// Read output from the child process's pipe for STDOUT
// and write to the parent process's pipe for STDOUT. 
// Stop when there is no more data. 
void ReadExecFromPipe(PROCESS_INFORMATION piProcInfo, std::string &output, std::string &err)
{
  DWORD dwRead;
  CHAR chBuf[EXECBUFSIZE];
  BOOL bSuccess = FALSE;
  output = "";
  err = "";
  for (;;)
  { 
    bSuccess=ReadFile( g_hChildStd_OUT_Rd, chBuf, EXECBUFSIZE, &dwRead, NULL);
    if( ! bSuccess || dwRead == 0 ) break; 
 
    std::string s(chBuf, dwRead);
    output += s;
  } 
  dwRead = 0;
  for (;;)
  { 
    bSuccess=ReadFile( g_hChildStd_ERR_Rd, chBuf, EXECBUFSIZE, &dwRead, NULL);
    if( ! bSuccess || dwRead == 0 ) break; 
 
    std::string s(chBuf, dwRead);
    err += s;
  }
}
 
// add a directory and all its content to a zip archive
void addDirToArchive(zip_t *archive, const boost::filesystem::path &srcdir, const boost::filesystem::path &inputdir)
{
  std::string outputdir = inputdir.generic_string().substr(srcdir.parent_path().generic_string().length() + 1);
  if (zip_dir_add(archive, outputdir.c_str(), 0) < 0)
    throw std::runtime_error("Failed to add directory to archive: " + std::string(zip_strerror(archive)));
 
  boost::filesystem::directory_iterator dirIter(inputdir);
  boost::filesystem::directory_iterator end;
  while (dirIter != end)
  {
    if (boost::filesystem::is_directory(dirIter->path()))
      addDirToArchive(archive, srcdir, dirIter->path());
    else
    {
      zip_source_t *source = zip_source_file(archive, dirIter->path().generic_string().c_str(), 0, 0);
      if (source == NULL)
        throw std::runtime_error("Failed to add file to archive: " + std::string(zip_strerror(archive)));
 
      std::string outputfile = outputdir + "/" + dirIter->path().filename().generic_string();
      if (zip_file_add(archive, outputfile.c_str(), source, 0) < 0)
      {
        zip_source_free(source);
        throw std::runtime_error("Failed to add file to archive: " + std::string(zip_strerror(archive)));
      }
    }
    dirIter++;
  }
}
 
 
// /////////////////////////////////////////////////////////////////////////////////
// //////////////////////////////// SCOL FUNCTIONS /////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////////
 
int _MAKEandroidUnsignedAppBundle(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_MAKEandroidUnsignedAPK\n");
#endif
  boost::system::error_code ec;
 
  int imanifestPath = MMpull(m);
  int iname = MMget(m, 0);
 
  if (imanifestPath == NIL || iname == NIL)
  {
    MMechostr(MSKDEBUG, "error: manifest path or name is NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Parse args
  boost::filesystem::path manifestPath = MMstartstr(m, MTOP(imanifestPath));
  boost::filesystem::path basePath = manifestPath;
  basePath.remove_filename();
  std::string name = MMstartstr(m, MTOP(iname));
  std::string cmd = "";
  std::string cmdargs = "";
  std::string output;
  bool result;
 
  if (!boost::filesystem::exists(toolsPathBox.exe_aapt2Path))
  {
    std::string errmsg(std::string("error: ") + toolsPathBox.exe_aapt2Path.generic_string() + std::string(" doesn't exist !"));
    MMechostr(MSKDEBUG, "_MAKEandroidUnsignedAppBundle : %s\n", errmsg.c_str());
    MMset(m, 0, NIL);
    return 0;
  }
  ProjectPathBox projectPathBox(basePath);
 
  boost::filesystem::path unsignedAppBundle = projectPathBox.binPath / (name + ".unsigned.aab");
 
  // remove files if exist
  if (boost::filesystem::exists(unsignedAppBundle))
    boost::filesystem::remove(unsignedAppBundle, ec);
 
 
  // compile resources with aapt2
  std::string res_arg = " -R";
  if (boost::filesystem::exists(projectPathBox.resPath) && boost::filesystem::is_directory(projectPathBox.resPath))
  {
    boost::filesystem::create_directory(projectPathBox.tmpPath);
    boost::filesystem::recursive_directory_iterator resDirIter(projectPathBox.resPath);
    boost::filesystem::recursive_directory_iterator end;
 
    while (resDirIter != end)
    {
      if (!boost::filesystem::is_directory(resDirIter->path()))
      {
        cmd = "\"" + toolsPathBox.exe_aapt2Path.generic_string() + "\""
            + " compile \"" + resDirIter->path().string() + "\""
            + " -o \"" + projectPathBox.tmpPath.generic_string() + "\"";
        result = execProcess(cmd, output);
        if (!result)
        {
          MMechostr(MSKDEBUG, "error running aapt2 compile : %s\n", output.c_str());
          MMset(m, 0, NIL);
          Mpushstrbloc(m, (char*)output.c_str());
          MMpush(m, 2 * 2);
          MBdeftab(m);
          return 0;
        }
      }
      resDirIter++;
    }
 
    // list compiled resources files for next step
    boost::filesystem::directory_iterator compResDirIter(projectPathBox.tmpPath);
    boost::filesystem::directory_iterator compResEnd;
    while (compResDirIter != compResEnd)
    {
      res_arg += " \"" + compResDirIter->path().string() + "\"";
      compResDirIter++;
    }
  }
 
  // link resources with aapt2
  cmd = "\"" + toolsPathBox.exe_aapt2Path.generic_string() + "\""
      + " link"
      + " --proto-format"
      + " -o \"" + projectPathBox.projectArchive.generic_string() + "\""
      + " -I \"" + toolsPathBox.jar_androidPath.generic_string() + "\""
      + " --manifest \"" + projectPathBox.manifestPath.generic_string() + "\""
      + res_arg
      + " --auto-add-overlay";
 
 
  MMechostr(MSKRUNTIME, "_MAKEandroidUnsignedAppBundle command: %s\n", cmd.c_str());
  result = execProcess(cmd, output);
  if (!result)
  {
    MMechostr(MSKDEBUG, "error running aapt2 link : %s\n", output.c_str());
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2 * 2);
    MBdeftab(m);
    return 0;
  }
 
  // add assets, dex and lib dir to archive
  zip_t *archive;
  zip_error_t ziperror;
  try
  {
    // open archive
    int errorp;
    archive = zip_open(projectPathBox.projectArchive.generic_string().c_str(), 0, &errorp);
    if (archive == NULL)
    {
      zip_error_init_with_code(&ziperror, errorp);
      throw std::runtime_error("Failed to open archive " + projectPathBox.projectArchive.generic_string() + ": " + zip_error_strerror(&ziperror));
    }
 
    // move AndroidManifest.xml to manifest/AndroidManifest.xml
    zip_uint64_t index = zip_name_locate(archive, "AndroidManifest.xml", 0);
    if (index < 0 || zip_dir_add(archive, "manifest", 0) < 0 || zip_file_rename(archive, index, "manifest/AndroidManifest.xml", 0) < 0)
      throw std::runtime_error("Failed to move manifest inside archive " + projectPathBox.projectArchive.generic_string() + ": " + zip_error_strerror(&ziperror));
    
    // add assets, lib and dex directories to the archive
    addDirToArchive(archive, projectPathBox.assetsPath, projectPathBox.assetsPath);
    addDirToArchive(archive, projectPathBox.dexPath, projectPathBox.dexPath);
    addDirToArchive(archive, projectPathBox.libPath, projectPathBox.libPath);
    zip_close(archive);
  }
  catch(std::exception e)
  {
    if (archive != NULL)
      zip_close(archive);
    MMechostr(MSKDEBUG, "error packaging archive : %s\n", e.what());
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)e.what());
    MMpush(m, 2 * 2);
    MBdeftab(m);
    return 0;
  }
  
  // create bin directory
  boost::filesystem::create_directory(projectPathBox.binPath);
 
  // call bundletool with its arguments
  cmd = "\"" + toolsPathBox.exe_javacPath.generic_string() + "\" -jar \"" + toolsPathBox.jar_bundletoolPath.generic_string() + "\""
      + " build-bundle"
      + " --modules=\"" + projectPathBox.projectArchive.generic_string() + "\""
      + " --output=\"" + unsignedAppBundle.generic_string() + "\"";
 
  result = execProcess(cmd, output);
  if (!result)
  {
    MMechostr(MSKDEBUG, "error running bundletool : %s\n", output.c_str());
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2 * 2);
    MBdeftab(m);
    return 0;
  }
 
  if (boost::filesystem::exists(unsignedAppBundle))
  {
    MMpull(m);
    Mpushstrbloc(m, (char*)unsignedAppBundle.generic_string().c_str());
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2 * 2);
    MBdeftab(m);
  }
  else
  {
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2 * 2);
    MBdeftab(m);
  }
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _MAKEandroidUnsignedAppBundle\n");
#endif
  return 0;
}
 
int _MAKEandroidUnsignedAPK(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_MAKEandroidUnsignedAPK\n");
#endif
 
  boost::system::error_code ec;
  int imanifestPath = MMpull(m);
  int iname = MMget(m, 0);
 
  if (imanifestPath == NIL || iname == NIL)
  {
    MMechostr(MSKDEBUG, "error: manifest path or name is NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Parse args
  boost::filesystem::path manifestPath = MMstartstr(m, MTOP(imanifestPath));
  boost::filesystem::path basePath = manifestPath;
  basePath.remove_filename();
  std::string name = MMstartstr(m, MTOP(iname));
  std::string cmdargs = "";
 
  if (!boost::filesystem::exists(toolsPathBox.exe_aaptPath))
  {
    std::string errmsg(std::string("error: ") + toolsPathBox.exe_aaptPath.generic_string() + std::string(" doesn't exist !"));
    MMechostr(MSKDEBUG, "_MAKEandroidUnsignedAPK : %s\n", errmsg.c_str());
    MMset(m, 0, NIL);
    return 0;
  }
  ProjectPathBox projectPathBox(basePath);
 
  boost::filesystem::path unsignedApk = projectPathBox.binPath / (name + ".unsigned.apk");
 
  // remove files if exist
  if(boost::filesystem::exists(unsignedApk))
    boost::filesystem::remove(unsignedApk, ec);
 
  // Pile up aapt arguments
  cmdargs += "package";
  cmdargs += " -M \"" + projectPathBox.manifestPath.generic_string() + "\"";
  cmdargs += " -I \"" + toolsPathBox.jar_androidPath.generic_string() + "\"";
  cmdargs += " -F \"" + unsignedApk.generic_string() + "\"";
  cmdargs += " -S \"" + projectPathBox.resPath.generic_string() + "\"";
  cmdargs += " \"" + projectPathBox.dexPath.generic_string() + "\"";
  cmdargs += " \"" + projectPathBox.packagePath.generic_string() + "\"";
 
  //create bin directory
  boost::filesystem::create_directory(projectPathBox.binPath);
 
  // Call aapt with its arguments
  std::string cmd = "\"" + toolsPathBox.exe_aaptPath.generic_string() + "\" " + cmdargs;
 
  MMechostr(MSKRUNTIME, "_MAKEandroidUnsignedAPK command: %s\n", cmd.c_str());
  //int res = system(cmd.c_str());
  //if (res != 0)
 
  /*
  PROCESS_INFORMATION ProcessInfoF = {0};
  STARTUPINFO StartupInfoF = {0};
  StartupInfoF.cb = sizeof(StartupInfoF);
 
  if (!CreateProcess(NULL, (LPSTR)cmd.c_str(), NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW, NULL, NULL, &StartupInfoF, &ProcessInfoF))
  {
    MMechostr(MSKDEBUG, "error running aapt : %s\n", cmd.c_str());
    MMset(m, 0, NIL);
    return 0;
  }
  WaitForSingleObject(ProcessInfoF.hProcess, INFINITE);
  // Close the handles.
  CloseHandle(ProcessInfoF.hProcess);
  CloseHandle(ProcessInfoF.hThread);
  */
 
  std::string output;
  bool result = execProcess(cmd, output);
  if (!result)
  {
    MMechostr(MSKDEBUG, "error running aapt : %s\n", output.c_str());
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2*2);
    MBdeftab (m);
    return 0;
  }
 
  if (boost::filesystem::exists(unsignedApk))
  {
    MMpull(m);
    Mpushstrbloc(m, (char*)unsignedApk.generic_string().c_str());
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2*2);
    MBdeftab (m);
  }
  else
  {
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2*2);
    MBdeftab (m);
  }
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _MAKEandroidUnsignedAPK\n");
#endif
  return 0;
}
 
int _ENCRYPTandroidSigningKey(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_ENCRYPTandroidSigningKey\n");
#endif
  boost::system::error_code ec;
 
  int ibundlePath = MMpull(m);
  int ikeyAlias = MMpull(m);
  int ikeyPassword = MMpull(m);
  int ikeystorePath = MMget(m, 0);
 
  if (ikeystorePath == NIL || ikeyPassword == NIL || ikeyAlias == NIL)
  {
    MMechostr(MSKDEBUG, "error: destination path, application name, password or key alias are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Parse args
  boost::filesystem::path keystorePath = MMstartstr(m, MTOP(ikeystorePath));
  boost::filesystem::path encryptedKeyPath = MMstartstr(m, MTOP(ibundlePath));
  encryptedKeyPath.remove_filename();
  encryptedKeyPath /= boost::filesystem::change_extension(keystorePath.filename(), "keystore.encrypted");
  std::string keyPassword = MMstartstr(m, MTOP(ikeyPassword));
  std::string keyAlias = MMstartstr(m, MTOP(ikeyAlias));
  std::string cmd;
 
  if (!boost::filesystem::exists(toolsPathBox.jar_pepkPath))
  {
    std::string errmsg(std::string("error: ") + toolsPathBox.jar_pepkPath.generic_string() + std::string(" doesn't exist !"));
    MMechostr(MSKDEBUG, errmsg.c_str());
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove files if exist
  if (boost::filesystem::exists(encryptedKeyPath))
    boost::filesystem::remove(encryptedKeyPath, ec);
  
  // test if Java is available
  std::string output;
  bool result = execProcess("java --version", output);
  if (!result)
  {
    MMechostr(MSKDEBUG, "error : Java is not available\n");
    MMset(m, 0, NIL);
    Mpushstrbloc(m, "Java is not available on your computer. You must install Java in order to create and sign an Android App bundle");
    MMpush(m, 2 * 2);
    MBdeftab(m);
    return 0;
  }
 
  // Call aapt with its arguments
  cmd = "echo Encryption of the store key to upload to the Play Store & echo Please enter your store key password twice (the password will not appear as you type, that is the normal behaviour) & java -jar \"" + toolsPathBox.jar_pepkPath.generic_string() + "\""
    + " --keystore=\"" + keystorePath.generic_string() + "\""
    + " --alias=\"" + keyAlias + "\""
    + " --output=\"" + encryptedKeyPath.generic_string() + "\""
    + " --encryptionkey=\"eb10fe8f7c7c9df715022017b00c6471f8ba8170b13049a11e6c09ffe3056a104a3bbe4ac5a955f4ba4fe93fc8cef27558a3eb9d2a529a2092761fb833b656cd48b9de6a\""
    + " --include-cert";
 
  //bool result = execProcess(cmd, output);
  //if (!result)
  int res = system(cmd.c_str());
  if (res != 0)
  {
    MMechostr(MSKRUNTIME, "_ENCRYPTandroidSigningKey : error running pepk : %s\n", output.c_str());
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2 * 2);
    MBdeftab(m);
    return 0;
  }
 
  if (boost::filesystem::exists(encryptedKeyPath))
  {
    MMpull(m);
    Mpushstrbloc(m, (char*)encryptedKeyPath.generic_string().c_str());
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2 * 2);
    MBdeftab(m);
  }
  else
  {
    MMechostr(MSKRUNTIME, "_ENCRYPTandroidSigningKey : error running pepk : %s\n", cmd.c_str());
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2 * 2);
    MBdeftab(m);
  }
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _ENCRYPTandroidSigningKey\n");
#endif
  return 0;
}
 
int _MAKEandroidSigningKey(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_MAKEandroidSigningKey\n");
#endif
  boost::system::error_code ec;
 
  int iadditional = MMpull(m);
  int ikeyAlias = MMpull(m);
  int ikeyPassword = MMpull(m);
  int ikeystorePath = MMget(m, 0);
 
  if (ikeystorePath == NIL || ikeyPassword == NIL || ikeyAlias == NIL)
  {
    MMechostr(MSKDEBUG, "error: destination path, application name, password or key alias are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Parse args
  boost::filesystem::path keystorePath = MMstartstr(m, MTOP(ikeystorePath));
  std::string keyPassword = MMstartstr(m, MTOP(ikeyPassword));
  std::string keyAlias = MMstartstr(m, MTOP(ikeyAlias));
  std::string cmdargs = "-J-Duser.language=en ";
 
  if (!boost::filesystem::exists(toolsPathBox.exe_keytoolPath))
  {
    std::string errmsg(std::string("error: ") + toolsPathBox.exe_keytoolPath.generic_string() + std::string(" doesn't exist !"));
    MMechostr(MSKDEBUG, errmsg.c_str());
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove files if exist
  if(boost::filesystem::exists(keystorePath))
    boost::filesystem::remove(keystorePath, ec);
 
  // Parse additional parameters
  int q = 0;
  int ikey = 0;
  int ivalue = 0;
  int nbData = 0;
  std::string dname = "";
  while(iadditional != NIL)
  {
    q = MMfetch(m, MTOP(iadditional), 0);
                if (q != NIL)
    {
      ikey = MMfetch(m, MTOP(q), 0);
      ivalue = MMfetch(m, MTOP(q), 1);
      // bad parameter cancel
      if (ikey == NIL)
        continue;
 
      std::string skey = MMstartstr(m, MTOP(ikey));
      std::string svalue = "";
      if (ivalue != NIL)
        svalue = MMstartstr(m, MTOP(ivalue));
 
      // Check if key is valid
      if (!svalue.empty() && ((skey == "CN") || (skey == "OU") || (skey == "O") || (skey == "L") || (skey == "S") || (skey == "C")))
      {
        if (nbData != 0)
          dname += ", ";
 
        dname += skey + "=" + svalue;
        nbData++;
      }
    }
                iadditional = MMfetch(m, MTOP(iadditional), 1);
  }
 
  cmdargs += "-genkeypair";
  cmdargs += " -validity 20000 ";
  if (dname != "")
    cmdargs += " -dname \"" + dname + "\"";
  else
    cmdargs += " -dname \"C=AQ\"";  // there must be at least one dname attribute .. let's say default Country Code is Antartica.
 
  cmdargs += " -keystore \"" + keystorePath.generic_string() + "\"";
  cmdargs += " -storepass " + keyPassword;
  cmdargs += " -keypass " + keyPassword;
  cmdargs += " -alias " + keyAlias;
  cmdargs += " -keyalg RSA";
  cmdargs += " -keysize 2048";
 
  // Call aapt with its arguments
  std::string cmd = "\"" + toolsPathBox.exe_keytoolPath.generic_string() + "\" " + cmdargs;
  
  /*
  PROCESS_INFORMATION ProcessInfoF = {0};
  STARTUPINFO StartupInfoF = {0};
  StartupInfoF.cb = sizeof(StartupInfoF);
 
  if (!CreateProcess(NULL, (LPSTR)cmd.c_str(), NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW, NULL, NULL, &StartupInfoF, &ProcessInfoF))
  {
    MMechostr(MSKDEBUG, "error running keytool : %s\n", cmd.c_str());
    MMset(m, 0, NIL);
    return 0;
  }
  WaitForSingleObject(ProcessInfoF.hProcess, INFINITE);
  // Close the handles.
  CloseHandle(ProcessInfoF.hProcess);
  CloseHandle(ProcessInfoF.hThread);
  */
 
  std::string output;
  bool result = execProcess(cmd, output);
  if (!result)
  {
    MMechostr(MSKRUNTIME, "_MAKEandroidSigningKey : error running keytool : %s\n", output.c_str());
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2*2);
    MBdeftab (m);
 
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (boost::filesystem::exists(keystorePath))
  {
    MMpull(m);
    Mpushstrbloc(m, (char*)keystorePath.generic_string().c_str());
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2*2);
    MBdeftab (m);
  }
  else
  {
    MMechostr(MSKRUNTIME, "_MAKEandroidSigningKey : error running keytool : %s\n", cmd.c_str());
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2*2);
    MBdeftab (m);
  }
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _MAKEandroidSigningKey\n");
#endif
  return 0;
}
 
int _SIGNandroidAppBundle(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_SIGNandroidAppBundle\n");
#endif
  boost::system::error_code ec;
 
  int ikeyAlias = MMpull(m);
  int ikeyPassword = MMpull(m);
  int ikeystorePath = MMpull(m);
  int iunsignedAppBundlepath = MMget(m, 0);
 
  // Check args
  if (ikeyAlias == NIL || ikeyPassword == NIL || ikeystorePath == NIL || iunsignedAppBundlepath == NIL)
  {
    MMechostr(MSKDEBUG, "_SIGNandroidAppBundle : error: manifest path, keystore path, key password or key alias are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!boost::filesystem::exists(toolsPathBox.exe_jarsignerPath))
  {
    std::string errmsg(std::string("error: ") + toolsPathBox.exe_jarsignerPath.generic_string() + std::string(" doesn't exist !"));
    MMechostr(MSKDEBUG, "_SIGNandroidAppBundle : %s\n", errmsg.c_str());
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Parse args
  boost::filesystem::path unsignedAppBundlePath = MMstartstr(m, MTOP(iunsignedAppBundlepath));
  boost::filesystem::path keystorePath = MMstartstr(m, MTOP(ikeystorePath));
  std::string password = MMstartstr(m, MTOP(ikeyPassword));
  std::string alias = MMstartstr(m, MTOP(ikeyAlias));
  std::string cmdargs = "-J-Duser.language=en ";
 
  // Strip suffix from unsigned apk path, and make final apk paths from it
  boost::filesystem::path appBundlePath(unsignedAppBundlePath);
  appBundlePath = boost::filesystem::change_extension(appBundlePath, "");
  int lastindex = appBundlePath.generic_string().find_last_of(".");
  appBundlePath = appBundlePath.generic_string().substr(0, lastindex);
 
  boost::filesystem::path finalAppBundlePath = appBundlePath.generic_string() + ".aab";
 
  // remove files if exist
  if (boost::filesystem::exists(finalAppBundlePath))
    boost::filesystem::remove(finalAppBundlePath, ec);
 
  cmdargs += "-tsa http://timestamp.digicert.com";
  cmdargs += " -keystore \"" + keystorePath.generic_string() + "\"";
  cmdargs += " -storepass " + password;
  cmdargs += " -keypass " + password;
  cmdargs += " -sigalg SHA1withRSA";
  cmdargs += " -digestalg SHA1";
  cmdargs += " -signedjar \"" + finalAppBundlePath.generic_string() + "\"";
  cmdargs += " \"" + unsignedAppBundlePath.generic_string() + "\"";
  cmdargs += " " + alias;
 
  // Call jarsigner with its arguments
  std::string cmd = "\"" + toolsPathBox.exe_jarsignerPath.generic_string() + "\" " + cmdargs;
 
  std::string output;
  bool result = execProcess(cmd, output);
  if (!result || !boost::filesystem::exists(finalAppBundlePath))
  {
    MMechostr(MSKDEBUG, "_SIGNandroidAppBundle : error running jarsigner : %s\n", output.c_str());
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2 * 2);
    MBdeftab(m);
 
    return 0;
  }
 
  // remove unsigned file keep only the final one
  if (boost::filesystem::exists(unsignedAppBundlePath))
    boost::filesystem::remove(unsignedAppBundlePath, ec);
 
  if (boost::filesystem::exists(finalAppBundlePath))
  {
    MMpull(m);
    Mpushstrbloc(m, (char*)finalAppBundlePath.generic_string().c_str());
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2 * 2);
    MBdeftab(m);
  }
  else
  {
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2 * 2);
    MBdeftab(m);
  }
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _SIGNandroidAppBundle\n");
#endif
  return 0;
}
 
int _SIGNandroidAPK(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_SIGNandroidAPK\n");
#endif
  boost::system::error_code ec;
 
  int ikeyAlias = MMpull(m);
  int ikeyPassword = MMpull(m);
  int ikeystorePath = MMpull(m);
  int iunsignedAPKpath = MMget(m, 0);
 
  // Check args
  if (ikeyAlias == NIL || ikeyPassword == NIL || ikeystorePath == NIL || iunsignedAPKpath == NIL)
  {
    MMechostr(MSKDEBUG, "_SIGNandroidAPK : error: manifest path, keystore path, key password or key alias are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!boost::filesystem::exists(toolsPathBox.exe_jarsignerPath))
  {
    std::string errmsg(std::string("error: ") + toolsPathBox.exe_jarsignerPath.generic_string() + std::string(" doesn't exist !"));
    MMechostr(MSKDEBUG, "_SIGNandroidAPK : %s\n", errmsg.c_str());
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Parse args
  boost::filesystem::path unsignedAPKPath = MMstartstr(m, MTOP(iunsignedAPKpath));
  boost::filesystem::path keystorePath = MMstartstr(m, MTOP(ikeystorePath));
  std::string password = MMstartstr(m, MTOP(ikeyPassword));
  std::string alias = MMstartstr(m, MTOP(ikeyAlias));
  std::string cmdargs = "";
 
  // Strip suffix from unsigned apk path, and make signed and final apk paths from it
 
  boost::filesystem::path apkPath(unsignedAPKPath);
  apkPath = boost::filesystem::change_extension(apkPath, "");
  int lastindex = apkPath.generic_string().find_last_of(".");
  apkPath = apkPath.generic_string().substr(0, lastindex);
 
  boost::filesystem::path alignedAPKPath = apkPath.generic_string() + ".aligned.apk";
  boost::filesystem::path finalAPKPath = apkPath.generic_string() + ".apk";
  
  // remove files if exist
  if(boost::filesystem::exists(alignedAPKPath))
    boost::filesystem::remove(alignedAPKPath, ec);
  
  if(boost::filesystem::exists(finalAPKPath))
    boost::filesystem::remove(finalAPKPath, ec);
 
  cmdargs += "-f 4 ";
  cmdargs += "\"" + unsignedAPKPath.generic_string() + "\" ";
  cmdargs += "\"" + alignedAPKPath.generic_string() + "\" ";
 
  std::string cmd = "\"" + toolsPathBox.exe_zipalignPath.generic_string() + "\" " + cmdargs;
  //res = system(cmd.c_str());
  //if (res != 0)
 
  /*StartupInfoF.cb = sizeof(StartupInfoF);
 
  if (!CreateProcess(NULL, (LPSTR)cmd.c_str(), NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW, NULL, NULL, &StartupInfoF, &ProcessInfoF))
  {
    MMechostr(MSKDEBUG, "error running zipalign : %s\n", cmd.c_str());
    system("cd %__LASTDIR%");
    MMset(m, 0, NIL);
    return 0;
  }
 
  WaitForSingleObject(ProcessInfoF.hProcess, INFINITE);
  // Close the handles.
  CloseHandle(ProcessInfoF.hProcess);
  CloseHandle(ProcessInfoF.hThread);
  */
 
  std::string output;
  bool result = execProcess(cmd, output);
  if (!result)
  {
    MMechostr(MSKDEBUG, "_SIGNandroidAPK : error running zipalign : %s\n", output.c_str());
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2*2);
    MBdeftab (m);
    return 0;
  }
 
  cmd = "\"" + toolsPathBox.exe_javacPath.generic_string() + "\" -jar \"" + toolsPathBox.jar_apksignerPath.generic_string() + "\""
    + " sign"
    + " --ks \"" + keystorePath.generic_string() + "\""
    + " --ks-pass \"pass:" + password + "\""
    + " --v1-signing-enabled true"
    + " --v2-signing-enabled true"
    + " --out \"" + finalAPKPath.generic_string() + "\""
    + " \"" + alignedAPKPath.generic_string() + "\"";
 
  result = execProcess(cmd, output);
  if (!result)
  {
    MMechostr(MSKDEBUG, "error running apksigner : %s\n", output.c_str());
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2 * 2);
    MBdeftab(m);
    return 0;
  }
 
  // remove signed / unsigned file keep only the final one
  if(boost::filesystem::exists(unsignedAPKPath))
    boost::filesystem::remove(unsignedAPKPath, ec);
 
  if(boost::filesystem::exists(alignedAPKPath))
    boost::filesystem::remove(alignedAPKPath, ec);
 
  if (boost::filesystem::exists(finalAPKPath))
  {
    MMpull(m);
    Mpushstrbloc(m, (char*)finalAPKPath.generic_string().c_str());
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2*2);
    MBdeftab (m);
  }
  else
  {
    MMset(m, 0, NIL);
    Mpushstrbloc(m, (char*)output.c_str());
    MMpush(m, 2*2);
    MBdeftab (m);
  }
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _SIGNandroidAPK\n");
#endif
  return 0;
}
 
int _INSTALLandroidAPK(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_INSTALLandroidAPK\n");
#endif
 
  int iAPKPath = MMget(m, 0);
 
  if (iAPKPath == NIL)
  {
    MMechostr(MSKDEBUG, "error: APK path is NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!boost::filesystem::exists(toolsPathBox.exe_adbPath))
  {
    std::string errmsg(std::string("error: ") + toolsPathBox.exe_adbPath.generic_string() + std::string(" doesn't exist !"));
    MMechostr(MSKDEBUG, errmsg.c_str());
    MMset(m, 0, NIL);
    return 0;
  }
 
  boost::filesystem::path APKPath = MMstartstr(m, MTOP(iAPKPath));
 
  // Call adb
  std::string cmd = "\"\"" + toolsPathBox.exe_adbPath.generic_string() + "\" install -r \"" + APKPath.generic_string() + "\"\"";
  int res = system(cmd.c_str());
  if (res != 0)
  {
    MMechostr(MSKDEBUG, "error running adb : %s\n", cmd.c_str());
    system("cd %__LASTDIR%");
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(0));
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _INSTALLandroidAPK\n");
#endif
  return 0;
}
 
int _CHECKandroidTools(mmachine m)
{
  if (!boost::filesystem::exists(toolsPathBox.exe_aaptPath))
    MMpush(m, ITOM(0));
  else
    MMpush(m, ITOM(1));
  return 0;
}
 
// /////////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////////
 
// /////////////////////////////////////////////////////////////////////////////////
// //////////////////////////////////// BINDING ////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////////
 
NativeDefinition base_android_deployer[] =
{
  { "_MAKEandroidUnsignedAppBundle", 2, "fun [S P] [P S]", _MAKEandroidUnsignedAppBundle },
  { "_MAKEandroidUnsignedAPK", 2, "fun [S P] [P S]", _MAKEandroidUnsignedAPK },
  { "_ENCRYPTandroidSigningKey", 4, "fun [P S S P] [P S]", _ENCRYPTandroidSigningKey },
  { "_MAKEandroidSigningKey", 4, "fun [W S S [[S S] r1]] [P S]", _MAKEandroidSigningKey },
  { "_SIGNandroidAppBundle", 4, "fun [P P S S] [P S]", _SIGNandroidAppBundle },
  { "_SIGNandroidAPK", 4, "fun [P P S S] [P S]", _SIGNandroidAPK },
  { "_INSTALLandroidAPK", 1, "fun [P] I", _INSTALLandroidAPK },
  { "_CHECKandroidTools", 0, "fun [] I", _CHECKandroidTools }
};
 
int LoadAndroidDeployer(mmachine m)
{
  int k;
  MMechostr(MSKDEBUG, " > Loading Android Deployer\n");
  k = PKhardpak2(m, "android_deployer.pkg", sizeof(base_android_deployer) / sizeof(base_android_deployer[0]), base_android_deployer);
  MMechostr(MSKDEBUG, " > Successfully Loaded\n\n");
  return k;
}
 
// /////////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////////