#include "musengdisplayhandler.h"

#include "mussipprofileuser.h"

#include "muspropertyobserver.h"

#include <lcsessionobserver.h>

#include <lcuiprovider.h>

#include <lcwindow.h>

#include <lcaudiocontrol.h>

#include <ecom.h>

                            public MMusSipProfileUser

    public: // Constructors and destructor

    public: // From MMusEngSessionDurationTimerObserver

        void UpdateTimerEvent();        

    public: // From MMusEngAudioRoutingObserver

        void AudioRoutingChanged();

    public: // From MMusSipProfileUser    

        TBool IsRoamingBetweenAPsAllowed();

        void ProfileRegistered();

        TBool iAudioRoutingChangedCalled;       

        TBool iRoamingBetweenAPsAllowed;

        TBool iProfileRegisteredCalled;

    };

class TMusEngDisplayHandlerStub : public MMusEngDisplayHandler

    {

public:

    TMusEngDisplayHandlerStub();

    void Reset();

public: // From MMusEngDisplayHandler

    TRect Rect() const;

    void SetRectL( const TRect& aRect );

    void SetSecondaryRectL( const TRect& aSecondaryRect );

    TRect SecondaryRect() const;

    void EnableDisplayL( TBool aEnable );

    TBool IsDisplayEnabled();

    TDisplayOrientation OrientationL();

    void SetOrientationL( TDisplayOrientation aOrientation );

    TBool IsDisplayActive();

public:

    TRect iRect;

    TRect iSecondaryRect;

    TBool iIsEnabled;

    TDisplayOrientation iOrientation;

    TBool iIsActive;

    };

class CLcSessionObserverStub : public CBase, public MLcSessionObserver

    {

    public: // Constructors and destructor

        CLcSessionObserverStub();

        ~CLcSessionObserverStub();

    public: // From MLcSessionObserver

        void StateChanged( MLcSession& aSession );

        void StateChanged( MLcVideoPlayer& aPlayer );

        void Updated( MLcSession& aSession );

        void Updated( MLcVideoPlayer& aPlayer );

        void Failed( 

            MLcSession& aSession,

            TInt aError );

        void Failed( 

            MLcVideoPlayer& aPlayer, 

            TInt aError );

        void SessionTimeChanged( 

            MLcSession& aSession,

            const TTimeIntervalSeconds& aSeconds );

    public: // New functions

        void Reset();    

        TBool IsReseted();

    public: // Data

        enum TCalledFunction

            {

            EUnknown,

            ESessionStateChanged,

            EPlayerStateChanged,

            ESessionUpdated,

            EPlayerUpdated,

            ESessionFailed,

            EPlayerFailed,

            ESessionTimeChanged

            };  

        TInt iCalledFunction;

        MLcSession* iCurrentSession;

        MLcVideoPlayer* iCurrentPlayer;

        TInt iSessionTime;

        TInt iError;

    }; 

class CLcUiProviderStub : public CBase, public MLcUiProvider

    {

    public: // Constructors and destructor

        CLcUiProviderStub();

        ~CLcUiProviderStub();

    public: // From MLcUiProvider

        TBool SelectRecipient( 

            MDesCArray& aRecipientAddresses, 

            TDes& aSelectedRecipientAddress );        

        TBool InputRecipient( TDes& aRecipientAddress );

        void HandleForegroundStatus( TBool aForeground );

        void BlockUi( TBool aBlocked );

    public: // New functions

        void Reset();

    public: // Data

        enum TCalledFunction

            {

            EUnknown,

            ESelectRecipient,

            EInputRecipient,

            EHandleForegroundStatus

            };  

        TInt iForeground;

        TInt iCalledFunction;

        TPtrC iRecipient;

        TBool iSimulatedReturnValue;     

    };

class TLcWindowStub : public MLcWindow

    {

    public: // Constructor     

        TLcWindowStub();

    public: // From MLcWindow      

        void EnableLcWindowL( TBool aEnable );

        TBool IsLcWindowEnabled();    

        void SetLcWindowRectL( TRect aRect );

        TRect LcWindowRect();

        void SetLcWindowOrientationL( TLcWindowOrientation aOrientation );

        TLcWindowOrientation LcWindowOrientationL();

    public: // New functions

        void Reset();

    private: // Data

        TBool iEnabled;

        TRect iRect;

        TLcWindowOrientation iOrientation;

    };

class TLcAudioControlStub : public MLcAudioControl

    {

    public: // Constructor

        TLcAudioControlStub();    

    public:

        TBool IsLcAudioMutedL();

        void MuteLcAudioL( TBool aMute );       

        TBool IsLcMicMutedL();    

        void MuteLcMicL( TBool aMute );

        TBool IsEnablingLcLoudspeakerAllowed();   

        void EnableLcLoudspeakerL( TBool aEnabled );

        TBool IsLcLoudspeakerEnabled();

        TInt LcVolumeL();

        void SetLcVolumeL( TInt aValue );    

        void IncreaseLcVolumeL();

        void DecreaseLcVolumeL();

    public: // New functions

        void Reset();        

    private: // Data      

        TBool iAudioMuted;

        TBool iMicMuted;

        TBool iEnablingLoudspeakerAllowed;

        TBool iLoudspeakerEnabled;

    };

class TMusPropertyObserverStub : public MMusPropertyObserver

    {

    public:

        enum TMusPropertyObserverFunction

            {

            ENone, // default value

            EPropertyChanged,

            EHandlePropertyError

            };

        TMusPropertyObserverStub()

            {

            iCalledFunction = ENone;

            iKey = 0;

            iValue = 0;

            iReason = 0;

            }

        void PropertyChanged( const TUint aKey, const TInt aValue )

            {

            iCalledFunction = EPropertyChanged;

            iKey = aKey;

            iValue = aValue;

            }

        void HandlePropertyError( const TInt aReason )

            {

            iCalledFunction = EHandlePropertyError;

            iReason = aReason;

            }

    public: // data

        TMusPropertyObserverFunction iCalledFunction;

        TInt iKey;

        TInt iValue;

        TInt iReason;