Application: gvSIG desktop

/* Copyright (c) 2004 Julien Ponge - All rights reserved.

 * Some windows 98 debugging done by Dustin Sacks.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

 * IN THE SOFTWARE.

 */

#include <wx/string.h>

#include <wx/file.h>

#include <wx/filename.h>

#include <wx/url.h>

#include <wx/process.h>

#include "launcher.h"

#ifdef __UNIX__

  #include <stdlib.h>

  #include <map>

  #include <list>

#endif

/*

 * Helper function to run an external program. It takes care of the subtule

 * differences between the OS-specific implementations.

 *

 * @param cmd The command to run.

 * @return <code>true</code> in case of a success, <code>false</code> otherwise.

 */

bool run_external(wxString cmd)

{

 int code = wxExecute(cmd, wxEXEC_SYNC);

 return (code == 0);

}

bool run_external_async(wxString cmd)

{

 return (wxExecute(cmd, wxEXEC_ASYNC) != 0);

}

bool string_to_bool(wxString value, bool defaultValue){

 bool returnValue = defaultValue;

 if (value != wxEmptyString)

    if (

       value.CmpNoCase("s")   == 0  ||

       value.CmpNoCase("si")  == 0  ||

       value.CmpNoCase("1")   == 0  ||

       value.CmpNoCase("y")   == 0  ||

       value.CmpNoCase("yes") == 0

       ) 

    {

       returnValue = true;

    } else {

       returnValue = false;

    }

  return returnValue;

}

long LAUNCHAPP_TIMER_ID = wxNewId();

BEGIN_EVENT_TABLE(LauncherApp, wxApp)

    EVT_TIMER(LAUNCHAPP_TIMER_ID, LauncherApp::OnTimer)

END_EVENT_TABLE()

/* Main Application $Revision: 7006 $

 *

 * $Id: launcher.cpp 7006 2006-09-04 15:25:57Z jmvivo $

 */

LauncherApp::LauncherApp()

  : wxApp()

{

  APPLICATION_NAME = wxString("gvSIG Install-Launcher");

  completed = false;

  SetAppName(_( APPLICATION_NAME ));

  loadParams();

}

void LauncherApp::echo(const wxString &msg) 

{

  wxMessageDialog dlg(0, msg, _(APPLICATION_NAME), wxOK);

  dlg.ShowModal();

}

void LauncherApp::notifyToUser(const wxString &msg) 

{

  wxMessageDialog dlg(0, msg, _(APPLICATION_NAME), wxOK | wxICON_INFORMATION);

  dlg.ShowModal();

}

LauncherApp::~LauncherApp()

{

}

void LauncherApp::loadParams()

{

  cfgName = wxString( "launcher.ini" );

  wxFileInputStream in( cfgName );

  wxFileConfig cfg( in );

  wxString downloadEnabled;

  wxString launchJarAsync;

  wxString askForCheckingProcess;

  cfg.Read( "jar",                    &paramsJar,                wxEmptyString);

  cfg.Read( "jre",                    &paramsJre,                wxEmptyString);

  cfg.Read( "downloadJre",            &paramsJreDownload,        wxEmptyString);

  cfg.Read( "jai",                    &paramsJai,                wxEmptyString);

  cfg.Read( "downloadJai",            &paramsJaiDownload,        wxEmptyString);

  cfg.Read( "jai_io",                 &paramsJaiIo,              wxEmptyString);

  cfg.Read( "downloadJai_io",         &paramsJaiIoDownload,      wxEmptyString);

  cfg.Read( "jre_version",            &paramsJreVersion,         wxEmptyString);

  cfg.Read( "jre_version_prefered",   &paramsJreVersionPrefered, wxEmptyString);

  cfg.Read( "jarParams",              &paramsJarParams,          wxEmptyString);

  cfg.Read( "downloadEnabled",        &downloadEnabled,          wxEmptyString);

  cfg.Read( "launchJarAsync",         &launchJarAsync,           wxEmptyString);

  cfg.Read( "askForCheckingProcess",  &askForCheckingProcess,    wxEmptyString);

  //procesamos el parametro booleano 'downloadEnabled'

  paramsEnabledDownload =string_to_bool(downloadEnabled,false);

  //procesamos el parametro booleano 'launchJarAsync'

  paramsLaunchJarAsync =string_to_bool(launchJarAsync,false);

  //procesamos el parametro booleano 'askForCheckingProcess'

  paramsAskForCheckingProcess=string_to_bool(askForCheckingProcess,true);

  if (paramsJar == wxEmptyString )

  {

    error(_("The configuration file '") + cfgName + _("' does not contain a jar file entry."));

  }

  if (paramsJreVersionPrefered == wxEmptyString ) {

     paramsJreVersionPrefered = wxString(paramsJreVersion);

  }

}

