| // Copyright 2017 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "topaz/runtime/web_view/web_view_impl.h" |
| |
| #include <hid/hid.h> |
| #include <hid/usages.h> |
| #include <lib/async/cpp/task.h> |
| #include <lib/async/default.h> |
| #include <lib/fdio/io.h> |
| #include <zircon/pixelformat.h> |
| #include <zircon/syscalls.h> |
| #include <zircon/types.h> |
| |
| #include "topaz/runtime/web_view/schema_org_context.h" |
| |
| using namespace WebCore; |
| |
| TouchTracker::TouchTracker(int x, int y) |
| : start_x_(x), start_y_(y), last_x_(0), last_y_(0), is_drag_(false) {} |
| |
| void TouchTracker::HandleEvent(const fuchsia::ui::input::PointerEvent& pointer, |
| const fuchsia::ui::gfx::Metrics& metrics, |
| WebView& web_view) { |
| const auto x = pointer.x * metrics.scale_x; |
| const auto y = pointer.y * metrics.scale_y; |
| const int kDragThreshhold = 50 * metrics.scale_x; |
| auto delta_x = last_x_ - x; |
| auto delta_y = last_y_ - y; |
| auto distance_x = abs(start_x_ - x); |
| auto distance_y = abs(start_y_ - y); |
| last_y_ = y; |
| last_x_ = x; |
| |
| if (distance_x > kDragThreshhold || distance_y > kDragThreshhold) { |
| is_drag_ = true; |
| } |
| |
| if (is_drag_) { |
| switch (pointer.phase) { |
| case fuchsia::ui::input::PointerEventPhase::MOVE: |
| web_view.scrollPixels(delta_x, delta_y); |
| break; |
| |
| case fuchsia::ui::input::PointerEventPhase::UP: |
| web_view.scrollPixels(delta_x, delta_y); |
| break; |
| |
| default: |
| break; |
| } |
| } else { |
| switch (pointer.phase) { |
| case fuchsia::ui::input::PointerEventPhase::UP: |
| web_view.handleMouseEvent(start_x_, start_y_, WebView::kMouseDown); |
| web_view.handleMouseEvent(start_x_, start_y_, WebView::kMouseUp); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| } |
| |
| WebViewImpl::WebViewImpl(scenic::ViewContext view_context, |
| fuchsia::ui::input::ImeServicePtr ime_service, |
| const std::string& url) |
| : V1BaseView(std::move(view_context), "WebView"), |
| ime_service_(std::move(ime_service)), |
| ime_client_binding_(this), |
| weak_factory_(this), |
| url_(url), |
| #ifdef EXPERIMENTAL_WEB_ENTITY_EXTRACTION |
| schema_org_(web_view_), |
| #endif |
| image_cycler_(session()) { |
| FXL_LOG(INFO) << "WebViewImpl constructor"; |
| web_view_.setup_once(); |
| |
| std::function<void(bool)> focusDelegate = [=](bool focused) { |
| this->HandleWebRequestsFocusEvent(focused); |
| }; |
| |
| web_view_.setInputFocusDelegate(focusDelegate); |
| |
| SetNeedSquareMetrics(true); |
| parent_node().AddChild(image_cycler_); |
| |
| // Expose |WebView| interface to caller. |
| outgoing_services().AddService<fuchsia::webview::WebView>( |
| [this](fidl::InterfaceRequest<fuchsia::webview::WebView> request) { |
| FXL_LOG(INFO) << "web view service request"; |
| web_view_interface_bindings_.AddBinding(this, std::move(request)); |
| }); |
| |
| async::PostTask(async_get_default_dispatcher(), |
| ([weak = weak_factory_.GetWeakPtr()]() { |
| if (weak) |
| weak->CallIdle(); |
| })); |
| } |
| |
| void WebViewImpl::HandleWebRequestsFocusEvent(bool focused) { |
| FXL_LOG(INFO) << "WebView: web requests input focus:" |
| << (focused ? "focused" : "unfocused"); |
| web_requests_input_ = focused; |
| UpdateInputConnection(); |
| } |
| |
| void WebViewImpl::UpdateInputConnection() { |
| if (web_requests_input_) { |
| ime_service_->ShowKeyboard(); |
| |
| fuchsia::ui::input::InputMethodEditorClientPtr client_ptr; |
| ime_client_binding_.Bind(client_ptr.NewRequest()); |
| auto state = fuchsia::ui::input::TextInputState{}; |
| state.text = ""; |
| ime_service_->GetInputMethodEditor( |
| fuchsia::ui::input::KeyboardType::TEXT, |
| fuchsia::ui::input::InputMethodAction::SEND, std::move(state), |
| std::move(client_ptr), ime_.NewRequest()); |
| } else if (ime_client_binding_.is_bound()) { |
| ime_service_->HideKeyboard(); |
| ime_client_binding_.Unbind(); |
| } |
| } |
| |
| // |fuchsia::ui::input::InputMethodEditorClient| |
| void WebViewImpl::DidUpdateState(fuchsia::ui::input::TextInputState state, |
| fuchsia::ui::input::InputEventPtr event) { |
| if (event != nullptr && event->is_keyboard() && has_scenic_focus_) { |
| HandleKeyboardEvent(*event); |
| } |
| } |
| |
| // |fuchsia::ui::input::InputMethodEditorClient| |
| void WebViewImpl::OnAction(fuchsia::ui::input::InputMethodAction action) { |
| if (fuchsia::ui::input::InputMethodAction::SEND == action) { |
| // treat send action as return, simulate press and release. |
| fuchsia::ui::input::InputEvent event; |
| fuchsia::ui::input::KeyboardEvent keyboard; |
| keyboard.phase = fuchsia::ui::input::KeyboardEventPhase::PRESSED; |
| keyboard.hid_usage = HID_USAGE_KEY_ENTER; |
| event.set_keyboard(keyboard); |
| HandleKeyboardEvent(event); |
| |
| keyboard.phase = fuchsia::ui::input::KeyboardEventPhase::RELEASED; |
| HandleKeyboardEvent(event); |
| } |
| } |
| |
| // |WebView|: |
| void WebViewImpl::SetUrl(fidl::StringPtr url) { |
| url_ = url; |
| // Reset url_set_ so that the next OnDraw() knows to call |
| // web_view_.setURL() |
| url_set_ = false; |
| InvalidateScene(); |
| } |
| |
| // |WebView|: |
| void WebViewImpl::ClearCookies() { web_view_.deleteAllCookies(); } |
| |
| void WebViewImpl::SetWebRequestDelegate( |
| ::fidl::InterfaceHandle<fuchsia::webview::WebRequestDelegate> delegate) { |
| webRequestDelegate_ = delegate.Bind(); |
| } |
| |
| bool WebViewImpl::HandleKeyboardEvent( |
| const fuchsia::ui::input::InputEvent& event) { |
| bool handled = true; |
| const fuchsia::ui::input::KeyboardEvent& keyboard = event.keyboard(); |
| bool pressed = |
| keyboard.phase == fuchsia::ui::input::KeyboardEventPhase::PRESSED; |
| bool repeating = |
| keyboard.phase == fuchsia::ui::input::KeyboardEventPhase::REPEAT; |
| if (pressed && keyboard.code_point == 'c' && |
| keyboard.modifiers & fuchsia::ui::input::kModifierControl) { |
| exit(0); |
| } else if (pressed && keyboard.code_point == '[' && |
| keyboard.modifiers & fuchsia::ui::input::kModifierControl) { |
| web_view_.goBack(); |
| } else if (pressed && keyboard.code_point == ']' && |
| keyboard.modifiers & fuchsia::ui::input::kModifierControl) { |
| web_view_.goForward(); |
| } else if (pressed && keyboard.code_point == 'r' && |
| keyboard.modifiers & fuchsia::ui::input::kModifierControl) { |
| web_view_.reload(); |
| } else { |
| bool handled = |
| web_view_.handleKeyEvent(keyboard.hid_usage, keyboard.code_point, |
| pressed || repeating, repeating); |
| if (!handled) { |
| if (pressed || repeating) { |
| if (keyboard.hid_usage == HID_USAGE_KEY_DOWN) { |
| } else if (keyboard.hid_usage == HID_USAGE_KEY_UP) { |
| web_view_.scrollUpOneLine(); |
| } else if (keyboard.hid_usage == HID_USAGE_KEY_RIGHT) { |
| web_view_.scrollRightOneLine(); |
| } else if (keyboard.hid_usage == HID_USAGE_KEY_LEFT) { |
| web_view_.scrollLeftOneLine(); |
| } |
| } |
| } |
| } |
| return handled; |
| } |
| |
| void WebViewImpl::HandleMouseEvent( |
| const fuchsia::ui::input::PointerEvent& pointer) { |
| if (pointer.buttons & fuchsia::ui::input::kMousePrimaryButton) { |
| switch (pointer.phase) { |
| case fuchsia::ui::input::PointerEventPhase::DOWN: |
| case fuchsia::ui::input::PointerEventPhase::MOVE: |
| web_view_.handleMouseEvent( |
| pointer.x * metrics().scale_x, pointer.y * metrics().scale_y, |
| pointer.phase == fuchsia::ui::input::PointerEventPhase::DOWN |
| ? ::WebView::kMouseDown |
| : ::WebView::kMouseMoved); |
| break; |
| case fuchsia::ui::input::PointerEventPhase::UP: |
| web_view_.handleMouseEvent(pointer.x * metrics().scale_x, |
| pointer.y * metrics().scale_y, |
| ::WebView::kMouseUp); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| |
| void WebViewImpl::HandleTouchDown( |
| const fuchsia::ui::input::PointerEvent& pointer) { |
| const auto x = pointer.x * metrics().scale_x; |
| const auto y = pointer.y * metrics().scale_y; |
| touch_trackers_[pointer.pointer_id] = TouchTracker(x, y); |
| } |
| |
| void WebViewImpl::HandleTouchEvent( |
| const fuchsia::ui::input::PointerEvent& pointer) { |
| auto pointer_id = pointer.pointer_id; |
| switch (pointer.phase) { |
| case fuchsia::ui::input::PointerEventPhase::DOWN: |
| HandleTouchDown(pointer); |
| break; |
| case fuchsia::ui::input::PointerEventPhase::MOVE: |
| touch_trackers_[pointer_id].HandleEvent(pointer, metrics(), web_view_); |
| break; |
| case fuchsia::ui::input::PointerEventPhase::UP: |
| touch_trackers_[pointer_id].HandleEvent(pointer, metrics(), web_view_); |
| touch_trackers_.erase(pointer_id); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| void WebViewImpl::HandleFocusEvent( |
| const fuchsia::ui::input::FocusEvent& focus) { |
| has_scenic_focus_ = focus.focused; |
| web_view_.setFocused(focus.focused); |
| UpdateInputConnection(); |
| } |
| |
| // |scenic::V1BaseView| |
| bool WebViewImpl::OnInputEvent(fuchsia::ui::input::InputEvent event) { |
| bool handled = false; |
| web_view_.setVisible(true); |
| if (event.is_pointer()) { |
| handled = true; |
| const fuchsia::ui::input::PointerEvent& pointer = event.pointer(); |
| if (pointer.type == fuchsia::ui::input::PointerEventType::TOUCH) { |
| HandleTouchEvent(pointer); |
| } else if (pointer.type == fuchsia::ui::input::PointerEventType::MOUSE) { |
| HandleMouseEvent(pointer); |
| } |
| } else if (event.is_keyboard()) { |
| handled = true; |
| HandleKeyboardEvent(event); |
| } else if (event.is_focus()) { |
| handled = true; |
| HandleFocusEvent(event.focus()); |
| } |
| |
| InvalidateScene(); |
| return handled; |
| } |
| |
| // |scenic::V1BaseView| |
| void WebViewImpl::OnSceneInvalidated( |
| fuchsia::images::PresentationInfo presentation_info) { |
| if (!has_physical_size()) |
| return; |
| |
| // Update the image. |
| const scenic::HostImage* image = image_cycler_.AcquireImage( |
| physical_size().width, physical_size().height, physical_size().width * 4u, |
| fuchsia::images::PixelFormat::BGRA_8, fuchsia::images::ColorSpace::SRGB); |
| FXL_DCHECK(image); |
| |
| // Paint the webview. |
| web_view_.setup(reinterpret_cast<unsigned char*>(image->image_ptr()), |
| ZX_PIXEL_FORMAT_ARGB_8888, physical_size().width, |
| physical_size().height, physical_size().width * 4u); |
| if (!url_set_) { |
| const char* urlToOpen = url_.c_str(); |
| web_view_.setURL(urlToOpen); |
| url_set_ = true; |
| |
| FXL_DCHECK(metrics().scale_x == |
| metrics().scale_y); // we asked for square metrics |
| |
| auto requestCallback = [this](std::string url) { |
| if (webRequestDelegate_) { |
| webRequestDelegate_->WillSendRequest(url); |
| } |
| return url; |
| }; |
| web_view_.setWebRequestDelegate(requestCallback); |
| } |
| |
| if (page_scale_factor_ != metrics().scale_x) { |
| page_scale_factor_ = metrics().scale_x; |
| web_view_.setPageAndTextZoomFactors(page_scale_factor_, 1.0); |
| } |
| |
| web_view_.iterateEventLoop(); |
| web_view_.layoutAndPaint(); |
| |
| image_cycler_.ReleaseAndSwapImage(); |
| image_cycler_.SetScale(1.f / metrics().scale_x, 1.f / metrics().scale_y, 1.f); |
| image_cycler_.SetTranslation(logical_size().width * .5f, |
| logical_size().height * .5f, 0.f); |
| } |
| |
| void WebViewImpl::CallIdle() { |
| web_view_.iterateEventLoop(); |
| InvalidateScene(); |
| async::PostTask(async_get_default_dispatcher(), |
| ([weak = weak_factory_.GetWeakPtr()]() { |
| if (weak) |
| weak->CallIdle(); |
| })); |
| } |
