2 * Copyright (c) 2022 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 #include <dali/devel-api/common/stage.h>
22 #include <dali/integration-api/debug.h>
23 #include <dali/public-api/actors/layer.h>
25 #include <unordered_map>
28 #include <dali/devel-api/adaptor-framework/environment-variable.h>
29 #include <dali/devel-api/adaptor-framework/window-devel.h>
30 #include <dali/internal/accessibility/bridge/accessibility-common.h>
31 #include <dali/internal/accessibility/bridge/bridge-accessible.h>
32 #include <dali/internal/accessibility/bridge/bridge-action.h>
33 #include <dali/internal/accessibility/bridge/bridge-collection.h>
34 #include <dali/internal/accessibility/bridge/bridge-component.h>
35 #include <dali/internal/accessibility/bridge/bridge-editable-text.h>
36 #include <dali/internal/accessibility/bridge/bridge-hypertext.h>
37 #include <dali/internal/accessibility/bridge/bridge-hyperlink.h>
38 #include <dali/internal/accessibility/bridge/bridge-object.h>
39 #include <dali/internal/accessibility/bridge/bridge-selection.h>
40 #include <dali/internal/accessibility/bridge/bridge-socket.h>
41 #include <dali/internal/accessibility/bridge/bridge-text.h>
42 #include <dali/internal/accessibility/bridge/bridge-value.h>
43 #include <dali/internal/accessibility/bridge/bridge-application.h>
44 #include <dali/internal/accessibility/bridge/dummy/dummy-atspi.h>
45 #include <dali/internal/adaptor/common/adaptor-impl.h>
46 #include <dali/internal/system/common/environment-variables.h>
48 using namespace Dali::Accessibility;
50 namespace // unnamed namespace
53 const int RETRY_INTERVAL = 1000;
55 } // unnamed namespace
58 * @brief The BridgeImpl class is to implement some Bridge functions.
60 class BridgeImpl : public virtual BridgeBase,
61 public BridgeAccessible,
63 public BridgeComponent,
64 public BridgeCollection,
68 public BridgeEditableText,
69 public BridgeSelection,
70 public BridgeApplication,
71 public BridgeHypertext,
72 public BridgeHyperlink,
75 DBus::DBusClient mAccessibilityStatusClient;
76 DBus::DBusClient mRegistryClient;
77 DBus::DBusClient mDirectReadingClient;
78 bool mIsScreenReaderEnabled = false;
79 bool mIsEnabled = false;
80 std::unordered_map<int32_t, std::function<void(std::string)>> mDirectReadingCallbacks;
81 Dali::Actor mHighlightedActor;
82 std::function<void(Dali::Actor)> mHighlightClearAction;
83 Dali::CallbackBase* mIdleCallback = NULL;
84 Dali::Timer mInitializeTimer;
85 Dali::Timer mReadIsEnabledTimer;
86 Dali::Timer mReadScreenReaderEnabledTimer;
87 Dali::Timer mForceUpTimer;
88 std::string mPreferredBusName;
96 * @copydoc Dali::Accessibility::Bridge::Emit()
98 Consumed Emit(KeyEventType type, unsigned int keyCode, const std::string& keyName, unsigned int timeStamp, bool isText) override
105 unsigned int keyType = 0;
109 case KeyEventType::KEY_PRESSED:
114 case KeyEventType::KEY_RELEASED:
129 * @copydoc Dali::Accessibility::Bridge::Pause()
131 void Pause() override
138 mDirectReadingClient.method<DBus::ValueOrError<void>(bool)>("PauseResume").asyncCall([](DBus::ValueOrError<void> msg) {
141 LOG() << "Direct reading command failed (" << msg.getError().message << ")\n";
148 * @copydoc Dali::Accessibility::Bridge::Resume()
150 void Resume() override
157 mDirectReadingClient.method<DBus::ValueOrError<void>(bool)>("PauseResume").asyncCall([](DBus::ValueOrError<void> msg) {
160 LOG() << "Direct reading command failed (" << msg.getError().message << ")\n";
167 * @copydoc Dali::Accessibility::Bridge::StopReading()
169 void StopReading(bool alsoNonDiscardable) override
176 mDirectReadingClient.method<DBus::ValueOrError<void>(bool)>("StopReading").asyncCall([](DBus::ValueOrError<void> msg) {
179 LOG() << "Direct reading command failed (" << msg.getError().message << ")\n";
186 * @copydoc Dali::Accessibility::Bridge::Say()
188 void Say(const std::string& text, bool discardable, std::function<void(std::string)> callback) override
195 mDirectReadingClient.method<DBus::ValueOrError<std::string, bool, int32_t>(std::string, bool)>("ReadCommand").asyncCall([=](DBus::ValueOrError<std::string, bool, int32_t> msg) {
198 LOG() << "Direct reading command failed (" << msg.getError().message << ")\n";
202 mDirectReadingCallbacks.emplace(std::get<2>(msg), callback);
210 * @copydoc Dali::Accessibility::Bridge::ForceDown()
212 void ForceDown() override
216 if(mData->mCurrentlyHighlightedActor && mData->mHighlightActor)
218 mData->mCurrentlyHighlightedActor.Remove(mData->mHighlightActor);
220 mData->mCurrentlyHighlightedActor = {};
221 mData->mHighlightActor = {};
223 mDisabledSignal.Emit();
224 UnembedSocket(mApplication.GetAddress(), {AtspiDbusNameRegistry, "root"});
225 ReleaseBusName(mPreferredBusName);
228 mHighlightedActor = {};
229 mHighlightClearAction = {};
230 BridgeAccessible::ForceDown();
231 mRegistryClient = {};
232 mDirectReadingClient = {};
233 mDirectReadingCallbacks.clear();
234 mApplication.mChildren.clear();
242 mInitializeTimer.Stop();
243 mInitializeTimer.Reset();
246 if(mReadIsEnabledTimer)
248 mReadIsEnabledTimer.Stop();
249 mReadIsEnabledTimer.Reset();
252 if(mReadScreenReaderEnabledTimer)
254 mReadScreenReaderEnabledTimer.Stop();
255 mReadScreenReaderEnabledTimer.Reset();
260 mForceUpTimer.Stop();
261 mForceUpTimer.Reset();
266 * @copydoc Dali::Accessibility::Bridge::Terminate()
268 void Terminate() override
272 // The ~Window() after this point cannot emit DESTROY, because Bridge is not available. So emit DESTROY here.
273 for(auto windowAccessible : mApplication.mChildren)
275 BridgeObject::Emit(windowAccessible, WindowEvent::DESTROY);
277 mData->mCurrentlyHighlightedActor = {};
278 mData->mHighlightActor = {};
281 if((NULL != mIdleCallback) && Dali::Adaptor::IsAvailable())
283 Dali::Adaptor::Get().RemoveIdle(mIdleCallback);
285 mAccessibilityStatusClient = {};
290 bool ForceUpTimerCallback()
292 if(ForceUp() != ForceUpResult::FAILED)
300 * @copydoc Dali::Accessibility::Bridge::ForceUp()
302 ForceUpResult ForceUp() override
304 auto forceUpResult = BridgeAccessible::ForceUp();
305 if(forceUpResult == ForceUpResult::ALREADY_UP)
307 return forceUpResult;
309 else if(forceUpResult == ForceUpResult::FAILED)
313 mForceUpTimer = Dali::Timer::New(RETRY_INTERVAL);
314 mForceUpTimer.TickSignal().Connect(this, &BridgeImpl::ForceUpTimerCallback);
315 mForceUpTimer.Start();
317 return forceUpResult;
320 BridgeObject::RegisterInterfaces();
321 BridgeAccessible::RegisterInterfaces();
322 BridgeComponent::RegisterInterfaces();
323 BridgeCollection::RegisterInterfaces();
324 BridgeAction::RegisterInterfaces();
325 BridgeValue::RegisterInterfaces();
326 BridgeText::RegisterInterfaces();
327 BridgeEditableText::RegisterInterfaces();
328 BridgeSelection::RegisterInterfaces();
329 BridgeApplication::RegisterInterfaces();
330 BridgeHypertext::RegisterInterfaces();
331 BridgeHyperlink::RegisterInterfaces();
332 BridgeSocket::RegisterInterfaces();
334 RegisterOnBridge(&mApplication);
336 mRegistryClient = {AtspiDbusNameRegistry, AtspiDbusPathDec, Accessible::GetInterfaceName(AtspiInterface::DEVICE_EVENT_CONTROLLER), mConnectionPtr};
337 mDirectReadingClient = DBus::DBusClient{DirectReadingDBusName, DirectReadingDBusPath, DirectReadingDBusInterface, mConnectionPtr};
339 mDirectReadingClient.addSignal<void(int32_t, std::string)>("ReadingStateChanged", [=](int32_t id, std::string readingState) {
340 auto it = mDirectReadingCallbacks.find(id);
341 if(it != mDirectReadingCallbacks.end())
343 it->second(readingState);
344 if(readingState != "ReadingPaused" && readingState != "ReadingResumed" && readingState != "ReadingStarted")
346 mDirectReadingCallbacks.erase(it);
351 RequestBusName(mPreferredBusName);
353 auto parentAddress = EmbedSocket(mApplication.GetAddress(), {AtspiDbusNameRegistry, "root"});
354 mApplication.mParent.SetAddress(std::move(parentAddress));
355 mEnabledSignal.Emit();
357 return ForceUpResult::JUST_STARTED;
361 * @brief Sends a signal to dbus that the window is shown.
363 * @param[in] window The window to be shown
364 * @see Accessible::EmitShowing() and BridgeObject::EmitStateChanged()
366 void EmitShown(Dali::Window window)
368 auto windowAccessible = mApplication.GetWindowAccessible(window);
371 windowAccessible->EmitShowing(true);
376 * @brief Sends a signal to dbus that the window is hidden.
378 * @param[in] window The window to be hidden
379 * @see Accessible::EmitShowing() and BridgeObject::EmitStateChanged()
381 void EmitHidden(Dali::Window window)
383 auto windowAccessible = mApplication.GetWindowAccessible(window);
386 windowAccessible->EmitShowing(false);
391 * @brief Sends a signal to dbus that the window is activated.
393 * @param[in] window The window to be activated
394 * @see BridgeObject::Emit()
396 void EmitActivate(Dali::Window window)
398 auto windowAccessible = mApplication.GetWindowAccessible(window);
401 windowAccessible->Emit(WindowEvent::ACTIVATE, 0);
406 * @brief Sends a signal to dbus that the window is deactivated.
408 * @param[in] window The window to be deactivated
409 * @see BridgeObject::Emit()
411 void EmitDeactivate(Dali::Window window)
413 auto windowAccessible = mApplication.GetWindowAccessible(window);
416 windowAccessible->Emit(WindowEvent::DEACTIVATE, 0);
421 * @brief Sends a signal to dbus that the window is minimized.
423 * @param[in] window The window to be minimized
424 * @see BridgeObject::Emit()
426 void EmitMinimize(Dali::Window window)
428 auto windowAccessible = mApplication.GetWindowAccessible(window);
431 windowAccessible->Emit(WindowEvent::MINIMIZE, 0);
436 * @brief Sends a signal to dbus that the window is restored.
438 * @param[in] window The window to be restored
439 * @param[in] detail Restored window state
440 * @see BridgeObject::Emit()
442 void EmitRestore(Dali::Window window, Dali::Accessibility::WindowRestoreType detail)
444 auto windowAccessible = mApplication.GetWindowAccessible(window);
447 windowAccessible->Emit(WindowEvent::RESTORE, static_cast<unsigned int>(detail));
452 * @brief Sends a signal to dbus that the window is maximized.
454 * @param[in] window The window to be maximized
455 * @see BridgeObject::Emit()
457 void EmitMaximize(Dali::Window window)
459 auto windowAccessible = mApplication.GetWindowAccessible(window);
462 windowAccessible->Emit(WindowEvent::MAXIMIZE, 0);
467 * @copydoc Dali::Accessibility::Bridge::WindowShown()
469 void WindowShown(Dali::Window window) override
478 * @copydoc Dali::Accessibility::Bridge::WindowHidden()
480 void WindowHidden(Dali::Window window) override
489 * @copydoc Dali::Accessibility::Bridge::WindowFocused()
491 void WindowFocused(Dali::Window window) override
495 EmitActivate(window);
500 * @copydoc Dali::Accessibility::Bridge::WindowUnfocused()
502 void WindowUnfocused(Dali::Window window) override
506 EmitDeactivate(window);
511 * @copydoc Dali::Accessibility::Bridge::WindowMinimized()
513 void WindowMinimized(Dali::Window window) override
517 EmitMinimize(window);
522 * @copydoc Dali::Accessibility::Bridge::WindowRestored()
524 void WindowRestored(Dali::Window window, WindowRestoreType detail) override
528 EmitRestore(window, detail);
533 * @copydoc Dali::Accessibility::Bridge::WindowMaximized()
535 void WindowMaximized(Dali::Window window) override
539 EmitMaximize(window);
544 * @copydoc Dali::Accessibility::Bridge::SuppressScreenReader()
546 void SuppressScreenReader(bool suppress) override
548 if(mIsScreenReaderSuppressed == suppress)
552 mIsScreenReaderSuppressed = suppress;
553 ReadScreenReaderEnabledProperty();
558 if((!mIsScreenReaderSuppressed && mIsScreenReaderEnabled) || mIsEnabled)
568 bool ReadIsEnabledTimerCallback()
570 ReadIsEnabledProperty();
574 void ReadIsEnabledProperty()
576 mAccessibilityStatusClient.property<bool>("IsEnabled").asyncGet([this](DBus::ValueOrError<bool> msg) {
579 DALI_LOG_ERROR("Get IsEnabled property error: %s\n", msg.getError().message.c_str());
580 if(msg.getError().errorType == DBus::ErrorType::INVALID_REPLY)
582 if(!mReadIsEnabledTimer)
584 mReadIsEnabledTimer = Dali::Timer::New(RETRY_INTERVAL);
585 mReadIsEnabledTimer.TickSignal().Connect(this, &BridgeImpl::ReadIsEnabledTimerCallback);
587 mReadIsEnabledTimer.Start();
592 if(mReadIsEnabledTimer)
594 mReadIsEnabledTimer.Stop();
595 mReadIsEnabledTimer.Reset();
598 mIsEnabled = std::get<0>(msg);
603 void ListenIsEnabledProperty()
605 mAccessibilityStatusClient.addPropertyChangedEvent<bool>("IsEnabled", [this](bool res) {
611 bool ReadScreenReaderEnabledTimerCallback()
613 ReadScreenReaderEnabledProperty();
617 void ReadScreenReaderEnabledProperty()
619 // can be true because of SuppressScreenReader before init
620 if (!mAccessibilityStatusClient)
625 mAccessibilityStatusClient.property<bool>("ScreenReaderEnabled").asyncGet([this](DBus::ValueOrError<bool> msg) {
628 DALI_LOG_ERROR("Get ScreenReaderEnabled property error: %s\n", msg.getError().message.c_str());
629 if(msg.getError().errorType == DBus::ErrorType::INVALID_REPLY)
631 if(!mReadScreenReaderEnabledTimer)
633 mReadScreenReaderEnabledTimer = Dali::Timer::New(RETRY_INTERVAL);
634 mReadScreenReaderEnabledTimer.TickSignal().Connect(this, &BridgeImpl::ReadScreenReaderEnabledTimerCallback);
636 mReadScreenReaderEnabledTimer.Start();
641 if(mReadScreenReaderEnabledTimer)
643 mReadScreenReaderEnabledTimer.Stop();
644 mReadScreenReaderEnabledTimer.Reset();
647 mIsScreenReaderEnabled = std::get<0>(msg);
652 void EmitScreenReaderEnabledSignal()
654 if (mIsScreenReaderEnabled)
656 mScreenReaderEnabledSignal.Emit();
660 mScreenReaderDisabledSignal.Emit();
664 void ListenScreenReaderEnabledProperty()
666 mAccessibilityStatusClient.addPropertyChangedEvent<bool>("ScreenReaderEnabled", [this](bool res) {
667 mIsScreenReaderEnabled = res;
668 EmitScreenReaderEnabledSignal();
673 void ReadAndListenProperties()
675 ReadIsEnabledProperty();
676 ListenIsEnabledProperty();
678 ReadScreenReaderEnabledProperty();
679 ListenScreenReaderEnabledProperty();
682 bool InitializeAccessibilityStatusClient()
684 mAccessibilityStatusClient = DBus::DBusClient{A11yDbusName, A11yDbusPath, A11yDbusStatusInterface, DBus::ConnectionType::SESSION};
686 if (!mAccessibilityStatusClient)
688 DALI_LOG_ERROR("Accessibility Status DbusClient is not ready\n");
695 bool InitializeTimerCallback()
697 if ( InitializeAccessibilityStatusClient() )
699 ReadAndListenProperties();
707 if ( InitializeAccessibilityStatusClient() )
709 ReadAndListenProperties();
710 mIdleCallback = NULL;
714 if(!mInitializeTimer)
716 mInitializeTimer = Dali::Timer::New(RETRY_INTERVAL);
717 mInitializeTimer.TickSignal().Connect(this, &BridgeImpl::InitializeTimerCallback);
719 mInitializeTimer.Start();
721 mIdleCallback = NULL;
726 * @copydoc Dali::Accessibility::Bridge::Initialize()
728 void Initialize() override
730 if ( InitializeAccessibilityStatusClient() )
732 ReadAndListenProperties();
736 // Initialize failed. Try it again on Idle
737 if( Dali::Adaptor::IsAvailable() )
739 Dali::Adaptor& adaptor = Dali::Adaptor::Get();
740 if( NULL == mIdleCallback )
742 mIdleCallback = MakeCallback( this, &BridgeImpl::OnIdleSignal );
743 adaptor.AddIdle( mIdleCallback, true );
749 * @copydoc Dali::Accessibility::Bridge::GetScreenReaderEnabled()
751 bool GetScreenReaderEnabled() override
753 return mIsScreenReaderEnabled;
757 * @copydoc Dali::Accessibility::Bridge::IsEnabled()
759 bool IsEnabled() override
764 Address EmbedSocket(const Address& plug, const Address& socket) override
766 auto client = CreateSocketClient(socket);
767 auto reply = client.method<Address(Address)>("Embed").call(plug);
771 DALI_LOG_ERROR("Failed to embed socket %s: %s", socket.ToString().c_str(), reply.getError().message.c_str());
775 return std::get<0>(reply.getValues());
778 void EmbedAtkSocket(const Address& plug, const Address& socket) override
780 auto client = CreateSocketClient(socket);
782 client.method<void(std::string)>("Embedded").call(ATSPI_PREFIX_PATH + plug.GetPath());
785 void UnembedSocket(const Address& plug, const Address& socket) override
787 auto client = CreateSocketClient(socket);
789 client.method<void(Address)>("Unembed").call(plug);
792 void SetSocketOffset(ProxyAccessible* socket, std::int32_t x, std::int32_t y) override
794 AddCoalescableMessage(CoalescableMessages::SET_OFFSET, socket, 1.0f, [=]() {
795 auto client = CreateSocketClient(socket->GetAddress());
797 client.method<void(std::int32_t, std::int32_t)>("SetOffset").asyncCall([](DBus::ValueOrError<void>) {}, x, y);
801 void SetExtentsOffset(std::int32_t x, std::int32_t y) override
805 mData->mExtentsOffset = {x, y};
809 void SetPreferredBusName(std::string_view preferredBusName) override
811 if(preferredBusName == mPreferredBusName)
816 std::string oldPreferredBusName = std::move(mPreferredBusName);
817 mPreferredBusName = std::string{preferredBusName};
821 ReleaseBusName(oldPreferredBusName);
822 RequestBusName(mPreferredBusName);
824 // else: request/release will be handled by ForceUp/ForceDown, respectively
828 DBus::DBusClient CreateSocketClient(const Address& socket)
830 return {socket.GetBus(), ATSPI_PREFIX_PATH + socket.GetPath(), Accessible::GetInterfaceName(AtspiInterface::SOCKET), mConnectionPtr};
833 void RequestBusName(const std::string& busName)
840 DBus::requestBusName(mConnectionPtr, busName);
843 void ReleaseBusName(const std::string& busName)
850 DBus::releaseBusName(mConnectionPtr, busName);
854 namespace // unnamed namespace
857 bool INITIALIZED_BRIDGE = false;
860 * @brief Creates BridgeImpl instance.
862 * @return The BridgeImpl instance
863 * @note This method is to check environment variable first. If ATSPI is disable using env, it returns dummy bridge instance.
865 std::shared_ptr<Bridge> CreateBridge()
867 INITIALIZED_BRIDGE = true;
871 /* check environment variable first */
872 const char* envAtspiDisabled = Dali::EnvironmentVariable::GetEnvironmentVariable(DALI_ENV_DISABLE_ATSPI);
873 if(envAtspiDisabled && std::atoi(envAtspiDisabled) != 0)
875 return Dali::Accessibility::DummyBridge::GetInstance();
878 return std::make_shared<BridgeImpl>();
880 catch(const std::exception&)
882 DALI_LOG_ERROR("Failed to initialize AT-SPI bridge");
883 return Dali::Accessibility::DummyBridge::GetInstance();
887 } // unnamed namespace
889 // Dali::Accessibility::Bridge class implementation
891 std::shared_ptr<Bridge> Bridge::GetCurrentBridge()
893 static std::shared_ptr<Bridge> bridge;
899 else if(mAutoInitState == AutoInitState::ENABLED)
901 bridge = CreateBridge();
903 /* check environment variable for suppressing screen-reader */
904 const char* envSuppressScreenReader = Dali::EnvironmentVariable::GetEnvironmentVariable(DALI_ENV_SUPPRESS_SCREEN_READER);
905 if(envSuppressScreenReader && std::atoi(envSuppressScreenReader) != 0)
907 bridge->SuppressScreenReader(true);
913 return Dali::Accessibility::DummyBridge::GetInstance();
916 void Bridge::DisableAutoInit()
918 if(INITIALIZED_BRIDGE)
920 DALI_LOG_ERROR("Bridge::DisableAutoInit() called after bridge auto-initialization");
923 mAutoInitState = AutoInitState::DISABLED;
926 void Bridge::EnableAutoInit()
928 mAutoInitState = AutoInitState::ENABLED;
930 if(INITIALIZED_BRIDGE)
935 auto rootLayer = Dali::Stage::GetCurrent().GetRootLayer(); // A root layer of the default window.
936 auto window = Dali::DevelWindow::Get(rootLayer);
937 auto applicationName = Dali::Internal::Adaptor::Adaptor::GetApplicationPackageName();
939 auto accessible = Accessibility::Accessible::Get(rootLayer);
941 auto bridge = Bridge::GetCurrentBridge();
942 bridge->AddTopLevelWindow(accessible);
943 bridge->SetApplicationName(applicationName);
944 bridge->Initialize();
946 if(window && window.IsVisible())
948 bridge->WindowShown(window);
952 std::string Bridge::MakeBusNameForWidget(std::string_view widgetInstanceId)
954 // The bus name should consist of dot-separated alphanumeric elements, e.g. "com.example.BusName123".
955 // Allowed characters in each element: "[A-Z][a-z][0-9]_", but no element may start with a digit.
957 static const char prefix[] = "com.samsung.dali.widget_";
958 static const char underscore = '_';
960 std::stringstream tmp;
964 for(char ch : widgetInstanceId)
966 tmp << (std::isalnum(ch) ? ch : underscore);