Add video view control 91/63891/14
authortaeyoon <taeyoon0.lee@samsung.com>
Mon, 28 Mar 2016 09:28:50 +0000 (18:28 +0900)
committertaeyoon <taeyoon0.lee@samsung.com>
Wed, 15 Jun 2016 07:34:50 +0000 (16:34 +0900)
  Add VideoView class for video playback

Change-Id: I5ed6e35571b773e0a807c22d4a2cbf08763a9143

17 files changed:
automated-tests/src/dali-toolkit-styling/CMakeLists.txt
automated-tests/src/dali-toolkit/CMakeLists.txt
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp [new file with mode: 0644]
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-native-image-source.cpp [new file with mode: 0755]
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-tts-player.cpp
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-video-player.cpp [new file with mode: 0644]
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-video-player.h [new file with mode: 0644]
automated-tests/src/dali-toolkit/utc-Dali-VideoView.cpp [new file with mode: 0644]
build/tizen/dali-toolkit/Makefile.am
dali-toolkit/dali-toolkit.h
dali-toolkit/internal/controls/video-view/video-view-impl.cpp [new file with mode: 0644]
dali-toolkit/internal/controls/video-view/video-view-impl.h [new file with mode: 0644]
dali-toolkit/internal/file.list
dali-toolkit/public-api/controls/video-view/video-view.cpp [new file with mode: 0644]
dali-toolkit/public-api/controls/video-view/video-view.h [new file with mode: 0644]
dali-toolkit/public-api/file.list
doc/dali-toolkit-doc.h

