Fix IME Window is not shown issue.
[platform/core/uifw/dali-adaptor.git] / dali / internal / window-system / common / window-render-surface.h
1 #ifndef DALI_INTERNAL_WINDOWSYSTEM_COMMON_WINDOW_RENDER_SURFACE_H
2 #define DALI_INTERNAL_WINDOWSYSTEM_COMMON_WINDOW_RENDER_SURFACE_H
3
4 /*
5  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  */
20
21 // EXTERNAL INCLUDES
22 #include <dali/devel-api/threading/mutex.h>
23 #include <dali/integration-api/scene.h>
24 #include <dali/public-api/signals/connection-tracker.h>
25 #include <dali/public-api/signals/dali-signal.h>
26 #include <unistd.h>
27
28 // INTERNAL INCLUDES
29 #include <dali/integration-api/adaptor-framework/egl-interface.h>
30 #include <dali/integration-api/adaptor-framework/render-surface-interface.h>
31 #include <dali/internal/graphics/common/graphics-interface.h>
32 #include <dali/internal/system/common/file-descriptor-monitor.h>
33
34 namespace Dali
35 {
36 class TriggerEventInterface;
37
38 namespace Internal
39 {
40 namespace Adaptor
41 {
42 class WindowBase;
43 class AdaptorInternalServices;
44
45 /**
46  * Window interface of render surface.
47  */
48 class WindowRenderSurface : public Dali::RenderSurfaceInterface, public ConnectionTracker
49 {
50 public:
51
52   using RotationFinishedSignalType = Signal<void()>        ; ///<The signal of window rotation's finished.
53   using OutputSignalType           = Signal<void()>;
54   using DamagedRectsContainer      = std::vector<Rect<int>>;
55
56   /**
57     * @brief Uses an window surface to render to.
58     *
59     * @param [in] positionSize the position and size of the surface
60     * @param [in] surface can be a window or pixmap.
61     * @param [in] isTransparent if it is true, surface has 32 bit color depth, otherwise, 24 bit
62     */
63   WindowRenderSurface(Dali::PositionSize positionSize, Any surface, bool isTransparent = false);
64
65   /**
66    * @brief Destructor
67    */
68   virtual ~WindowRenderSurface();
69
70 public: // API
71   /**
72    * @brief Get the native window handle
73    *
74    * @return The native window handle
75    */
76   Any GetNativeWindow();
77
78   /**
79    * @brief Get the native window id
80    *
81    * @return The native window id
82    */
83   int GetNativeWindowId();
84
85   /**
86    * @brief Map window
87    */
88   void Map();
89
90   /**
91    * @brief Sets the render notification trigger to call when render thread is completed a frame
92    *
93    * @param renderNotification to use
94    */
95   void SetRenderNotification(TriggerEventInterface* renderNotification);
96
97   /**
98    * @brief Sets whether the surface is transparent or not.
99    *
100    * @param[in] transparent Whether the surface is transparent
101    */
102   void SetTransparency(bool transparent);
103
104   /**
105    * @brief Request surface rotation
106    *
107    * @param[in] angle A new angle of the surface
108    * @param[in] positionSize A new position and size of the surface
109    */
110   void RequestRotation(int angle, PositionSize positionSize);
111
112   /**
113    * @brief Gets the window base object
114    *
115    * @return The window base object
116    */
117   WindowBase* GetWindowBase();
118
119   /**
120    * @brief Intiailize Ime Surface for Ime window rendering.
121    * It sets one flag and callback function for Ime window rendering
122    * This callback function calls one special native window function for ready to commit buffer.
123    * The special function notify to display server.
124    * It is only used for Ime window.
125    */
126   void InitializeImeSurface();
127
128   /**
129    * @brief Sets the necessary for window rotation acknowledge.
130    * After this function called, SendRotationCompletedAcknowledgement() should be called to complete window rotation.
131    * More detail description is written in DevelWindow::SetNeedsRotationCompletedAcknowledgement().
132    *
133    * @param[in] window The window instance.
134    * @param[in] needAcknowledgement the flag is true if window rotation acknowledgement is sent.
135    */
136   void SetNeedsRotationCompletedAcknowledgement(bool needAcknowledgement);
137
138   /**
139    * @brief Updates window surface's position and size.
140    * It is just to update the local variable in window surface.
141    * This function is only called when window's position or size is changed by display server.
142    *
143    * @param[in] positionSize The updated window surface's position and size.
144    */
145   void UpdatePositionSize(Dali::PositionSize positionSize);
146
147   /**
148    * @brief Moves the window to the specified position.
149    *
150    * @param positionSize The new position of the window.
151    */
152   void Move(Dali::PositionSize positionSize);
153
154   /**
155    * @brief This signal is emitted when the output is transformed.
156    */
157   OutputSignalType& OutputTransformedSignal();
158
159   /**
160    * @brief This signal is emitted when a rotation job is finished.
161    */
162   RotationFinishedSignalType& RotationFinishedSignal();
163
164 public: // from Dali::RenderSurfaceInterface
165   /**
166    * @copydoc Dali::RenderSurfaceInterface::GetPositionSize()
167    */
168   PositionSize GetPositionSize() const override;
169
170   /**
171    * @copydoc Dali::RenderSurfaceInterface::GetDpi()
172    */
173   void GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical) override;
174
175   /**
176    * @copydoc Dali::RenderSurfaceInterface::GetSurfaceOrientation()
177    */
178   int GetSurfaceOrientation() const override;
179
180   /**
181    * @copydoc Dali::RenderSurfaceInterface::GetScreenOrientation()
182    */
183   int GetScreenOrientation() const override;
184
185   /**
186    * @copydoc Dali::RenderSurfaceInterface::InitializeGraphics()
187    */
188   void InitializeGraphics() override;
189
190   /**
191    * @copydoc Dali::RenderSurfaceInterface::CreateSurface()
192    */
193   void CreateSurface() override;
194
195   /**
196    * @copydoc Dali::RenderSurfaceInterface::DestroySurface()
197    */
198   void DestroySurface() override;
199
200   /**
201    * @copydoc Dali::RenderSurfaceInterface::ReplaceGraphicsSurface()
202    */
203   bool ReplaceGraphicsSurface() override;
204
205   /**
206    * @copydoc Dali::RenderSurfaceInterface::MoveResize()
207    */
208   void MoveResize(Dali::PositionSize positionSize) override;
209
210   /**
211    * @copydoc Dali::RenderSurfaceInterface::StartRender()
212    */
213   void StartRender() override;
214
215   /**
216    * @copydoc Dali::RenderSurfaceInterface::PreRender()
217    */
218   bool PreRender(bool resizingSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect) override;
219
220   /**
221    * @copydoc Dali::RenderSurfaceInterface::PostRender()
222    */
223   void PostRender() override;
224
225   /**
226    * @copydoc Dali::RenderSurfaceInterface::StopRender()
227    */
228   void StopRender() override;
229
230   /**
231    * @copydoc Dali::RenderSurfaceInterface::SetThreadSynchronization
232    */
233   void SetThreadSynchronization(ThreadSynchronizationInterface& threadSynchronization) override;
234
235   /**
236    * @copydoc Dali::RenderSurfaceInterface::ReleaseLock()
237    */
238   void ReleaseLock() override;
239
240   /**
241    * @copydoc Dali::RenderSurfaceInterface::GetSurfaceType()
242    */
243   Dali::RenderSurfaceInterface::Type GetSurfaceType() override;
244
245   /**
246    * @copydoc Dali::RenderSurfaceInterface::MakeContextCurrent()
247    */
248   void MakeContextCurrent() override;
249
250   /**
251    * @copydoc Dali::RenderSurfaceInterface::GetDepthBufferRequired()
252    */
253   Integration::DepthBufferAvailable GetDepthBufferRequired() override;
254
255   /**
256    * @copydoc Dali::RenderSurfaceInterface::GetStencilBufferRequired()
257    */
258   Integration::StencilBufferAvailable GetStencilBufferRequired() override;
259
260 private:
261   /**
262    * @brief Second stage construction
263    */
264   void Initialize(Any surface);
265
266   /**
267    * @brief Notify output is transformed.
268    */
269   void OutputTransformed();
270
271   /**
272    * @brief Used as the callback for the post render.
273    * It is used both window rotation and supporting Ime window
274    */
275   void ProcessPostRender();
276
277   /**
278    * @brief Used as the callback for the frame rendered / presented.
279    */
280   void ProcessFrameCallback();
281
282   /**
283    * @brief Called when our event file descriptor has been written to.
284    *
285    * @param[in] eventBitMask bit mask of events that occured on the file descriptor
286    * @param[in] fileDescriptor The file descriptor
287    */
288   void OnFileDescriptorEventDispatched(FileDescriptorMonitor::EventType eventBitMask, int fileDescriptor);
289
290   /**
291    * @brief Set the buffer damage rects.
292    *
293    * @param[in] damagedRects List of damaged rects
294    * @param[in] clippingRect The rect to clip rendered scene
295    */
296   void SetBufferDamagedRects(const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect);
297
298   /**
299    * @brief Swap buffers.
300    *
301    * @param[in] damagedRects List of damaged rects
302    */
303   void SwapBuffers(const std::vector<Rect<int>>& damagedRects);
304
305 protected:
306   // Undefined
307   WindowRenderSurface(const WindowRenderSurface&) = delete;
308
309   // Undefined
310   WindowRenderSurface& operator=(const WindowRenderSurface& rhs) = delete;
311
312 private:
313   struct FrameCallbackInfo
314   {
315     FrameCallbackInfo(Dali::Integration::Scene::FrameCallbackContainer& callbackList, int fd)
316     : callbacks(),
317       fileDescriptorMonitor(),
318       fileDescriptor(fd)
319     {
320       // Transfer owership of the CallbackBase
321       for(auto&& iter : callbackList)
322       {
323         callbacks.push_back(std::make_pair(std::move(iter.first), iter.second));
324       }
325     }
326
327     ~FrameCallbackInfo()
328     {
329       // Delete FileDescriptorMonitor before close fd.
330       fileDescriptorMonitor.reset();
331       close(fileDescriptor);
332     }
333
334     Dali::Integration::Scene::FrameCallbackContainer callbacks;
335     std::unique_ptr<FileDescriptorMonitor>           fileDescriptorMonitor;
336     int                                              fileDescriptor;
337   };
338
339   using FrameCallbackInfoContainer = std::vector<std::unique_ptr<FrameCallbackInfo>>;
340
341 private: // Data
342   EglInterface*                          mEGL;
343   Dali::DisplayConnection*               mDisplayConnection;
344   PositionSize                           mPositionSize; ///< Position
345   std::unique_ptr<WindowBase>            mWindowBase;
346   ThreadSynchronizationInterface*        mThreadSynchronization;
347   TriggerEventInterface*                 mRenderNotification; ///< Render notification trigger
348   std::unique_ptr<TriggerEventInterface> mPostRenderTrigger;  ///< Post render callback function
349   std::unique_ptr<TriggerEventInterface> mFrameRenderedTrigger;
350   GraphicsInterface*                     mGraphics; ///< Graphics interface
351   EGLSurface                             mEGLSurface;
352   EGLContext                             mEGLContext;
353   ColorDepth                             mColorDepth; ///< Color depth of surface (32 bit or 24 bit)
354   OutputSignalType                       mOutputTransformedSignal;       ///< The signal of screen rotation occurs
355   RotationFinishedSignalType             mWindowRotationFinishedSignal;  ///< The signal of window rotation's finished
356   FrameCallbackInfoContainer             mFrameCallbackInfoContainer;
357   DamagedRectsContainer                  mBufferDamagedRects;
358   Dali::Mutex                            mMutex;
359   int                                    mWindowRotationAngle;
360   int                                    mScreenRotationAngle;
361   uint32_t                               mDpiHorizontal;
362   uint32_t                               mDpiVertical;
363   std::vector<Rect<int>>                 mDamagedRects{}; ///< Keeps collected damaged render items rects for one render pass. These rects are rotated by scene orientation.
364   bool                                   mOwnSurface;     ///< Whether we own the surface (responsible for deleting it)
365   bool                                   mIsImeWindowSurface;
366   bool                                   mNeedWindowRotationAcknowledgement;
367   bool                                   mIsWindowOrientationChanging;
368
369 }; // class WindowRenderSurface
370
371 } // namespace Adaptor
372
373 } // namespace Internal
374
375 } // namespace Dali
376
377 #endif // DALI_INTERNAL_WINDOWSYSTEM_COMMON_WINDOW_RENDER_SURFACE_H