Aurum: Improve performance of findElements command

Change-Id: Iecd9e98bab5e48dccb9a2475f745406fad6c1f46

diff --git a/libaurum/inc/AurumXML.h b/libaurum/inc/AurumXML.h
index 025508e..9bc84a4 100644 (file)
--- a/libaurum/inc/AurumXML.h
+++ b/libaurum/inc/AurumXML.h
@@ -81,11 +81,11 @@ public:
      *
      * @param xpath
      *
-     * @return the list of found AccessibleNode vector
+     * @param ret vector contains objects
      *
      * @since_tizen 7.0
      */
-    std::vector<std::shared_ptr<AccessibleNode>> findObjects(std::string xpath, bool earlyReturn = false);
+    void findObjects(std::vector<std::shared_ptr<AccessibleNode>> &ret, std::string xpath, bool earlyReturn = false);
 
 private:
     /**

diff --git a/libaurum/inc/Comparer.h b/libaurum/inc/Comparer.h
index eb1f23b..66cde43 100644 (file)
--- a/libaurum/inc/Comparer.h
+++ b/libaurum/inc/Comparer.h
@@ -82,16 +82,16 @@ public:
      *        it finds focused window then start to find object as it root.
      *        Finds all objects to the end of tree.
      *
+     * @param[in] ret vector where found objects stored
      * @param[in] device @UiDevice
      * @param[in] selector @UiSelector
      * @param[in] root @AccessibleNode root object(focused window on current state)
      * @param[in] earlyReturn find all object or not (default = false)
      *
-     * @return AccessibleNode if found, else nullptr
      *
      * @since_tizen 6.5
      */
