[Tizen][AT-SPI] do not keep window in ApplicationAccessible

[platform/core/uifw/dali-adaptor.git] / dali / internal / accessibility / bridge / bridge-impl.cpp

diff --git a/dali/internal/accessibility/bridge/bridge-impl.cpp b/dali/internal/accessibility/bridge/bridge-impl.cpp
index 3f4914b..27525b4 100644 (file)
--- a/dali/internal/accessibility/bridge/bridge-impl.cpp
+++ b/dali/internal/accessibility/bridge/bridge-impl.cpp
@@ -43,6 +43,13 @@
 
 using namespace Dali::Accessibility;
 
+namespace // unnamed namespace
+{
+
+const int RETRY_INTERVAL = 1000;
+
+} // unnamed namespace
+
 /**
  * @brief The BridgeImpl class is to implement some Bridge functions.
  */
@@ -68,6 +75,9 @@ class BridgeImpl : public virtual BridgeBase,
   Dali::Actor                                                   mHighlightedActor;
   std::function<void(Dali::Actor)>                              mHighlightClearAction;
   Dali::CallbackBase*                                           mIdleCallback          = NULL;
+  Dali::Timer                                                   mInitializeTimer;
+  Dali::Timer                                                   mReadIsEnabledTimer;
+  Dali::Timer                                                   mReadScreenReaderEnabledTimer;
 
 public:
   BridgeImpl()
@@ -208,6 +218,8 @@ public:
       }
       mData->mCurrentlyHighlightedActor = {};
       mData->mHighlightActor            = {};
+
+      mDisabledSignal.Emit();
     }
     mHighlightedActor     = {};
     mHighlightClearAction = {};
@@ -216,7 +228,24 @@ public:
     mDirectReadingClient  = {};
     mDirectReadingCallbacks.clear();
     mApplication.mChildren.clear();
-    mApplication.mWindows.clear();
+  }
+
+  void StopTimer()
+  {
+    if(mInitializeTimer)
+    {
+      mInitializeTimer.Stop();
+    }
+
+    if(mReadIsEnabledTimer)
+    {
+      mReadIsEnabledTimer.Stop();
+    }
+
+    if(mReadScreenReaderEnabledTimer)
+    {
+      mReadScreenReaderEnabledTimer.Stop();
+    }
   }
 
   /**
@@ -230,6 +259,7 @@ public:
       mData->mHighlightActor            = {};
     }
     ForceDown();
+    StopTimer();
     if((NULL != mIdleCallback) && Dali::Adaptor::IsAvailable())
     {
       Dali::Adaptor::Get().RemoveIdle(mIdleCallback);
@@ -288,12 +318,8 @@ public:
 
     mApplication.mParent.SetAddress(std::move(std::get<0>(res)));
 
-    if(mIsShown)
-    {
-      auto rootLayer = Dali::Stage::GetCurrent().GetRootLayer();
-      auto window    = Dali::DevelWindow::Get(rootLayer);
-      EmitActivate(window); // Currently, sends a signal that the default window is activated here.
-    }
+    mEnabledSignal.Emit();
+
     return ForceUpResult::JUST_STARTED;
   }
 
@@ -403,6 +429,25 @@ public:
     }
   }
 
+  /**
+   * @copydoc Dali::Accessibility::Bridge::SuppressScreenReader()
+   */
+  void SuppressScreenReader(bool suppress) override
+  {
+    if(mIsScreenReaderSuppressed == suppress)
+    {
+      return;
+    }
+    mIsScreenReaderSuppressed = suppress;
+    ReadScreenReaderEnabledProperty();
+  }
+
+  bool ReadIsEnabledTimerCallback()
+  {
+    ReadIsEnabledProperty();
+    return false;
+  }
+
   void ReadIsEnabledProperty()
   {
     mAccessibilityStatusClient.property<bool>("IsEnabled").asyncGet([this](DBus::ValueOrError<bool> msg) {
@@ -411,15 +456,24 @@ public:
         DALI_LOG_ERROR("Get IsEnabled property error: %s\n", msg.getError().message.c_str());
         if(msg.getError().errorType == DBus::ErrorType::INVALID_REPLY)
         {
-          ReadIsEnabledProperty();
+          if(!mReadIsEnabledTimer)
+          {
+            mReadIsEnabledTimer = Dali::Timer::New(RETRY_INTERVAL);
+            mReadIsEnabledTimer.TickSignal().Connect(this, &BridgeImpl::ReadIsEnabledTimerCallback);
+          }
+          mReadIsEnabledTimer.Start();
         }
         return;
       }
       mIsEnabled = std::get<0>(msg);
-      if(mIsEnabled)
+      if((!mIsScreenReaderSuppressed && mIsScreenReaderEnabled) || mIsEnabled)
       {
         ForceUp();
       }
+      else
+      {
+        ForceDown();
+      }
     });
   }
 
