SO3EmbeddedWebNavigatorManager.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) 2011 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
-----------------------------------------------------------------------------
*/
 
#include "SO3Web/SO3EmbeddedWebNavigatorManager.h"
#include "SO3Web/SO3EmbeddedWebNavigator.h"
#include "SO3Web/SO3EmbeddedWebNavigatorThread.h"
#if SO3_WEB_NAVIGATOR_BUILD == 1
#include "include/cef_app.h"
#include "include/cef_cookie.h"
#include "include/cef_task.h"
 
namespace SO3
{
  namespace EmbeddedWebNavigator
  {
    // Instanciate static member
    WebNavigatorManager* WebNavigatorManager::thisInstance = 0;
 
    WebNavigatorManager::WebNavigatorManager(const ScolWindowHandle& scolMainWindow, std::string cacheDirectory) : scolMainWindowHandle(scolMainWindow)
    {
      // Initialise singleton first
      assert(!WebNavigatorManager::thisInstance);
      WebNavigatorManager::thisInstance = this;
      nextUniqueId = 1; // 0 is reserved id
 
      sCachePath = cacheDirectory;
      std::replace(sCachePath.begin(), sCachePath.end(), '/', '\\');
 
      // Create synchro events
      synchroEventSetCookie = CreateEvent(NULL, TRUE, FALSE, NULL);
      synchroEventDeleteCookie = CreateEvent(NULL, TRUE, FALSE, NULL);
 
      bInitialized = false;
      bContextInitialized = false;
    }
 
    WebNavigatorManager::WebNavigatorManager() : scolMainWindowHandle(0)
    {
      // Forbiden
    }
 
    WebNavigatorManager::~WebNavigatorManager()
    {
      // Destroy synchro events
      CloseHandle(synchroEventSetCookie);
      synchroEventSetCookie = 0;
      CloseHandle(synchroEventDeleteCookie);
      synchroEventDeleteCookie = 0;
 
      // Destroy all the remaining WebNavigator instances
      WebNavigatorList webNavigatorListCopy = webNavigatorList;
      WebNavigatorList::iterator iWebNavigator = webNavigatorListCopy.begin();
      if (iWebNavigator != webNavigatorListCopy.end())
      {
        DestroyNavigator(iWebNavigator->second);
        iWebNavigator++;
      }
 
      // Reset singleton
      assert(WebNavigatorManager::thisInstance);
      WebNavigatorManager::thisInstance = 0;       
    }
 
    void WebNavigatorManager::OnContextInitialized()
    {
      bContextInitialized = true;
    }
 
    void WebNavigatorManager::init()
    {
      // Enable High-DPI support on Windows 7 or newer.
      CefEnableHighDPISupport();
 
      // Specify a cache path value.
      CefSettings settings;
      CefString(&settings.cache_path).FromString(sCachePath);
      CefString(&settings.log_file).FromString(sCachePath + "\\libcef.log");
 
      char exePath[512];
      std::string strexePath;
      GetModuleFileName(NULL, exePath, 512);
      strexePath = exePath;
      strexePath = strexePath.substr(0, strexePath.find_last_of('\\'));
 
      CefString(&settings.resources_dir_path).FromString(strexePath + "\\plugins\\cefres");
      CefString(&settings.locales_dir_path).FromString(strexePath + "\\plugins\\cefres\\locales");
      
      // Use the English language locale.
      CefString(&settings.locale).FromASCII("en-US");
 
#ifdef NDEBUG
      // Only log error messages and higher in release build.
      settings.log_severity = LOGSEVERITY_ERROR;
#endif
 
      // processed using a separate UI thread.
      settings.multi_threaded_message_loop = true;
      settings.windowless_rendering_enabled = true;
      settings.ignore_certificate_errors = true;
      settings.no_sandbox = true;
 
      // Init CEF.
      CefMainArgs args;
      CefInitialize(args, settings, this, NULL);
      bInitialized = true;
    }
 
    WebNavigatorManager& WebNavigatorManager::GetSingleton()
    {
      assert(WebNavigatorManager::thisInstance);
      return *WebNavigatorManager::thisInstance;
    }
 
