src/Core/View/WebView.cpp

   1 /*
   2  * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Flora License, Version 1.1 (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://floralicense.org/license/
   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    WebView.cpp
  18  * @author  Yunchan Cho (yunchan.cho@samsung.com)
  19  */
  20 #include <string>
  21 #include <Evas.h>
  22 #include <Eina.h>
  23 #include <ewk_context.h>
  24 #include <ewk_view.h>
  25 #include <Core/Util/Log.h>
  26 #include "InjectedScript.h"
  27 #include "WebView.h"
  28
  29 std::map<const std::string, const Evas_Smart_Cb> WebView::m_smartCallbacksMap =
  30 {
  31     {"load,started", WebView::loadStartedCallback},
  32     {"load,finished", WebView::loadFinishedCallback},
  33     {"title,changed", WebView::titleChangedCallback},
  34     {"uri,changed", WebView::uriChangedCallback},
  35     {"load,progress", WebView::loadProgressCallback},
  36     {"load,progress,finished", WebView::loadProgressFinishedCallback},
  37     {"process,crashed", WebView::processCrashedCallback},
  38     {"create,window", WebView::createWindowCallback},
  39     {"close,window", WebView::closeWindowCallback},
  40     {"policy,navigation,decide", WebView::policyNavigationDecideCallback},
  41     {"policy,newwindow,decide", WebView::policyNewWindowDecideCallback},
  42     {"policy,response,decide", WebView::pageResponseDecideCallback},
  43     {"contextmenu,customize", WebView::contextmenuCustomizeCallback},
  44     {"form,submit", WebView::formSubmitCallback},
  45     {"request,geolocation,permission", WebView::geolocationPermissionRequestCallback},
  46     {"notification,show", WebView::notificationShowCallback},
  47     {"notification,cancel", WebView::notificationCancelCallback},
  48     {"notification,permission,request", WebView::notificationPermissionRequestCallback},
  49     {"database,quota,exceeded", WebView::databaseUsagePermissionRequestCallback},
  50     {"filesystem,permission,request", WebView::fileSystemPermissionRequestCallback},
  51     {"fullscreen,enterfullscreen", WebView::enterFullscreenCallback},
  52     {"fullscreen,exitfullscreen", WebView::exitFullscreenCallback},
  53     {"inputmethod,changed", WebView::imeChangedCallback},
  54     {"editorclient,ime,opened", WebView::imeOpenedCallback},
  55     {"editorclient,ime,closed", WebView::imeClosedCallback},
  56     {"usermedia,permission,request", WebView::usermediaPermissionRequestCallback},
  57     {"protocolhandler,registration,requested", WebView::protocolHandlerRegistrationCallback},
  58     {"protocolhandler,isregistered", WebView::protocolHandlerIsRegisteredCallback},
  59     {"protocolhandler,unregistration,requested", WebView::protocolHandlerUnregistrationCallback},
  60     {"contenthandler,registration,requested", WebView::contentHandlerRegistrationCallback},
  61     {"contenthandler,isregistered", WebView::contentHandlerIsRegisteredCallback},
  62     {"contenthandler,unregistration,requested", WebView::contentHandlerUnregistrationCallback},
  63     {"request,certificate,confirm", WebView::certificateConfirmRequestCallback}
  64 };
  65
  66 WebView::WebView(Evas_Object* win, Ewk_Context* ewkContext)
  67     : m_topWebview(NULL)
  68     , m_win(win)
  69     , m_ewkContext(ewkContext)
  70 {
  71 }
  72
  73 WebView::~WebView()
  74 {
  75 }
  76
  77 bool WebView::show(
  78         std::string& startUrl, int width, int height,
  79         WebViewCallback didCreateBaseWebView, void* data)
  80 {
  81     LogD("enter");
  82     if (!m_topWebview) {
  83         m_topWebview = ewk_view_add_with_context(
  84                         evas_object_evas_get(m_win), m_ewkContext);
  85         if (!setBasicSetting(m_topWebview)) {
  86             return false;
  87         }
  88     }
  89
  90     // inform base webview to caller
  91     if (didCreateBaseWebView) {
  92         didCreateBaseWebView(data, static_cast<void*>(m_topWebview));
  93     }
  94
  95     // check scheme of url
  96     std::string url = validateUrl(startUrl);
  97     LogD("load: %s", url.c_str());
  98     evas_object_resize(m_topWebview, width, height);
  99     evas_object_show(m_topWebview);
 100     ewk_view_url_set(m_topWebview, url.c_str());
 101
 102     return true;
 103 }
 104
 105 bool WebView::hide()
 106 {
 107     LogD("enter");
 108
 109     // TODO If created webviews are managed by WebView Class,
 110     //  add code regarding created all webviews
 111     if (!unsetBasicSetting(m_topWebview)) {
 112         return false;
 113     }
 114     evas_object_del(m_topWebview);
 115     m_topWebview = NULL;
 116
 117     return true;
 118 }
 119
 120 bool WebView::suspend()
 121 {
 122     LogD("enter");
 123     ewk_view_page_visibility_state_set(
 124             m_topWebview, EWK_PAGE_VISIBILITY_STATE_HIDDEN, EINA_FALSE);
 125     ewk_view_visibility_set(m_topWebview, EINA_FALSE);
 126     ewk_view_suspend(m_topWebview);
 127     return true;
 128 }
 129
 130 bool WebView::resume()
 131 {
 132     LogD("enter");
 133     ewk_view_resume(m_topWebview);
 134     ewk_view_page_visibility_state_set(
 135             m_topWebview, EWK_PAGE_VISIBILITY_STATE_VISIBLE, EINA_FALSE);
 136     ewk_view_visibility_set(m_topWebview, EINA_TRUE);
 137     return true;
 138 }
 139
 140 bool WebView::setBasicSetting(Evas_Object* webview)
 141 {
 142     LogD("enter");
 143
 144     if (!webview) {
 145         return false;
 146     }
 147
 148     for (auto it = m_smartCallbacksMap.begin();
 149             it != m_smartCallbacksMap.end(); it++) {
 150         evas_object_smart_callback_add(
 151             webview, it->first.c_str(), it->second, this);
 152     }
 153
 154     // set specific features
 155     Ewk_Settings* setting = ewk_view_settings_get(webview);
 156     // set user agent like WRT, or Browser?
 157     // ewk_view_user_agent_set(webview, "some_ua_string");
 158     ewk_settings_plugins_enabled_set(setting, EINA_TRUE);
 159     ewk_settings_javascript_enabled_set(setting, EINA_TRUE);
 160     ewk_settings_loads_images_automatically_set(setting, EINA_TRUE);
 161     ewk_settings_auto_fitting_set(setting, EINA_FALSE);
 162
 163     // set visibility
 164     ewk_view_page_visibility_state_set(
 165             webview, EWK_PAGE_VISIBILITY_STATE_VISIBLE, EINA_TRUE);
 166
 167     // set orientation
 168     ewk_view_orientation_lock_callback_set(
 169             webview, orientationLockCallback, this);
 170
 171     evas_object_color_set(webview, 0, 0, 0, 0);
 172
 173     return true;
 174 }
 175
 176 bool WebView::unsetBasicSetting(Evas_Object* webview)
 177 {
 178     LogD("enter");
 179
 180     if (!webview) {
 181         return false;
 182     }
 183
 184     for (auto it = m_smartCallbacksMap.begin();
 185             it != m_smartCallbacksMap.end(); it++) {
 186         evas_object_smart_callback_del(
 187             m_topWebview, it->first.c_str(), it->second);
 188     }
 189
 190     ewk_view_orientation_lock_callback_set(m_topWebview, NULL, NULL);
 191     return true;
 192 }
 193
 194 std::string WebView::validateUrl(std::string& url)
 195 {
 196     LogD("enter");
 197
 198     if (url.empty()) {
 199         return std::string();
 200     }
 201
 202     if((!url.compare(0, 4, "http")) ||
 203             (!url.compare(0, 5, "https")) ||
 204             (!url.compare(0, 4, "file")))
 205     {
 206         return url;
 207     }
 208
 209     std::string newUrl("file://");
 210     newUrl += url;
 211     return newUrl;
 212 }
 213
 214 void WebView::loadStartedCallback(
 215         void* data, Evas_Object* obj, void* eventInfo)
 216 {
 217     LogD("enter");
 218
 219     WebView* This = static_cast<WebView*>(data);
 220     const char* injectedScript = INJECTED_SCRIPT;
 221     ewk_view_script_execute(obj, injectedScript, executeScriptCallback, This);
 222     This->didLoadStarted(obj);
 223 }
 224
 225 void WebView::loadFinishedCallback(
 226         void* data, Evas_Object* obj, void* eventInfo)
 227 {
 228     LogD("enter");
 229
 230     WebView* This = static_cast<WebView*>(data);
 231     This->didLoadFinished(obj);
 232 }
 233
 234 void WebView::titleChangedCallback(
 235         void* data, Evas_Object* obj, void* eventInfo)
 236 {
 237     LogD("enter");
 238
 239     WebView* This = static_cast<WebView*>(data);
 240     This->didTitleChanged(obj, eventInfo);
 241 }
 242
 243 void WebView::uriChangedCallback(
 244         void* data, Evas_Object* obj, void* eventInfo)
 245 {
 246     LogD("enter");
 247
 248     WebView* This = static_cast<WebView*>(data);
 249     This->didUriChanged(obj, eventInfo);
 250 }
 251
 252 void WebView::loadProgressCallback(
 253         void* data, Evas_Object* obj, void* eventInfo)
 254 {
 255     LogD("enter");
 256
 257     WebView* This = static_cast<WebView*>(data);
 258     This->didLoadProgress(obj, eventInfo);
 259 }
 260
 261 void WebView::loadProgressFinishedCallback(
 262         void* data, Evas_Object* obj, void* eventInfo)
 263 {
 264     LogD("enter");
 265
 266     WebView* This = static_cast<WebView*>(data);
 267     This->didLoadProgressFinished(obj);
 268 }
 269
 270 void WebView::processCrashedCallback(
 271         void* data, Evas_Object* obj, void* eventInfo)
 272 {
 273     LogD("enter");
 274
 275     WebView* This = static_cast<WebView*>(data);
 276     This->didProcessCrashed(obj);
 277 }
 278
 279 void WebView::createWindowCallback(
 280         void* data, Evas_Object* obj, void* eventInfo)
 281 {
 282     LogD("enter");
 283
 284     WebView* This = static_cast<WebView*>(data);
 285     This->didCreateWindow(obj, eventInfo);
 286 }
 287
 288 void WebView::closeWindowCallback(
 289         void* data, Evas_Object* obj, void* eventInfo)
 290 {
 291     LogD("enter");
 292
 293     WebView* This = static_cast<WebView*>(data);
 294     This->didCloseWindow(obj);
 295 }
 296
 297 void WebView::policyNavigationDecideCallback(
 298         void* data, Evas_Object* obj, void* eventInfo)
 299 {
 300     LogD("enter");
 301
 302     WebView* This = static_cast<WebView*>(data);
 303     This->didPolicyNavigationDecide(obj, eventInfo);
 304 }
 305
 306 void WebView::policyNewWindowDecideCallback(
 307         void* data, Evas_Object* obj, void* eventInfo)
 308 {
 309     LogD("enter");
 310
 311     WebView* This = static_cast<WebView*>(data);
 312     This->didPolicyNewWindowDecide(obj, eventInfo);
 313 }
 314
 315 void WebView::pageResponseDecideCallback(
 316         void* data, Evas_Object* obj, void* eventInfo)
 317 {
 318     LogD("enter");
 319
 320     WebView* This = static_cast<WebView*>(data);
 321     This->didPageResponseDecide(obj);
 322 }
 323
 324 void WebView::contextmenuCustomizeCallback(
 325         void* data, Evas_Object* obj, void* eventInfo)
 326 {
 327     LogD("enter");
 328
 329     WebView* This = static_cast<WebView*>(data);
 330     This->didContextmenuCustomize(obj, eventInfo);
 331 }
 332
 333 void WebView::formSubmitCallback(
 334         void* data, Evas_Object *obj, void* eventInfo)
 335 {
 336     LogD("enter");
 337
 338     WebView* This = static_cast<WebView*>(data);
 339     This->didFormSubmit(obj);
 340 }
 341
 342 void WebView::geolocationPermissionRequestCallback(
 343         void* data, Evas_Object* obj, void* eventInfo)
 344 {
 345     LogD("enter");
 346
 347     WebView* This = static_cast<WebView*>(data);
 348     This->didGeolocationPermissionRequest(obj, eventInfo);
 349 }
 350
 351 void WebView::notificationShowCallback(
 352         void* data, Evas_Object* obj, void* eventInfo)
 353 {
 354     LogD("enter");
 355
 356     WebView* This = static_cast<WebView*>(data);
 357     This->didNotificationShow(obj, eventInfo);
 358 }
 359
 360 void WebView::notificationCancelCallback(
 361         void* data, Evas_Object* obj, void* eventInfo)
 362 {
 363     LogD("enter");
 364
 365     WebView* This = static_cast<WebView*>(data);
 366     This->didNotificationCancel(obj, eventInfo);
 367 }
 368
 369 void WebView::notificationPermissionRequestCallback(
 370         void* data, Evas_Object* obj, void* eventInfo)
 371 {
 372     LogD("enter");
 373
 374     WebView* This = static_cast<WebView*>(data);
 375     This->didNotificationPermissionRequest(obj, eventInfo);
 376 }
 377
 378 void WebView::databaseUsagePermissionRequestCallback(
 379         void* data, Evas_Object* obj, void* eventInfo)
 380 {
 381     LogD("enter");
 382
 383     WebView* This = static_cast<WebView*>(data);
 384     This->didDatabaseUsagePermissionRequest(obj, eventInfo);
 385 }
 386
 387 void WebView::fileSystemPermissionRequestCallback(
 388         void* data, Evas_Object* obj, void* eventInfo)
 389 {
 390     LogD("enter");
 391
 392     WebView* This = static_cast<WebView*>(data);
 393     This->didFilesystemPermissionRequest(obj, eventInfo);
 394 }
 395
 396 void WebView::enterFullscreenCallback(
 397         void* data, Evas_Object* obj, void* eventInfo)
 398 {
 399     LogD("enter");
 400
 401     WebView* This = static_cast<WebView*>(data);
 402     This->didEnterFullscreen(obj);
 403 }
 404
 405 void WebView::exitFullscreenCallback(
 406         void* data, Evas_Object* obj, void* eventInfo)
 407 {
 408     LogD("enter");
 409
 410     WebView* This = static_cast<WebView*>(data);
 411     This->didExitFullscreen(obj);
 412 }
 413
 414 void WebView::imeChangedCallback(
 415         void* data, Evas_Object* obj, void* eventInfo)
 416 {
 417     LogD("enter");
 418
 419     WebView* This = static_cast<WebView*>(data);
 420     This->didImeChanged(obj, eventInfo);
 421 }
 422
 423 void WebView::imeOpenedCallback(
 424         void* data, Evas_Object* obj, void* eventInfo)
 425 {
 426     LogD("enter");
 427
 428     WebView* This = static_cast<WebView*>(data);
 429     This->didImeOpened(obj);
 430 }
 431
 432 void WebView::imeClosedCallback(
 433         void* data, Evas_Object* obj, void* eventInfo)
 434 {
 435     LogD("enter");
 436
 437     WebView* This = static_cast<WebView*>(data);
 438     This->didImeClosed(obj);
 439 }
 440
 441 void WebView::usermediaPermissionRequestCallback(
 442         void* data, Evas_Object* obj, void* eventInfo)
 443 {
 444     LogD("enter");
 445
 446     WebView* This = static_cast<WebView*>(data);
 447     This->didUsermediaPermissionRequest(obj, eventInfo);
 448 }
 449
 450 void WebView::protocolHandlerRegistrationCallback(
 451         void* data, Evas_Object* obj, void* eventInfo)
 452 {
 453     LogD("enter");
 454
 455     WebView* This = static_cast<WebView*>(data);
 456     This->didProtocolHandlerRegistration(obj, eventInfo);
 457 }
 458
 459 void WebView::protocolHandlerIsRegisteredCallback(
 460         void* data, Evas_Object* obj, void* eventInfo)
 461 {
 462     LogD("enter");
 463
 464     WebView* This = static_cast<WebView*>(data);
 465     This->didProtocolHandlerIsRegistered(obj, eventInfo);
 466 }
 467
 468 void WebView::protocolHandlerUnregistrationCallback(
 469         void* data, Evas_Object* obj, void* eventInfo)
 470 {
 471     LogD("enter");
 472
 473     WebView* This = static_cast<WebView*>(data);
 474     This->didProtocolHandlerUnregistration(obj, eventInfo);
 475 }
 476
 477 void WebView::contentHandlerRegistrationCallback(
 478         void* data, Evas_Object* obj, void* eventInfo)
 479 {
 480     LogD("enter");
 481
 482     WebView* This = static_cast<WebView*>(data);
 483     This->didContentHandlerRegistration(obj, eventInfo);
 484 }
 485
 486 void WebView::contentHandlerIsRegisteredCallback(
 487         void* data, Evas_Object* obj, void* eventInfo)
 488 {
 489     LogD("enter");
 490
 491     WebView* This = static_cast<WebView*>(data);
 492     This->didContentHandlerIsRegistered(obj, eventInfo);
 493 }
 494
 495 void WebView::contentHandlerUnregistrationCallback(
 496         void* data, Evas_Object* obj, void* eventInfo)
 497 {
 498     LogD("enter");
 499
 500     WebView* This = static_cast<WebView*>(data);
 501     This->didContentHandlerUnregistration(obj, eventInfo);
 502 }
 503
 504 void WebView::certificateConfirmRequestCallback(
 505     void* data, Evas_Object* obj, void* eventInfo)
 506 {
 507     LogD("enter");
 508
 509     WebView* This = static_cast<WebView*>(data);
 510     This->didCertificateConfirmRequest(obj, eventInfo);
 511 }
 512
 513 void WebView::didLoadStarted(Evas_Object* obj)
 514 {
 515     LogD("enter");
 516     // This Will be implemented by derived class
 517 }
 518
 519 void WebView::didLoadFinished(Evas_Object* obj)
 520 {
 521     LogD("enter");
 522     // This Will be implemented by derived class
 523 }
 524
 525 void WebView::didTitleChanged(Evas_Object* obj, void* eventInfo)
 526 {
 527     LogD("enter");
 528     // This Will be implemented by derived class
 529 }
 530
 531 void WebView::didUriChanged(Evas_Object* obj, void* eventInfo)
 532 {
 533     LogD("enter");
 534     // This Will be implemented by derived class
 535 }
 536
 537 void WebView::didLoadProgress(Evas_Object* obj, void* eventInfo)
 538 {
 539     LogD("enter");
 540     // This Will be implemented by derived class
 541 }
 542
 543 void WebView::didLoadProgressFinished(Evas_Object* obj)
 544 {
 545     LogD("enter");
 546     // This Will be implemented by derived class
 547 }
 548
 549 void WebView::didProcessCrashed(Evas_Object* obj)
 550 {
 551     LogD("enter");
 552     // This Will be implemented by derived class
 553 }
 554
 555 void WebView::didCreateWindow(Evas_Object* obj, void* eventInfo)
 556 {
 557     LogD("enter");
 558     // This Will be implemented by derived class
 559 }
 560
 561 void WebView::didCloseWindow(Evas_Object* obj)
 562 {
 563     LogD("enter");
 564     // This Will be implemented by derived class
 565 }
 566
 567 void WebView::didPolicyNavigationDecide(Evas_Object* obj, void* eventInfo)
 568 {
 569     LogD("enter");
 570     // This Will be implemented by derived class
 571 }
 572
 573 void WebView::didPolicyNewWindowDecide(Evas_Object* obj, void* eventInfo)
 574 {
 575     LogD("enter");
 576     // This Will be implemented by derived class
 577 }
 578
 579 void WebView::didPageResponseDecide(Evas_Object* obj)
 580 {
 581     LogD("enter");
 582     // This Will be implemented by derived class
 583 }
 584
 585 void WebView::didContextmenuCustomize(Evas_Object* obj, void* eventInfo)
 586 {
 587     LogD("enter");
 588     // This Will be implemented by derived class
 589 }
 590
 591 void WebView::didFormSubmit(Evas_Object* obj)
 592 {
 593     LogD("enter");
 594     // This Will be implemented by derived class
 595 }
 596
 597 void WebView::didGeolocationPermissionRequest(Evas_Object* obj, void* eventInfo)
 598 {
 599     LogD("enter");
 600     // This Will be implemented by derived class
 601 }
 602
 603 void WebView::didNotificationShow(Evas_Object* obj, void* eventInfo)
 604 {
 605     LogD("enter");
 606     // This Will be implemented by derived class
 607 }
 608
 609 void WebView::didNotificationCancel(Evas_Object* obj, void* eventInfo)
 610 {
 611     LogD("enter");
 612     // This Will be implemented by derived class
 613 }
 614
 615 void WebView::didNotificationPermissionRequest(Evas_Object* obj, void* eventInfo)
 616 {
 617     LogD("enter");
 618     // This Will be implemented by derived class
 619 }
 620
 621 void WebView::didDatabaseUsagePermissionRequest(Evas_Object* obj, void* eventInfo)
 622 {
 623     LogD("enter");
 624     // This Will be implemented by derived class
 625 }
 626
 627 void WebView::didFilesystemPermissionRequest(Evas_Object* obj, void* eventInfo)
 628 {
 629     LogD("enter");
 630     // This Will be implemented by derived class
 631 }
 632
 633 void WebView::didEnterFullscreen(Evas_Object* obj)
 634 {
 635     LogD("enter");
 636     // This Will be implemented by derived class
 637 }
 638
 639 void WebView::didExitFullscreen(Evas_Object* obj)
 640 {
 641     LogD("enter");
 642     // This Will be implemented by derived class
 643 }
 644
 645 void WebView::didImeChanged(Evas_Object* obj, void* eventInfo)
 646 {
 647     LogD("enter");
 648     // This Will be implemented by derived class
 649 }
 650
 651 void WebView::didImeOpened(Evas_Object* obj)
 652 {
 653     LogD("enter");
 654     // This Will be implemented by derived class
 655 }
 656
 657 void WebView::didImeClosed(Evas_Object* obj)
 658 {
 659     LogD("enter");
 660     // This Will be implemented by derived class
 661 }
 662
 663 void WebView::didUsermediaPermissionRequest(Evas_Object* obj, void* eventInfo)
 664 {
 665     LogD("enter");
 666     // This Will be implemented by derived class
 667 }
 668
 669 void WebView::didProtocolHandlerRegistration(Evas_Object* obj, void* eventInfo)
 670 {
 671     LogD("enter");
 672     // This Will be implemented by derived class
 673 }
 674
 675 void WebView::didProtocolHandlerIsRegistered(Evas_Object* obj, void* eventInfo)
 676 {
 677     LogD("enter");
 678     // This Will be implemented by derived class
 679 }
 680
 681 void WebView::didProtocolHandlerUnregistration(Evas_Object* obj, void* eventInfo)
 682 {
 683     LogD("enter");
 684     // This Will be implemented by derived class
 685 }
 686
 687 void WebView::didContentHandlerRegistration(Evas_Object* obj, void* eventInfo)
 688 {
 689     LogD("enter");
 690     // This Will be implemented by derived class
 691 }
 692
 693 void WebView::didContentHandlerIsRegistered(Evas_Object* obj, void* eventInfo)
 694 {
 695     LogD("enter");
 696     // This Will be implemented by derived class
 697 }
 698
 699 void WebView::didContentHandlerUnregistration(Evas_Object* obj, void* eventInfo)
 700 {
 701     LogD("enter");
 702     // This Will be implemented by derived class
 703 }
 704
 705 void WebView::didCertificateConfirmRequest(Evas_Object* obj, void* eventInfo)
 706 {
 707     LogD("enter");
 708     // This Will be implemented by derived class
 709 }
 710
 711 Eina_Bool WebView::orientationLockCallback(
 712         Evas_Object* obj, Eina_Bool needLock, int orientation, void* data)
 713 {
 714     LogD("enter");
 715     return EINA_TRUE;
 716 }
 717
 718 void WebView::executeScriptCallback(
 719                 Evas_Object* obj, const char* result, void* data)
 720 {
 721     LogD("enter");
 722 }
 723