Merge "[AT-SPI] Call EmbedAtkSocket() from WebViewAccessible" into devel/master
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / texture-manager / texture-manager-impl.h
1 #ifndef DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H
2 #define DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_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 // EXTERNAL INCLUDES
21 #include <dali/devel-api/adaptor-framework/animated-image-loading.h>
22 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
23 #include <dali/public-api/adaptor-framework/encoded-image-buffer.h>
24 #include <dali/public-api/common/dali-vector.h>
25 #include <dali/public-api/rendering/geometry.h>
26
27 // INTERNAL INCLUDES
28 #include <dali-toolkit/devel-api/image-loader/image-atlas.h>
29 #include <dali-toolkit/internal/helpers/round-robin-container-view.h>
30 #include <dali-toolkit/internal/texture-manager/texture-cache-manager.h>
31 #include <dali-toolkit/internal/texture-manager/texture-manager-type.h>
32 #include <dali-toolkit/internal/texture-manager/texture-upload-observer.h>
33 #include <dali-toolkit/internal/visuals/visual-url.h>
34
35 namespace Dali
36 {
37 namespace Toolkit
38 {
39 namespace Internal
40 {
41 class ImageAtlasManager;
42 typedef IntrusivePtr<ImageAtlasManager> ImageAtlasManagerPtr;
43 class TextureAsyncLoadingHelper;
44
45 /**
46  * The TextureManager provides a common Image loading API for Visuals.
47  *
48  * The TextureManager is responsible for providing sync, async, atlased and non-atlased
49  * CPU time alpha masking, animated image loads.
50  *
51  * Texture caching is provided and performed by TextureCacheManager.
52  * TextureUploadObserver.LoadComplete called when async load completed.
53  */
54 class TextureManager : public ConnectionTracker
55 {
56 public:
57   // Copy enum and types and const values that TextureManager will use.
58   using TextureId         = TextureManagerType::TextureId;
59   using TextureCacheIndex = TextureManagerType::TextureCacheIndex;
60   using TextureHash       = TextureManagerType::TextureHash;
61
62   static constexpr TextureId         INVALID_TEXTURE_ID  = TextureManagerType::INVALID_TEXTURE_ID;
63   static constexpr TextureCacheIndex INVALID_CACHE_INDEX = TextureManagerType::INVALID_CACHE_INDEX;
64
65   using UseAtlas       = TextureManagerType::UseAtlas;
66   using StorageType    = TextureManagerType::StorageType;
67   using LoadType       = TextureManagerType::LoadType;
68   using LoadState      = TextureManagerType::LoadState;
69   using ReloadPolicy   = TextureManagerType::ReloadPolicy;
70   using MultiplyOnLoad = TextureManagerType::MultiplyOnLoad;
71   using TextureInfo    = TextureManagerType::TextureInfo;
72
73 public:
74   struct MaskingData
75   {
76     MaskingData();
77     ~MaskingData() = default;
78
79     VisualUrl                 mAlphaMaskUrl;
80     TextureManager::TextureId mAlphaMaskId;
81     float                     mContentScaleFactor;
82     bool                      mCropToMask;
83   };
84   using MaskingDataPointer = std::unique_ptr<MaskingData>;
85
86   /**
87    * Class to provide lifecycle event on destruction of texture manager.
88    */
89   struct LifecycleObserver
90   {
91     /**
92      * Called shortly before the texture manager is destroyed.
93      */
94     virtual void TextureManagerDestroyed() = 0;
95   };
96
97   /**
98    * Constructor.
99    */
100   TextureManager();
101
102   /**
103    * Destructor.
104    */
105   ~TextureManager() override;
106
107   // TextureManager Main API:
108
109   /**
110    * @brief Requests an frame of animated image load.
111    *
112    * The parameters are used to specify how the animated image is loaded.
113    * The observer has the LoadComplete method called when the load is ready.
114    *
115    * @param[in]  animatedImageLoading  The AnimatedImageLoading that contain the animated image information
116    * @param[in]  frameIndex            The frame index to load.
117    * @param[out] textureId             The textureId of the frame
118    * @param[in, out] maskInfo          Mask info structure
119    * @param[in]  samplingMode          The SamplingMode to use
120    * @param[in]  wrapModeU             Horizontal Wrap mode
121    * @param[in]  wrapModeV             Vertical Wrap mode
122    * @param[in]  synchronousLoading    true if the frame should be loaded synchronously
123    * @param[in]  useCache              true if this frame loading uses cache.
124    * @param[in]  textureObserver       The client object should inherit from this and provide the "LoadCompleted" virtual.
125    *                                   This is called when an image load completes (or fails).
126    *
127    * @return                           The texture set containing the frame of animated image, or empty if still loading.
128    */
129   TextureSet LoadAnimatedImageTexture(Dali::AnimatedImageLoading      animatedImageLoading,
130                                       const uint32_t&                 frameIndex,
131                                       TextureManager::TextureId&      textureId,
132                                       MaskingDataPointer&             maskInfo,
133                                       const Dali::SamplingMode::Type& samplingMode,
134                                       const Dali::WrapMode::Type&     wrapModeU,
135                                       const Dali::WrapMode::Type&     wrapModeV,
136                                       const bool&                     synchronousLoading,
137                                       const bool&                     useCache,
138                                       TextureUploadObserver*          textureObserver);
139
140   /**
141    * @brief Requests an image load of the given URL to get PixelBuffer.
142    *
143    * The parameters are used to specify how the image is loaded.
144    * The observer has the LoadComplete method called when the load is ready.
145    *
146    * @param[in] url                   The URL of the image to load
147    * @param[in] desiredSize           The size the image is likely to appear at. This can be set to 0,0 for automatic
148    * @param[in] fittingMode           The FittingMode to use
149    * @param[in] samplingMode          The SamplingMode to use
150    * @param[in] synchronousLoading    true if the URL should be loaded synchronously
151    * @param[in] textureObserver       The client object should inherit from this and provide the "LoadCompleted" virtual.
152    *                                  This is called when an image load completes (or fails).
153    * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
154    * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the
155    *                                  image has no alpha channel
156    *
157    * @return                          The pixel buffer containing the image, or empty if still loading.
158    */
159   Devel::PixelBuffer LoadPixelBuffer(
160     const VisualUrl&                url,
161     const Dali::ImageDimensions&    desiredSize,
162     const Dali::FittingMode::Type&  fittingMode,
163     const Dali::SamplingMode::Type& samplingMode,
164     const bool&                     synchronousLoading,
165     TextureUploadObserver*          textureObserver,
166     const bool&                     orientationCorrection,
167     TextureManager::MultiplyOnLoad& preMultiplyOnLoad);
168
169   /**
170    * @brief Requests an image load of the given URL.
171    *
172    * The parameters are used to specify how the image is loaded.
173    * The observer has the LoadComplete method called when the load is ready.
174    *
175    * When the client has finished with the Texture, Remove() should be called.
176    *
177    * @param[in] url                   The URL of the image to load
178    * @param[in] desiredSize           The size the image is likely to appear at. This can be set to 0,0 for automatic
179    * @param[in] fittingMode           The FittingMode to use
180    * @param[in] samplingMode          The SamplingMode to use
181    * @param[in, out] maskInfo         Mask info structure
182    * @param[in] synchronousLoading    true if the URL should be loaded synchronously
183    * @param[out] textureId,           The textureId of the URL
184    * @param[out] textureRect          The rectangle within the texture atlas that this URL occupies,
185    *                                  this is the rectangle in normalized coordinates.
186    * @param[out] textureRectSize      The rectangle within the texture atlas that this URL occupies,
187    *                                  this is the same rectangle in pixels.
188    * @param[in,out] atlasingStatus    Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still
189    *                                  be loaded, and marked successful, but this will be set to false.
190    *                                  If atlasing succeeds, this will be set to true.
191    * @param[out] loadingStatus        The loading status of the texture
192    * @param[in] wrapModeU             Horizontal Wrap mode
193    * @param[in] wrapModeV             Vertical Wrap mode
194    * @param[in] textureObserver       The client object should inherit from this and provide the "LoadCompleted" virtual.
195    *                                  This is called when an image load completes (or fails).
196    * @param[in] atlasObserver         This is used if the texture is atlased, and will be called instead of
197    *                                  textureObserver.LoadCompleted
198    * @param[in] imageAtlasManager     The atlas manager to use for atlasing textures
199    * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
200    * @param[in] reloadPolicy          Forces a reload of the texture even if already cached
201    * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the
202    *                                  image has no alpha channel
203    *
204    * @return                          The texture set containing the image, or empty if still loading.
205    */
206   TextureSet LoadTexture(
207     const VisualUrl&                    url,
208     const Dali::ImageDimensions&        desiredSize,
209     const Dali::FittingMode::Type&      fittingMode,
210     const Dali::SamplingMode::Type&     samplingMode,
211     MaskingDataPointer&                 maskInfo,
212     const bool&                         synchronousLoading,
213     TextureManager::TextureId&          textureId,
214     Dali::Vector4&                      textureRect,
215     Dali::ImageDimensions&              textureRectSize,
216     bool&                               atlasingStatus,
217     bool&                               loadingStatus,
218     const Dali::WrapMode::Type&         wrapModeU,
219     const Dali::WrapMode::Type&         wrapModeV,
220     TextureUploadObserver*              textureObserver,
221     AtlasUploadObserver*                atlasObserver,
222     ImageAtlasManagerPtr                imageAtlasManager,
223     const bool&                         orientationCorrection,
224     const TextureManager::ReloadPolicy& reloadPolicy,
225     TextureManager::MultiplyOnLoad&     preMultiplyOnLoad);
226
227   /**
228    * @brief Remove a Texture from the TextureManager.
229    *
230    * Textures are cached and therefore only the removal of the last
231    * occurrence of a Texture will cause its removal internally.
232    *
233    * @param[in] textureId The ID of the Texture to remove.
234    * @param[in] textureObserver The texture observer.
235    */
236   void Remove(const TextureManager::TextureId& textureId, TextureUploadObserver* textureObserver);
237
238   /**
239    * Add an observer to the object.
240    * @param[in] observer The observer to add.
241    */
242   void AddObserver(TextureManager::LifecycleObserver& observer);
243
244   /**
245    * Remove an observer from the object
246    * @pre The observer has already been added.
247    * @param[in] observer The observer to remove.
248    */
249   void RemoveObserver(TextureManager::LifecycleObserver& observer);
250
251   /**
252    * @brief Returns the geometry associated with texture.
253    * @param[in] textureId Id of the texture
254    * @param[out] frontElements number of front elements
255    * @param[out] backElements number of back elements
256    * @return Returns valid geometry object
257    */
258   Geometry GetRenderGeometry(const TextureManager::TextureId& textureId, std::uint32_t& frontElements, std::uint32_t& backElements);
259
260 public:
261   // API list that need to access TextureCacheManager.
262
263   /**
264    * @copydoc TextureCacheManager::GetVisualUrl
265    */
266   inline VisualUrl GetVisualUrl(const TextureManager::TextureId& textureId)
267   {
268     return mTextureCacheManager.GetVisualUrl(textureId);
269   }
270
271   /**
272    * @copydoc TextureCacheManager::GetTextureSet
273    */
274   inline TextureSet GetTextureSet(const TextureManager::TextureId& textureId)
275   {
276     return mTextureCacheManager.GetTextureSet(textureId);
277   }
278
279   /**
280    * @copydoc TextureCacheManager::RemoveExternalTexture
281    */
282   inline TextureSet RemoveExternalTexture(const std::string& url)
283   {
284     return mTextureCacheManager.RemoveExternalTexture(url);
285   }
286
287   /**
288    * @copydoc TextureCacheManager::RemoveEncodedImageBuffer
289    */
290   inline EncodedImageBuffer RemoveEncodedImageBuffer(const std::string& url)
291   {
292     return mTextureCacheManager.RemoveEncodedImageBuffer(url);
293   }
294
295   /**
296    * @copydoc TextureCacheManager::UseExternalResource
297    */
298   inline void UseExternalResource(const VisualUrl& url)
299   {
300     mTextureCacheManager.UseExternalResource(url);
301   }
302
303   /**
304    * @copydoc TextureCacheManager::GetEncodedImageBuffer
305    */
306   inline EncodedImageBuffer GetEncodedImageBuffer(const std::string& url)
307   {
308     return mTextureCacheManager.GetEncodedImageBuffer(url);
309   }
310
311   /**
312    * @copydoc TextureCacheManager::AddExternalTexture
313    */
314   inline std::string AddExternalTexture(const TextureSet& texture)
315   {
316     return mTextureCacheManager.AddExternalTexture(texture);
317   }
318
319   /**
320    * @copydoc TextureCacheManager::AddEncodedImageBuffer
321    */
322   inline std::string AddEncodedImageBuffer(const EncodedImageBuffer& encodedImageBuffer)
323   {
324     return mTextureCacheManager.AddEncodedImageBuffer(encodedImageBuffer);
325   }
326
327 public: // Load Request API
328   /**
329    * @brief Requests an image load of the given URL.
330    *
331    * The parameters are used to specify how the image is loaded.
332    * The observer has the LoadComplete method called when the load is ready.
333    *
334    * When the client has finished with the Texture, Remove() should be called.
335    *
336    * @param[in] url                   The URL of the image to load
337    * @param[in] desiredSize           The size the image is likely to appear at. This can be set to 0,0 for automatic
338    * @param[in] fittingMode           The FittingMode to use
339    * @param[in] samplingMode          The SamplingMode to use
340    * @param[in] useAtlasing           Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be loaded, and marked successful,
341    *                                  but "useAtlasing" will be set to false in the "LoadCompleted" callback from the TextureManagerUploadObserver.
342    * @param[in] observer              The client object should inherit from this and provide the "LoadCompleted" virtual.
343    *                                  This is called when an image load completes (or fails).
344    * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
345    * @param[in] reloadPolicy          Forces a reload of the texture even if already cached
346    * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the image has no alpha channel
347    * @param[in] synchronousLoading    True if the frame should be loaded synchronously. If you skip this parameter,
348    *                                  default is false.
349    * @return                          A TextureId to use as a handle to reference this Texture
350    */
351   TextureId RequestLoad(
352     const VisualUrl&                    url,
353     const ImageDimensions&              desiredSize,
354     const Dali::FittingMode::Type&      fittingMode,
355     const Dali::SamplingMode::Type&     samplingMode,
356     const TextureManager::UseAtlas&     useAtlasing,
357     TextureUploadObserver*              observer,
358     const bool&                         orientationCorrection,
359     const TextureManager::ReloadPolicy& reloadPolicy,
360     TextureManager::MultiplyOnLoad&     preMultiplyOnLoad,
361     const bool&                         synchronousLoading = false);
362
363   /**
364    * @brief Requests an image load of the given URL, when the texture has
365    * have loaded, it will perform a blend with the image mask, and upload
366    * the blended texture.
367    *
368    * The parameters are used to specify how the image is loaded.
369    * The observer has the LoadComplete method called when the load is ready.
370    *
371    * When the client has finished with the Texture, Remove() should be called.
372    *
373    * @param[in] url                   The URL of the image to load
374    * @param[in] maskTextureId         The texture id of an image to mask this with
375    *                                  (can be INVALID if no masking required)
376    * @param[in] contentScale          The scale factor to apply to the image before masking
377    * @param[in] desiredSize           The size the image is likely to appear at. This can be set to 0,0 for automatic
378    * @param[in] fittingMode           The FittingMode to use
379    * @param[in] samplingMode          The SamplingMode to use
380    * @param[in] useAtlasing           Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still
381    *                                  be loaded, and marked successful,
382    *                                  but "useAtlasing" will be set to false in the "LoadCompleted" callback from
383    *                                  the TextureManagerUploadObserver.
384    * @param[in] cropToMask            Only used with masking, this will crop the scaled image to the mask size.
385    *                                  If false, then the mask will be scaled to fit the image before being applied.
386    * @param[in] observer              The client object should inherit from this and provide the "LoadCompleted"
387    *                                  virtual.
388    *                                  This is called when an image load completes (or fails).
389    * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
390    * @param[in] reloadPolicy          Forces a reload of the texture even if already cached
391    * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the
392    *                                  image has no alpha channel
393    * @param[in] synchronousLoading    True if the frame should be loaded synchronously. If you skip this parameter,
394    *                                  default is false.
395    * @return                          A TextureId to use as a handle to reference this Texture
396    */
397   TextureId RequestLoad(
398     const VisualUrl&                    url,
399     const TextureManager::TextureId&    maskTextureId,
400     const float&                        contentScale,
401     const ImageDimensions&              desiredSize,
402     const Dali::FittingMode::Type&      fittingMode,
403     const Dali::SamplingMode::Type&     samplingMode,
404     const TextureManager::UseAtlas&     useAtlasing,
405     const bool&                         cropToMask,
406     TextureUploadObserver*              observer,
407     const bool&                         orientationCorrection,
408     const TextureManager::ReloadPolicy& reloadPolicy,
409     TextureManager::MultiplyOnLoad&     preMultiplyOnLoad,
410     const bool&                         synchronousLoading = false);
411
412   /**
413    * @brief Requests a masking image to be loaded. This mask is not uploaded to GL,
414    * instead, it is stored in CPU memory, and can be used for CPU blending.
415    * @param[in] maskUrl            The URL of the mask image to load
416    * @param[in] synchronousLoading True if the frame should be loaded synchronously. If you skip this parameter,
417    *                               default is false.
418    * @return                       A TextureId to use as a handle to reference this mask Texture
419    */
420   TextureId RequestMaskLoad(
421     const VisualUrl& maskUrl,
422     const bool&      synchronousLoading = false);
423
424 private:
425   /**
426    * @brief Requests an image load of the given URL, when the texture has
427    * have loaded, if there is a valid maskTextureId, it will perform a
428    * CPU blend with the mask, and upload the blend texture.
429    *
430    * The parameters are used to specify how the image is loaded.
431    * The observer has the LoadComplete method called when the load is ready.
432    *
433    * When the client has finished with the Texture, Remove() should be called.
434    *
435    * @param[in] url                   The URL of the image to load
436    * @param[in] maskTextureId         The texture id of an image to use as a mask. If no mask is required, then set
437    *                                  to INVALID_TEXTURE_ID
438    * @param[in] contentScale          The scaling factor to apply to the content when masking
439    * @param[in] desiredSize           The size the image is likely to appear at. This can be set to 0,0 for automatic
440    * @param[in] fittingMode           The FittingMode to use
441    * @param[in] samplingMode          The SamplingMode to use
442    * @param[in] useAtlasing           Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be
443    *                                  loaded, and marked successful, but "useAtlasing" will be set to false in the
444    *                                  "LoadCompleted" callback from the TextureManagerUploadObserver.
445    * @param[in] cropToMask            Whether to crop the target after masking, or scale the mask to the image before
446    *                                  masking.
447    * @param[in] storageType,          Whether the pixel data is stored in the cache or uploaded to the GPU
448    * @param[in] observer              The client object should inherit from this and provide the "LoadCompleted"
449    *                                  virtual.
450    *                                  This is called when an image load completes (or fails).
451    * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
452    * @param[in] reloadPolicy          Forces a reload of the texture even if already cached
453    * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if
454    *                                  there is no alpha
455    * @param[in] animatedImageLoading  The AnimatedImageLoading to load animated image
456    * @param[in] frameIndex            The frame index of a frame to be loaded frame
457    * @param[in] synchronousLoading    True if the frame should be loaded synchronously. If you skip this parameter,
458    *                                  default is false.
459    * @param[in] useCache              True if the texture will be cached.
460    * @return                          A TextureId to use as a handle to reference this Texture
461    */
462   TextureId RequestLoadInternal(
463     const VisualUrl&                    url,
464     const TextureManager::TextureId&    maskTextureId,
465     const float&                        contentScale,
466     const Dali::ImageDimensions&        desiredSize,
467     const Dali::FittingMode::Type&      fittingMode,
468     const Dali::SamplingMode::Type&     samplingMode,
469     const TextureManager::UseAtlas&     useAtlas,
470     const bool&                         cropToMask,
471     const TextureManager::StorageType&  storageType,
472     TextureUploadObserver*              observer,
473     const bool&                         orientationCorrection,
474     const TextureManager::ReloadPolicy& reloadPolicy,
475     TextureManager::MultiplyOnLoad&     preMultiplyOnLoad,
476     Dali::AnimatedImageLoading          animatedImageLoading,
477     const std::uint32_t&                frameIndex,
478     const bool&                         synchronousLoading,
479     const bool&                         useCache);
480
481   /**
482    * @brief Load a new image synchronously.
483    * @param[in] url                   The URL of the image to load
484    * @param[in] desiredSize           The size the image is likely to appear at.
485    *                                  This can be set to 0,0 for automatic
486    * @param[in] fittingMode           The FittingMode to use
487    * @param[in] samplingMode          The SamplingMode to use
488    * @param[in] orientationCorrection Whether to use image metadata to rotate or flip the image,
489    *                                  e.g., from portrait to landscape
490    * @return PixelBuffer of loaded image.
491    */
492   Devel::PixelBuffer LoadImageSynchronously(
493     const VisualUrl&                url,
494     const Dali::ImageDimensions&    desiredSize,
495     const Dali::FittingMode::Type&  fittingMode,
496     const Dali::SamplingMode::Type& samplingMode,
497     const bool&                     orientationCorrection);
498
499 private:
500   // Load and queue
501
502   /**
503    * Structure to hold info about a texture load queued during NotifyObservers
504    */
505   struct LoadQueueElement
506   {
507     LoadQueueElement(TextureManager::TextureId textureId, TextureUploadObserver* observer)
508     : mTextureId(textureId),
509       mObserver(observer)
510     {
511     }
512
513     TextureManager::TextureId mTextureId; ///< The texture id of the requested load.
514     TextureUploadObserver*    mObserver;  ///< Observer of texture load.
515   };
516
517   /**
518    * @brief Initiate a load or queue load if NotifyObservers is invoking callbacks
519    * @param[in] textureInfo The TextureInfo struct associated with the Texture
520    * @param[in] observer The observer wishing to observe the texture upload
521    */
522   void LoadOrQueueTexture(TextureManager::TextureInfo& textureInfo, TextureUploadObserver* observer);
523
524   /**
525    * @brief Queue a texture load to be subsequently handled by ProcessQueuedTextures.
526    * @param[in] textureInfo The TextureInfo struct associated with the Texture
527    * @param[in] observer The observer wishing to observe the texture upload
528    */
529   void QueueLoadTexture(const TextureManager::TextureInfo& textureInfo, TextureUploadObserver* observer);
530
531   /**
532    * @brief Used internally to initiate a load.
533    * @param[in] textureInfo The TextureInfo struct associated with the Texture
534    * @param[in] observer The observer wishing to observe the texture upload
535    */
536   void LoadTexture(TextureManager::TextureInfo& textureInfo, TextureUploadObserver* observer);
537
538   /**
539    * @brief Initiate load of textures queued whilst NotifyObservers invoking callbacks.
540    */
541   void ProcessLoadQueue();
542
543   /**
544    * @brief Initiate remove of texture queued whilst NotifyObservers invoking callbacks.
545    */
546   void ProcessRemoveQueue();
547
548   /**
549    * Add the observer to the observer list
550    * @param[in] textureInfo The TextureInfo struct associated with the texture
551    * @param[in] observer The observer wishing to observe the texture upload
552    */
553   void ObserveTexture(TextureManager::TextureInfo& textureInfo, TextureUploadObserver* observer);
554
555   /**
556    * @brief Performs Post-Load steps including atlasing.
557    * @param[in] textureInfo The struct associated with this Texture
558    * @param[in] pixelBuffer The image pixelBuffer
559    * @return    True if successful
560    */
561   void PostLoad(TextureManager::TextureInfo& textureInfo, Devel::PixelBuffer& pixelBuffer);
562
563   /**
564    * Check if there is a texture waiting to be masked. If there
565    * is then apply this mask and upload it.
566    * @param[in] maskTextureInfo The texture info of the mask that has just loaded.
567    */
568   void CheckForWaitingTexture(TextureManager::TextureInfo& maskTextureInfo);
569
570   /**
571    * Apply the mask to the pixelBuffer.
572    * @param[in] textureInfo The information of texture to apply the mask to
573    * @param[in] maskTextureId The texture id of the mask.
574    */
575   void ApplyMask(TextureManager::TextureInfo& textureInfo, const TextureManager::TextureId& maskTextureId);
576
577   /**
578    * Upload the texture specified in pixelBuffer to the appropriate location
579    * @param[in] pixelBuffer The image data to upload
580    * @param[in] textureInfo The texture info containing the location to
581    * store the data to.
582    */
583   void UploadTexture(Devel::PixelBuffer& pixelBuffer, TextureManager::TextureInfo& textureInfo);
584
585   /**
586    * Notify the current observers that the texture upload is complete,
587    * then remove the observers from the list.
588    * @param[in] textureInfo The struct associated with this Texture
589    * @param[in] success If the pixel data was retrieved successfully and uploaded to GPU
590    */
591   void NotifyObservers(TextureManager::TextureInfo& textureInfo, const bool& success);
592
593   /**
594    * Call LoadComplete to the observer.
595    * @param[in] observer    The client object should inherit from this and provide the "LoadCompleted"
596    * @param[in] textureInfo The struct associated with this Texture
597    * @param[in] success     If the pixel data was retrieved successfully and uploaded to GPU
598    */
599   void EmitLoadComplete(TextureUploadObserver* observer, TextureManager::TextureInfo& textureInfo, const bool& success);
600
601 public:
602   /**
603    * @brief Common method to handle loading completion.
604    * TextureAsyncLoadingHelper will call this API After async loading finished.
605    * @param[in] textureId   The ID of the texture load complete.
606    * @param[in] pixelBuffer The loaded image data
607    */
608   void AsyncLoadComplete(const TextureManager::TextureId& textureId, Devel::PixelBuffer pixelBuffer);
609
610 private:
611   /**
612    * Deleted copy constructor.
613    */
614   TextureManager(const TextureManager&) = delete;
615
616   /**
617    * Deleted assignment operator.
618    */
619   TextureManager& operator=(const TextureManager& rhs) = delete;
620
621   /**
622    * This is called by the TextureManagerUploadObserver when an observer is destroyed.
623    * We use the callback to know when to remove an observer from our notify list.
624    * @param[in] observer The observer that generated the callback
625    */
626   void ObserverDestroyed(TextureUploadObserver* observer);
627
628 private:                                    // Member Variables:
629   TextureCacheManager mTextureCacheManager; ///< Manager the life-cycle and caching of Textures
630
631   RoundRobinContainerView<TextureAsyncLoadingHelper> mAsyncLocalLoaders;  ///< The Asynchronous image loaders used to provide all local async loads
632   RoundRobinContainerView<TextureAsyncLoadingHelper> mAsyncRemoteLoaders; ///< The Asynchronous image loaders used to provide all remote async loads
633
634   Dali::Vector<LifecycleObserver*>        mLifecycleObservers; ///< Lifecycle observers of texture manager
635   Dali::Vector<LoadQueueElement>          mLoadQueue;          ///< Queue of textures to load after NotifyObservers
636   Dali::Vector<TextureManager::TextureId> mRemoveQueue;        ///< Queue of textures to remove after NotifyObservers
637   bool                                    mQueueLoadFlag;      ///< Flag that causes Load Textures to be queued.
638 };
639
640 } // namespace Internal
641
642 } // namespace Toolkit
643
644 } // namespace Dali
645
646 #endif // DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H