index 92653f1fbae8edb1ab58a4e19c1e06bc84dedadb..d8d55f808ba73b9b8d960372c34aea157188c83b 100644 (file)
@@ -13,6 +13,7 @@ SET(TC_SOURCES
 # Append list of test harness files (Won't get parsed for test cases)
 LIST(APPEND TC_SOURCES
    ../dali-toolkit/dali-toolkit-test-utils/test-harness.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-application.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-bitmap-loader.cpp
@@ -23,6 +24,7 @@ LIST(APPEND TC_SOURCES
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-feedback-player.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-file-loader.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-imf-manager.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-native-image-source.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-orientation.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-physical-keyboard.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.cpp
@@ -32,6 +34,7 @@ LIST(APPEND TC_SOURCES
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-timer.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-tts-player.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-video-player.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-virtual-keyboard.cpp
    ../dali-toolkit/dali-toolkit-test-utils/dummy-control.cpp
    ../dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp
index 8a6003f287c8fa0fa2893049f50f6813009c7e13..77b2c967b38ea2958f239203d9a70678ca3a6040 100644 (file)
@@ -7,51 +7,52 @@ SET(CAPI_LIB "dali-toolkit")
 
 # List of test case sources (Only these get parsed for test cases)
 SET(TC_SOURCES
-   utc-Dali-Alignment.cpp
-   utc-Dali-BloomView.cpp
-   utc-Dali-BubbleEmitter.cpp
-   utc-Dali-Builder.cpp
-   utc-Dali-CheckBoxButton.cpp
-   utc-Dali-ConfirmationPopup.cpp
-   utc-Dali-CubeTransitionEffect.cpp
-   utc-Dali-EffectsView.cpp
-   utc-Dali-FlexContainer.cpp
-   utc-Dali-GaussianBlurView.cpp
-   utc-Dali-ImageView.cpp
-   utc-Dali-JsonParser.cpp
-   utc-Dali-KeyInputFocusManager.cpp
-   utc-Dali-PageTurnView.cpp
-   utc-Dali-Script.cpp
-   utc-Dali-ScrollBar.cpp
-   utc-Dali-ScrollView.cpp
-   utc-Dali-ShaderEffects.cpp
-   utc-Dali-ShadowView.cpp
-   utc-Dali-Slider.cpp
-   utc-Dali-TableView.cpp
-   utc-Dali-TextEditor.cpp
-   utc-Dali-TextField.cpp
-   utc-Dali-TextLabel.cpp
-   utc-Dali-TextSelectionPopup.cpp
-   utc-Dali-ToolBar.cpp
-   utc-Dali-Button.cpp
-   utc-Dali-Control.cpp
-   utc-Dali-ControlImpl.cpp
-   utc-Dali-AccessibilityManager.cpp
-   utc-Dali-ItemLayout.cpp
-   utc-Dali-ItemView.cpp
-   utc-Dali-KeyboardFocusManager.cpp
-   utc-Dali-Magnifier.cpp
-   utc-Dali-Popup.cpp
-   utc-Dali-PushButton.cpp
-   utc-Dali-RadioButton.cpp
-   utc-Dali-ScrollViewEffect.cpp
-   utc-Dali-SuperBlurView.cpp
-   utc-Dali-Toolkit.cpp
-   utc-Dali-Model3dView.cpp
-   utc-Dali-ControlRenderer.cpp
-   utc-Dali-RendererFactory.cpp
-   utc-Dali-DebugRenderer.cpp
-   utc-Dali-ImageAtlas.cpp
+#   utc-Dali-Alignment.cpp
+#   utc-Dali-BloomView.cpp
+#   utc-Dali-BubbleEmitter.cpp
+#   utc-Dali-Builder.cpp
+#   utc-Dali-CheckBoxButton.cpp
+#   utc-Dali-ConfirmationPopup.cpp
+#   utc-Dali-CubeTransitionEffect.cpp
+#   utc-Dali-EffectsView.cpp
+#   utc-Dali-FlexContainer.cpp
+#   utc-Dali-GaussianBlurView.cpp
+#   utc-Dali-ImageView.cpp
+#   utc-Dali-JsonParser.cpp
+#   utc-Dali-KeyInputFocusManager.cpp
+#   utc-Dali-PageTurnView.cpp
+#   utc-Dali-Script.cpp
+#   utc-Dali-ScrollBar.cpp
+#   utc-Dali-ScrollView.cpp
+#   utc-Dali-ShaderEffects.cpp
+#   utc-Dali-ShadowView.cpp
+#   utc-Dali-Slider.cpp
+#   utc-Dali-TableView.cpp
+#   utc-Dali-TextEditor.cpp
+#   utc-Dali-TextField.cpp
+#   utc-Dali-TextLabel.cpp
+#   utc-Dali-TextSelectionPopup.cpp
+#   utc-Dali-ToolBar.cpp
+#   utc-Dali-Button.cpp
+#   utc-Dali-Control.cpp
+#   utc-Dali-ControlImpl.cpp
+#   utc-Dali-AccessibilityManager.cpp
+#   utc-Dali-ItemLayout.cpp
+#   utc-Dali-ItemView.cpp
+#   utc-Dali-KeyboardFocusManager.cpp
+#   utc-Dali-Magnifier.cpp
+#   utc-Dali-Popup.cpp
+#   utc-Dali-PushButton.cpp
+#   utc-Dali-RadioButton.cpp
+#   utc-Dali-ScrollViewEffect.cpp
+#   utc-Dali-SuperBlurView.cpp
+#   utc-Dali-Toolkit.cpp
+#   utc-Dali-Model3dView.cpp
+#   utc-Dali-ControlRenderer.cpp
+#   utc-Dali-RendererFactory.cpp
+#   utc-Dali-DebugRenderer.cpp
+#   utc-Dali-ImageAtlas.cpp
+   utc-Dali-VideoView.cpp
 )
 
 # Append list of test harness files (Won't get parsed for test cases)
@@ -70,6 +71,8 @@ LIST(APPEND TC_SOURCES
    dali-toolkit-test-utils/toolkit-singleton-service.cpp
    dali-toolkit-test-utils/toolkit-timer.cpp
    dali-toolkit-test-utils/toolkit-tts-player.cpp
+   dali-toolkit-test-utils/toolkit-native-image-source.cpp
+   dali-toolkit-test-utils/toolkit-video-player.cpp
    dali-toolkit-test-utils/dali-test-suite-utils.cpp
    dali-toolkit-test-utils/dummy-control.cpp
    dali-toolkit-test-utils/mesh-builder.cpp
diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp
new file mode 100644 (file)
index 0000000..ebab526
--- /dev/null
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/integration-api/adaptors/adaptor.h>
+
+#include <dali/public-api/object/base-object.h>
+#include <dali/devel-api/adaptor-framework/render-surface.h>
+
+namespace Dali
+{
+
+class EglInterface;
+class DisplayConnection;
+class ThreadSynchronizationInterface;
+
+namespace Integration
+{
+
+class GlAbstraction;
+
+} // namespace Integration
+
+class TestRenderSurface : public RenderSurface
+{
+public:
+  virtual PositionSize GetPositionSize() const { PositionSize size; return size; }
+
+  virtual void InitializeEgl( EglInterface& egl ) {}
+
+  virtual void CreateEglSurface( EglInterface& egl ) {}
+
+  virtual void DestroyEglSurface( EglInterface& egl ) {}
+
+  virtual bool ReplaceEGLSurface( EglInterface& egl ) { return false; }
+
+  virtual void MoveResize( Dali::PositionSize positionSize ) {}
+
+  virtual void SetViewMode( ViewMode viewMode ) {}
+
+  virtual void StartRender() {}
+
+  virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction ) { return false; }
+
+  virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface ) {}
+
+  virtual void StopRender() {}
+
+  virtual void ReleaseLock() {}
+
+  virtual void SetThreadSynchronization( ThreadSynchronizationInterface& threadSynchronization ) {}
+
+};
+
+namespace Internal
+{
+namespace Adaptor
+{
+
+class Adaptor: public BaseObject
+{
+public:
+  static Dali::Adaptor& Get();
+  Adaptor();
+  ~Adaptor();
+
+public:
+  static Dali::RenderSurface& GetSurface();
+  static Dali::Adaptor::AdaptorSignalType& AdaptorSignal();
+};
+
+Dali::Adaptor& Adaptor::Get()
+{
+  Dali::Adaptor* adaptor = new Dali::Adaptor;
+  return *adaptor;
+}
+
+Dali::RenderSurface& Adaptor::GetSurface()
+{
+  Dali::RenderSurface *renderSurface = new Dali::TestRenderSurface;
+  return *renderSurface;
+}
+
+Dali::Adaptor::AdaptorSignalType& Adaptor::AdaptorSignal()
+{
+  Dali::Adaptor::AdaptorSignalType* signal = new Dali::Adaptor::AdaptorSignalType;
+  return *signal;
+}
+
+}
+}
+}
+
+namespace Dali
+{
+
+Adaptor& Adaptor::New( Window window )
+{
+  return Internal::Adaptor::Adaptor::Get();
+}
+
+Adaptor& Adaptor::New( Window window, Configuration::ContextLoss configuration )
+{
+  return Internal::Adaptor::Adaptor::Get();
+}
+
+Adaptor& Adaptor::New( Any nativeWindow, const Dali::RenderSurface& surface )
+{
+  return Internal::Adaptor::Adaptor::Get();
+}
+
+Adaptor& Adaptor::New( Any nativeWindow, const Dali::RenderSurface& surface, Configuration::ContextLoss configuration )
+{
+  return Internal::Adaptor::Adaptor::Get();
+}
+
+Adaptor::~Adaptor()
+{
+}
+
+void Adaptor::Start()
+{
+}
+
+void Adaptor::Pause()
+{
+}
+
+void Adaptor::Resume()
+{
+}
+
+void Adaptor::Stop()
+{
+}
+
+bool Adaptor::AddIdle( CallbackBase* callback )
+{
+  return false;
+}
+
+void Adaptor::ReplaceSurface( Any nativeWindow, Dali::RenderSurface& surface )
+{
+}
+
+Adaptor::AdaptorSignalType& Adaptor::ResizedSignal()
+{
+  return Internal::Adaptor::Adaptor::AdaptorSignal();
+}
+
+Adaptor::AdaptorSignalType& Adaptor::LanguageChangedSignal()
+{
+  return Internal::Adaptor::Adaptor::AdaptorSignal();
+}
+
+RenderSurface& Adaptor::GetSurface()
+{
+  return Internal::Adaptor::Adaptor::GetSurface();
+}
+
+Any Adaptor::GetNativeWindowHandle()
+{
+  Any window;
+  return window;
+}
+
+void Adaptor::ReleaseSurfaceLock()
+{
+}
+
+void Adaptor::SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender )
+{
+}
+
+void Adaptor::SetUseHardwareVSync(bool useHardware)
+{
+}
+
+Adaptor& Adaptor::Get()
+{
+  return Internal::Adaptor::Adaptor::Get();
+}
+
+bool Adaptor::IsAvailable()
+{
+  return false;
+}
+
+void Adaptor::NotifySceneCreated()
+{
+}
+
+void Adaptor::NotifyLanguageChanged()
+{
+}
+
+void Adaptor::SetMinimumPinchDistance(float distance)
+{
+}
+
+void Adaptor::FeedTouchPoint( TouchPoint& point, int timeStamp )
+{
+}
+
+void Adaptor::FeedWheelEvent( WheelEvent& wheelEvent )
+{
+}
+
+void Adaptor::FeedKeyEvent( KeyEvent& keyEvent )
+{
+}
+
+void Adaptor::SceneCreated()
+{
+}
+
+void Adaptor::SetViewMode( ViewMode mode )
+{
+}
+
+void Adaptor::SetStereoBase(  float stereoBase )
+{
+}
+
+Adaptor::Adaptor()
+: mImpl( NULL )
+{
+}
+
+} // namespace Dali
diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-native-image-source.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-native-image-source.cpp
new file mode 100755 (executable)
index 0000000..2277014
--- /dev/null
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/public-api/adaptor-framework/native-image-source.h>
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/any.h>
+
+namespace Dali
+{
+
+NativeImageSourcePtr NativeImageSource::New( unsigned int width, unsigned int height, ColorDepth depth )
+{
+  Any empty;
+  NativeImageSourcePtr image = new NativeImageSource( width, height, depth, empty );
+  return image;
+}
+
+Any NativeImageSource::GetNativeImageSource()
+{
+  Any source;
+  return source;
+}
+
+NativeImageSourcePtr NativeImageSource::New( Any nativeImageSource )
+{
+  NativeImageSourcePtr image = new NativeImageSource(0, 0, COLOR_DEPTH_DEFAULT, nativeImageSource);
+  return image;
+}
+
+bool NativeImageSource::GetPixels( std::vector<unsigned char> &pixbuf, unsigned int &width, unsigned int &height, Pixel::Format& pixelFormat ) const
+{
+  return false;
+}
+
+bool NativeImageSource::EncodeToFile(const std::string& filename) const
+{
+  return false;
+}
+
+void NativeImageSource::SetSource( Any source )
+{
+}
+
+bool NativeImageSource::IsColorDepthSupported( ColorDepth colorDepth )
+{
+  return false;
+}
+
+bool NativeImageSource::GlExtensionCreate()
+{
+  return false;
+}
+
+void NativeImageSource::GlExtensionDestroy()
+{
+}
+
+unsigned int NativeImageSource::TargetTexture()
+{
+  return 0;
+}
+
+void NativeImageSource::PrepareTexture()
+{
+}
+
+unsigned int NativeImageSource::GetWidth() const
+{
+  return 0;
+}
+
+unsigned int NativeImageSource::GetHeight() const
+{
+  return 0;
+}
+
+bool NativeImageSource::RequiresBlending() const
+{
+  return false;
+}
+
+NativeImageInterface::Extension* NativeImageSource::GetExtension()
+{
+  return NULL;
+}
+
+NativeImageSource::NativeImageSource( unsigned int width, unsigned int height, ColorDepth depth, Any nativeImageSource )
+{
+}
+
+NativeImageSource::~NativeImageSource()
+{
+}
+
+} // namespace Dali
index abd5f1c019c94e7cd45c81d0a6bd33cb6e50c37e..6da3d4741bf53523abfd741ff61e7ec1619491c4 100644 (file)
@@ -80,5 +80,4 @@ TtsPlayer::StateChangedSignalType& TtsPlayer::StateChangedSignal()
   return mStateChangedSignal; // GetImplementation(*this).StateChangedSignal();
 }
 
-
 } // namespace Dali
diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-video-player.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-video-player.cpp
new file mode 100644 (file)
index 0000000..05e66d8
--- /dev/null
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "toolkit-video-player.h"
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/any.h>
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+namespace Adaptor
+{
+
+class VideoPlayer: public Dali::BaseObject
+{
+public:
+
+  VideoPlayer()
+  {
+    mMuted = false;
+    mLooping = false;
+  }
+
+  void SetMuted( bool muted )
+  {
+    mMuted = muted;
+  }
+
+  bool IsMuted()
+  {
+    return mMuted;
+  }
+
+  void SetLooping( bool looping )
+  {
+    mLooping = looping;
+  }
+
+  bool IsLooping()
+  {
+    return mLooping;
+  }
+
+public:
+
+  std::string mUrl;
+  float mVolumeLeft;
+  float mVolumeRight;
+  Dali::VideoPlayerPlugin::VideoPlayerSignalType mFinishedSignal;
+
+private:
+
+  bool mMuted;
+  bool mLooping;
+};
+
+inline VideoPlayer& GetImplementation( Dali::VideoPlayer& player )
+{
+  DALI_ASSERT_ALWAYS(player && "VideoPlayer handle is empty");
+  BaseObject& handle = player.GetBaseObject();
+  return static_cast< Internal::Adaptor::VideoPlayer& >( handle );
+}
+
+inline const VideoPlayer& GetImplementation( const Dali::VideoPlayer& player )
+{
+  DALI_ASSERT_ALWAYS(player && "VideoPlayer handle is empty");
+  const BaseObject& handle = player.GetBaseObject();
+  return static_cast< const Internal::Adaptor::VideoPlayer& >( handle );
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+
+/********************************************************************************/
+/*********************************  PUBLIC CLASS  *******************************/
+/********************************************************************************/
+
+VideoPlayer::VideoPlayer()
+{
+}
+
+VideoPlayer::VideoPlayer( Internal::Adaptor::VideoPlayer* internal )
+: BaseHandle( internal )
+{
+}
+
+VideoPlayer::~VideoPlayer()
+{
+}
+
+VideoPlayer VideoPlayer::New()
+{
+  Internal::Adaptor::VideoPlayer* player = new Internal::Adaptor::VideoPlayer();
+
+  return VideoPlayer( player );
+}
+
+VideoPlayer::VideoPlayer( const VideoPlayer& player )
+: BaseHandle( player )
+{
+}
+
+VideoPlayer& VideoPlayer::operator=( const VideoPlayer& player )
+{
+  BaseHandle::operator=( player );
+  return *this;
+}
+
+VideoPlayer VideoPlayer::DownCast( BaseHandle handle )
+{
+  VideoPlayer videoPlayer;
+  return videoPlayer;
+}
+
+void VideoPlayer::SetUrl( const std::string& url )
+{
+  Internal::Adaptor::GetImplementation( *this ).mUrl = url;
+}
+
+std::string VideoPlayer::GetUrl()
+{
+  return Internal::Adaptor::GetImplementation( *this ).mUrl;
+}
+
+void VideoPlayer::SetLooping(bool looping)
+{
+  Internal::Adaptor::GetImplementation( *this ).SetLooping( looping );
+}
+
+bool VideoPlayer::IsLooping()
+{
+  return Internal::Adaptor::GetImplementation( *this ).IsLooping();
+}
+
+void VideoPlayer::Play()
+{
+}
+
+void VideoPlayer::Pause()
+{
+}
+
+void VideoPlayer::Stop()
+{
+}
+
+void VideoPlayer::SetMute( bool mute )
+{
+  Internal::Adaptor::GetImplementation( *this ).SetMuted( mute );
+}
+
+bool VideoPlayer::IsMuted()
+{
+  return Internal::Adaptor::GetImplementation( *this ).IsMuted();
+}
+
+void VideoPlayer::SetVolume( float left, float right )
+{
+  Internal::Adaptor::GetImplementation( *this ).mVolumeLeft = left;
+  Internal::Adaptor::GetImplementation( *this ).mVolumeRight = right;
+}
+
+void VideoPlayer::GetVolume( float& left, float& right )
+{
+  left = Internal::Adaptor::GetImplementation( *this ).mVolumeLeft;
+  right = Internal::Adaptor::GetImplementation( *this ).mVolumeRight;
+}
+
+void VideoPlayer::SetRenderingTarget( Any target )
+{
+}
+
+void VideoPlayer::SetPlayPosition( int millisecond )
+{
+}
+
+int VideoPlayer::GetPlayPosition()
+{
+  return 0;
+}
+
+void VideoPlayer::SetDisplayRotation( Dali::VideoPlayerPlugin::DisplayRotation rotation )
+{
+}
+
+Dali::VideoPlayerPlugin::DisplayRotation VideoPlayer::GetDisplayRotation()
+{
+  return Dali::VideoPlayerPlugin::ROTATION_NONE;
+}
+
+Dali::VideoPlayerPlugin::VideoPlayerSignalType& VideoPlayer::FinishedSignal()
+{
+  return Internal::Adaptor::GetImplementation( *this ).mFinishedSignal;
+}
+
+} // namespace Dali;
+
diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-video-player.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-video-player.h
new file mode 100644 (file)
index 0000000..f33a68c
--- /dev/null
@@ -0,0 +1,105 @@
+#ifndef __DALI_TOOLKIT_VIDEO_PLAYER_H__
+#define __DALI_TOOLKIT_VIDEO_PLAYER_H__
+
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/base-handle.h>
+#include <dali/public-api/object/base-object.h>
+
+#include <dali/devel-api/adaptor-framework/video-player-plugin.h>
+
+namespace Dali
+{
+
+class Any;
+
+namespace Internal
+{
+namespace Adaptor
+{
+
+class VideoPlayer;
+
+}
+}
+
+/**
+ * @brief VideoPlayer class is used for video playback.
+ * @SINCE_1_1.38
+ */
+class VideoPlayer: public BaseHandle
+{
+public:
+
+  VideoPlayer();
+
+  virtual ~VideoPlayer();
+
+  static VideoPlayer New();
+
+  VideoPlayer( const VideoPlayer& player );
+
+  VideoPlayer& operator=( const VideoPlayer& player );
+
+  static VideoPlayer DownCast( BaseHandle handle );
+
+  void SetUrl( const std::string& url );
+
+  std::string GetUrl();
+
+  void SetLooping(bool looping);
+
+  bool IsLooping();
+
+  void Play();
+
+  void Pause();
+
+  void Stop();
+
+  void SetMute( bool mute );
+
+  bool IsMuted();
+
+  void SetVolume( float left, float right );
+
+  void GetVolume( float& left, float& right );
+
+  void SetRenderingTarget( Any target );
+
+  void SetPlayPosition( int millisecond );
+
+  int GetPlayPosition();
+
+  void SetDisplayRotation( Dali::VideoPlayerPlugin::DisplayRotation rotation );
+
+  Dali::VideoPlayerPlugin::DisplayRotation GetDisplayRotation();
+
+  Dali::VideoPlayerPlugin::VideoPlayerSignalType& FinishedSignal();
+
+private:
+
+  VideoPlayer( Internal::Adaptor::VideoPlayer* internal );
+
+};
+
+} // namespace Dali;
+
+#endif
+
diff --git a/automated-tests/src/dali-toolkit/utc-Dali-VideoView.cpp b/automated-tests/src/dali-toolkit/utc-Dali-VideoView.cpp
new file mode 100644 (file)
index 0000000..b64b500
--- /dev/null
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <stdlib.h>
+#include <dali-toolkit-test-suite-utils.h>
+#include <dali-toolkit/dali-toolkit.h>
+#include <dali-toolkit/public-api/controls/video-view/video-view.h>
+
+using namespace Dali;
+using namespace Dali::Toolkit;
+
+namespace
+{
+const char* const TEST_FILE( "test.mp4" );
+const char* const VOLUME_LEFT( "volumeLeft" );
+const char* const VOLUME_RIGHT( "volumeRight" );
+
+}
+
+void video_view_startup(void)
+{
+  test_return_value = TET_UNDEF;
+}
+
+void video_view_cleanup(void)
+{
+  test_return_value = TET_PASS;
+}
+
+// Negative test case for a method
+int UtcDaliVideoViewUninitialized(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline(" UtcDaliVideoViewUninitialized");
+
+  Toolkit::VideoView view;
+
+  try
+  {
+    // New() must be called to create a VideoView or it wont be valid.
+    Actor a = Actor::New();
+    view.Add( a );
+    DALI_TEST_CHECK( false );
+  }
+  catch (Dali::DaliException& e)
+  {
+    // Tests that a negative test of an assertion succeeds
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_CHECK(!view);
+  }
+  END_TEST;
+}
+
+// Positive test case for a method
+int UtcDaliVideoViewNew(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline(" UtcDaliVideoViewNew");
+
+  Toolkit::VideoView view = Toolkit::VideoView::New();
+  DALI_TEST_CHECK( view );
+
+  Toolkit::VideoView view2 = Toolkit::VideoView::New( "" );
+  DALI_TEST_CHECK( view2 );
+  END_TEST;
+}
+
+// Positive test case for a method
+int UtcDaliVideoViewDownCast(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline(" UtcDaliVideoViewDownCast");
+
+  Toolkit::VideoView view = Toolkit::VideoView::New();
+  BaseHandle handle(view);
+
+  Toolkit::VideoView view2 = Toolkit::VideoView::DownCast( handle );
+  DALI_TEST_CHECK( view );
+  DALI_TEST_CHECK( view2 );
+  DALI_TEST_CHECK( view == view2 );
+  END_TEST;
+}
+
+// Positive test case for a method
+int UtcDaliVideoViewProperty1(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline(" UtcDaliVideoViewProperty1");
+
+  Toolkit::VideoView view = Toolkit::VideoView::New();
+  DALI_TEST_CHECK( view );
+
+  std::string file;
+  view.SetProperty( VideoView::Property::VIDEO, TEST_FILE );
+  Property::Value val = view.GetProperty( VideoView::Property::VIDEO );
+  DALI_TEST_CHECK( val.Get( file ) );
+  DALI_TEST_CHECK( file == TEST_FILE );
+  END_TEST;
+}
+
+int UtcDaliVideoViewProperty2(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline(" UtcDaliVideoViewProperty2");
+
+  Toolkit::VideoView view = Toolkit::VideoView::New();
+  DALI_TEST_CHECK( view );
+
+  bool looping;
+  Property::Value val = view.GetProperty( VideoView::Property::LOOPING );
+  DALI_TEST_CHECK( val.Get( looping ) );
+  DALI_TEST_CHECK( !looping );
+
+  view.SetProperty( VideoView::Property::LOOPING, true );
+  val = view.GetProperty( VideoView::Property::LOOPING );
+  DALI_TEST_CHECK( val.Get( looping ) );
+  DALI_TEST_CHECK( looping );
+  END_TEST;
+}
+
+int UtcDaliVideoViewProperty3(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline(" UtcDaliVideoViewProperty3");
+
+  Toolkit::VideoView view = Toolkit::VideoView::New();
+  DALI_TEST_CHECK( view );
+
+  bool muted;
+  Property::Value val = view.GetProperty( VideoView::Property::MUTED );
+  DALI_TEST_CHECK( val.Get( muted ) );
+  DALI_TEST_CHECK( !muted );
+
+  view.SetProperty( VideoView::Property::MUTED, true );
+  val = view.GetProperty( VideoView::Property::MUTED );
+  DALI_TEST_CHECK( val.Get( muted ) );
+  DALI_TEST_CHECK( muted );
+  END_TEST;
+}
+
+int UtcDaliVideoViewProperty4(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline(" UtcDaliVideoViewProperty4");
+
+  Toolkit::VideoView view = Toolkit::VideoView::New();
+  DALI_TEST_CHECK( view );
+
+  float left, right;
+  left = right = 0.f;
+
+  Property::Map map;
+  map.Insert( VOLUME_LEFT, 1.0f );
+  map.Insert( VOLUME_RIGHT, 0.5f );
+
+  Property::Map map2;
+  view.SetProperty( VideoView::Property::VOLUME, map );
+  Property::Value val4 = view.GetProperty( VideoView::Property::VOLUME );
+  DALI_TEST_CHECK( val4.Get( map2 ) );
+
+  Property::Value* volumeLeft = map.Find( VOLUME_LEFT );
+  Property::Value* volumeRight = map.Find( VOLUME_RIGHT );
+
+  DALI_TEST_CHECK( volumeLeft && volumeLeft->Get( left ) );
+  DALI_TEST_CHECK( volumeRight && volumeRight->Get( right ) );
+  DALI_TEST_CHECK( left == 1.0f );
+  DALI_TEST_CHECK( right == 0.5f );
+
+  END_TEST;
+}
+
+int UtcDaliVideoViewCopyAndAssignment(void)
+{
+  ToolkitTestApplication application;
+
+  VideoView view = Toolkit::VideoView::New();
+  DALI_TEST_CHECK( view );
+
+  VideoView copy( view );
+  DALI_TEST_CHECK( view == copy );
+
+  VideoView assign;
+  DALI_TEST_CHECK( !assign );
+
+  assign = copy;
+  DALI_TEST_CHECK( assign == view );
+
+  END_TEST;
+}
+
+int UtcDaliVideoViewTypeRegistry(void)
+{
+  ToolkitTestApplication application;
+
+  TypeRegistry typeRegistry = TypeRegistry::Get();
+  DALI_TEST_CHECK( typeRegistry );
+
+  TypeInfo typeInfo = typeRegistry.GetTypeInfo( "VideoView" );
+  DALI_TEST_CHECK( typeInfo );
+
+  BaseHandle handle = typeInfo.CreateInstance();
+  DALI_TEST_CHECK( handle );
+
+  VideoView view = VideoView::DownCast( handle );
+  DALI_TEST_CHECK( view );
+
+  END_TEST;
+}
index 75aa867ac20b2335ae8aa7c20b45f4d2fd710eba..469c9aea1dd0a864914e290857fcb12dff9884a4 100644 (file)
@@ -142,6 +142,7 @@ publicapidefaultcontrolsdir =      $(publicapicontrolsdir)/default-controls
 publicapiflexcontainerdir =        $(publicapicontrolsdir)/flex-container
 publicapigaussianblurviewdir =     $(publicapicontrolsdir)/gaussian-blur-view
 publicapiimageviewdir =            $(publicapicontrolsdir)/image-view
+publicapivideoviewdir =            $(publicapicontrolsdir)/video-view
 publicapimodel3dviewdir =          $(publicapicontrolsdir)/model3d-view
 publicapipageturnviewdir =         $(publicapicontrolsdir)/page-turn-view
 publicapiscrollbardir =            $(publicapicontrolsdir)/scroll-bar
@@ -164,6 +165,7 @@ publicapidefaultcontrols_HEADERS =      $(public_api_default_controls_header_fil
 publicapiflexcontainer_HEADERS =        $(public_api_flex_container_header_files)
 publicapigaussianblurview_HEADERS =     $(public_api_gaussian_blur_view_header_files)
 publicapiimageview_HEADERS =            $(public_api_image_view_header_files)
+publicapivideoview_HEADERS =            $(public_api_video_view_header_files)
 publicapiitemview_HEADERS =             $(public_api_item_view_header_files)
 publicapimodel3dview_HEADERS =          $(public_api_model3d_view_header_files)
 publicapipageturnview_HEADERS =         $(public_api_page_turn_view_header_files)
index 1883e2f860eea583edb5667ee498bf3a7232e1b9..b46a97fceba60a90c5c2abd26c684906f886d27c 100644 (file)
@@ -51,6 +51,7 @@
 #include <dali-toolkit/public-api/controls/text-controls/text-editor.h>
 #include <dali-toolkit/public-api/controls/text-controls/text-field.h>
 #include <dali-toolkit/public-api/controls/text-controls/text-label.h>
+#include <dali-toolkit/public-api/controls/video-view/video-view.h>
 #include <dali-toolkit/public-api/accessibility-manager/accessibility-manager.h>
 #include <dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h>
 #include <dali-toolkit/public-api/styling/style-manager.h>
diff --git a/dali-toolkit/internal/controls/video-view/video-view-impl.cpp b/dali-toolkit/internal/controls/video-view/video-view-impl.cpp
new file mode 100644 (file)
index 0000000..28cb38a
--- /dev/null
@@ -0,0 +1,560 @@
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "video-view-impl.h"
+
+// EXTERNAL INCLUDES
+#include <cstring>
+#include <dali/public-api/object/type-registry.h>
+#include <dali/public-api/object/type-registry-helper.h>
+#include <dali/public-api/common/stage.h>
+#include <dali/devel-api/scripting/scripting.h>
+#include <dali/public-api/adaptor-framework/native-image-source.h>
+#include <dali/integration-api/adaptors/adaptor.h>
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/video-view/video-view.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace Internal
+{
+
+namespace
+{
+
+BaseHandle Create()
+{
+  return Toolkit::VideoView::New();
+}
+
+DALI_TYPE_REGISTRATION_BEGIN( Toolkit::VideoView, Toolkit::Control, Create );
+
+DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "video", MAP, VIDEO )
+DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "looping", BOOLEAN, LOOPING )
+DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "muted", BOOLEAN, MUTED )
+DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "volume", MAP, VOLUME )
+
+DALI_SIGNAL_REGISTRATION( Toolkit, VideoView, "finished", FINISHED_SIGNAL )
+
+DALI_ACTION_REGISTRATION( Toolkit, VideoView, "play", ACTION_VIDEOVIEW_PLAY )
+DALI_ACTION_REGISTRATION( Toolkit, VideoView, "pause", ACTION_VIDEOVIEW_PAUSE )
+DALI_ACTION_REGISTRATION( Toolkit, VideoView, "stop", ACTION_VIDEOVIEW_STOP )
+DALI_ACTION_REGISTRATION( Toolkit, VideoView, "forward", ACTION_VIDEOVIEW_FORWARD )
+DALI_ACTION_REGISTRATION( Toolkit, VideoView, "backward", ACTION_VIDEOVIEW_BACKWARD )
+
+DALI_TYPE_REGISTRATION_END()
+
+const char* const VOLUME_LEFT( "volumeLeft" );
+const char* const VOLUME_RIGHT( "volumeRight" );
+const char* const RENDERING_TARGET( "RENDERING_TARGET" );
+const char* const WINDOW_SURFACE_TARGET( "windowSurfaceTarget" );
+const char* const NATIVE_IMAGE_TARGET( "nativeImageTarget" );
+
+} // anonymous namepsace
+
+VideoView::VideoView()
+: Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
+  mCurrentVideoPlayPosition( 0 ),
+  mSetRenderingTarget( false ),
+  mIsPlay( false ),
+  mIsPause( false )
+{
+  mVideoPlayer = Dali::VideoPlayer::New();
+}
+
+VideoView::~VideoView()
+{
+}
+
+Toolkit::VideoView VideoView::New()
+{
+  VideoView* impl = new VideoView();
+  Toolkit::VideoView handle = Toolkit::VideoView( *impl );
+
+  impl->Initialize();
+
+  return handle;
+}
+
+void VideoView::SetUrl( const std::string& url )
+{
+  if( mUrl != url || !mPropertyMap.Empty() )
+  {
+    mPropertyMap.Clear();
+
+    mUrl = url;
+  }
+
+  if( mSetRenderingTarget )
+  {
+    mVideoPlayer.SetUrl( mUrl );
+  }
+  else
+  {
+    SetNativeImageTarget();
+  }
+}
+
+void VideoView::SetPropertyMap( Property::Map map )
+{
+  mPropertyMap = map;
+
+  Actor self = Self();
+  Toolkit::RendererFactory::Get().ResetRenderer( mRenderer, self, mPropertyMap );
+
+  Property::Value* widthValue = mPropertyMap.Find( "width" );
+  if( widthValue )
+  {
+    int width;
+    if( widthValue->Get( width ) )
+    {
+      mVideoSize = ImageDimensions( width, mVideoSize.GetHeight() );
+    }
+  }
+
+  Property::Value* heightValue = mPropertyMap.Find( "height" );
+  if( heightValue )
+  {
+    int height;
+    if( heightValue->Get( height ) )
+    {
+      mVideoSize = ImageDimensions( mVideoSize.GetWidth(), height );
+    }
+  }
+
+  RelayoutRequest();
+}
+
+std::string VideoView::GetUrl()
+{
+  return mUrl;
+}
+
+void VideoView::SetLooping(bool looping)
+{
+  mVideoPlayer.SetLooping( looping );
+}
+
+bool VideoView::IsLooping()
+{
+  return mVideoPlayer.IsLooping();
+}
+
+void VideoView::Play()
+{
+  mVideoPlayer.Play();
+  mIsPlay = true;
+  mIsPause = false;
+}
+
+void VideoView::Pause()
+{
+  mVideoPlayer.Pause();
+  mIsPlay = false;
+  mIsPause = true;
+}
+
+void VideoView::Stop()
+{
+  mVideoPlayer.Stop();
+  mIsPlay = false;
+  mIsPause = false;
+}
+
+void VideoView::Forward( int millisecond )
+{
+  int curPos = mVideoPlayer.GetPlayPosition();
+
+  int nextPos = curPos + millisecond;
+
+  mVideoPlayer.SetPlayPosition( nextPos );
+}
+
+void VideoView::Backward( int millisecond )
+{
+  int curPos = mVideoPlayer.GetPlayPosition();
+
+  int nextPos = curPos - millisecond;
+  nextPos = ( nextPos < 0 )? 0: nextPos;
+
+  mVideoPlayer.SetPlayPosition( nextPos );
+}
+
+void VideoView::SetMute( bool mute )
+{
+  mVideoPlayer.SetMute( mute );
+}
+
+bool VideoView::IsMuted()
+{
+  return mVideoPlayer.IsMuted();
+}
+
+void VideoView::SetVolume( float left, float right )
+{
+  mVideoPlayer.SetVolume( left, right );
+}
+
+void VideoView::GetVolume( float& left, float& right )
+{
+  mVideoPlayer.GetVolume( left, right );
+}
+
+Dali::Toolkit::VideoView::VideoViewSignalType& VideoView::FinishedSignal()
+{
+  return mFinishedSignal;
+}
+
+void VideoView::EmitSignalFinish()
+{
+  if ( !mFinishedSignal.Empty() )
+  {
+    Dali::Toolkit::VideoView handle( GetOwner() );
+    mFinishedSignal.Emit( handle );
+  }
+}
+
+bool VideoView::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& attributes )
+{
+  bool ret = false;
+
+  Dali::BaseHandle handle( object );
+  Toolkit::VideoView videoView = Toolkit::VideoView::DownCast( handle );
+
+  if( !videoView )
+  {
+    return ret;
+  }
+
+  VideoView& impl = GetImpl( videoView );
+
+  if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_PLAY ) == 0 )
+  {
+    impl.Play();
+    ret = true;
+  }
+  else if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_PAUSE ) == 0 )
+  {
+    impl.Pause();
+    ret = true;
+  }
+  else if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_STOP ) == 0 )
+  {
+    impl.Stop();
+    ret = true;
+  }
+  else if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_FORWARD ) == 0 )
+  {
+    int millisecond = 0;
+    if( attributes["videoForward"].Get( millisecond ) )
+    {
+      impl.Forward( millisecond );
+      ret = true;
+    }
+  }
+  else if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_BACKWARD ) == 0 )
+  {
+    int millisecond = 0;
+    if( attributes["videoBackward"].Get( millisecond ) )
+    {
+      impl.Backward( millisecond );
+      ret = true;
+    }
+  }
+
+  return ret;
+}
+
+bool VideoView::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
+{
+  Dali::BaseHandle handle( object );
+
+  bool connected( true );
+  Toolkit::VideoView videoView = Toolkit::VideoView::DownCast( handle );
+
+  if( 0 == strcmp( signalName.c_str(), FINISHED_SIGNAL ) )
+  {
+    videoView.FinishedSignal().Connect( tracker, functor );
+  }
+  else
+  {
+    // signalName does not match any signal
+    connected = false;
+  }
+
+  return connected;
+}
+
+void VideoView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
+{
+  Toolkit::VideoView videoView = Toolkit::VideoView::DownCast( Dali::BaseHandle( object ) );
+
+  if( videoView )
+  {
+    VideoView& impl = GetImpl( videoView );
+
+    switch( index )
+    {
+      case Toolkit::VideoView::Property::VIDEO:
+      {
+        std::string videoUrl;
+        if( value.Get( videoUrl ) )
+        {
+          impl.SetUrl( videoUrl );
+        }
+
+        Property::Map map;
+        if( value.Get( map ) )
+        {
+          impl.SetPropertyMap( map );
+
+          Property::Value* target = map.Find( RENDERING_TARGET );
+          std::string targetType;
+          if( target && target->Get( targetType ) && targetType == WINDOW_SURFACE_TARGET )
+          {
+            impl.SetWindowSurfaceTarget();
+          }
+          else if( target && target->Get( targetType ) && targetType == NATIVE_IMAGE_TARGET )
+          {
+            impl.SetNativeImageTarget();
+          }
+        }
+        break;
+      }
+      case Toolkit::VideoView::Property::LOOPING:
+      {
+        bool looping;
+        if( value.Get( looping ) )
+        {
+          impl.SetLooping( looping );
+        }
+        break;
+      }
+      case Toolkit::VideoView::Property::MUTED:
+      {
+        bool mute;
+        if( value.Get( mute ) )
+        {
+          impl.SetMute( mute );
+        }
+        break;
+      }
+      case Toolkit::VideoView::Property::VOLUME:
+      {
+        Property::Map map;
+        float left, right;
+        if( value.Get( map ) )
+        {
+          Property::Value* volumeLeft = map.Find( VOLUME_LEFT );
+          Property::Value* volumeRight = map.Find( VOLUME_RIGHT );
+          if( volumeLeft && volumeLeft->Get( left ) && volumeRight && volumeRight->Get( right ) )
+          {
+            impl.SetVolume( left, right );
+          }
+        }
+        break;
+      }
+    }
+  }
+}
+
+Property::Value VideoView::GetProperty( BaseObject* object, Property::Index propertyIndex )
+{
+  Property::Value value;
+  Toolkit::VideoView videoView = Toolkit::VideoView::DownCast( Dali::BaseHandle( object ) );
+
+  if( videoView )
+  {
+    VideoView& impl = GetImpl( videoView );
+
+    switch( propertyIndex )
+    {
+      case Toolkit::VideoView::Property::VIDEO:
+      {
+        if( !impl.mUrl.empty() )
+        {
+          value = impl.mUrl;
+        }
+        else if( !impl.mPropertyMap.Empty() )
+        {
+          value = impl.mPropertyMap;
+        }
+        break;
+      }
+      case Toolkit::VideoView::Property::LOOPING:
+      {
+        value = impl.IsLooping();
+        break;
+      }
+      case Toolkit::VideoView::Property::MUTED:
+      {
+        value = impl.IsMuted();
+        break;
+      }
+      case Toolkit::VideoView::Property::VOLUME:
+      {
+        Property::Map map;
+        float left, right;
+
+        impl.GetVolume( left, right );
+        map.Insert( VOLUME_LEFT, left );
+        map.Insert( VOLUME_RIGHT, right );
+        value = map;
+        break;
+      }
+    }
+  }
+
+  return value;
+}
+
+void VideoView::SetDepthIndex( int depthIndex )
+{
+  if( mRenderer )
+  {
+    mRenderer.SetDepthIndex( depthIndex );
+  }
+}
+
+void VideoView::OnStageConnection( int depth )
+{
+  Control::OnStageConnection( depth );
+
+  if( mRenderer )
+  {
+    CustomActor self = Self();
+    mRenderer.SetOnStage( self );
+  }
+}
+
+void VideoView::OnStageDisconnection()
+{
+  if( mRenderer )
+  {
+    CustomActor self = Self();
+    mRenderer.SetOffStage( self );
+  }
+
+  Control::OnStageDisconnection();
+}
+
+Vector3 VideoView::GetNaturalSize()
+{
+  Vector3 size;
+  size.x = mVideoSize.GetWidth();
+  size.y = mVideoSize.GetHeight();
+
+  if( size.x > 0 && size.y > 0 )
+  {
+    size.z = std::min( size.x, size.y );
+    return size;
+  }
+  else
+  {
+    return Control::GetNaturalSize();
+  }
+}
+
+float VideoView::GetHeightForWidth( float width )
+{
+  if( mVideoSize.GetWidth() > 0 && mVideoSize.GetHeight() > 0 )
+  {
+    return GetHeightForWidthBase( width );
+  }
+  else
+  {
+    return Control::GetHeightForWidthBase( width );
+  }
+}
+
+float VideoView::GetWidthForHeight( float height )
+{
+  if( mVideoSize.GetWidth() > 0 && mVideoSize.GetHeight() > 0 )
+  {
+    return GetWidthForHeightBase( height );
+  }
+  else
+  {
+    return Control::GetWidthForHeightBase( height );
+  }
+}
+
+void VideoView::SetWindowSurfaceTarget()
+{
+  Actor self = Self();
+  int curPos = mVideoPlayer.GetPlayPosition();
+
+  mSetRenderingTarget = true;
+  mRenderer.RemoveAndReset( self );
+
+  mVideoPlayer.SetRenderingTarget( Dali::Adaptor::Get().GetNativeWindowHandle() );
+  mVideoPlayer.SetUrl( mUrl );
+  mVideoPlayer.FinishedSignal().Connect( this, &VideoView::EmitSignalFinish );
+
+  if( mIsPlay )
+  {
+    mVideoPlayer.Play();
+  }
+  if( mIsPause )
+  {
+    mVideoPlayer.Play();
+    mVideoPlayer.Pause();
+  }
+  mVideoPlayer.SetPlayPosition( curPos );
+}
+
+void VideoView::SetNativeImageTarget()
+{
+  Actor self = Self();
+  int curPos = mVideoPlayer.GetPlayPosition();
+
+  mSetRenderingTarget = true;
+
+  Any source;
+  Dali::NativeImageSourcePtr nativeImageSourcePtr = Dali::NativeImageSource::New( source );
+  mNativeImage = Dali::NativeImage::New( *nativeImageSourcePtr );
+
+  mVideoPlayer.SetRenderingTarget( nativeImageSourcePtr );
+  mVideoPlayer.SetUrl( mUrl );
+  mVideoPlayer.FinishedSignal().Connect( this, &VideoView::EmitSignalFinish );
+
+  Toolkit::RendererFactory::Get().ResetRenderer( mRenderer, self, mNativeImage );
+
+  if( mIsPlay )
+  {
+    mVideoPlayer.Play();
+  }
+
+  if( mIsPause )
+  {
+    mVideoPlayer.Play();
+    mVideoPlayer.Pause();
+  }
+  mVideoPlayer.SetPlayPosition( curPos );
+}
+
+} // namespace Internal
+
+} // namespace Toolkit
+
+} // namespace Dali
diff --git a/dali-toolkit/internal/controls/video-view/video-view-impl.h b/dali-toolkit/internal/controls/video-view/video-view-impl.h
new file mode 100644 (file)
index 0000000..309a237
--- /dev/null
@@ -0,0 +1,274 @@
+#ifndef __DALI_TOOLKIT_INTERNAL_VIDEO_VIEW_H__
+#define __DALI_TOOLKIT_INTERNAL_VIDEO_VIEW_H__
+
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/property-map.h>
+#include <dali/public-api/images/native-image.h>
+#include <dali/devel-api/adaptor-framework/video-player.h>
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/controls/renderers/image/image-renderer.h>
+#include <dali-toolkit/public-api/controls/control-impl.h>
+#include <dali-toolkit/public-api/controls/video-view/video-view.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+class VideoView;
+
+namespace Internal
+{
+
+class VideoView: public Control
+{
+protected:
+
+  VideoView();
+
+  virtual ~VideoView();
+
+public:
+
+  /**
+   * @copydoc Toolkit::VideoView::New()
+   */
+  static Toolkit::VideoView New();
+
+  /**
+   * @brief Sets a video url to play.
+   *
+   * @SINCE_1_1.38
+   * @param [in] url The url of the video resource to play
+   */
+  void SetUrl( const std::string& url );
+
+  /**
+   * @brief Returns a video url.
+   * @SINCE_1_1.38
+   * @return Url of string type
+   */
+  std::string GetUrl();
+
+  /**
+   * @brief Sets the player looping status.
+   *
+   * @SINCE_1_1.38
+   * @param [in] looping The new looping status: true or false
+   */
+  void SetLooping(bool looping);
+
+  /**
+   * @brief Returns the player looping status.
+   *
+   * @SINCE_1_1.38
+   * @return True if player is looping, false otherwise.
+   */
+  bool IsLooping();
+
+  /**
+   * @copydoc Toolkit::VideoView::Play()
+   */
+  void Play();
+
+  /**
+   * @copydoc Toolkit::VideoView::Pause()
+   */
+  void Pause();
+
+  /**
+   * @copydoc Toolkit::VideoView::Stop()
+   */
+  void Stop();
+
+  /**
+   * @copydoc Toolkit::VideoView::Forward()
+   */
+  void Forward( int millisecond );
+
+  /**
+   * @copydoc Toolkit::VideoView::Backward()
+   */
+  void Backward( int millisecond );
+
+  /**
+   * @brief Sets the player mute status.
+   * @SINCE_1_1.38
+   * @param[i] mute The new mute status, true is mute.
+   */
+  void SetMute( bool mute );
+
+  /**
+   * @brief Returns the player mute status.
+   * @SINCE_1_1.38
+   * @return True if player is mute.
+   */
+  bool IsMuted();
+
+  /**
+   * @brief Sets the player volume.
+   * @SINCE_1_1.38
+   * @param[in] left The left volume scalar
+   * @param[in] right The right volume scalar
+   */
+  void SetVolume( float left, float right );
+
+  /**
+   * @brief Returns current volume factor.
+   * @SINCE_1_1.38
+   * @param[out] left The current left volume scalar
+   * @param[out] right The current right volume scalar
+   */
+  void GetVolume( float& left, float& right );
+
+ /**
+   * @copydoc Dali::Toolkit::VideoView::FinishedSignal()
+   */
+  Dali::Toolkit::VideoView::VideoViewSignalType& FinishedSignal();
+
+  /**
+   * @brief Emit the finished signal
+   */
+  void EmitSignalFinish();
+
+  /**
+   * @brief Set property map
+   * @SINCE_1_1.38
+   * @param[in] map The Dali::Property::Map to use for to display.
+   */
+  void SetPropertyMap( Property::Map map );
+
+  // Properties
+  /**
+   * @brief Called when a property of an object of this type is set.
+   * @SINCE_1_1.38
+   * @param[in] object The object whose property is set.
+   * @param[in] index The property index.
+   * @param[in] value The new property value.
+   */
+  static void SetProperty( BaseObject* object, Property::Index index, const Property::Value& value );
+
+  /**
+   * @brief Called to retrieve a property of an object of this type.
+   * @SINCE_1_1.38
+   * @param[in] object The object whose property is to be retrieved.
+   * @param[in] index The property index.
+   * @return The current value of the property.
+   */
+  static Property::Value GetProperty( BaseObject* object, Property::Index propertyIndex );
+
+  /**
+   * @brief Set the depth index of this image renderer
+   *
+   * Renderer with higher depth indices are rendered in front of other renderers with smaller values
+   * @SINCE_1_1.38
+   * @param[in] depthIndex The depth index of this renderer
+   */
+  void SetDepthIndex( int depthIndex );
+
+
+  /**
+   * @brief Performs actions as requested using the action name.
+   * @SINCE_1_1.38
+   * @param[in] object The object on which to perform the action.
+   * @param[in] actionName The action to perform.
+   * @param[in] attributes The attributes with which to perfrom this action.
+   * @return True if action has been accepted by this control
+   */
+  static bool DoAction( BaseObject* object, const std::string& actionName, const Property::Map& attributes );
+
+  static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor );
+
+private: // From Control
+
+  /**
+   * @copydoc Toolkit::Control::OnStageConnect()
+   */
+  virtual void OnStageConnection( int depth );
+
+  /**
+   * @copydoc Toolkit::Control::OnStageDisconnection()
+   */
+  virtual void OnStageDisconnection();
+
+  /**
+   * @copydoc Toolkit::Control::GetNaturalSize
+   */
+  virtual Vector3 GetNaturalSize();
+
+  /**
+   * @copydoc Toolkit::Control::GetHeightForWidth()
+   */
+  virtual float GetHeightForWidth( float width );
+
+  /**
+   * @copydoc Toolkit::Control::GetWidthForHeight()
+   */
+  virtual float GetWidthForHeight( float height );
+
+private:
+
+  // Undefined
+  VideoView( const VideoView& videoView );
+
+  VideoView& operator=( const VideoView& videoView );
+
+  void SetWindowSurfaceTarget();
+
+  void SetNativeImageTarget();
+
+private:
+
+  Dali::VideoPlayer mVideoPlayer;
+  Dali::ImageDimensions mVideoSize;
+  Toolkit::ControlRenderer mRenderer;
+  Dali::Property::Map mPropertyMap;
+  Dali::NativeImage mNativeImage; ///< Native image handle for video rendering by texture streaming
+  Dali::Toolkit::VideoView::VideoViewSignalType mFinishedSignal;
+  std::string mUrl;
+  int mCurrentVideoPlayPosition;
+  bool mSetRenderingTarget;
+  bool mIsPlay;
+  bool mIsPause;
+};
+
+} // namespace Internal
+
+inline Toolkit::Internal::VideoView& GetImpl( Toolkit::VideoView& handle )
+{
+  DALI_ASSERT_ALWAYS( handle );
+  Dali::RefObject& impl = handle.GetImplementation();
+  return static_cast< Toolkit::Internal::VideoView& >( impl );
+}
+
+inline const Toolkit::Internal::VideoView& GetImpl( const Toolkit::VideoView& handle )
+{
+  DALI_ASSERT_ALWAYS( handle );
+  const Dali::RefObject& impl = handle.GetImplementation();
+  return static_cast< const Toolkit::Internal::VideoView& >( impl );
+}
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif // __DALI_TOOLKIT_VIDEO_VIEW_H__
index fd199208c1547544c2923de31dff706f325d4d9d..f9edbdd205d1791e5779ae8facda4ac40a635e45 100644 (file)
@@ -73,6 +73,7 @@ toolkit_src_files = \
    $(toolkit_src_dir)/controls/text-controls/text-selection-popup-impl.cpp \
    $(toolkit_src_dir)/controls/text-controls/text-selection-toolbar-impl.cpp \
    $(toolkit_src_dir)/controls/tool-bar/tool-bar-impl.cpp \
