/*
* 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 the License "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:    Help methods for propriatary RTP format.*
*/




// INCLUDE FILES
#include <pathinfo.h>
#include <ipvideo/CRtpClipManager.h>
#include "CRtpClipRepairer.h"
#include <BaUtils.h>
#include "videoserviceutilsLogger.h"

// CONSTANTS
const TInt EContentRightsRecordingAllowed( 0 );
const TInt EContentRightsLockToDevice( 2 );
const TInt KMaxProgramChars( 8 );
const TInt KFirstFileIndex( 1 );
const TInt KMaxFileIndex( 99 );
_LIT( KDvrClipExtension, ".rtp" );
_LIT( KIndexFormat, "(%02d)" );

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

// -----------------------------------------------------------------------------
// CRtpClipManager::NewL
// Static two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CRtpClipManager* CRtpClipManager::NewL()
    {
    CRtpClipManager* self = CRtpClipManager::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CRtpClipManager::NewLC
// Static two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CRtpClipManager* CRtpClipManager::NewLC()
    {
    CRtpClipManager* self = new( ELeave ) CRtpClipManager();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// -----------------------------------------------------------------------------
// CRtpClipManager::CRtpClipManager
//
// -----------------------------------------------------------------------------
//
CRtpClipManager::CRtpClipManager()
    {
    // None
    }

// -----------------------------------------------------------------------------
// CRtpClipManager::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CRtpClipManager::ConstructL()
    {
    LOG( "CRtpClipManager::ConstructL() in" );
    
    // IMEI
    TName buf( KNullDesC );
    CRtpUtil::GetImeiL( buf );
    iImei = buf.AllocL();
    LOG1( "CRtpClipManager::ConstructL(), IMEI: %S", &*iImei );

    // File server
    User::LeaveIfError( iFs.Connect() );

    LOG( "CRtpClipManager::ConstructL() out" );
    }

// -----------------------------------------------------------------------------
// CRtpClipManager::~CRtpClipManager
//
// -----------------------------------------------------------------------------
//
EXPORT_C CRtpClipManager::~CRtpClipManager()
    {
    LOG( "CRtpClipManager::~CRtpClipManager()" );

    delete iImei;
    iRepairQueue.ResetAndDestroy();
    delete iClipRepairer;
    iFile.Close();
    iFs.Close();
    }

// -----------------------------------------------------------------------------
// CRtpClipManager::GetClipDetailsL
// Getter for clip details.
// -----------------------------------------------------------------------------
//
EXPORT_C void CRtpClipManager::GetClipDetailsL(
    const TDesC& aClipPath,
    SRtpClipDetails& aDetails )
    {
    iFile.Close();
    TBool clipOpen( EFalse );
    iFs.IsFileOpen( aClipPath, clipOpen );
    User::LeaveIfError( iFile.Open( iFs, aClipPath,
                        EFileShareAny | EFileStream | EFileRead ) );
    CRtpMetaHeader* metaheader = CRtpMetaHeader::NewLC( 
                                 iFile, CRtpMetaHeader::EMetaRead );
    // Attributes
    CRtpMetaHeader::SAttributes att;
    metaheader->ReadAttributesL( att );

    // Under version 2 clips not work any longer
    // Recording ongoing without file open indicates interrupted recording
    if ( att.iVersion < 2 || ( att.iOngoing && !clipOpen ) )
        {
        LOG3( "CRtpClipManager::GetClipDetailsL(), iVersion: %d, iOngoing: %d, clipOpen: %d",
                                                   att.iVersion, att.iOngoing, clipOpen );
        iFile.Close();
        User::Leave( KErrGeneral ); 
        }
    
    // Details
    GetDetailsL( att, aDetails, metaheader );
    CleanupStack::PopAndDestroy( metaheader );
    iFile.Close();
    }

// -----------------------------------------------------------------------------
// CRtpClipManager::GetClipDetailsL
// Getter for clip details.
// -----------------------------------------------------------------------------
//
EXPORT_C void CRtpClipManager::GetClipDetailsL(
    RFile& aFile,
    SRtpClipDetails& aDetails )
    {
    CRtpMetaHeader* metaheader = CRtpMetaHeader::NewLC( 
                                 aFile, CRtpMetaHeader::EMetaRead );
    // Attributes
    CRtpMetaHeader::SAttributes att;
    metaheader->ReadAttributesL( att );
    
    // Details
    GetDetailsL( att, aDetails, metaheader );
    CleanupStack::PopAndDestroy( metaheader );
    }

// -----------------------------------------------------------------------------
// CRtpClipManager::ProtectClipL
// Protects clip from deleting automatically during recording.
// -----------------------------------------------------------------------------
//
EXPORT_C void CRtpClipManager::ProtectClipL(
    const TDesC& aClipPath,
    const TBool aProtected )
    {
    LOG1( "CRtpClipManager::ProtectClipL(), aClipPath: %S", &aClipPath );
    LOG1( "CRtpClipManager::ProtectClipL(), aProtected: %d", aProtected );
    
    iFile.Close();
    User::LeaveIfError( iFile.Open( iFs, aClipPath,
                        EFileShareExclusive | EFileStream | EFileWrite ) );
    CRtpMetaHeader* metaheader = CRtpMetaHeader::NewLC( 
                                 iFile, CRtpMetaHeader::EMetaUpdate );
    // Read Attributes
    CRtpMetaHeader::SAttributes att;
    metaheader->ReadAttributesL( att );
    // Update protected attribute
    if ( aProtected != att.iProtected )
        {
        att.iProtected = aProtected;
        metaheader->WriteAttributesL( att );
        }
    
    CleanupStack::PopAndDestroy( metaheader );
    iFile.Close();
    }
    
// -----------------------------------------------------------------------------
// CRtpClipManager::FixMetaHeaderL
// Fixes corrupted clip's meta header.
// -----------------------------------------------------------------------------
//
EXPORT_C void CRtpClipManager::FixMetaHeaderL(
    MRtpClipRepairObserver* aObs,
    const TDesC& aClipPath )
    {
    LOG( "RM-CRtpClipManager::FixMetaHeaderL()" );

    iFile.Close();
    if ( !iClipRepairer )
        {
        LOG1( "CRtpClipManager::FixMetaHeaderL(), Fix started: %S", &aClipPath );
        AddClipToRepairQueueL( aClipPath );
        iClipRepairer = CRtpClipRepairer::NewL( aObs );
        iClipRepairer->CheckMetaHeaderL( aClipPath );
        }
    else
        {
        // Verify that not exist in queue
        TInt loop( iRepairQueue.Count() - 1 );
        for ( ; loop >= 0; loop-- )
            {
            if ( !aClipPath.CompareC( iRepairQueue[loop]->Des() ) )
                {
                break;
                }
            }

        // Add to queue
        if ( loop < 0 )
            {
            LOG1( "CRtpClipManager::FixMetaHeaderL(), Fix queued: %S", &aClipPath );
            AddClipToRepairQueueL( aClipPath );
            }
        }
    }
    
// -----------------------------------------------------------------------------
// CRtpClipManager::FixMetaHeaderL
// Fixes corrupted clip's meta header syncronously.
// -----------------------------------------------------------------------------
//
EXPORT_C void CRtpClipManager::FixMetaHeaderL( const TDesC& aClipPath )
    {
    LOG1( "CRtpClipManager::FixMetaHeaderL(), aClipPath: %S", &aClipPath );

    iFile.Close();
    delete iClipRepairer; iClipRepairer = NULL;
    iClipRepairer = CRtpClipRepairer::NewL( NULL );
    iClipRepairer->CheckMetaHeaderL( aClipPath );
    }
    
// -----------------------------------------------------------------------------
// CRtpClipManager::DeleteRtpRepairer
// Kills clip repairer after work done.
// -----------------------------------------------------------------------------
//
EXPORT_C void CRtpClipManager::DeleteRtpRepairer( MRtpClipRepairObserver* aObs )
    {
    // Remove handled name from the queue first
    iFile.Close();
    TInt last( iRepairQueue.Count() - 1 );
    if ( last > KErrNotFound && iClipRepairer &&
         !iRepairQueue[last]->Des().Compare( iClipRepairer->CurrentClipName() ) )
        {
        delete iRepairQueue[last];
        iRepairQueue[last] = NULL;
        iRepairQueue.Remove( last );
        }

    // Repairer must be deleted in any case
    delete iClipRepairer; iClipRepairer = NULL;
    TInt err( KErrNotFound );
    last = iRepairQueue.Count() - 1;
    LOG1( "CRtpClipManager::DeleteRtpRepairer(), queue count: %d", iRepairQueue.Count() );
    
    while ( last > KErrNotFound && err )
        {
        // Create new repairer and start it
        TPath path( iRepairQueue[last]->Des() );
        TRAP( err, iClipRepairer = CRtpClipRepairer::NewL( aObs ) );
        if ( !err )
            {
            TRAP( err, iClipRepairer->CheckMetaHeaderL( path ) );
            if ( err )
                {
                LOG1( "CRtpClipManager::DeleteRtpRepairerL(), CheckMetaHeaderL Leaved: %d", err );

                // Remove clip which can't be repaired from the queue
                delete iRepairQueue[last];
                iRepairQueue[last] = NULL;
                iRepairQueue.Remove( last );
                
                // Ready for the next clip
                last = iRepairQueue.Count() - 1;
                delete iClipRepairer; iClipRepairer = NULL;
                }
            }
        else
            {
            LOG1( "CRtpClipManager::DeleteRtpRepairerL(), No memory for new repairer: %d", err );
            break;
            }
        }
    }
    
// -----------------------------------------------------------------------------
// CRtpClipManager::VerifyPostRuleL
// Verifies post acqusition rule of clip.
// -----------------------------------------------------------------------------
//
TInt CRtpClipManager::VerifyPostRuleL(
    const TUint8 aPostRule,
    CRtpMetaHeader* aMetaHeader )
    {
    LOG( "CRtpClipManager::VerifyPostRule()" );

    switch ( aPostRule )
        {
        case EContentRightsRecordingAllowed:
            LOG( "CRtpClipManager::VerifyPostRule(), EContentRightsRecordingAllowed !" );
            break;
        
        case EContentRightsLockToDevice:
            {
            TName imei( KNullDesC );
            aMetaHeader->ReadDeviceInfoL( imei );
            if ( !iImei || imei.Compare( iImei->Des() ) )
                {
                LOG( "CRtpClipManager::VerifyPostRule(), EContentRightsLockToDevice" );
                LOG1( "CRtpClipManager::VerifyPostRule(), ERmPlayDeviceLockError: %S", &imei );
                LOG1( "CRtpClipManager::VerifyPostRule(), Phone's IMEI: %S", &*iImei );
                return KErrAccessDenied;
                }
            }
            break;
        
        default:
            LOG1( "RM-CRtpClipManager::VerifyPostRule(), Default case: %d", aPostRule );
            break;
        }
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CRtpClipManager::GetDetailsL
// Updates details from meta header attributes.
// -----------------------------------------------------------------------------
//
void CRtpClipManager::GetDetailsL(
    const CRtpMetaHeader::SAttributes& aAttributes,
    SRtpClipDetails& aDetails,
    CRtpMetaHeader* aMetaHeader )
    {
    aDetails.iRecOngoing = aAttributes.iOngoing;
    aDetails.iCompleted = aAttributes.iCompleted;
    aDetails.iProtected = aAttributes.iProtected;
    aDetails.iFailed = aAttributes.iFailed;
    aDetails.iQuality = aAttributes.iQuality;
    aDetails.iPlayCount = aAttributes.iPlayCount;
    aDetails.iPlaySpot = aAttributes.iPlaySpot;
    aDetails.iParental = aAttributes.iParental;
    
    LOG1( "CRtpClipManager::GetDetailsL(), iRecOngoing: %d", aDetails.iRecOngoing );
    LOG1( "CRtpClipManager::GetDetailsL(), iCompleted: %d", aDetails.iCompleted );
    LOG1( "CRtpClipManager::GetDetailsL(), iProtected: %d", aDetails.iProtected );
    LOG1( "CRtpClipManager::GetDetailsL(), iFailed: %d", aDetails.iFailed );
    LOG1( "CRtpClipManager::GetDetailsL(), iQuality: %d", aDetails.iQuality );
    LOG1( "CRtpClipManager::GetDetailsL(), iPlayCount: %d", aDetails.iPlayCount );
    LOG1( "CRtpClipManager::GetDetailsL(), iPlaySpot: %d", aDetails.iPlaySpot );
    LOG1( "CRtpClipManager::GetDetailsL(), iParental: %d", aDetails.iParental );

    // ESG
    aMetaHeader->ReadEsgDataL( aDetails.iService, aDetails.iProgram );
    LOG1( "CRtpClipManager::GetDetailsL(), iService: %S", &aDetails.iService );
    LOG1( "CRtpClipManager::GetDetailsL(), iProgram: %S", &aDetails.iProgram );
    
    // Start time
    aMetaHeader->ReadStartTimeL( aDetails.iStartTime );
    
    // End time
    aMetaHeader->ReadEndTimeL( aDetails.iEndTime );

#if defined( LIVE_TV_RDEBUG_TRACE ) || defined( LIVE_TV_FILE_TRACE )
    TName time( KNullDesC ); aDetails.iEndTime.FormatL( time, KTimeDateFormat );
    LOG1( "CRtpClipManager::GetDetailsL(), End time: %S", &time );
#endif // LIVE_TV_RDEBUG_TRACE || LIVE_TV_FILE_TRACE

    // Duration
    aMetaHeader->ReadDurationL( aDetails.iDuration );
    LOG1( "CRtpClipManager::GetDetailsL(), iDuration: %d", aDetails.iDuration );
    aDetails.iDuration/= 1000; // convert to seconds

    // Post acquisition
    aDetails.iPostRuleOk = !VerifyPostRuleL( aAttributes.iPostRule, aMetaHeader );
    LOG1( "CRtpClipManager::GetDetailsL(), iPostRuleOk: %d", aDetails.iPostRuleOk );
    }

// -----------------------------------------------------------------------------
// CRtpClipManager::NewClipRootL
// Root path of the new clip, depends on user media setting.
// If memory card is selected, but not available, default saving to phone memory.
// -----------------------------------------------------------------------------
//
void CRtpClipManager::NewClipRootL( TDes& aClipPath, const TDriveNumber aDrive )
    {
    // Begin of the save path
    if ( aDrive == EDriveC )
        {
        aClipPath = PathInfo::PhoneMemoryRootPath();
        aClipPath.Append( PathInfo::VideosPath() );
        }
    else
        {
        aClipPath = PathInfo::MemoryCardRootPath();
        aClipPath.Append( PathInfo::VideosPath() );
        }
    
    // Verify and create path if not exist
    if ( !BaflUtils::PathExists( iFs, aClipPath ) )
        {
        TInt err( iFs.MkDirAll( aClipPath ) );
        if ( err && aDrive != EDriveC )
            {
            LOG1( "CRtpClipManager::NewClipRootL(), Forced to Use Phone Memory !", err );

            // Memorycard not acceptable -> Use phone memory
            err = KErrNone;
            aClipPath = PathInfo::PhoneMemoryRootPath();
            aClipPath.Append( PathInfo::VideosPath() );
            BaflUtils::EnsurePathExistsL( iFs, aClipPath );
            }
        
        User::LeaveIfError( err );
        }
    }

// -----------------------------------------------------------------------------
// CRtpClipManager::NewIndexNameL
// Creates new clip name from program name (eigth first letters + index).
// If program name allready in use, adds indexing to the end of name.
// -----------------------------------------------------------------------------
//
void CRtpClipManager::NewIndexNameL( TDes& aClipPath, const TDesC& aProgram )
    {
    LOG1( "CRtpClipManager::NewIndexNameL(), aClipPath  : %S", &aClipPath );
    LOG1( "CRtpClipManager::NewIndexNameL(), aProgram   : %S", &aProgram );

    // Remove special characters
    TBuf<KMaxProgramChars> program( aProgram.Left( KMaxProgramChars ) );
    for ( TInt i( program.Length() - 1 ); i >= 0; i-- )
        {
        TChar letter( program[i] );
        // Remove if not alpha nor space
        if ( !letter.IsAlphaDigit() && !letter.IsSpace() )
            {
            program.Delete( i, 1 );
            }
        }
    program.TrimRight();
    
    TInt index( KFirstFileIndex );
    
    // Test name for existing clip check
    TPath testName( aClipPath );
    if ( program.Length() )
        {
        testName.Append( program );
        }
    else
        {
        // Zero length program name, start from "(01).rtp"
        testName.AppendFormat( KIndexFormat, index++ );        
        }

    // Name already used ?
    testName.Append( KDvrClipExtension );
    if ( BaflUtils::FileExists( iFs, testName ) )
        {
        do
            {
            LOG1( "CRtpClipManager::NewIndexNameL(), Clip exist: %S", &testName );
            
            // Abort if file index exceeds "(99)"
            User::LeaveIfError( ( index > KMaxFileIndex ) * KErrOverflow );
            
            // New test name
            testName.Copy( aClipPath );
            testName.Append( program );
            testName.AppendFormat( KIndexFormat, index++ );
            testName.Append( KDvrClipExtension );
            }
            while ( BaflUtils::FileExists( iFs, testName ) );
        }
    
    // Return suitable filename
    aClipPath.Copy( testName );
    }
    
// -----------------------------------------------------------------------------
// CRtpClipManager::AddClipToRepairQueueL
// Inserts new clip name to the first in queue.
// -----------------------------------------------------------------------------
//
void CRtpClipManager::AddClipToRepairQueueL( const TDesC& aClipPath )
    {
    HBufC* clip = aClipPath.AllocLC();
    User::LeaveIfError( iRepairQueue.Insert( clip, 0 ) );
    CleanupStack::Pop( clip );
    }

// End of File