void LauncherApp::error(const wxString &msg)

{

  wxMessageDialog dlg(0, msg, _(APPLICATION_NAME), wxOK | wxICON_ERROR);

  dlg.ShowModal();

  exit(1);

}

void LauncherApp::confirm(const wxString &msg)

{

  int response;

  wxMessageDialog dlg(0, msg, _(APPLICATION_NAME), wxOK | wxCANCEL | wxICON_QUESTION );

  response = dlg.ShowModal();

  if (response != wxID_OK) {

    notifyToUser(_("Canceled by user"));

    exit(1);

  }

}

bool LauncherApp::confirmYesNoCancel(const wxString &msg,const int yesDefault = true)

{

  int response;

  long maskDefault;

  if (yesDefault) {

     maskDefault = wxYES_DEFAULT | wxYES_NO | wxCANCEL | wxICON_QUESTION;

  } else {

     maskDefault = wxNO_DEFAULT | wxYES_NO | wxCANCEL | wxICON_QUESTION;       

  }

  wxMessageDialog dlg(0, msg, _(APPLICATION_NAME),  maskDefault);

  response = dlg.ShowModal();

  if (response != wxID_YES && response != wxID_NO) {

    notifyToUser(_("Canceled by user"));

    exit(1);

  }

  return (response == wxID_YES);

}

bool LauncherApp::OnInit()

{

  isStatusDialogVisible = false;

  locale.Init();

  locale.AddCatalog("launcher");

  statusDialog = new StatusDialog( APPLICATION_NAME );

  statusDialog->Centre();

  statusDialog->Show(TRUE);

  isStatusDialogVisible = true;

  showStatusMsg(_("Intializing..."));

  myTimer = new wxTimer(this,LAUNCHAPP_TIMER_ID);

  myTimer->Start(150,true);

  this->MainLoop();

  return true;

  /*

  if (!searchJRE())

  {

    jreInstall();

  }

  fixSystemJREConfig();

  jaiInstall();

  jaiIoInstall();

  runJRE();

  exit(0);    

  return false;

  */

}

void LauncherApp::fixSystemJREConfig(){

  showStatusMsg(_("Updating the system..."));

  //actualizamos CurrentVersion

  wxString baseKey = "HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft"

                     "\\Java Runtime Environment\\";

  wxString genericVersion = paramsJreVersion.Left(3);

  wxString baseKeyGeneric = baseKey + genericVersion + "\\";

  wxString baseKeyVersion = baseKey + localVersionToUse + "\\";

  wxRegKey *pRegKey = new wxRegKey(baseKey);

  if( !pRegKey->Exists() ) {

    error(_("JRE not found."));

  }

  //pRegKey->SetValue("CurrentVersion",genericVersion); // **********

  // compiamos el contenido de la rama de la version

  // que queremos a la generica (1.4 o 1.5 o ...)

  wxRegKey *pRegKeyGeneric = new wxRegKey(baseKeyGeneric);

  wxRegKey *pRegKeyVersion = new wxRegKey(baseKeyVersion);

  if ( !pRegKeyGeneric->Exists() ){

    pRegKeyGeneric->Create();  

  }

  wxString tempKey;

  wxString tempValue;

  size_t nValues;

  //pRegKeyGeneric->SetValue("hola","generico");

  //pRegKeyVersion->SetValue("hola","version");

  pRegKeyVersion->GetKeyInfo(NULL,NULL,&nValues,NULL);

  long pos = 1;

  pRegKeyVersion->GetFirstValue(tempKey,pos);

  for(unsigned i=0;i<nValues;i++)        {

      //echo("copy " + tempKey);

      pRegKeyVersion->QueryValue(tempKey,tempValue);

      pRegKeyGeneric->SetValue(tempKey,tempValue);

      pRegKeyVersion->GetNextValue(tempKey,pos);

  }

  //copiamos el java.exe a Windows/System32

  //wxString source = javaHome + "\\bin\\java.exe";

  //wxString target = getenv("windir"); 

  //target = target + "\\system32\\java.exe";

  //bool isOk = wxCopyFile(source, target, true);

  //if (!isOk) {

  //  error(_("Error perform copy ") + source + _(" to ") + target);

  //}

}

bool LauncherApp::compareVersions(const wxString localVersion, const wxString requireVersion)

