*/
virtual bool registerCallback(const A11yEvent type, EventHandler cb, void *data) = 0;
+ /**
+ * @brief Set AurumXML synchronization.
+ *
+ * @param[in] sync Whether to synchronize
+ *
+ * @since_tizen 7.5
+ */
+ virtual void setXMLsync(bool sync) = 0;
+
public:
/**
* @brief Gets active application vector.
void findXNodes(std::vector<std::shared_ptr<AccessibleNode>> &ret, std::string xpath, bool earlyReturn);
private:
+
+ AurumXML(const AurumXML&) = delete;
+ AurumXML& operator=(const AurumXML&) = delete;
+
xml_document *mDoc;
const std::shared_ptr<AccessibleNode> mRoot;
std::unordered_map<std::string, std::shared_ptr<AccessibleNode>> mXNodeMap;
*/
virtual bool registerCallback(const A11yEvent type, EventHandler cb, void *data) override;
+ /**
+ * @copydoc @AccessibleWatcher::setXMLsync()
+ */
+ virtual void setXMLsync(bool sync) override;
+
public:
/**
* @brief Listen atspi events.
static gpointer timerThread(gpointer data);
void appendApp(AtspiAccessibleWatcher *instance, AtspiAccessible *app, char *pkg);
void removeApp(AtspiAccessibleWatcher *instance, AtspiAccessible *app, char *pkg);
+ void setXMLsync();
private:
GDBusProxy *mDbusProxy;
std::mutex mXMLMutex;
std::condition_variable mXMLConditionVar;
+ bool mXMLSync;
+
static GThread *mTimerThread;
static std::chrono::system_clock::time_point mStartTime;
static IdleEventState isIdle;
std::shared_ptr<AurumXML> getXMLDoc(std::string pkgName);
+ void setXMLsync(bool sync);
+
public:
/**
* @brief TBD
mAppCount = 0;
mAppXMLLoadedCount = 0;
+ mXMLSync = false;
atspi_init();
LOGI("app(%s) is already in map", pkg);
}
- std::string package(pkg);
- if (!package.empty()) {
- if (instance->mXMLDocMap.count(package)) {
- instance->mXMLDocMap.erase(package);
- }
+ if (mXMLSync)
+ {
+ std::string package(pkg);
+ if (!package.empty()) {
+
+ if (instance->mXMLDocMap.count(package)) {
+ instance->mXMLDocMap.erase(package);
+ }
- mAppCount++;
- instance->mXMLDocMap.insert(std::pair<std::string, std::shared_ptr<AurumXML>>(package,
- std::make_shared<AurumXML>(std::make_shared<AtspiAccessibleNode>(app), &mAppXMLLoadedCount, &mXMLMutex, &mXMLConditionVar)));
+ mAppCount++;
+ instance->mXMLDocMap.insert(std::pair<std::string, std::shared_ptr<AurumXML>>(package,
+ std::make_shared<AurumXML>(std::make_shared<AtspiAccessibleNode>(app), &mAppXMLLoadedCount, &mXMLMutex, &mXMLConditionVar)));
+ }
}
}
LOGE("deactivated window's app(%s) is not in map", pkg);
}
- if (instance->mXMLDocMap.count(std::string(pkg))) {
- instance->mXMLDocMap.erase(std::string(pkg));
+ if (mXMLSync)
+ {
+ if (instance->mXMLDocMap.count(std::string(pkg))) {
+ instance->mXMLDocMap.erase(std::string(pkg));
+ }
}
g_object_unref(app);
std::map<std::string, std::shared_ptr<AurumXML>> AtspiAccessibleWatcher::getXMLDocMap(void)
{
- std::unique_lock lk(mXMLMutex);
+ LOGI("XMLsync: %s", (mXMLSync ? "TRUE" : "FALSE"));
+ if(mXMLSync)
+ {
+ std::unique_lock lk(mXMLMutex);
- //LOGI("mAppCount: %d, mAppXMLLoadedCount: %d", mAppCount, mAppXMLLoadedCount);
- mXMLConditionVar.wait(lk, [&] {return mAppCount <= mAppXMLLoadedCount;});
+ //LOGI("mAppCount: %d, mAppXMLLoadedCount: %d", mAppCount, mAppXMLLoadedCount);
+ mXMLConditionVar.wait(lk, [&] {return mAppCount <= mAppXMLLoadedCount;});
- lk.unlock();
+ lk.unlock();
+ }
return mXMLDocMap;
}
std::shared_ptr<AurumXML> AtspiAccessibleWatcher::getXMLDoc(std::string pkgName)
{
- std::unique_lock lk(mXMLMutex);
+ LOGI("XMLsync: %s", (mXMLSync ? "TRUE" : "FALSE"));
+ if(mXMLSync)
+ {
+ std::unique_lock lk(mXMLMutex);
- //LOGI("mAppCount: %d, mAppXMLLoadedCount: %d", mAppCount, mAppXMLLoadedCount);
- mXMLConditionVar.wait(lk, [&] {return mAppCount <= mAppXMLLoadedCount;});
+ //LOGI("mAppCount: %d, mAppXMLLoadedCount: %d", mAppCount, mAppXMLLoadedCount);
+ mXMLConditionVar.wait(lk, [&] {return mAppCount <= mAppXMLLoadedCount;});
- lk.unlock();
+ lk.unlock();
+ }
if (mXMLDocMap.count(pkgName) > 0)
return mXMLDocMap[pkgName];
}
return true;
}
+
+void AtspiAccessibleWatcher::setXMLsync(bool sync)
+{
+ LOGI("setXMLSync: %s", (sync ? "TRUE" : "FALSE"));
+ mXMLSync = sync;
+
+ if(!sync) {
+ mXMLDocMap.clear();
+ }
+}
\ No newline at end of file
{
return true;
}
+
+void MockAccessibleWatcher::setXMLsync(bool sync)
+{
+}
::grpc::Status setTimeout(::grpc::ServerContext *context,
const ::aurum::ReqSetTimeout *request,
::aurum::RspSetTimeout *response) override;
+ ::grpc::Status setXMLSync(::grpc::ServerContext *context,
+ const ::aurum::ReqSetXMLSync *request,
+ ::aurum::RspSetXMLSync *response) override;
public:
int WAIT_TIMEOUT_MS;
};
#include "Commands/EnableScreenAnalyzerCommand.h"
#include "Commands/GetTextMinBoundingRectCommand.h"
+#include "Commands/SetXMLSyncCommand.h"
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <gio/gio.h>
+#include <grpcpp/grpcpp.h>
+#include "Commands/Command.h"
+#include "ObjectMapper.h"
+#include <aurum.grpc.pb.h>
+#include "config.h"
+
+class SetXMLSyncCommand : public Command {
+private:
+ const ::aurum::ReqSetXMLSync *mRequest;
+ ::aurum::RspSetXMLSync *mResponse;
+
+public:
+ SetXMLSyncCommand(const ::aurum::ReqSetXMLSync *request,
+ ::aurum::RspSetXMLSync *response);
+ ::grpc::Status execute() override;
+};
\ No newline at end of file
files('src/Commands/GetActiveAppToolkitNameCommand.cc'),
files('src/Commands/EnableScreenAnalyzerCommand.cc'),
files('src/Commands/GetTextMinBoundingRectCommand.cc'),
+ files('src/Commands/SetXMLSyncCommand.cc'),
]
bootstrap_svr_dep = [
response->set_status(::aurum::RspStatus::OK);
return ::grpc::Status::OK;
}
+
+::grpc::Status aurumServiceImpl::setXMLSync(::grpc::ServerContext *context,
+ const ::aurum::ReqSetXMLSync *request,
+ ::aurum::RspSetXMLSync *response)
+{
+ std::unique_ptr<SetXMLSyncCommand> cmd = std::make_unique<SetXMLSyncCommand>(request, response);
+ return execute(cmd.get(), true);
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "bootstrap.h"
+#include "SetXMLSyncCommand.h"
+
+SetXMLSyncCommand::SetXMLSyncCommand(const ::aurum::ReqSetXMLSync* request,
+ ::aurum::RspSetXMLSync* response)
+ : mRequest{request}, mResponse{response}
+{
+}
+
+::grpc::Status SetXMLSyncCommand::execute()
+{
+ bool sync = mRequest->enable();
+ AccessibleWatcher::getInstance()->setXMLsync(sync);
+
+ mResponse->set_status(::aurum::RspStatus::OK);
+ return grpc::Status::OK;
+}
rpc enableScreenAnalyzer(ReqEnableScreenAnalyzer) returns (RspEnableScreenAnalyzer) {}
rpc getTextMinBoundingRect(ReqGetTextMinBoundingRect) returns (RspGetTextMinBoundingRect) {}
rpc setTimeout(ReqSetTimeout) returns (RspSetTimeout) {}
+ rpc setXMLSync(ReqSetXMLSync) returns (RspSetXMLSync) {}
}
// ------------------------------------ //
message RspSetTimeout {
RspStatus status = 1;
}
+
+message ReqSetXMLSync {
+ bool enable = 1;
+}
+
+message RspSetXMLSync {
+ RspStatus status = 1;
+}
\ No newline at end of file
projects / platform / core / uifw / aurum.git / commitdiff