-    static std::vector<std::shared_ptr<AccessibleNode>> findObjects(
+    static void findObjects(std::vector<std::shared_ptr<AccessibleNode>> &ret,
         const std::shared_ptr<UiDevice>& device, const std::shared_ptr<UiSelector>& selector,
         const std::shared_ptr<AccessibleNode>& root, bool earlyReturn = false);
 
@@ -101,17 +101,20 @@ private:
      *
      * @brief Starts find object from root.
      *
+     * @param[in] ret vector where found objects stored
      * @param[in] root @AccessibleNode
      *
      * @since_tizen 6.5
      */
-    std::vector<std::shared_ptr<AccessibleNode>> findObjects(const std::shared_ptr<AccessibleNode>& root);
+    void findObjects(std::vector<std::shared_ptr<AccessibleNode>> &ret,
+        const std::shared_ptr<AccessibleNode>& root);
 
     /**
      * @internal
      *
      * @brief It updates all partialMatches and traverse tree till given depth to find objects
      *
+     * @param[in] ret vector where found objects stored
      * @param[in] root @AccessibleNode
      * @param[in] index node index
      * @param[in] depth tree depth
@@ -119,7 +122,8 @@ private:
      *
      * @since_tizen 6.5
      */
-    std::vector<std::shared_ptr<AccessibleNode>> findObjects(
+    void findObjects(
+        std::vector<std::shared_ptr<AccessibleNode>> &ret,
         const std::shared_ptr<AccessibleNode>& root, const int &index, const int &depth,
         std::list<std::shared_ptr<PartialMatch>> &partialMatches);
 

diff --git a/libaurum/src/AurumXML.cc b/libaurum/src/AurumXML.cc
index e6ef9f6..7da5c37 100644 (file)
--- a/libaurum/src/AurumXML.cc
+++ b/libaurum/src/AurumXML.cc
@@ -213,11 +213,9 @@ std::string AurumXML::getXPath(const std::shared_ptr<AccessibleNode>& node)
     return "NotSupported";
 }
 
-std::vector<std::shared_ptr<AccessibleNode>> AurumXML::findObjects(
+void AurumXML::findObjects(std::vector<std::shared_ptr<AccessibleNode>> &ret,
     std::string xpath, bool earlyReturn)
 {
-    std::vector<std::shared_ptr<AccessibleNode>> ret;
-
     createXMLtree();
 
     LOGI("xpath %s earlyReturn %d", xpath.c_str(), earlyReturn);
@@ -239,6 +237,4 @@ std::vector<std::shared_ptr<AccessibleNode>> AurumXML::findObjects(
     } catch (const xpath_exception &e) {
         LOGI("findObjects Error: %s", e.what());
     }
-
-    return ret;
 }

diff --git a/libaurum/src/Comparer.cc b/libaurum/src/Comparer.cc
index ec1e402..0262213 100644 (file)
--- a/libaurum/src/Comparer.cc
+++ b/libaurum/src/Comparer.cc
@@ -31,14 +31,16 @@ std::shared_ptr<AccessibleNode> Comparer::findObject(const std::shared_ptr<UiDev
                                      const std::shared_ptr<UiSelector>& selector,
                                      const std::shared_ptr<AccessibleNode>& root)
 {
-    std::vector<std::shared_ptr<AccessibleNode>> ret = findObjects(device, selector, root, true);
+    std::vector<std::shared_ptr<AccessibleNode>> ret;
+    findObjects(ret, device, selector, root, true);
     if (ret.size() > 0)
         return std::move(ret[0]);
     else
         return nullptr;
 }
 
-std::vector<std::shared_ptr<AccessibleNode>> Comparer::findObjects(const std::shared_ptr<UiDevice>& device,
+void Comparer::findObjects(std::vector<std::shared_ptr<AccessibleNode>> &ret,
+                                                    const std::shared_ptr<UiDevice>& device,
                                                     const std::shared_ptr<UiSelector>& selector,
                                                     const std::shared_ptr<AccessibleNode>& root, bool earlyReturn)
 {
@@ -46,48 +48,46 @@ std::vector<std::shared_ptr<AccessibleNode>> Comparer::findObjects(const std::sh
 
     LOGI("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::vector<std::shared_ptr<AccessibleNode>> merged{};
+
+        // TODO: Optimize findObjects() when selector has a parent
+        std::vector<std::shared_ptr<AccessibleNode>> ret;
+        Comparer::findObjects(ret, device, selector->mParent, root);
 
         for (const auto &node : ret) {
-            auto tmp = comparer.findObjects(node);
-            std::move(std::begin(tmp), std::end(tmp), std::back_inserter(merged));
+            comparer.findObjects(ret, node);
         }
-        return merged;
+
+        return;
     }
 
     if (selector->mMatchXPath) {
-        std::vector<std::shared_ptr<AccessibleNode>> merged{};
-
         std::string pkg = root->getPkg();
         auto XMLDoc = AccessibleWatcher::getInstance()->getXMLDoc(pkg);
 
-        if (XMLDoc.get() == nullptr) return merged;
+        if (XMLDoc.get() == nullptr) return;
 
-        auto tmp = XMLDoc->findObjects(selector->mXPath, earlyReturn);
-        std::move(std::begin(tmp), std::end(tmp), std::back_inserter(merged));
+        XMLDoc->findObjects(ret, selector->mXPath, earlyReturn);
 
-        return merged;
+        return;
     }
 
-    return comparer.findObjects(root);
+    comparer.findObjects(ret, root);
 }
 
-std::vector<std::shared_ptr<AccessibleNode>> Comparer::findObjects(const std::shared_ptr<AccessibleNode>& root)
+void Comparer::findObjects(std::vector<std::shared_ptr<AccessibleNode>> &ret,
+                                                            const std::shared_ptr<AccessibleNode>& root)
 {
     std::list<std::shared_ptr<PartialMatch>> partialList{};
-    std::vector<std::shared_ptr<AccessibleNode>> ret = findObjects(root, 0, 1, partialList);
+    findObjects(ret, root, 0, 1, partialList);
     LOGI("%d object(s) found", (int)ret.size());
-    return ret;
 }
 
-std::vector<std::shared_ptr<AccessibleNode>> Comparer::findObjects(
+void Comparer::findObjects(std::vector<std::shared_ptr<AccessibleNode>> &ret,
     const std::shared_ptr<AccessibleNode>& root, const int &index, const int &depth,
     std::list<std::shared_ptr<PartialMatch>> &partialMatches)
 {
-    std::vector<std::shared_ptr<AccessibleNode>> ret;
 
-    if (mSelector->mMatchShowing && !root->isShowing()) return ret;
+    if (mSelector->mMatchShowing && !root->isShowing()) return;
 
     for (auto &match : partialMatches)
         match->update(root, index, depth, partialMatches);
@@ -102,12 +102,10 @@ std::vector<std::shared_ptr<AccessibleNode>> Comparer::findObjects(
             auto child = children[i];
             if (child->getRawHandler() == nullptr) continue;
 
-            std::vector<std::shared_ptr<AccessibleNode>> childret =
-                findObjects(child, i, depth + 1, partialMatches);
-            std::move(std::begin(childret), std::end(childret), std::back_inserter(ret));
+            findObjects(ret, child, i, depth + 1, partialMatches);
             if (!ret.empty() && mEarlyReturn) {
                 LOGI("Object found and earlyReturn");
-                return ret;
+                return;
             }
         }
     } else {
@@ -118,6 +116,4 @@ std::vector<std::shared_ptr<AccessibleNode>> Comparer::findObjects(
         LOGI("Found matched = %s with criteria %s", root->description().c_str(), currentMatch->debugPrint().c_str());
         ret.push_back(root);
     }
-
-    return ret;
 }

diff --git a/libaurum/src/UiDevice.cc b/libaurum/src/UiDevice.cc
index 042837b..e6e24fe 100644 (file)
--- a/libaurum/src/UiDevice.cc
+++ b/libaurum/src/UiDevice.cc
@@ -258,8 +258,9 @@ std::vector<std::shared_ptr<UiObject>> UiDevice::findObjects(
     std::vector<std::shared_ptr<UiObject>> ret{};
     auto rootNodes = getWindowRoot();
     for (const auto &window : rootNodes) {
-        std::vector<std::shared_ptr<AccessibleNode>> nodes =
-            Comparer::findObjects(getInstance(), selector, window);
+        std::vector<std::shared_ptr<AccessibleNode>> nodes{};
+        Comparer::findObjects(nodes, getInstance(), selector, window);
+
         for (auto &node : nodes)
             ret.push_back(std::make_shared<UiObject>(getInstance(), selector, node));
     }

diff --git a/libaurum/src/UiObject.cc b/libaurum/src/UiObject.cc
index 41ef208..3bbecc0 100644 (file)
--- a/libaurum/src/UiObject.cc
+++ b/libaurum/src/UiObject.cc
@@ -92,7 +92,9 @@ std::vector<std::shared_ptr<UiObject>> UiObject::findObjects(
     const std::shared_ptr<UiSelector> selector) const
 {
     std::vector<std::shared_ptr<UiObject>> result{};
-    auto nodes = Comparer::findObjects(mDevice, selector, getAccessibleNode());
+
+    std::vector<std::shared_ptr<AccessibleNode>> nodes{};
+    Comparer::findObjects(nodes, mDevice, selector, getAccessibleNode());
     for ( auto& node : nodes) {
         if (!node) {
             LOGI("Skipped! (node == nullptr)");

diff --git a/org.tizen.aurum-bootstrap/src/Commands/FindElementsCommand.cc b/org.tizen.aurum-bootstrap/src/Commands/FindElementsCommand.cc
index e0575cd..626d6a9 100644 (file)
--- a/org.tizen.aurum-bootstrap/src/Commands/FindElementsCommand.cc
+++ b/org.tizen.aurum-bootstrap/src/Commands/FindElementsCommand.cc
@@ -81,7 +81,6 @@ std::vector<std::shared_ptr<UiSelector>> FindElementsCommand::getSelectors(void)
 
 ::grpc::Status FindElementsCommand::execute()
 {
-    LOGI("findElements --------------- ");
     auto searchableObj = getSearchableTop();
     auto selectors     = getSelectors();
     std::shared_ptr<UiDevice> mDevice = UiDevice::getInstance();