dali/internal/accessibility/bridge/bridge-base.h

   1 #ifndef DALI_INTERNAL_ACCESSIBILITY_BRIDGE_BASE_H
   2 #define DALI_INTERNAL_ACCESSIBILITY_BRIDGE_BASE_H
   3
   4 /*
   5  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/actors/layer.h>
  23 #include <dali/public-api/dali-adaptor-version.h>
  24 #include <dali/public-api/signals/connection-tracker.h>
  25 #include <memory>
  26 #include <tuple>
  27
  28 // INTERNAL INCLUDES
  29 #include <dali/devel-api/adaptor-framework/proxy-accessible.h>
  30 #include <dali/devel-api/adaptor-framework/window-devel.h>
  31 #include <dali/devel-api/atspi-interfaces/accessible.h>
  32 #include <dali/devel-api/atspi-interfaces/application.h>
  33 #include <dali/devel-api/atspi-interfaces/collection.h>
  34 #include <dali/devel-api/atspi-interfaces/socket.h>
  35 #include <dali/internal/accessibility/bridge/accessibility-common.h>
  36
  37 /**
  38  * @brief The ApplicationAccessible class is to define Accessibility Application.
  39  */
  40 class ApplicationAccessible : public virtual Dali::Accessibility::Accessible,
  41                               public virtual Dali::Accessibility::Application,
  42                               public virtual Dali::Accessibility::Collection,
  43                               public virtual Dali::Accessibility::Component,
  44                               public virtual Dali::Accessibility::Socket
  45 {
  46 public:
  47   Dali::Accessibility::ProxyAccessible          mParent;
  48   std::vector<Dali::Accessibility::Accessible*> mChildren;
  49   std::string                                   mName;
  50   std::string                                   mToolkitName{"dali"};
  51   bool                                          mIsEmbedded{false};
  52
  53   std::string GetName() const override
  54   {
  55     return mName;
  56   }
  57
  58   std::string GetDescription() const override
  59   {
  60     return "";
  61   }
  62
  63   Dali::Accessibility::Accessible* GetParent() override
  64   {
  65     return &mParent;
  66   }
  67
  68   size_t GetChildCount() const override
  69   {
  70     return mChildren.size();
  71   }
  72
  73   std::vector<Dali::Accessibility::Accessible*> GetChildren() override
  74   {
  75     return mChildren;
  76   }
  77
  78   Dali::Accessibility::Accessible* GetChildAtIndex(size_t index) override
  79   {
  80     auto size = mChildren.size();
  81     if(index >= size)
  82     {
  83       throw std::domain_error{"invalid index " + std::to_string(index) + " for object with " + std::to_string(size) + " children"};
  84     }
  85     return mChildren[index];
  86   }
  87
  88   size_t GetIndexInParent() override
  89   {
  90     if(mIsEmbedded)
  91     {
  92       return 0u;
  93     }
  94
  95     throw std::domain_error{"can't call GetIndexInParent on application object"};
  96   }
  97
  98   Dali::Accessibility::Role GetRole() const override
  99   {
 100     return Dali::Accessibility::Role::APPLICATION;
 101   }
 102
 103   Dali::Accessibility::States GetStates() override
 104   {
 105     Dali::Accessibility::States result;
 106
 107     for(auto* child : mChildren)
 108     {
 109       result = result | child->GetStates();
 110     }
 111
 112     return result;
 113   }
 114
 115   Dali::Accessibility::Attributes GetAttributes() const override
 116   {
 117     return {};
 118   }
 119
 120   /**
 121    * @brief Gets the Accessible object from the window.
 122    *
 123    * @param[in] window The window to find
 124    * @return Null if mChildren is empty, otherwise the Accessible object
 125    * @note Currently, the default window would be returned when mChildren is not empty.
 126    */
 127   Dali::Accessibility::Accessible* GetWindowAccessible(Dali::Window window)
 128   {
 129     if(mChildren.empty())
 130     {
 131       return nullptr;
 132     }
 133
 134     Dali::Layer rootLayer = window.GetRootLayer();
 135
 136     // Find a child which is related to the window.
 137     for(auto i = 0u; i < mChildren.size(); ++i)
 138     {
 139       if(rootLayer == mChildren[i]->GetInternalActor())
 140       {
 141         return mChildren[i];
 142       }
 143     }
 144
 145     // If can't find its children, return the default window.
 146     return mChildren[0];
 147   }
 148
 149   bool DoGesture(const Dali::Accessibility::GestureInfo& gestureInfo) override
 150   {
 151     return false;
 152   }
 153
 154   std::vector<Dali::Accessibility::Relation> GetRelationSet() override
 155   {
 156     return {};
 157   }
 158
 159   Dali::Actor GetInternalActor() override
 160   {
 161     return Dali::Actor{};
 162   }
 163
 164   Dali::Accessibility::Address GetAddress() const override
 165   {
 166     return {"", "root"};
 167   }
 168
 169   // Application
 170
 171   std::string GetToolkitName() const override
 172   {
 173     return mToolkitName;
 174   }
 175
 176   std::string GetVersion() const override
 177   {
 178     return std::to_string(Dali::ADAPTOR_MAJOR_VERSION) + "." + std::to_string(Dali::ADAPTOR_MINOR_VERSION);
 179   }
 180
 181   // Socket
 182
 183   Dali::Accessibility::Address Embed(Dali::Accessibility::Address plug) override
 184   {
 185     mIsEmbedded = true;
 186     mParent.SetAddress(plug);
 187
 188     return GetAddress();
 189   }
 190
 191   void Unembed(Dali::Accessibility::Address plug) override
 192   {
 193     if(mParent.GetAddress() == plug)
 194     {
 195       mIsEmbedded = false;
 196       mParent.SetAddress({});
 197       Dali::Accessibility::Bridge::GetCurrentBridge()->SetExtentsOffset(0, 0);
 198     }
 199   }
 200
 201   void SetOffset(std::int32_t x, std::int32_t y) override
 202   {
 203     if(!mIsEmbedded)
 204     {
 205       return;
 206     }
 207
 208     Dali::Accessibility::Bridge::GetCurrentBridge()->SetExtentsOffset(x, y);
 209   }
 210
 211   // Component
 212
 213   Dali::Rect<> GetExtents(Dali::Accessibility::CoordinateType type) const override
 214   {
 215     using limits = std::numeric_limits<float>;
 216
 217     float minX = limits::max();
 218     float minY = limits::max();
 219     float maxX = limits::min();
 220     float maxY = limits::min();
 221
 222     for(Dali::Accessibility::Accessible* child : mChildren)
 223     {
 224       auto* component = Dali::Accessibility::Component::DownCast(child);
 225       if(!component)
 226       {
 227         continue;
 228       }
 229
 230       auto extents = component->GetExtents(type);
 231
 232       minX = std::min(minX, extents.x);
 233       minY = std::min(minY, extents.y);
 234       maxX = std::max(maxX, extents.x + extents.width);
 235       maxY = std::max(maxY, extents.y + extents.height);
 236     }
 237
 238     return {minX, minY, maxX - minX, maxY - minY};
 239   }
 240
 241   Dali::Accessibility::ComponentLayer GetLayer() const override
 242   {
 243     return Dali::Accessibility::ComponentLayer::WINDOW;
 244   }
 245
 246   std::int16_t GetMdiZOrder() const override
 247   {
 248     return 0;
 249   }
 250
 251   bool GrabFocus() override
 252   {
 253     return false;
 254   }
 255
 256   double GetAlpha() const override
 257   {
 258     return 0.0;
 259   }
 260
 261   bool GrabHighlight() override
 262   {
 263     return false;
 264   }
 265
 266   bool ClearHighlight() override
 267   {
 268     return false;
 269   }
 270
 271   bool IsScrollable() const override
 272   {
 273     return false;
 274   }
 275 };
 276
 277 /**
 278  * @brief Enumeration for CoalescableMessages.
 279  */
 280 enum class CoalescableMessages
 281 {
 282   BOUNDS_CHANGED, ///< Bounds changed
 283   SET_OFFSET, ///< Set offset
 284   POST_RENDER, ///< Post render
 285 };
 286
 287 // Custom specialization of std::hash
 288 namespace std
 289 {
 290 template<>
 291 struct hash<std::pair<CoalescableMessages, Dali::Accessibility::Accessible*>>
 292 {
 293   size_t operator()(std::pair<CoalescableMessages, Dali::Accessibility::Accessible*> value) const
 294   {
 295     return (static_cast<size_t>(value.first) * 131) ^ reinterpret_cast<size_t>(value.second);
 296   }
 297 };
 298 } // namespace std
 299
 300 /**
 301  * @brief The BridgeBase class is basic class for Bridge functions.
 302  */
 303 class BridgeBase : public Dali::Accessibility::Bridge, public Dali::ConnectionTracker
 304 {
 305   std::unordered_map<std::pair<CoalescableMessages, Dali::Accessibility::Accessible*>, std::tuple<unsigned int, unsigned int, std::function<void()>>> mCoalescableMessages;
 306
 307   /**
 308    * @brief Removes all CoalescableMessages using Tick signal.
 309    *
 310    * @return False if mCoalescableMessages is empty, otherwise true.
 311    */
 312   bool TickCoalescableMessages();
 313
 314 public:
 315   /**
 316    * @brief Adds CoalescableMessages, Accessible, and delay time to mCoalescableMessages.
 317    *
 318    * @param[in] kind CoalescableMessages enum value
 319    * @param[in] obj Accessible object
 320    * @param[in] delay The delay time
 321    * @param[in] functor The function to be called // NEED TO UPDATE!
 322    */
 323   void AddCoalescableMessage(CoalescableMessages kind, Dali::Accessibility::Accessible* obj, float delay, std::function<void()> functor);
 324
 325   /**
 326    * @brief Callback when the visibility of the window is changed.
 327    *
 328    * @param[in] window The window to be changed
 329    * @param[in] visible The visibility of the window
 330    */
 331   void OnWindowVisibilityChanged(Dali::Window window, bool visible);
 332
 333   /**
 334    * @brief Callback when the window focus is changed.
 335    *
 336    * @param[in] window The window whose focus is changed
 337    * @param[in] focusIn Whether the focus is in/out
 338    */
 339   void OnWindowFocusChanged(Dali::Window window, bool focusIn);
 340
 341   /**
 342    * @copydoc Dali::Accessibility::Bridge::GetBusName()
 343    */
 344   const std::string& GetBusName() const override;
 345
 346   /**
 347    * @copydoc Dali::Accessibility::Bridge::AddTopLevelWindow()
 348    */
 349   void AddTopLevelWindow(Dali::Accessibility::Accessible* windowAccessible) override;
 350
 351   /**
 352    * @copydoc Dali::Accessibility::Bridge::RemoveTopLevelWindow()
 353    */
 354   void RemoveTopLevelWindow(Dali::Accessibility::Accessible* windowAccessible) override;
 355
 356   /**
 357    * @copydoc Dali::Accessibility::Bridge::RegisterDefaultLabel()
 358    */
 359   void RegisterDefaultLabel(Dali::Accessibility::Accessible* object) override;
 360
 361   /**
 362    * @copydoc Dali::Accessibility::Bridge::UnregisterDefaultLabel()
 363    */
 364   void UnregisterDefaultLabel(Dali::Accessibility::Accessible* object) override;
 365
 366   /**
 367    * @copydoc Dali::Accessibility::Bridge::GetDefaultLabel()
 368    */
 369   Dali::Accessibility::Accessible* GetDefaultLabel(Dali::Accessibility::Accessible* root) const override;
 370
 371   /**
 372    * @copydoc Dali::Accessibility::Bridge::GetApplication()
 373    */
 374   Dali::Accessibility::Accessible* GetApplication() const override
 375   {
 376     return &mApplication;
 377   }
 378
 379   /**
 380    * @brief Adds function to dbus interface.
 381    */
 382   template<typename SELF, typename... RET, typename... ARGS>
 383   void AddFunctionToInterface(
 384     DBus::DBusInterfaceDescription& desc, const std::string& funcName, DBus::ValueOrError<RET...> (SELF::*funcPtr)(ARGS...))
 385   {
 386     if(auto self = dynamic_cast<SELF*>(this))
 387       desc.addMethod<DBus::ValueOrError<RET...>(ARGS...)>(
 388         funcName,
 389         [=](ARGS... args) -> DBus::ValueOrError<RET...> {
 390           try
 391           {
 392             return (self->*funcPtr)(std::move(args)...);
 393           }
 394           catch(std::domain_error& e)
 395           {
 396             return DBus::Error{e.what()};
 397           }
 398         });
 399   }
 400
 401   /**
 402    * @brief Adds 'Get' property to dbus interface.
 403    */
 404   template<typename T, typename SELF>
 405   void AddGetPropertyToInterface(DBus::DBusInterfaceDescription& desc,
 406                                  const std::string&              funcName,
 407                                  T (SELF::*funcPtr)())
 408   {
 409     if(auto self = dynamic_cast<SELF*>(this))
 410       desc.addProperty<T>(funcName,
 411                           [=]() -> DBus::ValueOrError<T> {
 412                             try
 413                             {
 414                               return (self->*funcPtr)();
 415                             }
 416                             catch(std::domain_error& e)
 417                             {
 418                               return DBus::Error{e.what()};
 419                             }
 420                           },
 421                           {});
 422   }
 423
 424   /**
 425    * @brief Adds 'Set' property to dbus interface.
 426    */
 427   template<typename T, typename SELF>
 428   void AddSetPropertyToInterface(DBus::DBusInterfaceDescription& desc,
 429                                  const std::string&              funcName,
 430                                  void (SELF::*funcPtr)(T))
 431   {
 432     if(auto self = dynamic_cast<SELF*>(this))
 433       desc.addProperty<T>(funcName, {}, [=](T t) -> DBus::ValueOrError<void> {
 434         try
 435         {
 436           (self->*funcPtr)(std::move(t));
 437           return {};
 438         }
 439         catch(std::domain_error& e)
 440         {
 441           return DBus::Error{e.what()};
 442         }
 443       });
 444   }
 445
 446   /**
 447    * @brief Adds 'Set' and 'Get' properties to dbus interface.
 448    */
 449   template<typename T, typename T1, typename SELF>
 450   void AddGetSetPropertyToInterface(DBus::DBusInterfaceDescription& desc,
 451                                     const std::string&              funcName,
 452                                     T1 (SELF::*funcPtrGet)(),
 453                                     DBus::ValueOrError<void> (SELF::*funcPtrSet)(T))
 454   {
 455     if(auto self = dynamic_cast<SELF*>(this))
 456       desc.addProperty<T>(
 457         funcName,
 458         [=]() -> DBus::ValueOrError<T> {
 459           try
 460           {
 461             return (self->*funcPtrGet)();
 462           }
 463           catch(std::domain_error& e)
 464           {
 465             return DBus::Error{e.what()};
 466           }
 467         },
 468         [=](T t) -> DBus::ValueOrError<void> {
 469           try
 470           {
 471             (self->*funcPtrSet)(std::move(t));
 472             return {};
 473           }
 474           catch(std::domain_error& e)
 475           {
 476             return DBus::Error{e.what()};
 477           }
 478         });
 479   }
 480
 481   /**
 482    * @brief Adds 'Get' and 'Set' properties to dbus interface.
 483    */
 484   template<typename T, typename T1, typename SELF>
 485   void AddGetSetPropertyToInterface(DBus::DBusInterfaceDescription& desc,
 486                                     const std::string&              funcName,
 487                                     T1 (SELF::*funcPtrGet)(),
 488                                     void (SELF::*funcPtrSet)(T))
 489   {
 490     if(auto self = dynamic_cast<SELF*>(this))
 491       desc.addProperty<T>(
 492         funcName,
 493         [=]() -> DBus::ValueOrError<T> {
 494           try
 495           {
 496             return (self->*funcPtrGet)();
 497           }
 498           catch(std::domain_error& e)
 499           {
 500             return DBus::Error{e.what()};
 501           }
 502         },
 503         [=](T t) -> DBus::ValueOrError<void> {
 504           try
 505           {
 506             (self->*funcPtrSet)(std::move(t));
 507             return {};
 508           }
 509           catch(std::domain_error& e)
 510           {
 511             return DBus::Error{e.what()};
 512           }
 513         });
 514   }
 515
 516   /**
 517    * @brief Gets the string of the path excluding the specified prefix.
 518    *
 519    * @param path The path to get
 520    * @return The string stripped of the specific prefix
 521    */
 522   static std::string StripPrefix(const std::string& path);
 523
 524   /**
 525    * @brief Finds the Accessible object according to the path.
 526    *
 527    * @param[in] path The path for Accessible object
 528    * @return The Accessible object corresponding to the path
 529    */
 530   Dali::Accessibility::Accessible* Find(const std::string& path) const;
 531
 532   /**
 533    * @brief Finds the Accessible object with the given address.
 534    *
 535    * @param[in] ptr The unique Address of the object
 536    * @return The Accessible object corresponding to the path
 537    */
 538   Dali::Accessibility::Accessible* Find(const Dali::Accessibility::Address& ptr) const;
 539
 540   /**
 541    * @brief Returns the target object of the currently executed DBus method call.
 542    *
 543    * @return The Accessible object
 544    * @note When a DBus method is called on some object, this target object (`currentObject`) is temporarily saved by the bridge,
 545    * because DBus handles the invocation target separately from the method arguments.
 546    * We then use the saved object inside the 'glue' method (e.g. BridgeValue::GetMinimum)
 547    * to call the equivalent method on the respective C++ object (this could be ScrollBar::AccessibleImpl::GetMinimum in the example given).
 548    */
 549   Dali::Accessibility::Accessible* FindCurrentObject() const;
 550
 551   /**
 552    * @brief Returns the target object of the currently executed DBus method call.
 553    *
 554    * This method tries to downcast the return value of FindCurrentObject() to the requested type,
 555    * issuing an error reply to the DBus caller if the requested type is not implemented. Whether
 556    * a given type is implemented is decided based on the return value of Accessible::GetInterfaces()
 557    * for the current object.
 558    *
 559    * @tparam I The requested AT-SPI interface
 560    * @return The Accessible object (cast to a more derived type)
 561    *
 562    * @see FindCurrentObject()
 563    * @see Dali::Accessibility::AtspiInterface
 564    * @see Dali::Accessibility::AtspiInterfaceType
 565    * @see Dali::Accessibility::Accessible::GetInterfaces()
 566    */
 567   template<Dali::Accessibility::AtspiInterface I>
 568   auto* FindCurrentObjectWithInterface() const
 569   {
 570     using Type = Dali::Accessibility::AtspiInterfaceType<I>;
 571
 572     Type* result;
 573     auto* currentObject = FindCurrentObject();
 574     DALI_ASSERT_DEBUG(currentObject); // FindCurrentObject() throws domain_error
 575
 576     if(!(result = Dali::Accessibility::Accessible::DownCast<I>(currentObject)))
 577     {
 578       std::stringstream s;
 579
 580       s << "Object " << currentObject->GetAddress().ToString();
 581       s << " does not implement ";
 582       s << Dali::Accessibility::Accessible::GetInterfaceName(I);
 583
 584       throw std::domain_error{s.str()};
 585     }
 586
 587     return result;
 588   }
 589
 590   /**
 591    * @copydoc Dali::Accessibility::Bridge::FindByPath()
 592    */
 593   Dali::Accessibility::Accessible* FindByPath(const std::string& name) const override;
 594
 595   /**
 596    * @copydoc Dali::Accessibility::Bridge::SetApplicationName()
 597    */
 598   void SetApplicationName(std::string name) override
 599   {
 600     mApplication.mName = std::move(name);
 601   }
 602
 603   /**
 604    * @copydoc Dali::Accessibility::Bridge::SetToolkitName()
 605    */
 606   void SetToolkitName(std::string_view toolkitName) override
 607   {
 608     mApplication.mToolkitName = std::string{toolkitName};
 609   }
 610
 611 protected:
 612   mutable ApplicationAccessible                 mApplication;
 613   std::vector<Dali::Accessibility::Accessible*> mDefaultLabels;
 614   bool                                          mIsScreenReaderSuppressed = false;
 615
 616 private:
 617   /**
 618    * @brief Sets an ID.
 619    * @param[in] id An ID (integer value)
 620    */
 621   void SetId(int id);
 622
 623   /**
 624    * @brief Gets the ID.
 625    * @return The ID to be set
 626    */
 627   int GetId();
 628
 629   /**
 630    * @brief Update registered events.
 631    */
 632   void UpdateRegisteredEvents();
 633
 634   using CacheElementType = std::tuple<
 635     Dali::Accessibility::Address,
 636     Dali::Accessibility::Address,
 637     Dali::Accessibility::Address,
 638     std::vector<Dali::Accessibility::Address>,
 639     std::vector<std::string>,
 640     std::string,
 641     Dali::Accessibility::Role,
 642     std::string,
 643     std::array<uint32_t, 2>>;
 644
 645   /**
 646    * @brief Gets Items  // NEED TO UPDATE!
 647    *
 648    * @return
 649    */
 650   DBus::ValueOrError<std::vector<CacheElementType>> GetItems();
 651
 652   /**
 653    * @brief Creates CacheElement.
 654    *
 655    * CreateCacheElement method works for GetItems which is a part of ATSPI protocol.
 656    * ATSPI client library (libatspi from at-spi2-core) depending on cacheing policy configuration uses GetItems
 657    * to pre-load entire accessible tree from application to its own cache in single dbus call.
 658    * Otherwise the particular nodes in a tree are cached lazily when client library tries to access them.
 659    * @param item Accessible to get information
 660    * @return The elements to be cached
 661    */
 662   CacheElementType CreateCacheElement(Dali::Accessibility::Accessible* item);
 663
 664 protected:
 665   BridgeBase();
 666   virtual ~BridgeBase();
 667
 668   /**
 669    * @copydoc Dali::Accessibility::Bridge::ForceUp()
 670    */
 671   ForceUpResult ForceUp() override;
 672
 673   /**
 674    * @copydoc Dali::Accessibility::Bridge::ForceDown()
 675    */
 676   void ForceDown() override;
 677
 678   DBus::DBusServer           mDbusServer;
 679   DBusWrapper::ConnectionPtr mConnectionPtr;
 680   int                        mId = 0;
 681   DBus::DBusClient           mRegistry;
 682   bool                       IsBoundsChangedEventAllowed{false};
 683 };
 684
 685 #endif // DALI_INTERNAL_ACCESSIBILITY_BRIDGE_BASE_H