    WebNavigatorManager* WebNavigatorManager::GetSingletonPtr()
    {
      return WebNavigatorManager::thisInstance;
    }
 
    void WebNavigatorManager::DestroyManager()
    {
      bool cefkill = (WebNavigatorManager::thisInstance && WebNavigatorManager::thisInstance->IsInitialized()) ? true : false;
      SAFE_DELETE(WebNavigatorManager::thisInstance);
 
      if (cefkill)
        CefShutdown();
    }
 
    bool WebNavigatorManager::IsInitialized()
    {
      return bInitialized;
    }
 
    WebNavigator* WebNavigatorManager::CreateNavigator(const ScolWindowHandle& parentWindowHandle, int xPosition, int yPosition, int width, int height, std::string url)
    {
      if (!bInitialized)
        init();
 
      while (!bContextInitialized)
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
      // Create it.
      WebNavigator* newWebNavigator = new WebNavigator(nextUniqueId, scolMainWindowHandle, parentWindowHandle, xPosition, yPosition, width, height, url);
 
      // Store a reference to the newly created web navigator.
      webNavigatorList.insert(WebNavigatorList::value_type(nextUniqueId, newWebNavigator));
      nextUniqueId++;
      return newWebNavigator;
    }
 
    WebNavigator* WebNavigatorManager::CreateNavigator(const ScolWindowHandle& parentWindowHandle, int width, int height, std::string url, bool transparency)
    {
      if (!bInitialized)
        init();
 
      while (!bContextInitialized)
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
      // Create it.
      WebNavigator* newWebNavigator = new WebNavigator(nextUniqueId, scolMainWindowHandle, parentWindowHandle, width, height, url, transparency);
 
      // Store a reference to the newly created web navigator.
      webNavigatorList.insert(WebNavigatorList::value_type(nextUniqueId, newWebNavigator));
      nextUniqueId++;
      return newWebNavigator;
    }
 
    void WebNavigatorManager::DestroyNavigator(WebNavigator* webNavigator)
    {
      if (webNavigator)
      {
        //to be sure this never happend on update
        std::unique_lock< std::shared_mutex > lock(webMessageQueueCriticalSection);
 
        // Check if a web navigator instance with this parent window exist.
        WebNavigatorList::iterator iWebNavigatorSearched = webNavigatorList.find(webNavigator->GetUniqueId());
        if (iWebNavigatorSearched != webNavigatorList.end())
        {
          // Erase from first list
          WebNavigator* webNavigator = iWebNavigatorSearched->second;
          webNavigatorList.erase(iWebNavigatorSearched);
 
          // Delete web navigator instance
          delete(webNavigator);
        }
      }
    }
 
    WebNavigator* WebNavigatorManager::GetNavigator(unsigned long uniqueId)
    {
      WebNavigatorList::iterator iSearchedNavigator = webNavigatorList.find(uniqueId);
      if (iSearchedNavigator != webNavigatorList.end())
        return iSearchedNavigator->second;
      else
        return 0;
    }
 
    bool WebNavigatorManager::SetCookie(const std::string& url, const std::string& name, const std::string& value, const std::string& domain, const std::string& path, const bool& secure, const bool& httponly)
    {
      bool success = false;
      CefCookie newCookie;
      CefString(&newCookie.name).FromString(name);
      CefString(&newCookie.value).FromString(value);
      CefString(&newCookie.domain).FromString(domain);
      CefString(&newCookie.path).FromString(path);
      newCookie.secure = secure;
      newCookie.httponly = httponly;
 
      //
      ResetEvent(synchroEventSetCookie);
      CefPostTask(TID_IO, base::Bind(&WebNavigatorThread::SetCookie, url, newCookie, &success, synchroEventSetCookie));
      WaitForSingleObject(synchroEventSetCookie, WEB_NAVIGATOR_SYNCHRO_DEFAULT_WAITING_TIME);
      return success;
    }
 
