#pragma once
#include "bitmask.h"
-
#include <string>
enum class A11yEvent {
+#ifndef _AURUM_H_
+#define _AURUM_H_
+
+#include <dlog.h>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "AURUM"
+
#include "UiDevice.h"
#include "UiObject.h"
#include "UiSelector.h"
#include "IEventSource.h"
#include "Point2D.h"
#include "Rect.h"
+#include "PartialMatch.h"
+#include "Comparer.h"
+#include "A11yEvent.h"
+#include "Runnables.h"
+
+#endif /* _AURUM_H_ */
libaurum_dep += [
dependency('capi-system-info'),
dependency('capi-ui-efl-util'),
+ dependency('dlog'),
dependency('elementary'),
dependency('libtdm'),
]
#include "A11yEvent.h"
+#include "Aurum.h"
#include <unordered_map>
A11yEventInfo::A11yEventInfo() : A11yEventInfo(A11yEvent::EVENT_NONE, nullptr, nullptr) {}
-#include "AccessibleApplication.h"
-#include "AccessibleWatcher.h"
+#include "Aurum.h"
#include <algorithm>
-#include <loguru.hpp>
AccessibleApplication::AccessibleApplication(std::shared_ptr<AccessibleNode> node)
: mNode{node}
-#include "AccessibleNode.h"
+#include "Aurum.h"
+
#include <string.h>
#include <iostream>
#include <vector>
-#include <loguru.hpp>
#include "config.h"
#include <sstream>
-
AccessibleNode::~AccessibleNode()
{
}
void AccessibleNode::invalidate()
{
std::unique_lock<std::mutex> lock(mLock);
- LOG_F(INFO, "object %p is now invalid", this);
+ dlog_print(DLOG_INFO, LOG_TAG, "object %p is now invalid", this);
mValid = false;
}
void AccessibleNode::print(int d)
{
this->refresh();
- LOG_F(INFO, "%s%s",std::string(d, ' ').c_str(), description().c_str());
+ dlog_print(DLOG_INFO, LOG_TAG, "%s %s",std::string(d, ' ').c_str(), description().c_str());
}
bool AccessibleNode::isSupporting(AccessibleNodeInterface thisIface) const
-#include "AccessibleUtils.h"
-#include <loguru.hpp>
+#include "Aurum.h"
+
#include <string.h>
char* state_to_char(AtspiStateType state)
char *state_name = NULL;
AtspiStateType stat;
- LOG_F(INFO, "check ss:%p s:%p, len:%d", stateSet, states, states->len);
+ dlog_print(DLOG_INFO, LOG_TAG, "check ss:%p s:%p, len:%d", stateSet, states, states->len);
for (int i = 0; states && (i < states->len); ++i) {
stat = g_array_index(states, AtspiStateType, i);
state_name = state_to_char(stat);
- LOG_SCOPE_F(INFO, "state: %s", state_name);
+ dlog_print(DLOG_INFO, LOG_TAG, "state: %s", state_name);
free(state_name);
}
g_array_free(states, 1);
-#include "AccessibleWatcher.h"
+#include "Aurum.h"
#ifdef TIZEN
#include "AtspiAccessibleWatcher.h"
#endif
-
#include "MockAccessibleWatcher.h"
#include <string.h>
#include <iostream>
#include <utility>
#include <algorithm>
-#include <loguru.hpp>
AccessibleWatcher::AccessibleWatcher()
:mSources{}, mLock{}
std::vector<std::shared_ptr<AccessibleApplication>> AccessibleWatcher::getActiveApplications(void) const
{
- LOG_SCOPE_F(INFO, "getActiveApplications for this(%p)", this);
+ dlog_print(DLOG_INFO, LOG_TAG, "getActiveApplications for this(%p)", this);
std::vector<std::shared_ptr<AccessibleApplication>> ret{};
auto apps = this->getApplications();
- LOG_F(INFO, "apps size %d", apps.size());
+ dlog_print(DLOG_INFO, LOG_TAG, "apps size %d", apps.size());
apps.erase(std::remove_if(apps.begin(), apps.end(), [](auto app){
return !app->isActive();
}), apps.end());
- LOG_F(INFO, "active apps size %d", apps.size());
+ dlog_print(DLOG_INFO, LOG_TAG, "active apps size %d", apps.size());
return apps;
}
void AccessibleWatcher::attach(std::shared_ptr<IEventConsumer> source)
{
std::unique_lock<std::mutex> lock(mLock);
- LOG_F(INFO, "source attached %p", source.get());
+ dlog_print(DLOG_INFO, LOG_TAG, "source attached %p", source.get());
if (source) {
mSources.insert(source);
}
void AccessibleWatcher::detach(std::shared_ptr<IEventConsumer> source)
{
std::unique_lock<std::mutex> lock(mLock);
- LOG_F(INFO, "source detached %p", source.get());
+ dlog_print(DLOG_INFO, LOG_TAG, "source detached %p", source.get());
if (source) {
auto iter = mSources.find(source);
if (iter != mSources.end()) mSources.erase(iter);
-#include "AccessibleWindow.h"
-#include "AccessibleWatcher.h"
+#include "Aurum.h"
AccessibleWindow::AccessibleWindow(std::shared_ptr<AccessibleApplication> app, std::shared_ptr<AccessibleNode> node)
: mApp{app}, mNode{node}
-#include "Comparer.h"
-
-#include <loguru.hpp>
+#include "Aurum.h"
Comparer::Comparer(const std::shared_ptr<UiDevice> device, const std::shared_ptr<UiSelector> selector,
const bool &earlyReturn)
{
Comparer comparer(device, selector, earlyReturn);
- LOG_SCOPE_F(INFO, "findObjects selector(%s) from (type:%s style:%s, role:%s, text:%s) earlyReturn:%d", selector->description().c_str(), root->getType().c_str(), root->getStyle().c_str(), root->getRole().c_str(), root->getText().c_str(), earlyReturn);
+ dlog_print(DLOG_INFO, LOG_TAG, "findObjects selector(%s) from (type:%s style:%s, role:%s, text:%s) earlyReturn:%d", selector->description().c_str(), root->getType().c_str(), root->getStyle().c_str(), root->getRole().c_str(), root->getText().c_str(), earlyReturn);
if (selector->mParent) {
auto ret = Comparer::findObjects(device, selector->mParent, root);
{
std::list<std::shared_ptr<PartialMatch>> partialList{};
std::vector<std::shared_ptr<AccessibleNode>> ret = findObjects(root, 0, 0, partialList);
- LOG_F(INFO, "%d object(s) found", ret.size());
+ dlog_print(DLOG_INFO, LOG_TAG, "%d object(s) found", ret.size());
return ret;
}
std::list<std::shared_ptr<PartialMatch>> &partialMatches)
{
std::vector<std::shared_ptr<AccessibleNode>> ret;
- //LOG_SCOPE_F(INFO, "findObjects idx:%d, depth:%d, partialMatches.size:%d", index, depth, partialMatches.size());
root->refresh();
for (auto &match : partialMatches)
if (!ret.empty() && mEarlyReturn) return ret;
}
} else {
- LOG_F(INFO, "Abort searching! No need to search children(maxDepth limit overflow, %d < %d < %d)", mSelector->mMinDepth?*(mSelector->mMinDepth):-1, depth, mSelector->mMaxDepth?*(mSelector->mMaxDepth):9999999);
+ dlog_print(DLOG_INFO, LOG_TAG, "Abort searching! No need to search children(maxDepth limit overflow, %d < %d < %d)", mSelector->mMinDepth?*(mSelector->mMinDepth):-1, depth, mSelector->mMaxDepth?*(mSelector->mMaxDepth):9999999);
}
if (currentMatch && currentMatch->finalizeMatch()){
- LOG_F(INFO, "Found matched = %s with criteria %s", root->description().c_str(), currentMatch->debugPrint().c_str());
+ dlog_print(DLOG_INFO, LOG_TAG, "Found matched = %s with criteria %s", root->description().c_str(), currentMatch->debugPrint().c_str());
ret.push_back(root);
}
#include <algorithm>
#include <vector>
-#include <loguru.hpp>
-
AtspiAccessibleApplication::AtspiAccessibleApplication(std::shared_ptr<AccessibleNode> node)
: AccessibleApplication(node)
{
+#include "Aurum.h"
+
#include "AtspiAccessibleNode.h"
-#include "AccessibleWatcher.h"
#include "AtspiWrapper.h"
#include <gio/gio.h>
-#include <loguru.hpp>
-
//std::map<AtspiAccessible *, AccessibleNode *> AccessibleNode::mNodeMap{};
AtspiAccessibleNode::AtspiAccessibleNode(AtspiAccessible *node)
this->refresh();
} else {
- LOG_F(INFO, "AtspiAccessibleNode Ctor : mNode is null");
+ dlog_print(DLOG_INFO, LOG_TAG, "AtspiAccessibleNode Ctor : mNode is null");
}
}
AtspiWrapper::unlock();
return std::make_shared<AtspiAccessibleNode>(nullptr);
}
- LOG_SCOPE_F(INFO, "getChild @ %d from node(%p)", index, mNode);
+ dlog_print(DLOG_INFO, LOG_TAG, "getChild @ %d from node(%p)", index, mNode);
AtspiAccessible *rawChild = AtspiWrapper::Atspi_accessible_get_child_at_index(mNode, index, NULL);
AtspiWrapper::unlock();
return std::make_shared<AtspiAccessibleNode>(rawChild);
}
AtspiEditableText *iface = AtspiWrapper::Atspi_accessible_get_editable_text(mNode);
- LOG_F(INFO,"set Value iface:%p obj:%p text:%s", iface, mNode, text.c_str() );
+ dlog_print(DLOG_INFO, LOG_TAG, "set Value iface:%p obj:%p text:%s", iface, mNode, text.c_str() );
if (iface) {
int len = getText().length();
AtspiWrapper::Atspi_editable_text_delete_text(iface, 0, len, NULL);
-#include "AtspiAccessibleWatcher.h"
+#include "Aurum.h"
+#include "AtspiAccessibleWatcher.h"
#include "AtspiAccessibleApplication.h"
#include "AtspiAccessibleWindow.h"
#include "AtspiAccessibleNode.h"
#include "AtspiWrapper.h"
+
#include <algorithm>
#include <chrono>
#include <thread>
if (node) name = AtspiWrapper::Atspi_accessible_get_name(node, NULL);
else return false;
- LOG_SCOPE_F(INFO, "isShowing %s", name);
+ dlog_print(DLOG_INFO, LOG_TAG, "isShowing %s", name);
auto stateSet = AtspiWrapper::Atspi_accessible_get_state_set(node);
if (AtspiWrapper::Atspi_state_set_contains(stateSet, ATSPI_STATE_ACTIVE)
&& AtspiWrapper::Atspi_state_set_contains(stateSet, ATSPI_STATE_SHOWING)) {
- LOG_F(INFO, "active and showing %p %s", node, name);
+ dlog_print(DLOG_INFO, LOG_TAG, "active and showing %p %s", node, name);
free(name);
g_object_unref(stateSet);
return true;
findActiveNode(AtspiAccessible *node, int depth,
int max_depth)
{
- LOG_SCOPE_F(INFO, "findActiveNode %p %d/%d", node, depth, max_depth);
+ dlog_print(DLOG_INFO, LOG_TAG, "findActiveNode %p %d/%d", node, depth, max_depth);
std::vector<AtspiAccessible *> ret{};
if (iShowingNode(node)) {
char *name = AtspiWrapper::Atspi_accessible_get_name(node, NULL);
if (name) {
- LOG_SCOPE_F(INFO, "%s", name);
+ dlog_print(DLOG_INFO, LOG_TAG, "%s", name);
free(name);
}
ret.push_back(node);
int nchild = AtspiWrapper::Atspi_accessible_get_child_count(node, NULL);
if (nchild <= 0) return ret;
- LOG_F(INFO, "findActiveNode node %p has %d children", node, nchild);
+ dlog_print(DLOG_INFO, LOG_TAG, "findActiveNode node %p has %d children", node, nchild);
for (int i = 0; i < nchild; i++) {
AtspiAccessible* child = AtspiWrapper::Atspi_accessible_get_child_at_index(node, i, NULL);
- LOG_F(INFO, "a child found @ %d : %p", i, child);
+ dlog_print(DLOG_INFO, LOG_TAG, "a child found @ %d : %p", i, child);
std::vector<AtspiAccessible *> childRet = findActiveNode(child, depth + 1, max_depth);
ret.insert(ret.end(), childRet.begin(), childRet.end());
g_object_unref(child);
static gpointer _event_thread_loop (gpointer data)
{
- LOG_F(INFO, "event thread start");
+ dlog_print(DLOG_INFO, LOG_TAG, "event thread start");
AtspiEventListener * listener =
atspi_event_listener_new(AtspiAccessibleWatcher::onAtspiEvents, data, NULL);
atspi_event_main();
- LOG_F(INFO, "event thread end");
+ dlog_print(DLOG_INFO, LOG_TAG, "event thread end");
atspi_event_listener_deregister(listener, "object:", NULL);
atspi_event_listener_deregister(listener, "window:", NULL);
void AtspiAccessibleWatcher::print_debug()
{
- LOG_F(INFO, "activatewindowlist-------------------");
+ dlog_print(DLOG_INFO, LOG_TAG, "activatewindowlist-------------------");
std::for_each(mActivatedWindowList.begin(), mActivatedWindowList.end(), [](auto acc){
- LOG_F(INFO, "child:%p", acc);
+ dlog_print(DLOG_INFO, LOG_TAG, "child:%p", acc);
});
- LOG_F(INFO, "mActivatedApplicationList--------------------------");
+ dlog_print(DLOG_INFO, LOG_TAG, "mActivatedApplicationList--------------------------");
std::for_each(mActivatedApplicationList.begin(), mActivatedApplicationList.end(), [](auto acc){
- LOG_F(INFO, "child:%p", acc);
+ dlog_print(DLOG_INFO, LOG_TAG, "child:%p", acc);
});
- LOG_F(INFO, "mWindowSet------------------------------");
+ dlog_print(DLOG_INFO, LOG_TAG, "mWindowSet------------------------------");
std::for_each(mWindowSet.begin(), mWindowSet.end(), [](auto acc){
- LOG_F(INFO, "child:%p", acc);
+ dlog_print(DLOG_INFO, LOG_TAG, "child:%p", acc);
});
- LOG_F(INFO, "------------------------------");
+ dlog_print(DLOG_INFO, LOG_TAG, "------------------------------");
}
void AtspiAccessibleWatcher::onWindowActivated(AtspiAccessible *node,
WindowActivateInfoType type)
{
- LOG_SCOPE_F(INFO, "onWindowActivated obj:%p", node);
+ dlog_print(DLOG_INFO, LOG_TAG, "onWindowActivated obj:%p", node);
notifyAll((int)EventType::Window, (int)WindowEventType::WindowActivated, node);
}
void AtspiAccessibleWatcher::onWindowDeactivated(AtspiAccessible *node)
{
- LOG_SCOPE_F(INFO, "onWindowDeactivated obj:%p", node);
+ dlog_print(DLOG_INFO, LOG_TAG, "onWindowDeactivated obj:%p", node);
notifyAll((int)EventType::Window, (int)WindowEventType::WindowDeactivated, node);
}
void AtspiAccessibleWatcher::onWindowCreated(AtspiAccessible *node)
{
- LOG_SCOPE_F(INFO, "onWindowCreated obj:%p", node);
+ dlog_print(DLOG_INFO, LOG_TAG, "onWindowCreated obj:%p", node);
notifyAll((int)EventType::Window, (int)WindowEventType::WindowCreated, node);
}
void AtspiAccessibleWatcher::onWindowDestroyed(AtspiAccessible *node)
{
- LOG_SCOPE_F(INFO, "onWindowDestroyed obj:%p", node);
+ dlog_print(DLOG_INFO, LOG_TAG, "onWindowDestroyed obj:%p", node);
notifyAll((int)EventType::Window, (int)WindowEventType::WindowDestroyed, node);
}
void AtspiAccessibleWatcher::onVisibilityChanged(AtspiAccessible *node, bool visible)
{
- LOG_SCOPE_F(INFO, "onVisibilityChanged obj:%p", node);
+ dlog_print(DLOG_INFO, LOG_TAG, "onVisibilityChanged obj:%p", node);
notifyAll((int)EventType::Object, (int)ObjectEventType::ObjectStateVisible, node);
}
void AtspiAccessibleWatcher::onObjectDefunct(AtspiAccessible *node)
{
- LOG_SCOPE_F(INFO, "onObjectDefunct obj:%p", node);
+ dlog_print(DLOG_INFO, LOG_TAG, "onObjectDefunct obj:%p", node);
notifyAll((int)EventType::Object, (int)ObjectEventType::ObjectStateDefunct, node);
}
std::vector<std::shared_ptr<AccessibleApplication>> AtspiAccessibleWatcher::getApplications(void) const
{
AtspiWrapper::lock();
- LOG_SCOPE_F(INFO, "getApplications for this(%p)", this);
+ dlog_print(DLOG_INFO, LOG_TAG, "getApplications for this(%p)", this);
std::vector<std::shared_ptr<AccessibleApplication>> ret{};
AtspiAccessible *root = AtspiWrapper::Atspi_get_desktop(0);
int nchild = AtspiWrapper::Atspi_accessible_get_child_count(root, NULL);
for (const auto &event : localEvents) {
if (COMPARE(type, event->getEvent()))
{
- LOG_F(INFO, "type %d == %d name %s pkg %s",static_cast<int>(type), static_cast<int>(event->getEvent()), event->getName().c_str(), event->getPkg().c_str());
+ dlog_print(DLOG_INFO, LOG_TAG, "type %d == %d name %s pkg %s",static_cast<int>(type), static_cast<int>(event->getEvent()), event->getName().c_str(), event->getPkg().c_str());
return true;
}
}
bool AtspiAccessibleWatcher::removeFromActivatedList(AtspiAccessible *node)
{
- LOG_SCOPE_F(INFO,"remove from activelist node %p", node);
+ dlog_print(DLOG_INFO, LOG_TAG, "remove from activelist node %p", node);
mActivatedWindowList.remove_if([&](auto &n) { return n == node; });
AtspiAccessible *app = AtspiWrapper::Atspi_accessible_get_application(node, NULL);
- LOG_F(INFO, "node:%p, app:%p", node, app);
+ dlog_print(DLOG_INFO, LOG_TAG, "node:%p, app:%p", node, app);
if (app) {
mActivatedApplicationList.remove_if([&](auto &n) { return n == app; });
g_object_unref(app);
bool AtspiAccessibleWatcher::addToActivatedList(AtspiAccessible *node)
{
- LOG_SCOPE_F(INFO,"add to activelist node %p", node);
+ dlog_print(DLOG_INFO, LOG_TAG, "add to activelist node %p", node);
mActivatedWindowList.remove_if([&](auto &n) { return n == node; });
mActivatedWindowList.push_front(node);
if ( iter == mWindowSet.end()) mWindowSet.insert(node);
AtspiAccessible *app = AtspiWrapper::Atspi_accessible_get_application(node, NULL);
- LOG_F(INFO, "node:%p, app:%p", node, app);
+ dlog_print(DLOG_INFO, LOG_TAG, "node:%p, app:%p", node, app);
if (app) {
mActivatedApplicationList.remove_if([&](auto &n) { if(n == app) { g_object_unref(app); return true;} else return false; });
mActivatedApplicationList.push_front(app);
#include <algorithm>
-#include <loguru.hpp>
-
MockAccessibleApplication::MockAccessibleApplication(std::shared_ptr<AccessibleNode> node)
: AccessibleApplication(node), mWindowList{}
{
#include "MockDeviceImpl.h"
-#include <loguru.hpp>
#include <functional>
#include <algorithm>
-#include "PartialMatch.h"
+#include "Aurum.h"
#include <iostream>
#include <set>
#include <regex>
#include <sstream>
-#include <loguru.hpp>
-
-
bool PartialMatch::checkCriteria(const std::string *textA, const std::string textB, const bool *match)
{
if (!textA || !match) return false;
int index, int absoluteDepth,
int relativeDepth)
{
- //LOG_SCOPE_F(INFO, "PartialMatch::accept idx:%d abs:%d rel:%d / %d < %d < %d", index, absoluteDepth, relativeDepth, selector->mMinDepth?*(selector->mMinDepth):-1, relativeDepth, selector->mMaxDepth?*(selector->mMaxDepth):9999999);
PartialMatch *match = nullptr;
if ((selector->mMinDepth && (relativeDepth < *(selector->mMinDepth))) ||
-#include "SendKeyRunnable.h"
-
-#include <UiDevice.h>
-#include <loguru.hpp>
+#include "Aurum.h"
SendKeyRunnable::SendKeyRunnable(std::string keycode)
: mKeycode{keycode}
void SendKeyRunnable::run() const
{
- LOG_F(INFO, "sendKey %s",mKeycode.c_str());
+ dlog_print(DLOG_INFO, LOG_TAG, "sendKey %s",mKeycode.c_str());
std::shared_ptr<UiDevice> mDevice = UiDevice::getInstance();
mDevice->pressKeyCode(mKeycode.c_str(), KeyRequestType::PRESS);
mDevice->pressKeyCode(mKeycode.c_str(), KeyRequestType::RELEASE);
-#include "Sel.h"
+#include "Aurum.h"
#include <utility>
std::shared_ptr<UiSelector> Sel::text(std::string text)
-#include "UiDevice.h"
-#include "AccessibleWatcher.h"
-#include "Comparer.h"
+#include "Aurum.h"
#ifdef TIZEN
#include "TizenDeviceImpl.h"
#endif
#include "MockDeviceImpl.h"
-#include "Runnables.h"
-
#include <unistd.h>
#include <utility>
#include <vector>
#include <algorithm>
#include <iostream>
-#include <loguru.hpp>
UiDevice::UiDevice() : UiDevice(nullptr) {}
UiDevice::UiDevice(IDevice *impl)
-#include "UiObject.h"
-#include "Comparer.h"
-#include "Sel.h"
+#include "Aurum.h"
#include <iostream>
#include <utility>
-#include <loguru.hpp>
-
#include <chrono>
#include <thread>
+
UiObject::UiObject() : UiObject(nullptr, nullptr, nullptr) {}
UiObject::~UiObject()
auto nodes = Comparer::findObjects(mDevice, selector, getAccessibleNode());
for ( auto& node : nodes) {
if (!node) {
- LOG_F(INFO, "Skipped! (node == nullptr)");
+ dlog_print(DLOG_INFO, LOG_TAG, "Skipped! (node == nullptr)");
continue;
}
result.push_back(std::make_shared<UiObject>(mDevice, selector, std::move(node)));
-#include "UiScrollable.h"
+#include "Aurum.h"
UiScrollable::UiScrollable(std::shared_ptr<UiSelector> selector)
: mSelector{selector}, mMaxSearchSwipe{100}, mScrollStep{50}
-#include "UiSelector.h"
+#include "Aurum.h"
#include <string>
#include <sstream>
-#include <Until.h>
-
-#include <UiObject.h>
-#include <loguru.hpp>
+#include "Aurum.h"
std::function<bool(const ISearchable *)> Until::hasObject(
const std::shared_ptr<UiSelector> selector)
{
return [=](const ISearchable *searchable) -> bool {
- LOG_SCOPE_F(INFO, "Until::hasObject search:%p", searchable);
+ dlog_print(DLOG_INFO, LOG_TAG, "Until::hasObject search:%p", searchable);
std::shared_ptr<UiObject> obj = searchable->findObject(selector);
return obj.get() != nullptr;
};
const std::shared_ptr<UiSelector> selector)
{
return [=](const ISearchable *searchable) -> std::shared_ptr<UiObject> {
- LOG_SCOPE_F(INFO, "Until::findObject search:%p", searchable);
+ dlog_print(DLOG_INFO, LOG_TAG, "Until::findObject search:%p", searchable);
std::shared_ptr<UiObject> obj = searchable->findObject(selector);
return obj;
};
std::function<bool(const UiObject *)> Until::checkable(const bool isCheckable)
{
return [=](const UiObject *object) -> bool {
- LOG_SCOPE_F(INFO, "Until::checkable checkable:%d for obj %p", isCheckable, object);
+ dlog_print(DLOG_INFO, LOG_TAG, "Until::checkable checkable:%d for obj %p", isCheckable, object);
return object->isClickable() == isCheckable;
};
}
-#include "Waiter.h"
+#include "Aurum.h"
#include <unistd.h>
#include <chrono>
#include <thread>
-#include "ISearchable.h"
-#include "UiObject.h"
-#include <loguru.hpp>
-
Waiter::Waiter() : Waiter(nullptr) {}
Waiter::~Waiter() {}
template <typename R>
R Waiter::waitFor(const std::function<R(const ISearchable *)> condition) const
{
- LOG_SCOPE_F(INFO, "Waiter::waitFor ISearchable");
+ dlog_print(DLOG_INFO, LOG_TAG, "Waiter::waitFor ISearchable");
// startTime = currentTime();
std::chrono::system_clock::time_point start =
std::chrono::system_clock::now();
template <typename R>
R Waiter::waitFor(const std::function<R(const UiObject *)> condition) const
{
- LOG_SCOPE_F(INFO, "Waiter::waitFor UiObject");
+ dlog_print(DLOG_INFO, LOG_TAG, "Waiter::waitFor UiObject");
if (mUiObject) {
std::chrono::system_clock::time_point start =
std::chrono::system_clock::now();
BuildRequires: pkgconfig(capi-appfw-app-control)
BuildRequires: pkgconfig(capi-appfw-app-manager)
BuildRequires: pkgconfig(capi-appfw-service-application)
+BuildRequires: pkgconfig(dlog)
BuildRequires: pkgconfig(capi-system-device)
BuildRequires: pkgconfig(libtzplatform-config)
BuildRequires: pkgconfig(capi-system-system-settings)
projects / platform / core / uifw / aurum.git / commitdiff