src/xwalk/application/browser/application_tizen.cc

   1 // Copyright (c) 2013 Intel Corporation. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "xwalk/application/browser/application_tizen.h"
   6
   7 #include <set>
   8 #include <string>
   9 #include <vector>
  10
  11 #include "content/public/browser/web_contents.h"
  12 #include "content/public/browser/render_process_host.h"
  13 #include "content/browser/screen_orientation/screen_orientation_dispatcher_host.h"
  14 #include "content/browser/screen_orientation/screen_orientation_provider.h"
  15
  16 #include "xwalk/runtime/browser/ui/native_app_window.h"
  17 #include "xwalk/runtime/browser/ui/native_app_window_tizen.h"
  18 #include "xwalk/runtime/common/xwalk_common_messages.h"
  19
  20 #if defined(USE_OZONE)
  21 #include "content/public/browser/render_view_host.h"
  22 #include "ui/events/event.h"
  23 #include "ui/events/event_constants.h"
  24 #include "ui/events/keycodes/keyboard_codes_posix.h"
  25 #include "ui/events/platform/platform_event_source.h"
  26 #include "xwalk/application/common/manifest_handlers/tizen_setting_handler.h"
  27 #endif
  28
  29 #include "xwalk/application/common/application_manifest_constants.h"
  30 #include "xwalk/application/common/manifest_handlers/tizen_splash_screen_handler.h"
  31
  32 namespace xwalk {
  33
  34 namespace widget_keys = application_widget_keys;
  35
  36 namespace application {
  37
  38 class ScreenOrientationProviderTizen :
  39     public content::ScreenOrientationProvider {
  40  public:
  41   explicit ScreenOrientationProviderTizen(const base::WeakPtr<Application>& app)
  42       : app_(app),
  43         request_id_(0) {
  44   }
  45
  46   virtual void LockOrientation(
  47       int request_id,
  48       blink::WebScreenOrientationLockType lock) OVERRIDE {
  49     if (!app_)
  50       return;
  51     request_id_ = request_id;
  52     const std::set<Runtime*>& runtimes = app_->runtimes();
  53     DCHECK(!runtimes.empty());
  54     // FIXME: Probably need better alignment with
  55     // https://w3c.github.io/screen-orientation/#screen-orientation-lock-lifetime
  56     std::set<Runtime*>::iterator it = runtimes.begin();
  57     for (; it != runtimes.end(); ++it) {
  58       NativeAppWindow* window = (*it)->window();
  59       if (window && window->IsActive()) {
  60         ToNativeAppWindowTizen(window)->LockOrientation(lock);
  61         break;
  62       }
  63     }
  64   }
  65
  66   virtual void UnlockOrientation() OVERRIDE {
  67     LockOrientation(request_id_, blink::WebScreenOrientationLockDefault);
  68   }
  69
  70   virtual void OnOrientationChange() OVERRIDE {}
  71
  72  private:
  73   base::WeakPtr<Application> app_;
  74   int request_id_;
  75 };
  76
  77 ApplicationTizen::ApplicationTizen(
  78     scoped_refptr<ApplicationData> data,
  79     RuntimeContext* runtime_context,
  80     Application::Observer* observer)
  81     : Application(data, runtime_context, observer),
  82       is_suspended_(false) {
  83 #if defined(USE_OZONE)
  84   ui::PlatformEventSource::GetInstance()->AddPlatformEventObserver(this);
  85 #endif
  86 }
  87
  88 ApplicationTizen::~ApplicationTizen() {
  89 #if defined(USE_OZONE)
  90   ui::PlatformEventSource::GetInstance()->RemovePlatformEventObserver(this);
  91 #endif
  92 }
  93
  94 void ApplicationTizen::Hide() {
  95   DCHECK(!runtimes_.empty());
  96   std::set<Runtime*>::iterator it = runtimes_.begin();
  97   for (; it != runtimes_.end(); ++it) {
  98     if ((*it)->window())
  99       (*it)->window()->Hide();
 100   }
 101 }
 102
 103 bool ApplicationTizen::Launch(const LaunchParams& launch_params) {
 104   if (Application::Launch(launch_params)) {
 105     DCHECK(web_contents_);
 106     web_contents_->GetScreenOrientationDispatcherHost()->
 107         SetProvider(new ScreenOrientationProviderTizen(GetWeakPtr()));
 108     return true;
 109   }
 110   return false;
 111 }
 112
 113 base::FilePath ApplicationTizen::GetSplashScreenPath() {
 114   if (TizenSplashScreenInfo* ss_info = static_cast<TizenSplashScreenInfo*>(
 115       data()->GetManifestData(widget_keys::kTizenSplashScreenKey))) {
 116     return data()->Path().Append(FILE_PATH_LITERAL(ss_info->src()));
 117   }
 118   return base::FilePath();
 119 }
 120
 121 void ApplicationTizen::Suspend() {
 122   if (is_suspended_)
 123     return;
 124
 125   DCHECK(render_process_host_);
 126   render_process_host_->Send(new ViewMsg_SuspendJSEngine(true));
 127
 128   DCHECK(!runtimes_.empty());
 129   std::set<Runtime*>::iterator it = runtimes_.begin();
 130   for (; it != runtimes_.end(); ++it) {
 131     if ((*it)->web_contents())
 132       (*it)->web_contents()->WasHidden();
 133   }
 134   is_suspended_ = true;
 135 }
 136
 137 void ApplicationTizen::Resume() {
 138   if (!is_suspended_)
 139     return;
 140
 141   DCHECK(render_process_host_);
 142   render_process_host_->Send(new ViewMsg_SuspendJSEngine(false));
 143
 144   DCHECK(!runtimes_.empty());
 145   std::set<Runtime*>::iterator it = runtimes_.begin();
 146   for (; it != runtimes_.end(); ++it) {
 147     if ((*it)->web_contents())
 148       (*it)->web_contents()->WasShown();
 149   }
 150   is_suspended_ = false;
 151 }
 152
 153 #if defined(USE_OZONE)
 154 void ApplicationTizen::WillProcessEvent(const ui::PlatformEvent& event) {}
 155
 156 void ApplicationTizen::DidProcessEvent(
 157     const ui::PlatformEvent& event) {
 158   ui::Event* ui_event = static_cast<ui::Event*>(event);
 159   if (!ui_event->IsKeyEvent() || ui_event->type() != ui::ET_KEY_PRESSED)
 160     return;
 161
 162   ui::KeyEvent* key_event = static_cast<ui::KeyEvent*>(ui_event);
 163
 164   // FIXME: Most Wayland devices don't have similar hardware button for 'back'
 165   // and 'memu' as Tizen Mobile, even that hardare buttons could be different
 166   // across different kinds of Wayland platforms.
 167   // Here use external keyboard button 'Backspace' & 'HOME' to emulate 'back'
 168   // and 'menu' key. Should change this if there is customized key binding.
 169   if (key_event->key_code() != ui::VKEY_BACK &&
 170       key_event->key_code() != ui::VKEY_HOME)
 171     return;
 172
 173   TizenSettingInfo* info = static_cast<TizenSettingInfo*>(
 174       data()->GetManifestData(widget_keys::kTizenSettingKey));
 175   if (info && !info->hwkey_enabled())
 176     return;
 177
 178   for (std::set<xwalk::Runtime*>::iterator it = runtimes_.begin();
 179       it != runtimes_.end(); ++it) {
 180     (*it)->web_contents()->GetRenderViewHost()->Send(new ViewMsg_HWKeyPressed(
 181         (*it)->web_contents()->GetRoutingID(), key_event->key_code()));
 182   }
 183 }
 184 #endif
 185
 186 }  // namespace application
 187 }  // namespace xwalk