@@ -438,23 +492,44 @@ public:
     });
   }
 
+  bool ReadScreenReaderEnabledTimerCallback()
+  {
+    ReadScreenReaderEnabledProperty();
+    return false;
+  }
+
   void ReadScreenReaderEnabledProperty()
   {
+    // can be true because of SuppressScreenReader before init
+    if (!mAccessibilityStatusClient)
+    {
+      return;
+    }
+
     mAccessibilityStatusClient.property<bool>("ScreenReaderEnabled").asyncGet([this](DBus::ValueOrError<bool> msg) {
       if(!msg)
       {
         DALI_LOG_ERROR("Get ScreenReaderEnabled property error: %s\n", msg.getError().message.c_str());
         if(msg.getError().errorType == DBus::ErrorType::INVALID_REPLY)
         {
-          ReadScreenReaderEnabledProperty();
+          if(!mReadScreenReaderEnabledTimer)
+          {
+            mReadScreenReaderEnabledTimer = Dali::Timer::New(RETRY_INTERVAL);
+            mReadScreenReaderEnabledTimer.TickSignal().Connect(this, &BridgeImpl::ReadScreenReaderEnabledTimerCallback);
+          }
+          mReadScreenReaderEnabledTimer.Start();
         }
         return;
       }
       mIsScreenReaderEnabled = std::get<0>(msg);
-      if(mIsScreenReaderEnabled)
+      if((!mIsScreenReaderSuppressed && mIsScreenReaderEnabled) || mIsEnabled)
       {
         ForceUp();
       }
+      else
+      {
+        ForceDown();
+      }
     });
   }
 
@@ -462,7 +537,7 @@ public:
   {
     mAccessibilityStatusClient.addPropertyChangedEvent<bool>("ScreenReaderEnabled", [this](bool res) {
       mIsScreenReaderEnabled = res;
-      if(mIsScreenReaderEnabled || mIsEnabled)
+      if((!mIsScreenReaderSuppressed && mIsScreenReaderEnabled) || mIsEnabled)
       {
         ForceUp();
       }
@@ -495,6 +570,16 @@ public:
     return true;
   }
 
+  bool InitializeTimerCallback()
+  {
+    if ( InitializeAccessibilityStatusClient() )
+    {
+      ReadAndListenProperties();
+      return false;
+    }
+    return true;
+  }
+
   bool OnIdleSignal()
   {
     if ( InitializeAccessibilityStatusClient() )
@@ -504,7 +589,15 @@ public:
       return false;
     }
 
-    return true;
+    if(!mInitializeTimer)
+    {
+      mInitializeTimer = Dali::Timer::New(RETRY_INTERVAL);
+      mInitializeTimer.TickSignal().Connect(this, &BridgeImpl::InitializeTimerCallback);
+    }
+    mInitializeTimer.Start();
+
+    mIdleCallback = NULL;
+    return false;
   }
 
   /**