#include <dali/devel-api/adaptor-framework/event-thread-callback.h>
// INTERNAL INCLUDES
-#include <dali/internal/adaptor/common/adaptor-impl.h>
+#include <dali/integration-api/adaptor-framework/trigger-event-factory.h>
namespace Dali
{
EventThreadCallback::EventThreadCallback( CallbackBase* callback )
: mImpl( new Impl() )
{
- mImpl->eventTrigger = NULL;
- if ( Adaptor::IsAvailable() )
- {
- Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation( Adaptor::Get() );
- mImpl->eventTrigger = adaptorImpl.GetTriggerEventFactoryInterface().CreateTriggerEvent( callback, TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER );
- }
+ mImpl->eventTrigger = TriggerEventFactory::CreateTriggerEvent( callback, TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER );
}
EventThreadCallback::~EventThreadCallback()
{
- if ( Adaptor::IsAvailable() )
- {
- Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation( Adaptor::Get() );
- adaptorImpl.GetTriggerEventFactoryInterface().DestroyTriggerEvent( mImpl->eventTrigger );
- }
+ TriggerEventFactory::DestroyTriggerEvent( mImpl->eventTrigger );
delete mImpl;
}
+++ /dev/null
-#ifndef DALI_INTEGRATION_TRIGGER_EVENT_FACTORY_INTERFACE_H
-#define DALI_INTEGRATION_TRIGGER_EVENT_FACTORY_INTERFACE_H
-
-/*
- * Copyright (c) 2019 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/signals/callback.h>
-
-// INTERNAL INCLUDES
-#include <dali/integration-api/adaptor-framework/trigger-event-interface.h>
-
-namespace Dali
-{
-
-/**
- * @brief Trigger interface factory class for creating a TriggerEvents
- *
- */
-class TriggerEventFactoryInterface
-{
-public:
-
-
- /**
- * @brief Create a new concrete implementation of the event trigger interface.
- * @param callback called when interface->Trigger() is called
- * @param options TriggerEventInterface option
- * @return pointer to a new trigger event
- * @note Ownership of callback should be taken over by deriving classes
- */
- virtual TriggerEventInterface* CreateTriggerEvent( CallbackBase* callback,
- TriggerEventInterface::Options options ) = 0;
- /**
- * @brief destroy a trigger event
- * @param triggerEventInterface event to destroy
- */
- virtual void DestroyTriggerEvent( TriggerEventInterface* triggerEventInterface ) = 0;
-
-protected:
-
- /**
- * @brief Constructor
- */
- TriggerEventFactoryInterface()
- {
- }
-
- /**
- * @brief Virtual Destructor
- */
- virtual ~TriggerEventFactoryInterface()
- {
- }
-
-private:
-
-
- // Undefined copy constructor.
- TriggerEventFactoryInterface( const TriggerEventFactoryInterface& );
-
- // Undefined assignment operator.
- TriggerEventFactoryInterface& operator=( const TriggerEventFactoryInterface& );
-
-};
-
-} // namespace Dali
-
-#endif // DALI_INTEGRATION_TRIGGER_EVENT_FACTORY_INTERFACE_H
*
*/
+// EXTERNAL INCLUDES
+#include <dali/public-api/signals/callback.h>
+
// INTERNAL INCLUDES
#include <dali/public-api/dali-adaptor-common.h>
-#include <dali/integration-api/adaptor-framework/trigger-event-factory-interface.h>
+#include <dali/integration-api/adaptor-framework/trigger-event-interface.h>
namespace Dali
{
* @brief Trigger interface factory class
*
*/
-class DALI_ADAPTOR_API TriggerEventFactory : public TriggerEventFactoryInterface
+class DALI_ADAPTOR_API TriggerEventFactory
{
-
public:
/**
- * @brief Constructor
- */
- TriggerEventFactory()
- {
- }
-
- /**
- * @brief Destructor
- */
- virtual ~TriggerEventFactory()
- {
- }
-
- /**
* @copydoc TriggerEventFactoryInterface::CreateTriggerEvent
*/
- virtual TriggerEventInterface* CreateTriggerEvent( CallbackBase* callback, TriggerEventInterface::Options options );
-
+ static TriggerEventInterface* CreateTriggerEvent( CallbackBase* callback, TriggerEventInterface::Options options );
/**
* @copydoc TriggerEventFactoryInterface::DestroyTriggerEvent
*/
- virtual void DestroyTriggerEvent( TriggerEventInterface* triggerEventInterface );
+ static void DestroyTriggerEvent( TriggerEventInterface* triggerEventInterface );
};
${adaptor_integration_api_dir}/adaptor-framework/scene-holder-impl.h
${adaptor_integration_api_dir}/adaptor-framework/thread-synchronization-interface.h
${adaptor_integration_api_dir}/adaptor-framework/trigger-event-interface.h
- ${adaptor_integration_api_dir}/adaptor-framework/trigger-event-factory-interface.h
${adaptor_integration_api_dir}/adaptor-framework/trigger-event-factory.h
)
mObjectProfiler = new ObjectProfiler( timeInterval );
}
- mNotificationTrigger = mTriggerEventFactory.CreateTriggerEvent( MakeCallback( this, &Adaptor::ProcessCoreEvents ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER);
+ mNotificationTrigger = TriggerEventFactory::CreateTriggerEvent( MakeCallback( this, &Adaptor::ProcessCoreEvents ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER);
mDisplayConnection = Dali::DisplayConnection::New( *mGraphics, defaultWindow->GetSurface()->GetSurfaceType() );
return *mNotificationTrigger;
}
-TriggerEventFactoryInterface& Adaptor::GetTriggerEventFactoryInterface()
-{
- return mTriggerEventFactory;
-}
-
SocketFactoryInterface& Adaptor::GetSocketFactoryInterface()
{
return mSocketFactory;
mPerformanceInterface( nullptr ),
mKernelTracer(),
mSystemTracer(),
- mTriggerEventFactory(),
mObjectProfiler( nullptr ),
mSocketFactory(),
mEnvironmentOptionsOwned( environmentOptions ? false : true /* If not provided then we own the object */ ),
virtual TriggerEventInterface& GetProcessCoreEventsTrigger();
/**
- * @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetTriggerEventFactoryInterface()
- */
- virtual TriggerEventFactoryInterface& GetTriggerEventFactoryInterface();
-
- /**
* @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetSocketFactoryInterface()
*/
virtual SocketFactoryInterface& GetSocketFactoryInterface();
PerformanceInterface* mPerformanceInterface; ///< Performance interface
KernelTrace mKernelTracer; ///< Kernel tracer
SystemTrace mSystemTracer; ///< System tracer
- TriggerEventFactory mTriggerEventFactory; ///< Trigger event factory
ObjectProfiler* mObjectProfiler; ///< Tracks object lifetime for profiling
SocketFactory mSocketFactory; ///< Socket factory
const bool mEnvironmentOptionsOwned:1; ///< Whether we own the EnvironmentOptions (and thus, need to delete it)
// INTERNAL INCLUDES
#include <dali/integration-api/render-surface.h>
#include <dali/integration-api/adaptor-framework/render-surface-interface.h>
-#include <dali/integration-api/adaptor-framework/trigger-event-factory-interface.h>
#include <dali/integration-api/adaptor-framework/trigger-event-interface.h>
#include <dali/internal/graphics/common/graphics-interface.h>
#include <dali/internal/graphics/gles/egl-factory-interface.h>
virtual TriggerEventInterface& GetProcessCoreEventsTrigger() = 0;
/**
- * @return trigger event factory interface
- */
- virtual TriggerEventFactoryInterface& GetTriggerEventFactoryInterface() = 0;
-
- /**
* @return socket factory interface
*/
virtual SocketFactoryInterface& GetSocketFactoryInterface() = 0;
currentSurface->SetThreadSynchronization( *this );
}
- TriggerEventFactoryInterface& triggerFactory = mAdaptorInterfaces.GetTriggerEventFactoryInterface();
- mSleepTrigger = triggerFactory.CreateTriggerEvent( MakeCallback( this, &CombinedUpdateRenderController::ProcessSleepRequest ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER );
+ mSleepTrigger = TriggerEventFactory::CreateTriggerEvent( MakeCallback( this, &CombinedUpdateRenderController::ProcessSleepRequest ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER );
// Initialize to 0 so that it just waits if sem_post has not been called
sem_init( &mEventThreadSemaphore, 0, 0 );
NetworkPerformanceClient::NetworkPerformanceClient( pthread_t* thread,
SocketInterface *socket,
unsigned int clientId,
- TriggerEventFactoryInterface& triggerEventFactory,
ClientSendDataInterface& sendDataInterface,
SocketFactoryInterface& socketFactory )
: mThread( thread ),
mSocket( socket ),
mMarkerBitmask( PerformanceMarker::FILTERING_DISABLED ),
- mTriggerEventFactory( triggerEventFactory ),
mSendDataInterface( sendDataInterface ),
mSocketFactoryInterface( socketFactory ),
mClientId( clientId ),
callback->AssignDumpSceneCommand();
// create a trigger event that automatically deletes itself after the callback has run in the main thread
- TriggerEventInterface *interface = mTriggerEventFactory.CreateTriggerEvent( callback, TriggerEventInterface::DELETE_AFTER_TRIGGER );
+ TriggerEventInterface *interface = TriggerEventFactory::CreateTriggerEvent( callback, TriggerEventInterface::DELETE_AFTER_TRIGGER );
// asynchronous call, the call back will be run sometime later on the main thread
interface->Trigger();
callback->AssignSetPropertyCommand( stringParam );
// create a trigger event that automatically deletes itself after the callback has run in the main thread
- TriggerEventInterface *interface = mTriggerEventFactory.CreateTriggerEvent( callback, TriggerEventInterface::DELETE_AFTER_TRIGGER );
+ TriggerEventInterface *interface = TriggerEventFactory::CreateTriggerEvent( callback, TriggerEventInterface::DELETE_AFTER_TRIGGER );
// asynchronous call, the call back will be run sometime later on the main thread
interface->Trigger();
#include <dali/internal/system/common/performance-marker.h>
#include <dali/internal/network/common/client-send-data-interface.h>
#include <dali/internal/network/common/socket-factory-interface.h>
-#include <dali/integration-api/adaptor-framework/trigger-event-factory-interface.h>
+#include <dali/integration-api/adaptor-framework/trigger-event-factory.h>
namespace Dali
* @param thread thread pointer
* @param socket socket interface
* @param clientId unique client id
- * @param triggerEventFactory used to create trigger events
* @param sendDataInterface used to send data to the socket from main thread
* @param SocketFactoryInterface used to delete the socket when the client is destroyed
*/
NetworkPerformanceClient( pthread_t* thread,
SocketInterface *socket,
unsigned int clientId,
- TriggerEventFactoryInterface& triggerEventFactory,
ClientSendDataInterface& sendDataInterface,
SocketFactoryInterface& socketFactory );
pthread_t* mThread; ///< thread for the client
SocketInterface* mSocket; ///< socket interface
PerformanceMarker::MarkerFilter mMarkerBitmask; ///< What markers are currently filtered
- TriggerEventFactoryInterface& mTriggerEventFactory; ///< Trigger event factory
ClientSendDataInterface& mSendDataInterface; ///< used to send data to a client from the main event thread
SocketFactoryInterface& mSocketFactoryInterface; ///< used to delete the socket
unsigned int mClientId; ///< unique client id
NetworkPerformanceServer::NetworkPerformanceServer( AdaptorInternalServices& adaptorServices,
const EnvironmentOptions& logOptions )
-: mTriggerEventFactory( adaptorServices.GetTriggerEventFactoryInterface() ),
- mSocketFactory( adaptorServices.GetSocketFactoryInterface() ),
+: mSocketFactory( adaptorServices.GetSocketFactoryInterface() ),
mLogOptions( logOptions ),
mServerThread( 0 ),
mListeningSocket( NULL ),
NetworkPerformanceClient* client= new NetworkPerformanceClient( clientThread,
clientSocket,
mClientUniqueId++,
- mTriggerEventFactory,
*this,
mSocketFactory);
NetworkPerformanceServer( const NetworkPerformanceServer& ); ///< undefined copy constructor
NetworkPerformanceServer& operator=( const NetworkPerformanceServer& ); ///< undefined assignment operator
-
- TriggerEventFactoryInterface& mTriggerEventFactory; ///< used to create trigger events
SocketFactoryInterface& mSocketFactory; ///< used to create sockets
const EnvironmentOptions& mLogOptions; ///< log options
Dali::Vector< NetworkPerformanceClient* > mClients; ///< list of connected clients
// INTERNAL INCLUDES
#include <dali/integration-api/adaptor-framework/thread-synchronization-interface.h>
-#include <dali/integration-api/adaptor-framework/trigger-event-factory-interface.h>
+#include <dali/integration-api/adaptor-framework/trigger-event-factory.h>
#include <dali/internal/adaptor/common/adaptor-impl.h>
#include <dali/internal/adaptor/common/adaptor-internal-services.h>
#include <dali/internal/graphics/gles/egl-graphics.h>
if( !mRotationTrigger )
{
- TriggerEventFactoryInterface& triggerFactory = Internal::Adaptor::Adaptor::GetImplementation( Adaptor::Get() ).GetTriggerEventFactoryInterface();
- mRotationTrigger = triggerFactory.CreateTriggerEvent( MakeCallback( this, &WindowRenderSurface::ProcessRotationRequest ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER );
+ mRotationTrigger = TriggerEventFactory::CreateTriggerEvent( MakeCallback( this, &WindowRenderSurface::ProcessRotationRequest ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER );
}
mPositionSize.width = width;