src/view/webkit/view_logic.h

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /**
  17  * @file    view_logic.h
  18  * @author  Lukasz Wrzosek (l.wrzosek@samsung.com)
  19  * @brief   Declaration file for view logic for Webkit2
  20  */
  21
  22 #ifndef VIEW_LOGIC_H_
  23 #define VIEW_LOGIC_H_
  24
  25 #include <i_view_module.h>
  26
  27 //#include "view_logic.h"
  28
  29 #include <memory>
  30 #include <dpl/log/log.h>
  31 #include <dpl/assert.h>
  32
  33 #include <widget_model.h>
  34 #include <i_runnable_widget_object.h>
  35 #include <common/view_logic_apps_support.h>
  36 #include <common/view_logic_vibration_support.h>
  37
  38 #include <WebKit2.h>
  39 #include <EWebKit2.h>
  40
  41 class SchemeSupport;
  42
  43 class ViewLogic : public ViewModule::IViewModule
  44 {
  45   public:
  46     void createWebView(Ewk_Context* context,
  47                        Evas_Object* window,
  48                        Evas_Object* conformant = NULL,
  49                        ViewModule::ProgresFinishedCallback cb = NULL);
  50     void destroyWebView();
  51     void initialize();
  52     void terminate();
  53     void prepareView(WidgetModel* m, const std::string &startUrl);
  54     void showWidget();
  55     void hideWidget();
  56     void suspendWidget(const OperationStatusStruct &);
  57     void resumeWidget(const OperationStatusStruct &);
  58     void resetWidget();
  59     void goBack();
  60     Evas_Object* getCurrentWebview();
  61     void setUserCallbacks(WRT::UserCallbacksPtr cbs, void *data);
  62
  63     // Ewk_Context operations
  64     void initializeEwkContext(Ewk_Context* context);
  65     void finalizeEwkContext();
  66     ViewLogic();
  67     virtual ~ViewLogic();
  68
  69   private:
  70     void initializeSupport();
  71     void initializePluginLoading();
  72
  73     // EwkView operations
  74     void ewkClientInit(Evas_Object *wkView);
  75     void ewkClientDeinit(Evas_Object *wkView);
  76     void createEwkView();
  77     void setStartPage();
  78     void prepareEwkView(Evas_Object *wkView);
  79     void removeEwkView(Evas_Object *wkView);
  80     void resumeEwkView(Evas_Object *wkView);
  81     void suspendEwkView(Evas_Object *wkView);
  82     void resumeWebkit(Evas_Object *wkView);
  83     void suspendWebkit(Evas_Object *wkView);
  84
  85     // message from injected bundle Callback
  86     static void contextMessageFromInjectedBundleCallback(
  87             const char* name,
  88             const char* body,
  89             char** returnData,
  90             void* userData);
  91
  92     // EWK Context Callback
  93     static void didStartDownloadCallback(
  94             const char* downloadUrl,
  95             void* data);
  96
  97     // WKPageLoaderClient Callback
  98     static void didStartProvisionalLoadForFrameCallback(
  99             WKPageRef page,
 100             WKFrameRef frame,
 101             WKTypeRef userData,
 102             const void *clientInfo);
 103     static void didFinishLoadForFrameCallback(
 104             WKPageRef page,
 105             WKFrameRef frame,
 106             WKTypeRef userData,
 107             const void *clientInfo);
 108     static void didReceiveTitleForFrameCallback(
 109             WKPageRef page,
 110             WKStringRef title,
 111             WKFrameRef frame,
 112             WKTypeRef userData,
 113             const void* clientinfo);
 114     static void didStartProgressCallback(
 115             WKPageRef page,
 116             const void* clientinfo);
 117     static void didChangeProgressCallback(
 118             WKPageRef page,
 119             const void* clientinfo);
 120     static void didFinishProgressCallback(
 121             WKPageRef page,
 122             const void* clientinfo);
 123
 124     // EWK Callback
 125     static void createWindowCallback(
 126             void* data,
 127             Evas_Object* obj,
 128             void* eventInfo);
 129     static void closeWindowCallback(
 130             void* data,
 131             Evas_Object* obj,
 132             void* eventInfo);
 133
 134     // WKPagePolicyClient Callback
 135     static void pageDecidePolicyForNavigationActionCallback(
 136             WKPageRef page,
 137             WKFrameRef frame,
 138             WKFrameNavigationType navigationType,
 139             WKEventModifiers modifiers,
 140             WKEventMouseButton mouseButton,
 141             WKURLRequestRef request,
 142             WKFramePolicyListenerRef listener,
 143             WKTypeRef userData,
 144             const void* clientinfo);
 145     static void pageDecidePolicyForResponseCallback(
 146             WKPageRef page,
 147             WKFrameRef frame,
 148             WKURLResponseRef response,
 149             WKURLRequestRef request,
 150             WKFramePolicyListenerRef listener,
 151             WKTypeRef userData,
 152             const void* clientinfo);
 153     static void pageDecidePolicyForNewWindowActionCallback(
 154             WKPageRef page,
 155             WKFrameRef frame,
 156             WKFrameNavigationType navigationType,
 157             WKEventModifiers modifiers,
 158             WKEventMouseButton mouseButton,
 159             WKURLRequestRef request,
 160             WKStringRef frameName,
 161             WKFramePolicyListenerRef listener,
 162             WKTypeRef userData,
 163             const void* clientInfo);
 164
 165     // EWK ContextMenu Callback
 166     static void contextmenuCustomizeCallback(
 167             void* data,
 168             Evas_Object* obj,
 169             void* eventInfo);
 170
 171     // EWK FormClient Callback
 172     static void formSubmitCallback(
 173             void *data,
 174             Evas_Object *obj,
 175             void *eventInfo);
 176
 177     // EWK Geolocation Callback
 178     static void geolocationPermissionRequestCallback(
 179             void* data,
 180             Evas_Object* obj,
 181             void* eventInfo);
 182
 183     // EWK Notification Callback
 184     static void notificationShowCallback(
 185             void* data,
 186             Evas_Object* obj,
 187             void* eventInfo);
 188     static void notificationCancelCallback(
 189             void* data,
 190             Evas_Object* obj,
 191             void* eventInfo);
 192     static void notificationPermissionRequestCallback(
 193             void* data,
 194             Evas_Object* obj,
 195             void* eventInfo);
 196
 197     // EWK Vibration Callback
 198     static void vibrationVibrateCallback(
 199             void* data,
 200             Evas_Object* obj,
 201             void* eventInfo);
 202     static void vibrationCancelCallback(
 203             void* data,
 204             Evas_Object* obj,
 205             void* eventInfo);
 206
 207     // EWK Orientation Callback
 208     static Eina_Bool orientationLockCallback(
 209             Evas_Object* obj,
 210             Eina_Bool needLock,
 211             int orientation,
 212             void* data);
 213
 214     // JS execute callback
 215     static void didRunJavaScriptCallback(
 216             Evas_Object* obj,
 217             const char* result,
 218             void* userData);
 219
 220     // UI callback
 221     static void backButtonCallback(void* data,
 222                                    Evas_Object* obj,
 223                                    void* event_info);
 224
 225     // idler callback
 226     static Eina_Bool windowCloseIdlerCallback(void *data);
 227
 228     // process crash callback
 229     static void processDidCrashCallback(WKPageRef page,
 230                                         const void* clientInfo);
 231
 232     // appcore event callback
 233     static int appcoreLowMemoryCallback(void *data);
 234
 235     //bundle
 236     void didRecieveMessageFromInjectedBundle(
 237             const char* name,
 238             const char* body);
 239     void didReceiveSynchronousMessage(
 240             const char* name,
 241             const char* body,
 242             char** returnData);
 243
 244     // security
 245     DPL::Optional<DPL::String> requestWillSend(const DPL::String& str,
 246                                                bool is_xhr);
 247     std::string requestUriChanged(const DPL::String& changedURL);
 248     void disconnectNetworkConnectionsFunction();
 249
 250     // window
 251     void windowClose(void);
 252
 253     // UI
 254     void setLayout(Evas_Object* object);
 255     void unsetLayout();
 256
 257     Ewk_Context* m_ewkContext;
 258     std::list<Evas_Object*> m_ewkViewList;
 259     Evas_Object* m_currentEwkView;
 260     Evas_Object* m_window;
 261     Evas_Object* m_conformant;
 262     WidgetModel* m_model;
 263     std::string m_currentUri;
 264     std::string m_blockedUri;
 265     bool m_emptyView;
 266     std::string m_theme;
 267     std::string m_startUrl;
 268     WRT::UserCallbacksPtr m_cbs;
 269     void* m_cbsData;
 270
 271     ViewModule::ProgresFinishedCallback m_finishedCallback;
 272
 273     std::unique_ptr<SchemeSupport> m_schemeSupport;
 274     std::unique_ptr<ViewModule::AppsSupport> m_appsSupport;
 275     std::unique_ptr<ViewModule::VibrationSupport> m_vibrationSupport;
 276 };
 277
 278 #endif //VIEW_LOGIC_H_