/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <unordered_map>
// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/actor-accessible.h>
#include <dali/devel-api/adaptor-framework/environment-variable.h>
#include <dali/devel-api/adaptor-framework/window-devel.h>
#include <dali/internal/accessibility/bridge/accessibility-common.h>
#include <dali/internal/accessibility/bridge/bridge-accessible.h>
#include <dali/internal/accessibility/bridge/bridge-action.h>
+#include <dali/internal/accessibility/bridge/bridge-application.h>
#include <dali/internal/accessibility/bridge/bridge-collection.h>
#include <dali/internal/accessibility/bridge/bridge-component.h>
#include <dali/internal/accessibility/bridge/bridge-editable-text.h>
-#include <dali/internal/accessibility/bridge/bridge-hypertext.h>
#include <dali/internal/accessibility/bridge/bridge-hyperlink.h>
+#include <dali/internal/accessibility/bridge/bridge-hypertext.h>
#include <dali/internal/accessibility/bridge/bridge-object.h>
#include <dali/internal/accessibility/bridge/bridge-selection.h>
#include <dali/internal/accessibility/bridge/bridge-socket.h>
+#include <dali/internal/accessibility/bridge/bridge-table-cell.h>
+#include <dali/internal/accessibility/bridge/bridge-table.h>
#include <dali/internal/accessibility/bridge/bridge-text.h>
#include <dali/internal/accessibility/bridge/bridge-value.h>
-#include <dali/internal/accessibility/bridge/bridge-application.h>
#include <dali/internal/accessibility/bridge/dummy/dummy-atspi.h>
#include <dali/internal/adaptor/common/adaptor-impl.h>
#include <dali/internal/system/common/environment-variables.h>
namespace // unnamed namespace
{
-
const int RETRY_INTERVAL = 1000;
} // unnamed namespace
public BridgeApplication,
public BridgeHypertext,
public BridgeHyperlink,
- public BridgeSocket
+ public BridgeSocket,
+ public BridgeTable,
+ public BridgeTableCell
{
- DBus::DBusClient mAccessibilityStatusClient;
- DBus::DBusClient mRegistryClient;
- DBus::DBusClient mDirectReadingClient;
- bool mIsScreenReaderEnabled = false;
- bool mIsEnabled = false;
- std::unordered_map<int32_t, std::function<void(std::string)>> mDirectReadingCallbacks;
+ DBus::DBusClient mAccessibilityStatusClient{};
+ DBus::DBusClient mRegistryClient{};
+ DBus::DBusClient mDirectReadingClient{};
+ bool mIsScreenReaderEnabled{false};
+ bool mIsEnabled{false};
+ bool mIsApplicationRunning{false};
+ std::unordered_map<int32_t, std::function<void(std::string)>> mDirectReadingCallbacks{};
Dali::Actor mHighlightedActor;
- std::function<void(Dali::Actor)> mHighlightClearAction;
- Dali::CallbackBase* mIdleCallback = NULL;
+ std::function<void(Dali::Actor)> mHighlightClearAction{nullptr};
+ Dali::CallbackBase* mIdleCallback{};
Dali::Timer mInitializeTimer;
Dali::Timer mReadIsEnabledTimer;
Dali::Timer mReadScreenReaderEnabledTimer;
Dali::Timer mForceUpTimer;
std::string mPreferredBusName;
+ std::map<uint32_t, std::shared_ptr<Accessible>> mAccessibles; // Actor.ID to Accessible map
public:
- BridgeImpl()
+ BridgeImpl() = default;
+
+ /**
+ * @copydoc Dali::Accessibility::Bridge::AddAccessible()
+ */
+ void AddAccessible(uint32_t actorId, std::shared_ptr<Accessible> accessible) override
{
+ mAccessibles[actorId] = std::move(accessible);
}
/**
- * @copydoc Dali::Accessibility::Bridge::Emit()
+ * @copydoc Dali::Accessibility::Bridge::RemoveAccessible()
*/
- Consumed Emit(KeyEventType type, unsigned int keyCode, const std::string& keyName, unsigned int timeStamp, bool isText) override
+ void RemoveAccessible(uint32_t actorId) override
{
- if(!IsUp())
- {
- return Consumed::NO;
- }
+ mAccessibles.erase(actorId);
+ }
- unsigned int keyType = 0;
+ /**
+ * @copydoc Dali::Accessibility::Bridge::GetAccessible()
+ */
+ std::shared_ptr<Accessible> GetAccessible(Dali::Actor actor) const override
+ {
+ uint32_t actorId = actor.GetProperty<int>(Dali::Actor::Property::ID);
+ auto iter = mAccessibles.find(actorId);
+ return iter != mAccessibles.end() ? iter->second : nullptr;
+ }
- switch(type)
+ /**
+ * @copydoc Dali::Accessibility::Bridge::ShouldIncludeHidden()
+ */
+ bool ShouldIncludeHidden() const override
+ {
+ return mApplication.mShouldIncludeHidden;
+ }
+
+ void NotifyIncludeHiddenChanged() override
+ {
+ for(const auto& iter : mAccessibles)
{
- case KeyEventType::KEY_PRESSED:
+ const auto& accessible = iter.second;
+ if(accessible->IsHidden())
{
- keyType = 0;
- break;
+ auto* parent = dynamic_cast<ActorAccessible*>(accessible->GetParent());
+ if(parent)
+ {
+ parent->OnChildrenChanged();
+ }
}
- case KeyEventType::KEY_RELEASED:
+ }
+ }
+
+ /**
+ * @copydoc Dali::Accessibility::Bridge::EmitKeyEvent()
+ */
+ bool EmitKeyEvent(Dali::KeyEvent keyEvent, std::function<void(Dali::KeyEvent, bool)> callback) override
+ {
+ using ArgumentTypes = std::tuple<uint32_t, int32_t, int32_t, int32_t, int32_t, std::string, bool>;
+
+ static const char* methodName = "NotifyListenersSync";
+
+ if(!IsUp())
+ {
+ return false;
+ }
+
+ uint32_t keyType = (keyEvent.GetState() == Dali::KeyEvent::DOWN ? 0U : 1U);
+ auto timeStamp = static_cast<std::int32_t>(keyEvent.GetTime());
+ bool isText = !keyEvent.GetKeyString().empty();
+
+ ArgumentTypes arguments(keyType, 0, keyEvent.GetKeyCode(), 0, timeStamp, keyEvent.GetKeyName(), isText);
+
+ auto functor = [keyEvent = std::move(keyEvent), callback = std::move(callback)](DBus::ValueOrError<bool> reply) {
+ bool consumed = false;
+
+ if(!reply)
{
- keyType = 1;
- break;
+ DALI_LOG_ERROR("%s call failed: %s", methodName, reply.getError().message.c_str());
}
- default:
+ else
{
- return Consumed::NO;
+ consumed = std::get<0>(reply.getValues());
}
- }
- auto methodObject = mRegistryClient.method<bool(std::tuple<uint32_t, int32_t, int32_t, int32_t, int32_t, std::string, bool>)>("NotifyListenersSync");
- auto result = methodObject.call(std::tuple<uint32_t, int32_t, int32_t, int32_t, int32_t, std::string, bool>{keyType, 0, static_cast<int32_t>(keyCode), 0, static_cast<int32_t>(timeStamp), keyName, isText ? 1 : 0});
- if(!result)
- {
- LOG() << result.getError().message;
- return Consumed::NO;
- }
- return std::get<0>(result) ? Consumed::YES : Consumed::NO;
+ callback(std::move(keyEvent), consumed);
+ };
+
+ mRegistryClient.method<bool(ArgumentTypes)>(methodName).asyncCall(std::move(functor), arguments);
+
+ return true;
}
/**
LOG() << "Direct reading command failed (" << msg.getError().message << ")\n";
}
},
- true);
+ true);
}
/**
LOG() << "Direct reading command failed (" << msg.getError().message << ")\n";
}
},
- false);
+ false);
}
/**
LOG() << "Direct reading command failed (" << msg.getError().message << ")\n";
}
},
- alsoNonDiscardable);
+ alsoNonDiscardable);
}
/**
mDirectReadingCallbacks.emplace(std::get<2>(msg), callback);
}
},
- text,
- discardable);
+ text,
+ discardable);
}
/**
mHighlightedActor = {};
mHighlightClearAction = {};
BridgeAccessible::ForceDown();
- mRegistryClient = {};
- mDirectReadingClient = {};
+ mRegistryClient = {};
+ mDirectReadingClient = {};
mDirectReadingCallbacks.clear();
mApplication.mChildren.clear();
ClearTimer();
{
Dali::Adaptor::Get().RemoveIdle(mIdleCallback);
}
- mAccessibilityStatusClient = {};
- mDbusServer = {};
- mConnectionPtr = {};
+ mAccessibilityStatusClient = {};
+ mDbusServer = {};
+ mConnectionPtr = {};
}
bool ForceUpTimerCallback()
BridgeHypertext::RegisterInterfaces();
BridgeHyperlink::RegisterInterfaces();
BridgeSocket::RegisterInterfaces();
+ BridgeTable::RegisterInterfaces();
+ BridgeTableCell::RegisterInterfaces();
RegisterOnBridge(&mApplication);
}
/**
+ * @brief Sends a signal to dbus that the window is created.
+ *
+ * @param[in] window The window to be created
+ * @see BridgeObject::Emit()
+ */
+ void EmitCreated(Dali::Window window)
+ {
+ auto windowAccessible = mApplication.GetWindowAccessible(window);
+ if(windowAccessible)
+ {
+ windowAccessible->Emit(WindowEvent::CREATE, 0);
+ }
+ }
+
+ /**
* @brief Sends a signal to dbus that the window is shown.
*
* @param[in] window The window to be shown
}
/**
+ * @copydoc Dali::Accessibility::Bridge::WindowCreated()
+ */
+ void WindowCreated(Dali::Window window) override
+ {
+ if(IsUp())
+ {
+ EmitCreated(window);
+ }
+ }
+
+ /**
* @copydoc Dali::Accessibility::Bridge::WindowShown()
*/
void WindowShown(Dali::Window window) override
}
/**
+ * @copydoc Dali::Accessibility::Bridge::ApplicationPaused()
+ */
+ void ApplicationPaused() override
+ {
+ mIsApplicationRunning = false;
+ SwitchBridge();
+ }
+
+ /**
+ * @copydoc Dali::Accessibility::Bridge::ApplicationResumed()
+ */
+ void ApplicationResumed() override
+ {
+ mIsApplicationRunning = true;
+ SwitchBridge();
+ }
+
+ /**
* @copydoc Dali::Accessibility::Bridge::SuppressScreenReader()
*/
void SuppressScreenReader(bool suppress) override
void SwitchBridge()
{
- if((!mIsScreenReaderSuppressed && mIsScreenReaderEnabled) || mIsEnabled)
+ bool isScreenReaderEnabled = mIsScreenReaderEnabled && !mIsScreenReaderSuppressed;
+
+ if((isScreenReaderEnabled || mIsEnabled) && mIsApplicationRunning)
{
ForceUp();
}
void ReadScreenReaderEnabledProperty()
{
// can be true because of SuppressScreenReader before init
- if (!mAccessibilityStatusClient)
+ if(!mAccessibilityStatusClient)
{
return;
}
void EmitScreenReaderEnabledSignal()
{
- if (mIsScreenReaderEnabled)
+ if(mIsScreenReaderEnabled)
{
mScreenReaderEnabledSignal.Emit();
}
{
mAccessibilityStatusClient = DBus::DBusClient{A11yDbusName, A11yDbusPath, A11yDbusStatusInterface, DBus::ConnectionType::SESSION};
- if (!mAccessibilityStatusClient)
+ if(!mAccessibilityStatusClient)
{
DALI_LOG_ERROR("Accessibility Status DbusClient is not ready\n");
return false;
bool InitializeTimerCallback()
{
- if ( InitializeAccessibilityStatusClient() )
+ if(InitializeAccessibilityStatusClient())
{
ReadAndListenProperties();
return false;
bool OnIdleSignal()
{
- if ( InitializeAccessibilityStatusClient() )
+ if(InitializeAccessibilityStatusClient())
{
ReadAndListenProperties();
mIdleCallback = NULL;
*/
void Initialize() override
{
- if ( InitializeAccessibilityStatusClient() )
+ if(InitializeAccessibilityStatusClient())
{
ReadAndListenProperties();
return;
}
// Initialize failed. Try it again on Idle
- if( Dali::Adaptor::IsAvailable() )
+ if(Dali::Adaptor::IsAvailable())
{
Dali::Adaptor& adaptor = Dali::Adaptor::Get();
- if( NULL == mIdleCallback )
+ if(NULL == mIdleCallback)
{
- mIdleCallback = MakeCallback( this, &BridgeImpl::OnIdleSignal );
- adaptor.AddIdle( mIdleCallback, true );
+ mIdleCallback = MakeCallback(this, &BridgeImpl::OnIdleSignal);
+ if(DALI_UNLIKELY(!adaptor.AddIdle(mIdleCallback, true)))
+ {
+ DALI_LOG_ERROR("Fail to add idle callback for bridge initialize. Call it synchronously.\n");
+ OnIdleSignal();
+ }
}
}
}
return std::get<0>(reply.getValues());
}
- void EmbedAtkSocket(const Address& plug, const Address& socket) override
- {
- auto client = CreateSocketClient(socket);
-
- client.method<void(std::string)>("Embedded").call(ATSPI_PREFIX_PATH + plug.GetPath());
- }
-
void UnembedSocket(const Address& plug, const Address& socket) override
{
auto client = CreateSocketClient(socket);
- client.method<void(Address)>("Unembed").call(plug);
+ client.method<void(Address)>("Unembed").asyncCall([](DBus::ValueOrError<void>) {}, plug);
}
void SetSocketOffset(ProxyAccessible* socket, std::int32_t x, std::int32_t y) override
namespace // unnamed namespace
{
-
bool INITIALIZED_BRIDGE = false;
/**
}
}
-std::string Bridge::MakeBusNameForWidget(std::string_view widgetInstanceId)
+std::string Bridge::MakeBusNameForWidget(std::string_view widgetInstanceId, int widgetProcessId)
{
// The bus name should consist of dot-separated alphanumeric elements, e.g. "com.example.BusName123".
- // Allowed characters in each element: "[A-Z][a-z][0-9]_", but no element may start with a digit.
+ // Allowed characters in each element: "[A-Z][a-z][0-9]_-", but no element may start with a digit.
- static const char prefix[] = "com.samsung.dali.widget_";
+ static const char prefix[] = "elm.atspi.proxy.socket-";
static const char underscore = '_';
std::stringstream tmp;
for(char ch : widgetInstanceId)
{
- tmp << (std::isalnum(ch) ? ch : underscore);
+ tmp << (!std::isalnum(ch) && ch != '_' && ch != '-' && ch != '.' ? underscore : ch);
}
+ tmp << '-' << widgetProcessId;
+
return tmp.str();
}