{

    bool result  = (localVersion.Cmp(requireVersion) == 0);

    /*

        if (requireVersion.Len() > localVersion.Len() )        {   

                result = (localVersion.Find(requireVersion) == 0);

        }

        else 

        {

                result = (requireVersion.Find(localVersion) == 0);

        }

        */

    /*

        if (result) {

            echo("localversion = '" + localVersion +"' requireVersion = '"+ requireVersion +"' ==> true");

    } else {

       echo("localversion = '" + localVersion +"' requireVersion = '"+ requireVersion +"' ==> false");

    }

    */

        return result;

}

bool LauncherApp::searchJRE()

{

  showStatusMsg(_("Searching for JRE..."));

  wxString version("");

  // Windows[tm] registry lookup

  wxString baseKey = "HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft"

                     "\\Java Runtime Environment\\";

  wxRegKey bKey(baseKey);

  if (!bKey.Exists())  {

     return false;

  }

  if (!bKey.QueryValue("CurrentVersion", version)){

     return false;

  }

  if (version == "1.1") {

     return false;

  }

  if (!compareVersions(version, paramsJreVersionPrefered)){

        //Nos recorremos las versiones instaladas

        version = "";

        wxString strTemp;

        wxRegKey sKey(baseKey);

        if (sKey.HasSubKey(paramsJreVersionPrefered)) {

      version = wxString(paramsJreVersionPrefered);

    } else {              

          for(unsigned i=20;i>1;i--) {

        strTemp = wxString::Format(paramsJreVersion + "_%02d",i);

        if (sKey.HasSubKey(strTemp)) {

                        version = strTemp;

                        break;

                }

          }               

    }

  }

  if (version == "") {

     return false;

  }            

  localVersionToUse = version;

  wxRegKey vKey(baseKey + version);

  if (!vKey.QueryValue("JavaHome", javaHome)){

     return false;

  }

  int osVerMayor;

  int osVerMinor;

  wxGetOsVersion(&osVerMayor,&osVerMinor);

  if (osVerMayor < 5) {

    javaExecPath = javaHome + "\\bin\\java";

  }else{

    javaExecPath = javaHome + "\\bin\\javaw";

  }

  /*

  echo("paramsJreVersion=" + paramsJreVersion);

  echo("paramsJreVersionPrefered=" + paramsJreVersionPrefered);

  echo("localVersionToUse=" + localVersionToUse);

  echo("javaHome=" +javaHome);

  echo("javaExecPath=" +javaExecPath);

  */

  return true;

}

void LauncherApp::runJRE()

{

  showStatusMsg(_("Launching instalation..."));

  if (!wxFile::Exists(paramsJar))

  {

    error(_("The jar-file in the configuration file ") + cfgName + _(" does exist."));

  }

  wxString cmd = javaExecPath + paramsJarParams + wxString(" -jar ") + paramsJar;

  if (paramsLaunchJarAsync) {

      if (!run_external_async(cmd))

      {

        error(_("The jar-file ") + paramsJar + _(" could not be executed." ));

      }

  } else {

      if (!run_external(cmd))

      {

        error(_("The jar-file ") + paramsJar + _(" could not be executed." ));

      }  

  }

  completed = true;

}

void LauncherApp::jreInstall()

{

  showStatusMsg(_("Preparing to install JRE..."));

  if (!checkInstallerFile(paramsJre, paramsJreDownload,_("Java JRE version ")+paramsJreVersion))

  {

    error(_("The JRE could not be setup."));  

  }

  showStatusMsg(_("Installing JRE..."));

  if (!run_external(paramsJre))

  {

    error(_("The JRE could not be setup."));

  }

  if (!searchJRE()) {

    error(_("The JRE could not be setup."));

  }    

}

// Not used

void LauncherApp::netDownload()

{

  wxString browser;

#ifdef __WINDOWS__

  // We use the default browser.

  browser = "rundll32 url.dll,FileProtocolHandler ";

#endif

#ifdef __UNIX__

  // We try some browsers and use the first successful one.

  std::list<std::pair<wxString, wxString> > commands;

  std::pair<wxString, wxString> cmd;

  cmd.first = "konqueror "; cmd.second = "konqueror -v";

  commands.push_back(cmd);

  cmd.first = "mozilla -splash "; cmd.second = "mozilla -v";

  commands.push_back(cmd);

  cmd.first = "firefox -splash "; cmd.second = "firefox -v";

  commands.push_back(cmd);

  cmd.first = "firebird -splash "; cmd.second = "firebird -v";

  commands.push_back(cmd);

  cmd.first = "opera "; cmd.second = "opera -v";

  commands.push_back(cmd);

  cmd.first = "netscape "; cmd.second = "netscape -v";

  commands.push_back(cmd);

  std::list<std::pair<wxString, wxString> >::iterator it;

  for (it = commands.begin(); it != commands.end(); ++it)

  {

    if (wxExecute(it->second, wxEXEC_SYNC) == 0)

    {

      browser = it->first;

      break;

    }

  }

#endif

  /*

  if (run_external(browser + paramsDownload))

  {

    completed = true;

  }

  else

  {

    error(_("Could not find a web browser."));

  }

  */

}