+   $(toolkit_src_dir)/controls/video-view/video-view-impl.cpp \
    $(toolkit_src_dir)/accessibility-manager/accessibility-manager-impl.cpp \
    \
    $(toolkit_src_dir)/feedback/feedback-style.cpp \
diff --git a/dali-toolkit/public-api/controls/video-view/video-view.cpp b/dali-toolkit/public-api/controls/video-view/video-view.cpp
new file mode 100644 (file)
index 0000000..7a0aa1d
--- /dev/null
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali-toolkit/public-api/controls/video-view/video-view.h>
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/property-map.h>
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/controls/video-view/video-view-impl.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+VideoView::VideoView()
+{
+}
+
+VideoView::VideoView( const VideoView& videoView )
+: Control( videoView )
+{
+}
+
+VideoView& VideoView::operator=( const VideoView& videoView )
+{
+  if( &videoView != this )
+  {
+    Control::operator=( videoView );
+  }
+
+  return *this;
+}
+
+VideoView::~VideoView()
+{
+}
+
+VideoView VideoView::New()
+{
+  return Internal::VideoView::New();
+}
+
+VideoView VideoView::New( const std::string& url )
+{
+  VideoView videoView = Internal::VideoView::New();
+  Dali::Toolkit::GetImpl( videoView ).SetUrl( url );
+  return videoView;
+}
+
+VideoView VideoView::DownCast( BaseHandle handle )
+{
+  return Control::DownCast< VideoView, Internal::VideoView >( handle );
+}
+
+void VideoView::Play()
+{
+  Dali::Toolkit::GetImpl( *this ).Play();
+}
+
+void VideoView::Pause()
+{
+  Dali::Toolkit::GetImpl( *this ).Pause();
+}
+
+void VideoView::Stop()
+{
+  Dali::Toolkit::GetImpl( *this ).Stop();
+}
+
+void VideoView::Forward( int millisecond )
+{
+  Dali::Toolkit::GetImpl( *this ).Forward( millisecond );
+}
+
+void VideoView::Backward( int millisecond )
+{
+  Dali::Toolkit::GetImpl( *this ).Backward( millisecond );
+}
+
+VideoView::VideoViewSignalType& VideoView::FinishedSignal()
+{
+  return Dali::Toolkit::GetImpl( *this ).FinishedSignal();
+}
+
+VideoView::VideoView( Internal::VideoView& implementation )
+: Control( implementation )
+{
+}
+
+VideoView::VideoView( Dali::Internal::CustomActor* internal )
+: Control( internal )
+{
+  VerifyCustomActorPointer< Internal::VideoView >( internal );
+}
+
+} // namespace Toolkit
+
+} // namespace Dali
diff --git a/dali-toolkit/public-api/controls/video-view/video-view.h b/dali-toolkit/public-api/controls/video-view/video-view.h
new file mode 100644 (file)
index 0000000..e519db1
--- /dev/null
@@ -0,0 +1,238 @@
+#ifndef __DALI_TOOLKIT_VIDEO_VIEW_H__
+#define __DALI_TOOLKIT_VIDEO_VIEW_H__
+
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/control.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace Internal DALI_INTERNAL
+{
+  class VideoView;
+} // namespace Internal
+
+/**
+ * @addtogroup dali_toolkit_controls_video_view
+ * @{
+ */
+
+/**
+ * @brief VideoView is a control for video playback and display.
+ *
+ * For working VideoView, a video plugin for a platform should be provided.
+ *
+ * Signals
+ * | %Signal Name  | Method                  |
+ * |---------------|-------------------------|
+ * | finished      | @ref FinishedSignal()   |
+ * @SINCE_1_1.38
+ *
+ * Actions
+ * | %Action Name    | Attributes                                         | Description                                             |
+ * |-----------------|----------------------------------------------------|---------------------------------------------------------|
+ * | videoPlay       | Doesn't have attributes                            | Plays video. See @ref DoAction()                        |
+ * | videoPause      | Doesn't have attributes                            | Pauses video. See @ref DoAction()                       |
+ * | videoStop       | Doesn't have attributes                            | Stops video. See @ref DoAction()                        |
+ * | videoForward    | The position ( millisecond ) for forward playback  | Sets forward position for playback. See @ref DoAction() |
+ * | videoBackward   | The position ( millisecond ) for backward playback | Sets backward position for playback. See @ref DoAction()|
+ * @SINCE_1_1.38
+ *
+ */
+class DALI_IMPORT_API VideoView: public Control
+{
+public:
+
+  // Signal
+  typedef Signal< void (VideoView&) > VideoViewSignalType; ///< Video playback finished signal type @ SINCE_1_1.38
+
+  enum PropertyRange
+  {
+    PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1,  ///< @SINCE_1_0.0
+  };
+
+  struct Property
+  {
+    enum
+    {
+      /**
+       * @brief name "video", video file url as string type or Property::Map
+       * @SINCE_1_1.38
+       */
+      VIDEO = PROPERTY_START_INDEX,
+
+     /**
+       * @brief name "looping", looping status, true or false
+       * @SINCE_1_1.38
+       */
+      LOOPING,
+
+     /**
+       * @brief name "muted", mute status, true or false
+       * @SINCE_1_1.38
+       */
+      MUTED,
+
+     /**
+       * @brief name "volume", left and right volume scalar as float type, Property::Map with two values ( "left" and "right" )
+       * @SINCE_1_1.38
+       */
+      VOLUME
+    };
+  };
+
+public:
+
+  /**
+   * @brief Creates an initialized VideoView.
+   * @SINCE_1_1.38
+   * @return A handle to a newly allocated Dali ImageView
+   *
+   * @note VideoView will not display anything
+   */
+  static VideoView New();
+
+  /**
+   * @brief Creates an initialized VideoView.
+   * If the string is empty, VideoView will not display anything
+   *
+   * @SINCE_1_1.38
+   * @param[in] url The url of the video resource to display
+   * @return A handle to a newly allocated Dali VideoView
+   */
+  static VideoView New( const std::string& url );
+
+  /**
+   * @brief Create an uninitialized VideoView
+   * @SINCE_1_1.38
+   */
+  VideoView();
+
+  /**
+   * @brief Destructor
+   *
+   * This is non-virtual since derived Handel types must not contain data or virtual methods
+   * @SINCE_1_1.38
+   */
+  ~VideoView();
+
+  /*
+   * @brief Copy constructor
+   *
+   * @SINCE_1_1.38
+   * @param[in] videoView VideoView to copy. The copied VideoView will point at the same implementation
+   */
+  VideoView( const VideoView& videoView );
+
+  /**
+   * @brief Assignment operator.
+   *
+   * @SINCE_1_1.38
+   * @param[in] videoView The VideoView to assign from.
+   * @return The updated VideoView.
+   */
+  VideoView& operator=( const VideoView& videoView );
+
+  /**
+   * @brief Downcast a handle to VideoView handle.
+   *
+   * If handle points to a VideoView the downcast produces valid
+   * handle. If not the returned handle is left uninitialized.
+   *
+   * @SINCE_1_1.38
+   * @param[in] handle Handle to an object
+   * @return handle to a VideoView or an uninitialized handle
+   */
+  static VideoView DownCast( BaseHandle handle );
+
+  /**
+   * @brief Starts the video playback.
+   * @SINCE_1_1.38
+   */
+  void Play();
+
+  /**
+   * @brief Pauses the video playback.
+   * @SINCE_1_1.38
+   */
+  void Pause();
+
+  /**
+   * @brief Stops the video playback.
+   * @SINCE_1_1.38
+   */
+  void Stop();
+
+  /**
+   * @brief Seeks forward by the specified number of milliseconds.
+   *
+   * @SINCE_1_1.38
+   * @param[in] millisecond The position for forward playback
+   */
+  void Forward( int millisecond );
+
+  /**
+   * @brief Seeks backward by the specified number of milliseconds.
+   *
+   * @SINCE_1_1.38
+   * @param[in] millisecond The position for backward playback
+   */
+  void Backward( int millisecond );
+
+  /**
+   * @brief Connect to this signal to be notified when a video playback have finished.
+   *
+   * @SINCE_1_1.38
+   * @return A signal object to connect with.
+   */
+  VideoViewSignalType& FinishedSignal();
+
+public: // Not intended for application developers
+
+  /**
+   * @brief Creates a handle using the Toolkit::Internal implementation.
+   *
+   * @SINCE_1_1.38
+   * @param[in] implementation The VideoView implementation.
+   */
+  DALI_INTERNAL VideoView( Internal::VideoView& implementation );
+
+  /**
+   * @brief Allows the creation of this VideoView from an Internal::CustomActor pointer.
+   *
+   * @SINCE_1_1.38
+   * @param[in] internal A pointer to the internal CustomActor.
+   */
+  DALI_INTERNAL VideoView( Dali::Internal::CustomActor* internal );
+
+};
+
+/**
+ * @}
+ */
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif // __DALI_TOOLKIT_VIDEO_VIEW_H__
index d7e7034eac4fba7683bc24517c7ba84d53be98c2..fdd43d09e380befa85f76b4c5f9f19bb0e6014bf 100755 (executable)
@@ -32,6 +32,7 @@ public_api_src_files = \
   $(public_api_src_dir)/styling/style-manager.cpp \
   $(public_api_src_dir)/accessibility-manager/accessibility-manager.cpp \
   $(public_api_src_dir)/focus-manager/keyboard-focus-manager.cpp \
+  $(public_api_src_dir)/controls/video-view/video-view.cpp \
   $(public_api_src_dir)/dali-toolkit-version.cpp \
   $(public_api_src_dir)/enums.cpp
 
@@ -113,3 +114,6 @@ public_api_focus_manager_header_files = \
 
 public_api_rendering_backend_header_files = \
   $(public_api_src_dir)/text/rendering-backend.h
+
+public_api_video_view_header_files = \
+  $(public_api_src_dir)/controls/video-view/video-view.h
index d390f9af668d1654026a30fe40dcee7df1b50bfd..eef34abd23119478e5cedafd309ec1fdd7951e5a 100644 (file)
  *     @defgroup dali_toolkit_controls_flex_container Flex Container
  *     @brief FlexContainer is a container for Flexbox layout.
 
+ *     @defgroup dali_toolkit_controls_video_view Video View
+ *     @brief VideoView is a control for video playback and display.
+
  *   @}
 
  *   @defgroup dali_toolkit_managers Managers