/*
* Copyright (c) 2009 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:
*
*/


// INCLUDE FILES
#include <apgcli.h>
#include <DRMHelper.h>
#include <bldvariant.hrh>
#include <pathinfo.h>
#include <ProfileEngineDomainCRKeys.h>
#include "cphoneringingtone.h"
#include "cphonecenrepproxy.h"
#include "phonelogger.h"
#include "phoneconstants.h"
#include "phonelogger.h"

// CONSTANTS
// Rich audio file MIME types
_LIT(KAac, "audio/aac");
_LIT(KMp3, "audio/mp3");
_LIT(KMpeg, "audio/mpeg");
_LIT(K3gpp, "audio/3gpp");
_LIT(KMp4, "audio/mp4");
_LIT(KAmrWb, "audio/amr-wb");
_LIT(KWavX, "audio/x-wav");
_LIT(KWav, "audio/wav");

// Rich video file MIME types
_LIT(KV3gpp, "video/3gpp");
_LIT(KVMp4, "video/mp4");
_LIT(KV3gpp2, "video/3gpp2");

//file size limit
const TUint KPhoneToneFileSizeLimitKB = 5000;

// MACROS

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CPhoneRingingTone::CPhoneRingingTone
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPhoneRingingTone::CPhoneRingingTone( TBool aDrmInPlayback ) :
    iDrmInPlayback( aDrmInPlayback )
    {
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CPhoneRingingTone::ConstructL( const TDesC& aFileName )
    {
    iFileName = aFileName.AllocL();
    
    GetMaxToneFileSize();
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPhoneRingingTone* CPhoneRingingTone::NewL( 
    const TDesC& aFileName,
    TBool aDrmInPlayback )
    {
    CPhoneRingingTone* self = new( ELeave ) CPhoneRingingTone(
        aDrmInPlayback );

    CleanupStack::PushL( self );
    self->ConstructL( aFileName );
    CleanupStack::Pop( self );
    
    return self;
    }
    
// Destructor
CPhoneRingingTone::~CPhoneRingingTone()
    {
    delete iFileName;
    delete iMimeType;    
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::SetFileName
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPhoneRingingTone::SetFileName( const TDesC& aFileName )
    {
    delete iFileName;
    iFileName = NULL;
    iFileName = aFileName.Alloc();
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::SetVolume
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPhoneRingingTone::SetVolume( const TInt aVolume )
    {
    iVolume = aVolume;
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::SetRingingType
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPhoneRingingTone::SetRingingType( TProfileRingingType aRingingType)
    {
    iRingingType = aRingingType;
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::Volume
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CPhoneRingingTone::Volume() const
    {
    return iVolume;
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::RingingType
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TProfileRingingType CPhoneRingingTone::RingingType() const
    {
    return iRingingType; 
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::FileName
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
const TDesC& CPhoneRingingTone::FileName() const
    {
    // iFileName is never NULL
    return *iFileName;            
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::SetTtsToneToBePlayed
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPhoneRingingTone::SetTtsToneToBePlayed( TBool aTtsToneToBePlayed ) 
    {
    iTtsToneToBePlayed = aTtsToneToBePlayed;          
    }
// -----------------------------------------------------------------------------
// CPhoneRingingTone::TtsToneToBePlayed
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CPhoneRingingTone::TtsToneToBePlayed() const
    {
    
    return iTtsToneToBePlayed;    
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::MimeType
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
const TDesC& CPhoneRingingTone::MimeType() const
    {
    if ( iMimeType )
        {
        return *iMimeType;        
        }
    else
        {
        return KNullDesC;    
        }
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::IsVideoRingingTone
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//    
TBool CPhoneRingingTone::IsVideoRingingTone()
    {
#ifdef RD_VIDEO_AS_RINGING_TONE
    if ( RefreshMime() != KErrNone  )
        {
        // try to handle as audio
        return EFalse;                
        }

    TBool isVideo( EFalse );    
        
    if ( iMimeType && iMimeType->MatchF( KPhoneRingingToneVideoMime ) != 
         KErrNotFound )
        {
        isVideo = ETrue;
        }
    else if ( iMimeType && iMimeType->MatchF( KPhoneRingingToneRealVideoMime ) != 
              KErrNotFound )
        {
        isVideo = ETrue;    
        }
    
    if ( isVideo )
        {
        if ( IsFileInRom() && !IsFileInVideoDirectory() )
            {
            // For ROM files check also location, because
            // MIME check is not fully reliable.
            isVideo = EFalse;        
            }            
        }
    
    return isVideo;
#else
    // if extended security -> refresh MIME
    if ( iDrmInPlayback )
        {
        RefreshMime();            
        }
    
    return EFalse;
#endif    
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::IsFileDrmProtected
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//    
TBool CPhoneRingingTone::IsFileDrmProtected() const
    {
    const TDesC& type = MimeType();
        
    if ( type == KAac  || type == KMp3 || type == KMpeg ||
         type == K3gpp || type == KMp4 || type == KAmrWb ||
         type == KWavX || type == KWav || type == KV3gpp || 
         type == KVMp4 || type == KV3gpp2 )
        {
        ContentAccess::CContent* content = NULL;
        TRAPD( err, content = ContentAccess::CContent::NewL( *iFileName ) );
        if ( err == KErrNone && content )
            {
            TInt drmProtected( 0 );
            content->GetAttribute( ContentAccess::EIsProtected, drmProtected );
            delete content;
            return drmProtected;        
            }
        }
    
    return ETrue; // Other MIMEs can be played without DRM check.    
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::IsFileInRom
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//    
TBool CPhoneRingingTone::IsFileInRom() const
    {
    TParsePtrC parsedName( *iFileName );
    
    // Files on rom are not DRM checked
    if ( parsedName.Drive().CompareF( KPhoneRingingToneDriveZ ) == 0 )
        {
        return ETrue;
        }
    else
        {
        return EFalse;    
        }        
    }    

// -----------------------------------------------------------------------------
// CPhoneRingingTone::IsFileInVideoDirectory
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CPhoneRingingTone::IsFileInVideoDirectory() const
    {
    TParsePtrC parsedName( *iFileName );
    
    if ( PathInfo::PathType( parsedName.DriveAndPath() ) == 
         PathInfo::EVideosPath )
        {
        return ETrue;
        }
    else
        {
        return EFalse;    
        }    
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::RefreshMime
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CPhoneRingingTone::RefreshMime()
    {
    TRAPD( err, RefreshMimeL() );
    return err;        
    }

// -----------------------------------------------------------------------------
// CPhoneRingingTone::RefreshMimeL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//    
void CPhoneRingingTone::RefreshMimeL()
    {
    RApaLsSession apaLsSession;
    User::LeaveIfError( apaLsSession.Connect() );
    CleanupClosePushL( apaLsSession );

    TUid dummyUid = { 0 };
    TDataType dataType( dummyUid );
    
    User::LeaveIfError(
        apaLsSession.AppForDocument( *iFileName, dummyUid, dataType ) );
        
    CleanupStack::PopAndDestroy(); // CleanupClosePushL
    
    delete iMimeType;
    iMimeType = NULL;
    iMimeType = dataType.Des().AllocL();
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
TBool CPhoneRingingTone::CheckAndHandleToneSizeLimit()
    {
    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtone::CheckAndHandleToneSizeLimit()" );
    
    TBool bValidSize = ETrue;
 
    // If user has somehow managed to get a too large file as ringing tone,
    // play default tone instead.
    if ( iToneFileSizeLimitKB )
        {
        if ( CheckToneFileSize( FileName(), iToneFileSizeLimitKB) != KErrNone )
            {
            bValidSize = EFalse;
            }            
        }
    __PHONELOG1( 
        EBasic,
        EPhoneControl, 
        "CPhoneRingingtone::CheckAndHandleToneSizeLimit - bValidSize(%d)",
        bValidSize);
        
    return bValidSize;
    }
// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
TInt CPhoneRingingTone::CheckToneFileSize( const TDesC& aFile, 
                                           TInt aSizeLimitKB )
    {
    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtone::CheckToneFileSize()" );
    //return KErrNone;
    
    // Get file size
    TInt size = 0;

    RFs fs;   
    TInt error = fs.Connect();
    TEntry entry;
    if ( KErrNone == error )
        {
        if (KErrNone == fs.Entry( aFile, entry ))
            {
            size = entry.iSize;
            }    
            
        // Check
        aSizeLimitKB *= Kkilo;
        if ( aSizeLimitKB  &&  size > aSizeLimitKB )
            {
            error = KErrTooBig;
            }
        }

    fs.Close();
    __PHONELOG1( 
        EBasic,
        EPhoneControl, 
        "CPhoneRingingtonePlayer::CheckToneFileSize - size (%d)",
        size );    
    return error;
   
    }


// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CPhoneRingingTone::GetMaxToneFileSize()
    {
    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtone::GetMaxToneFileSize()" );              
    iToneFileSizeLimitKB = KPhoneToneFileSizeLimitKB;   
    }

//  End of File