IMPLEMENT_APP(LauncherApp)

void LauncherApp::jaiInstall()

{

  bool isOK;

  showStatusMsg(_("Checking JAI Library..."));

  wxString baseKey = "HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft"

                     "\\Java Runtime Environment\\";

  wxString currentVersion;

  wxRegKey *pRegKey = new wxRegKey(baseKey);

  if( !pRegKey->Exists() )

    error(_("JRE not found."));

  if (!pRegKey->QueryValue("CurrentVersion", currentVersion)) error(_("JRE not found."));

  isOK=true;  

  if (!checksJai()) {

      //confirm(_("JAI library is required, Install it?"));

      showStatusMsg(_("Preparing to install JAI Library..."));

      if (!checkInstallerFile(paramsJai, paramsJaiDownload, _("JAI Library")))

      {

        isOK=false;  

      } else {

        pRegKey->SetValue("CurrentVersion",localVersionToUse);

        showStatusMsg(_("Preparing to install JAI Library..."));

        if (run_external(paramsJai))

        {

          isOK=(checksJai());

        } else {

          isOK=false;

        }  

        pRegKey->SetValue("CurrentVersion",currentVersion);

      }

  }  

  if (!isOK) {

    error(_("The JAI could not be setup."));

  }

}

void LauncherApp::jaiIoInstall()

{

  bool isOK;

  showStatusMsg(_("Checking JAI imageIO Library..."));

  wxString baseKey = "HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft"

                     "\\Java Runtime Environment\\";

  wxString currentVersion;

  wxRegKey *pRegKey = new wxRegKey(baseKey);

  if( !pRegKey->Exists() )

    error(_("JRE not found."));

  if (!pRegKey->QueryValue("CurrentVersion", currentVersion)) error(_("JRE not found."));

  isOK=true;  

  if (!checksJaiIo()) {

      //confirm(_("JAI ImageIO library is required, Install it?"));

      showStatusMsg(_("Preparing to install JAI imageIO Library..."));

      if (!checkInstallerFile(paramsJaiIo, paramsJaiIoDownload,"JAI ImageIO Library"))

      {

        isOK=false;  

      } else {

        pRegKey->SetValue("CurrentVersion",localVersionToUse);

        showStatusMsg(_("Installing JAI imageIO Library..."));

        if (run_external(paramsJaiIo))

        {                                    

          isOK=(checksJaiIo());

        } else {

          isOK=false;        

        }

         pRegKey->SetValue("CurrentVersion",currentVersion);

      }

  }  

  if (!isOK) {

             error(_("The JAI imageIO could not be setup."));

  }

}

bool LauncherApp::checksJai(){

   return (wxFileExists(javaHome + "\\lib\\ext\\jai_core.jar"));

}

bool LauncherApp::checksJaiIo(){

   return (wxFileExists(javaHome + "\\lib\\ext\\jai_imageio.jar"));     

}

bool LauncherApp::downloadFileHttp(const wxString urlOfFile, const wxString filePath, const wxString msg){

  bool isOk;

  //echo(urlOfFile);

  if (urlOfFile == wxEmptyString) {

     return false;

  }

  if (filePath == wxEmptyString) {

     return false;

  }

  showStatusMsg(msg);

  wxURL url(urlOfFile);

  //echo("url open");

  wxInputStream *in_stream;

  in_stream = url.GetInputStream();

  //echo("in_stream open");

  if (!in_stream->IsOk()) {

     //echo("in_stream.IsOk == false");

     return false;

  }

  //echo("in_stream.IsOk == true");

  //echo("filePath =" + filePath);

  wxFileName fileName(filePath);

  // Preparamos la ruta para el fichero destino

  wxArrayString dirs;

  dirs = fileName.GetDirs();

  wxString dir;

  wxFileName curDir(".");

  for (size_t i=0; i < dirs.GetCount(); i++) {

      dir = dirs.Item(i);

      curDir.AppendDir(dir);

      //echo("dir " + curDir.GetPath());

      if (!curDir.DirExists()) {

         //echo("creating dir");

         isOk = curDir.Mkdir();

         if (!isOk) {

            //echo("dir create no ok");

            return false;

         }

         //echo("dir create ok");

      }

  }

  wxFileOutputStream out_stream  = wxFileOutputStream(filePath);

  //echo("out_stream open");

  //in_stream->Read(out_stream);

  size_t nbytes = 10240;

  char buffer[nbytes];

  //while (!in_stream->Eof()) {

  while (!in_stream->Eof()) {

      in_stream->Read(&buffer,nbytes);  

      if (in_stream->LastError() != wxSTREAM_NO_ERROR && in_stream->LastError() != wxSTREAM_EOF) {

          return false;

      }

      out_stream.Write(&buffer,in_stream->LastRead());

      if (out_stream.LastError() != wxSTREAM_NO_ERROR) {       

         return false;                                                                   

      }

      int totalKb = out_stream.GetSize() / 1024;

      wxString totalMsg =msg.Format("%i",totalKb);

      showStatusMsg(msg+" "+ totalMsg + " Kb");

  }

  isOk = true;

  /*

  if (isOk) {

    echo("isOk = true");

  } else {

    echo("isOk = false");         

  }

  */

  delete in_stream;

  //echo("end");

  return isOk;

}

