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 #include <memory>
  27 #include <dpl/log/log.h>
  28 #include <dpl/assert.h>
  29
  30 #include <widget_model.h>
  31 #include <i_runnable_widget_object.h>
  32 #include <common/view_logic_apps_support.h>
  33 #include <common/view_logic_vibration_support.h>
  34
  35 #include <EWebKit2.h>
  36
  37 class SchemeSupport;
  38
  39 class ViewLogic : public ViewModule::IViewModule
  40 {
  41   public:
  42     ViewLogic();
  43     virtual ~ViewLogic();
  44
  45     void createWebView(Ewk_Context* context,
  46                        Evas_Object* window);
  47     void destroyWebView();
  48     void initialize();
  49     void terminate();
  50     void prepareView(WidgetModel* m, const std::string &startUrl);
  51     void showWidget();
  52     void hideWidget();
  53     void suspendWidget();
  54     void resumeWidget();
  55     void resetWidget();
  56     void backward();
  57     void reload();
  58     void forward();
  59     void reloadStartPage();
  60     Evas_Object* getCurrentWebview();
  61     void setUserCallbacks(const WRT::UserDelegatesPtr& cbs);
  62
  63     // Ewk_Context operations
  64     void initializeEwkContext(Ewk_Context* context);
  65     void finalizeEwkContext();
  66
  67   private:
  68     void initializeSupport();
  69     void initializePluginLoading();
  70
  71     // EwkView operations
  72     void ewkClientInit(Evas_Object *wkView);
  73     void ewkClientDeinit(Evas_Object *wkView);
  74     void createEwkView();
  75     void setStartPage();
  76     void prepareEwkView(Evas_Object *wkView);
  77     void removeEwkView(Evas_Object *wkView);
  78     void resumeEwkView(Evas_Object *wkView);
  79     void suspendEwkView(Evas_Object *wkView);
  80     void resumeWebkit(Evas_Object *wkView);
  81     void suspendWebkit(Evas_Object *wkView);
  82
  83     // message from injected bundle Callback
  84     static void contextMessageFromInjectedBundleCallback(
  85             const char* name,
  86             const char* body,
  87             char** returnData,
  88             void* userData);
  89
  90     // EWK Context Callback
  91     static void didStartDownloadCallback(
  92             const char* downloadUrl,
  93             void* data);
  94
  95     // WKPageLoaderClient
  96     static void loadStartedCallback(
  97             void* data,
  98             Evas_Object* obj,
  99             void* eventInfo);
 100     static void loadFinishedCallback(
 101             void* data,
 102             Evas_Object* obj,
 103             void* eventInfo);
 104     static void titleChangedCallback(
 105             void* data,
 106             Evas_Object* obj,
 107             void* eventInfo);
 108     static void loadProgressCallback(
 109             void* data,
 110             Evas_Object* obj,
 111             void* eventInfo);
 112     static void loadProgressFinishedCallback(
 113             void* data,
 114             Evas_Object* obj,
 115             void* eventInfo);
 116     static void processCrashedCallback(
 117             void* data,
 118             Evas_Object* obj,
 119             void* eventInfo);
 120
 121     // EWK Callback
 122     static void createWindowCallback(
 123             void* data,
 124             Evas_Object* obj,
 125             void* eventInfo);
 126     static void closeWindowCallback(
 127             void* data,
 128             Evas_Object* obj,
 129             void* eventInfo);
 130
 131     // EWK PolicyDecide Callback
 132     static void policyNavigationDecideCallback(
 133             void* data,
 134             Evas_Object* obj,
 135             void* eventInfo);
 136     static void policyNewWindowDecideCallback(
 137             void* data,
 138             Evas_Object* obj,
 139             void* eventInfo);
 140     static void pageResponseDecideCallback(
 141             void* data,
 142             Evas_Object* obj,
 143             void* eventInfo);
 144
 145     // EWK ContextMenu Callback
 146     static void contextmenuCustomizeCallback(
 147             void* data,
 148             Evas_Object* obj,
 149             void* eventInfo);
 150
 151     // EWK FormClient Callback
 152     static void formSubmitCallback(
 153             void *data,
 154             Evas_Object *obj,
 155             void *eventInfo);
 156
 157     // EWK Geolocation Callback
 158     static void geolocationPermissionRequestCallback(
 159             void* data,
 160             Evas_Object* obj,
 161             void* eventInfo);
 162
 163     // EWK Notification Callback
 164     static void notificationShowCallback(
 165             void* data,
 166             Evas_Object* obj,
 167             void* eventInfo);
 168     static void notificationCancelCallback(
 169             void* data,
 170             Evas_Object* obj,
 171             void* eventInfo);
 172     static void notificationPermissionRequestCallback(
 173             void* data,
 174             Evas_Object* obj,
 175             void* eventInfo);
 176
 177     // EWK Vibration Callback
 178     static void vibrationVibrateCallback(
 179             void* data,
 180             Evas_Object* obj,
 181             void* eventInfo);
 182     static void vibrationCancelCallback(
 183             void* data,
 184             Evas_Object* obj,
 185             void* eventInfo);
 186
 187     // EWK Orientation Callback
 188     static Eina_Bool orientationLockCallback(
 189             Evas_Object* obj,
 190             Eina_Bool needLock,
 191             int orientation,
 192             void* data);
 193
 194     // EWK Fullscreen API callbacks
 195     static void enterFullscreenCallback(
 196             void* data,
 197             Evas_Object* obj,
 198             void* eventInfo);
 199     static void exitFullscreenCallback(
 200             void* data,
 201             Evas_Object* obj,
 202             void* eventInfo);
 203
 204     // JS execute callback
 205     static void didRunJavaScriptCallback(
 206             Evas_Object* obj,
 207             const char* result,
 208             void* userData);
 209
 210     // idler callback
 211     static Eina_Bool windowCloseIdlerCallback(void *data);
 212
 213     // appcore event callback
 214     static int appcoreLowMemoryCallback(void *data);
 215     // database usage permission request callback
 216     static void databaseUsagePermissionRequestCallback(
 217         void* data,
 218         Evas_Object* obj,
 219         void* eventInfo);
 220     void databaseUsagePermissionRequest(
 221            void* eventInfo);
 222     bool askUserForDatabaseExceedPermission(
 223         Ewk_Context_Exceeded_Quota* exceededQuota);
 224
 225     // file System Permission Request Callback
 226     static void fileSystemPermissionRequestCallback(
 227         void* data,
 228         Evas_Object* obj,
 229         void* eventInfo);
 230     void fileSystemPermissionRequest(
 231            void* eventInfo);
 232     bool askUserForFileSystemPermission(
 233         Ewk_Context_File_System_Permission* fileSystemPermission);
 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     void rememberBlockedURI(const DPL::String& str);
 246     std::string requestUriChanged(const DPL::String& changedURL);
 247     void disconnectNetworkConnectionsFunction();
 248
 249     // window
 250     void windowClose(void);
 251
 252
 253     Ewk_Context* m_ewkContext;
 254     std::list<Evas_Object*> m_ewkViewList;
 255     Evas_Object* m_currentEwkView;
 256     Evas_Object* m_window;
 257     WidgetModel* m_model;
 258     std::string m_currentUri;
 259     std::string m_blockedUri;
 260     std::string m_theme;
 261     std::string m_startUrl;
 262     WRT::UserDelegatesPtr m_cbs;
 263
 264     std::unique_ptr<SchemeSupport> m_schemeSupport;
 265     std::unique_ptr<ViewModule::AppsSupport> m_appsSupport;
 266     std::unique_ptr<ViewModule::VibrationSupport> m_vibrationSupport;
 267 };
 268
 269 #endif //VIEW_LOGIC_H_