    bool WebNavigatorManager::DeleteCookies(const std::string& url, const std::string& cookie_name)
    {
      bool success = false;
      ResetEvent(synchroEventDeleteCookie);
      CefPostTask(TID_IO, base::Bind(&WebNavigatorThread::DeleteCookies, url, cookie_name, &success, synchroEventDeleteCookie));
      WaitForSingleObject(synchroEventDeleteCookie, WEB_NAVIGATOR_SYNCHRO_DEFAULT_WAITING_TIME);
      return success;
    }
 
    void WebNavigatorManager::Update()
    {
      if (bInitialized && bContextInitialized)
      {
        std::unique_lock< std::shared_mutex > lock(webMessageQueueCriticalSection);
        mainThreadWebMessageQueue.poll();
      }      
    }
 
    void WebNavigatorManager::InvokeExternalCall(unsigned long uniqueId, SScriptFunction functionCalled)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnExternalCall(targetWebNavigator, functionCalled);
    }
 
    void WebNavigatorManager::InvokeExternalCallStr(unsigned long uniqueId, SScriptFunction functionCalled)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnExternalCallStr(targetWebNavigator, functionCalled);
    }
 
    void WebNavigatorManager::InvokeNavStateChange(unsigned long uniqueId, bool canGoBack, bool canGoForward)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
      {
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnNavStateChange(targetWebNavigator, canGoBack, canGoForward);
      }
    }
 
    void WebNavigatorManager::InvokeAddressChange(unsigned long uniqueId, const std::string& frameName, const std::string& url)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
      {
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnAddressChange(targetWebNavigator, frameName, url);
      }
    }
 
    void WebNavigatorManager::InvokeTitleChange(unsigned long uniqueId, const std::string& title)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
      {
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnTitleChange(targetWebNavigator, title);
      }
    }
 
    void WebNavigatorManager::InvokeTooltip(unsigned long uniqueId, std::string& text)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
      {
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnTooltip(targetWebNavigator, text);
      }
    }
 
    void WebNavigatorManager::InvokeCursorChange(unsigned long uniqueId, HCURSOR newCursor)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
      {
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnCursorChange(targetWebNavigator, newCursor);
      }
    }
 
    void WebNavigatorManager::InvokeStatusMessage(unsigned long uniqueId, const std::string& value)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
      {
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnStatusMessage(targetWebNavigator, value);
      }
    }
 
    void WebNavigatorManager::InvokeConsoleMessage(unsigned long uniqueId, const std::string& message, const std::string& source, int line)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
      {
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnConsoleMessage(targetWebNavigator, message, source, line);
      }
    }
 
    void WebNavigatorManager::InvokeBeforePopup(unsigned long uniqueId, int popupX, int popupY, int popupWidth, int popupHeight, std::string popupUrl)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
      {
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnBeforePopup(targetWebNavigator, popupX, popupY, popupWidth, popupHeight, popupUrl);
      }
    }
 
    void WebNavigatorManager::InvokeRunModal(unsigned long uniqueId)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
      {
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->RunModal(targetWebNavigator);
      }
    }
 
    void WebNavigatorManager::InvokeLoadStart(unsigned long uniqueId, const std::string& frameName)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
      {
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnLoadStart(targetWebNavigator, frameName);
      }
    }
 
    void WebNavigatorManager::InvokeLoadEnd(unsigned long uniqueId, const std::string& frameName, int httpStatusCode)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
      {
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnLoadEnd(targetWebNavigator, frameName, httpStatusCode);
      }
    }
 
    void WebNavigatorManager::InvokeLoadError(unsigned long uniqueId, const std::string& frameName, int errorCode, const std::string& failedUrl, std::string& errorText)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
      {
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnLoadError(targetWebNavigator, frameName, errorCode, failedUrl, errorText);
      }
    }
 
    void WebNavigatorManager::InvokeFindResult(unsigned long uniqueId, int identifier, int count, const CefRect& selectionRect, int activeMatchOrdinal, bool finalUpdate)
    {
      WebNavigator* targetWebNavigator = GetNavigator(uniqueId);
      if (targetWebNavigator != 0)
      {
        if (targetWebNavigator->GetListener() != 0)
          targetWebNavigator->GetListener()->OnFindResult(targetWebNavigator, identifier, count, selectionRect, activeMatchOrdinal, finalUpdate);
      }
    }
  }
}
 
#endif