bool LauncherApp::checkInstallerFile(const wxString filePath, const wxString urlDownload, const wxString fileDescription) {

  if (!wxFile::Exists(filePath))

  {

    if (paramsEnabledDownload) 

    {

      wxString msg = _("Instalation require download this file:\n") + 

                     fileDescription + "\n" +

                     _("Do you want to continue?");

      confirm(msg);

      //showStatusMsg(_("Downloading ") + fileDescription + "...");      

      if (!downloadFileHttp(urlDownload,filePath,_("Downloading ") + fileDescription + "..." )) 

      {

        //FIXME: Falta msgError

        return false;  

      }       

    }

    else

    {

      return false;  

    }

  }

  return true;

}

void LauncherApp::showStatusMsg(const wxString msg) {

  if (isStatusDialogVisible) {

     while (this->Pending()) {

           this->Dispatch();

     }

     if (statusDialog->IsCanceled()) {

        int response;

        wxMessageDialog dlg(0, _("Are you sure to cancel instalation process?"), _(APPLICATION_NAME), wxYES_NO | wxICON_QUESTION );

        response = dlg.ShowModal();

        if (response == wxID_YES) {

            notifyToUser(_("Canceled by user"));

            exit(1);

        }

        statusDialog->DoNotCancel();

     }

     statusDialog->showStatus(msg);

  }

}

bool LauncherApp::checkVersion(const wxString javaexe)

{

     wxString cmd;

     wxArrayString out;

     wxArrayString err;

     cmd = cmd.Format("%s -version", javaexe.c_str());

     if( wxExecute(cmd,out,err)!= 0 ) {

         notifyToUser("wxExecute ha petao.");      

         exit(1);

     }

     if (err[0].Contains("1.4.2") && err[0].Contains("version")) {

        return true; 

     }

     notifyToUser(cmd.Format(_("%s\nJava 1.4.2 recommended"), err[0].c_str()));

     return false;

}

void LauncherApp::run(){

  bool doChecks = true;

  if (paramsAskForCheckingProcess) {

     wxString msg = _("Do you want to check the application requirements?");

     doChecks = confirmYesNoCancel(msg,true);

  }

  if (doChecks) {

      if (!searchJRE())

      {

        jreInstall();

      }

      fixSystemJREConfig();

      jaiInstall();

      jaiIoInstall();

  } else {

    // No quiere comprobacion, por lo que solicitamos 

    wxString msgDir = _("Find de Java Virtual Machine executable file to run");   

    wxFileDialog dlg(

        0,

        msgDir,

        wxEmptyString,

        wxString("java.exe"),

        wxString("Java VM executable file (java.exe)|java.exe"),

        wxOPEN | wxFILE_MUST_EXIST,

        wxDefaultPosition

    );

    int response = dlg.ShowModal();  

    if (response != wxID_OK) {

       notifyToUser(_("Canceled by user"));

       exit(1);

    }

    //caragamos la variable con el eljecutable

    javaExecPath = dlg.GetPath();

    checkVersion(javaExecPath);

    //generamos el path para el JavaHome (por si acaso)

    wxFileName fileName(javaExecPath);

    fileName.SetFullName("");

    fileName.AppendDir("..");

    fileName.Normalize();

    javaHome = fileName.GetPath();

  }

  runJRE();

  exit(0);    

}

void LauncherApp::OnTimer(wxTimerEvent& event) {     

     run();

}