/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   Class for preview audio and video

*

*/

// INCLUDE FILES

#include "mediafilepreview.h"

#include "mediafiledialogutils.h"

#include "mediafilelist.h"

#include "mediafilelistdebug.h"

#include <ScreensaverInternalPSKeys.h>   // KPSUidScreenSaver

#include <AudioPreference.h>             // KAudioPriorityPreview

#include <c3dringingtoneinterface.h>     // C3DRingingToneInterface

#include <ctsydomainpskeys.h>            // for phone call states

// for reading active profile settings

#include <MProfileEngine.h>

#include <MProfile.h>

#include <MProfileTones.h>

#include "TProfileToneSettings.h"

#include <MProfileExtraSettings.h>

#include <MProfile3DToneSettings.h>

#include <ProfileInternal.hrh>

#include <ProfileEngineDomainCRKeys.h>   // KProEngDefaultRingingTone

/******************************************************************************

 * class CMFPreviewHandlerBase

 ******************************************************************************/

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::CMFPreviewHandlerBase

// 

// -----------------------------------------------------------------------------

//

CMFPreviewHandlerBase::CMFPreviewHandlerBase()

	{

    iMediaType = KErrNotFound;

    iRingingVolume = KErrNotFound;

    iRingingType = KErrNotFound;

    iVibra = KErrNotFound;

    i3DEffect = KErrNotFound;

    i3DEcho = KErrNotFound;

    iFileSize = KErrNotFound;

	iFullName = NULL;

	iActiveProfileRead = EFalse;

	iPlayerStatus = EPlayerNotCreated;

    iObserver = NULL;

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::CMFPreviewHandlerBase

//

// -----------------------------------------------------------------------------

//

void CMFPreviewHandlerBase::ConstructL()

    {

   	// To allow/not allow screensaver

   	// Errors ignored, no actions needed if API is not available

    iProperty.Attach( KPSUidScreenSaver, KScreenSaverAllowScreenSaver );

    User::LeaveIfError( iApaSession.Connect() );

    TRAP_IGNORE( ReadDefaultToneL() );

    // To keep backlight on while a video is being previewed

    iBacklightTimer = CPeriodic::NewL( EPriorityLow );

    }

// ----------------------------------------------------------------------------

// Destructor

//

// ----------------------------------------------------------------------------

//

CMFPreviewHandlerBase::~CMFPreviewHandlerBase()

    {

    delete iFullName;

    iProperty.Close();

    iApaSession.Close();

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::SetAttr

// 

// -----------------------------------------------------------------------------

void CMFPreviewHandlerBase::SetAttrL( TInt aAttr, TInt aValue )

	{

	switch ( aAttr )

	    {

	    case CMediaFileList::EAttrVolume:

	        {

	        iRingingVolume = aValue;

	        break;

	        }

	    case CMediaFileList::EAttrRingingType:

	        {

	        iRingingType = aValue;

	        break;

	        }

	    case CMediaFileList::EAttrVibra:

	        {

	        iVibra = aValue;

	        break;

	        }

	    case CMediaFileList::EAttr3DEffect:

	        {

	        i3DEffect = aValue;

	        break;

	        }

	    case CMediaFileList::EAttr3DEcho:

	        {

	        i3DEcho = aValue;

	        break;

	        }

	    case CMediaFileList::EAttrFileSize:

	        {

	        iFileSize = aValue;

	        break;

	        }

	    default:

	        {

	        break;

	        }

	    }

	}

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::Attr

// 

// -----------------------------------------------------------------------------

TInt CMFPreviewHandlerBase::Attr( TInt aAttr )

    {

    TInt ret = KErrNotFound;

    switch ( aAttr )

        {

        case CMediaFileList::EAttrVolume:

            {

            ret = iRingingVolume;

            break;

            }

        case CMediaFileList::EAttrRingingType:

            {

            ret = iRingingType;

            break;

            }

        case CMediaFileList::EAttrVibra:

            {

            ret = iVibra;

            break;

            }

        case CMediaFileList::EAttr3DEffect:

            {

            ret = i3DEffect;

            break;

            }

        case CMediaFileList::EAttr3DEcho:

            {

            ret = i3DEcho;

            break;

            }

        case CMediaFileList::EAttrFileSize:

            {

            ret = iFileSize;

            break;

            }

        default:

            {

            break;

            }

        }

    return ret;

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::SetAttrL

// 

// -----------------------------------------------------------------------------

void CMFPreviewHandlerBase::SetAttrL( TInt aAttr, const TDesC& aValue )

	{

    if ( aAttr == TMFDialogUtil::EAttrFileName )

	    {

	    delete iFullName;

	    iFullName = NULL;

	    iFullName = aValue.AllocL();

	    }

	}

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::SetAttr

// 

// -----------------------------------------------------------------------------

//

void CMFPreviewHandlerBase::SetAttrL( TInt aAttr, TAny* aValue )

    {

	if ( aAttr == TMFDialogUtil::EAttrDrawingWindow )

	    {

	    iWindow = static_cast<RWindow*>( aValue );

	    }

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::SetObserver

// 

// -----------------------------------------------------------------------------

//

void CMFPreviewHandlerBase::SetObserver( MPreviewHandlerObserver* aObserver )

    {

    iObserver = aObserver;

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::IsCallOngoing

//

// -----------------------------------------------------------------------------

//

TBool CMFPreviewHandlerBase::IsCallOngoing()

    {

    TInt err = KErrNone;

    TInt callState = EPSCTsyCallStateUninitialized; 

    err = RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallState, callState );

    if ( err == KErrNone )

        {

        if( callState != EPSCTsyCallStateUninitialized && 

            callState != EPSCTsyCallStateNone && 

            callState != EPSCTsyCallStateDisconnecting ) 

            {

            // There was call ongoing

            return ETrue;

            }

        }

    return EFalse;

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::RingingVolume

//

// -----------------------------------------------------------------------------

//

TInt CMFPreviewHandlerBase::RingingVolume()

    {

    const TInt KDefaultVolumeLevel = 7; // see profile.hrh for volume levels

    if ( iRingingVolume != KErrNotFound )

        {

        return iRingingVolume;

        }

    if ( iActiveProfileRead )

        {

        return iActiveProfileRingingVolume;

        }

    return KDefaultVolumeLevel;

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::RingingType

//

// -----------------------------------------------------------------------------

//

TInt CMFPreviewHandlerBase::RingingType()

    {

    if ( iRingingType != KErrNotFound )

        {

        return iRingingType;

        }

    if ( iActiveProfileRead )

        {

        return iActiveProfileRingingType;

        }

    return ERingingTypeRinging;

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::Vibra

//

// -----------------------------------------------------------------------------

//

TInt CMFPreviewHandlerBase::Vibra()

    {

    if ( iVibra != KErrNotFound )

        {

        return iVibra;

        }

    if ( iActiveProfileRead )

        {

        return iActiveProfileVibra;

        }

    return 0;  // in case of error vibra is off

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::Echo3D

//

// -----------------------------------------------------------------------------

//

TInt CMFPreviewHandlerBase::Echo3D()

    {

    if ( i3DEcho != KErrNotFound )

        {

        return i3DEcho;

        }

    if ( iActiveProfileRead )

        {

        return iActiveProfile3DEcho;

        }

    return EProfile3DEchoOff;  // from ProfileInternal.hrh

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::Effect3D

//

// -----------------------------------------------------------------------------

//

TInt CMFPreviewHandlerBase::Effect3D()

    {

    if ( i3DEffect != KErrNotFound )

        {

        return i3DEffect;

        }

    if ( iActiveProfileRead )

        {

        return iActiveProfile3DEffect;

        }

    return EProfile3DEffectOff;

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::ConvertVolume

//

// -----------------------------------------------------------------------------

//

TInt CMFPreviewHandlerBase::ConvertVolume( TInt aVolume, TInt aMaxVolume )

    {

  	const TInt KMinVolumeLevel = 1;

    const TInt KMaxVolumeLevel = 10;

    TInt result = aMaxVolume * aVolume / KMaxVolumeLevel;

    // if user has selected minimum volume level set HW volume 1

    if ( aVolume == KMinVolumeLevel && result == 0 )

        {

        result = 1;

        }

    return result;

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::ReadActiveProfileL

// -----------------------------------------------------------------------------

//    

void CMFPreviewHandlerBase::ReadActiveProfileL()

    {

    iActiveProfileRead = EFalse;

    MProfileEngine* profileEngine = CreateProfileEngineL();

    CleanupReleasePushL( *profileEngine );

    MProfile* activeProfile  = profileEngine->ActiveProfileL();

    CleanupReleasePushL( *activeProfile );

    const MProfileTones& profileTones = activeProfile->ProfileTones();

    const TProfileToneSettings& toneSettings = profileTones.ToneSettings();

    iActiveProfileVibra = toneSettings.iVibratingAlert;

    iActiveProfileRingingVolume = toneSettings.iRingingVolume;

    iActiveProfileRingingType = toneSettings.iRingingType;

    const MProfileExtraSettings& extra = activeProfile->ProfileExtraSettings();

    const MProfile3DToneSettings& threeD = extra.Profile3DToneSettings();

    iActiveProfile3DEffect = threeD.Effect();

    iActiveProfile3DEcho = threeD.Echo();

    CleanupStack::PopAndDestroy( activeProfile ); 

    CleanupStack::PopAndDestroy( profileEngine );

    iActiveProfileRead = ETrue;

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::ReadDefaultToneL

// -----------------------------------------------------------------------------

//    

void CMFPreviewHandlerBase::ReadDefaultToneL()

    {

    CRepository* cenrep = CRepository::NewLC( KCRUidProfileEngine );

    User::LeaveIfError( cenrep->Get( KProEngDefaultRingingTone, iDefaultTone ) );

    CleanupStack::PopAndDestroy( cenrep );

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::EnableScreenSaver

//

// -----------------------------------------------------------------------------

//

void CMFPreviewHandlerBase::EnableScreenSaver( TBool aEnable )

    {

    if ( aEnable )

        {

   	    // allow screen saver, unless there's a call ongoing

   	    if( !IsCallOngoing() )

   		    {

	        // ignore error, no actions needed if API is not available	   	

	   	    iProperty.Set( KPSUidScreenSaver, KScreenSaverAllowScreenSaver,

	   	                   EFLScreenSaverAllowed );

   		    }

        }

    else

        {

   	    iProperty.Set( KPSUidScreenSaver,

			       KScreenSaverAllowScreenSaver, EFLScreenSaverNotAllowed );

        }

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::GetDataType

//

// -----------------------------------------------------------------------------

//

TInt CMFPreviewHandlerBase::GetDataType( const TDesC& aFileName, TDataType& aDataType )

    {

   	TUid dummyUid( KNullUid );

	return iApaSession.AppForDocument( aFileName, dummyUid, aDataType );

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::Panic

//

// -----------------------------------------------------------------------------

//

void CMFPreviewHandlerBase::Panic( TInt aReason ) 

    {

	_LIT( KPanicCategory, "CMFPreviewHandlerBase" );

	User::Panic( KPanicCategory, aReason ); 

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::DoResetInactivityTimer()

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CMFPreviewHandlerBase::DoResetInactivityTimer( TAny* /*aObject*/ )

    {

    User::ResetInactivityTime();

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CMFPreviewHandlerBase::DisableBackLight()

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CMFPreviewHandlerBase::DisableBackLight()

	{

		const TInt KResetInactivityTimerDelay = 2000000;

    iBacklightTimer->Cancel(); // Just in case

    // Disable backlight turn off during video preview

    iBacklightTimer->Start( KResetInactivityTimerDelay,

                            KResetInactivityTimerDelay,

                            TCallBack( DoResetInactivityTimer, NULL ) );

	}