/*
* Copyright (c) 2006 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:  Implementation of CBavpMediaRecognizer
*
*/


// INCLUDE FILES
#include <eikenv.h>
#include <bautils.h>
#include <mmf/server/mmfdatasourcesink.hrh>
#include <mmf/common/mmfcontrollerpluginresolver.h>

#include "BavpMediaRecognizer.h"
#include "BavpLogger.h"

// CONSTANTS
_LIT8(KDataTypeRAM, "audio/x-pn-realaudio-plugin");
_LIT8(KDataTypeSDP, "application/sdp");
_LIT8(KDataTypePlaylist, "audio/mpegurl");
_LIT8(KDataTypeRNG, "application/vnd.nokia.ringing-tone"); 
_LIT8(KDataTypeMp3, "audio/mp3"); 
_LIT8(KDataTypeXmp3, "audio/x-mp3"); 
_LIT8(KDataTypeAudio3gp, "audio/3gpp");

#if defined(BRDO_ASX_FF)
_LIT8(KDataTypeWvx, "video/x-ms-wvx");
_LIT8(KDataTypeWax, "audio/x-ms-wax");
_LIT8(KDataTypeAsx, "video/x-ms-asx");
#endif // BRDO_ASX_FF

_LIT(KUrlRtsp, "rtsp:");

const TInt KDefaultBufferSize = 1000;
 
// _LIT(KRamFileExtension,".ram");

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

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

// -----------------------------------------------------------------------------
// CBavpMediaRecognizer::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
void CBavpMediaRecognizer::ConstructL()
    {
    User::LeaveIfError( iRecognizer.Connect() );
    if ( iRecognizer.GetMaxDataBufSize( iBufSize) || iBufSize <= 0 )
        {
        iBufSize = KDefaultBufferSize;
        }
    CreateVideoFormatsArrayL();
    CreateAudioFormatsArrayL();
    }

// -----------------------------------------------------------------------------
// CBavpMediaRecognizer::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
CBavpMediaRecognizer* CBavpMediaRecognizer::NewL()
    {
    CBavpMediaRecognizer* self = new( ELeave ) CBavpMediaRecognizer; 
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

// -----------------------------------------------------------------------------
// CBavpMediaRecognizer::~CBavpMediaRecognizer   
// Destructor
// -----------------------------------------------------------------------------
CBavpMediaRecognizer::~CBavpMediaRecognizer()
    {
    iVideoControllers.ResetAndDestroy();
    iAudioControllers.ResetAndDestroy();
    iRecognizer.Close();
    iFileHandle.Close();
    }

// -----------------------------------------------------------------------------
//  CBavpMediaRecognizer::IdentifyMediaTypeL
// -----------------------------------------------------------------------------
TBavpMediaType
CBavpMediaRecognizer::IdentifyMediaTypeL( const TDesC& aMediaName, 
                                          TBool aIncludeUrls )
    {
    TBavpMediaType ret = EUnidentified;

    if ( BaflUtils::FileExists( CEikonEnv::Static()->FsSession(), aMediaName ) )
        {
        TDataRecognitionResult fileRecognitionResult;
        RecognizeFileL( aMediaName, fileRecognitionResult );
        
        if ( !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeSDP ) )
            {
            ret = ELocalSdpFile;
            Log( EFalse, _L("CBavpMediaRecognizer::IdentifyMediaTypeL - ELocalSdpFile") );
            }
        
        if ( ret == EUnidentified && 
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypePlaylist ) )
            {
            ret = ELocalAudioPlaylist;
            Log( EFalse, _L("CBavpMediaRecognizer::IdentifyMediaTypeL - ELocalAudioPlaylist") );
            }
        
        if ( ret == EUnidentified && 
             FileHasAudioSupport( aMediaName, fileRecognitionResult ) || 
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeRNG ) ||
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeMp3 ) ||
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeXmp3 ) ||
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeAudio3gp ) ) 
            {
            ret = ELocalAudioFile; 
            Log( EFalse, _L("CBavpMediaRecognizer::IdentifyMediaTypeL - ELocalAudioFile") );
            }
        
        if ( ret == EUnidentified && 
             FileHasVideoSupport( aMediaName, fileRecognitionResult ) )
            {
            ret = ELocalVideoFile;
            Log( EFalse, _L("CBavpMediaRecognizer::IdentifyMediaTypeL - ELocalVideoFile") );
            }
        
        if ( ret == EUnidentified && 
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeRAM ) )
            {
            ret = ELocalRamFile;
            Log( EFalse, _L("CBavpMediaRecognizer::IdentifyMediaTypeL - ELocalRamFile") );
            }
#if defined(BRDO_ASX_FF)
        if ( ret == EUnidentified && 
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeWvx ) ||
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeWax ) ||
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeAsx ))
            {
            ret = ELocalAsxFile;
            Log( EFalse, _L("CBavpMediaRecognizer::IdentifyMediaTypeL - ELocalAsxFile") );
            }
#endif // BRDO_ASX_FF
        }
    else
        {
        if ( aIncludeUrls && ValidUrl( aMediaName ) )
            {
            ret = EUrl;
            Log( EFalse, _L("CBavpMediaRecognizer::IdentifyMediaTypeL - EUrl") );
            }
        }
    return ret;
    }

// -----------------------------------------------------------------------------
//  CBavpMediaRecognizer::IdentifyMediaTypeL 
// -----------------------------------------------------------------------------
TBavpMediaType 
CBavpMediaRecognizer::IdentifyMediaTypeL( const TDesC& aMediaName, 
                                          RFile& aFile,
                                          TBool aIncludeUrls )
    {
    if( aFile.SubSessionHandle() )
        {
        User::LeaveIfError( iFileHandle.Duplicate( aFile ) ); 
        }
    
    TBavpMediaType ret = EUnidentified;

    if ( BaflUtils::FileExists( CEikonEnv::Static()->FsSession(), aMediaName ) || FileHandleExists() ) 
        {
        TDataRecognitionResult fileRecognitionResult;
        RecognizeFileL( aMediaName, fileRecognitionResult );
        
        if ( !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeSDP ) )
            {
            ret = ELocalSdpFile;
            Log( EFalse, _L("CBavpMediaRecognizer::IdentifyMediaTypeL - ELocalSdpFile") );
            }
            
        if ( ret == EUnidentified && 
             !fileRecognitionResult.iDataType.Des8().CompareF( 
             KDataTypePlaylist ) )
            {
            ret = ELocalAudioPlaylist;
            Log( EFalse, _L("CBavpMediaRecognizer::IdentifyMediaTypeL - ELocalAudioPlaylist") );
            }
        
        if ( ret == EUnidentified && 
             FileHasAudioSupport( aMediaName, fileRecognitionResult ) || 
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeRNG ) ||
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeMp3 ) ||
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeXmp3 ) ||
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeAudio3gp ) ) 
            {
            ret = ELocalAudioFile; 
            Log( EFalse, _L("CBavpMediaRecognizer::IdentifyMediaTypeL - ELocalAudioFile") );
            }

        if ( ret == EUnidentified && 
             FileHasVideoSupport( aMediaName, fileRecognitionResult ) )
            {
            ret = ELocalVideoFile;
            Log( EFalse, _L("CBavpMediaRecognizer::IdentifyMediaTypeL - ELocalVideoFile") );
            }

        if ( ret == EUnidentified && 
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeRAM ) )
            {
            ret = ELocalRamFile;
            Log( EFalse, _L("CBavpMediaRecognizer::IdentifyMediaTypeL - ELocalRamFile") );
            }
#if defined(BRDO_ASX_FF)
        if ( ret == EUnidentified && 
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeWvx ) ||
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeWax ) ||
             !fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeAsx ) )
            {
            ret = ELocalAsxFile;
            Log( EFalse, _L("CBavpMediaRecognizer::IdentifyMediaTypeL - ELocalAsxFile") );
            }
#endif // BRDO_ASX_FF
        }
    else
        {
        if (aIncludeUrls && ValidUrl(aMediaName))
            {
            ret = EUrl;
            }
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CBavpMediaRecognizer::MimeTypeL
// -----------------------------------------------------------------------------
TBuf<KMaxDataTypeLength>
CBavpMediaRecognizer::MimeTypeL( const TDesC& aLocalFile )
    {
    TDataRecognitionResult fileRecognitionResult;
    RecognizeFileL( aLocalFile,fileRecognitionResult );
    
    if ( fileRecognitionResult.iConfidence >= CApaDataRecognizerType::EPossible )
        {
        return fileRecognitionResult.iDataType.Des();
        }
        
    return KNullDesC();
    }

// -----------------------------------------------------------------------------
// CBavpMediaRecognizer::FileHasVideoSupport
// -----------------------------------------------------------------------------
TBool CBavpMediaRecognizer::FileHasVideoSupport( const TDesC& /*aFileName*/, 
                                TDataRecognitionResult& aFileRecognitionResult)
    {
    // Try with mime type
    // We have a good quess -> go with mime type
    if ( aFileRecognitionResult.iConfidence >= CApaDataRecognizerType::EPossible )
        {
        for (TInt i = 0 ; i < iVideoControllers.Count() ; i++)
            {           
            RMMFFormatImplInfoArray formats = 
                        iVideoControllers[i]->PlayFormats();
                for ( TInt j = 0; j < formats.Count() ; j++ )
                    { 
                    if ( formats[j]->SupportsMimeType( 
                            aFileRecognitionResult.iDataType.Des8() ) )
                        return ETrue;
                    }
            }
        } 
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CBavpMediaRecognizer::FileHasAudioSupport
// -----------------------------------------------------------------------------
TBool CBavpMediaRecognizer::FileHasAudioSupport(const TDesC& aFileName, 
                               TDataRecognitionResult& aFileRecognitionResult )
    {
     // try with mime type
    // we have a good quess -> gogo with mime type
    if (aFileRecognitionResult.iConfidence >= CApaDataRecognizerType::EPossible)
        {
        for (TInt i = 0 ; i < iAudioControllers.Count() ; i++)
            {           
            RMMFFormatImplInfoArray formats = 
                    iAudioControllers[i]->PlayFormats();
                for (TInt j = 0; j < formats.Count() ; j++)
                    { 
                    if ( formats[j]->SupportsMimeType( 
                            aFileRecognitionResult.iDataType.Des8() ) )
                        return ETrue;
                    }
            }
        }
 
    // we can't quess -> try with file extension
    else
        {
        TParsePtrC parser(aFileName);
        TBuf8<KMaxFileName> fileExtension;
        fileExtension.Copy(parser.Ext());
        for (TInt i = 0 ; i < iVideoControllers.Count() ; i++)
            {
            RMMFFormatImplInfoArray formats = 
                    iAudioControllers[i]->PlayFormats();
            for (TInt j = 0; j < formats.Count() ; j++)
                {
                if (formats[j]->SupportsFileExtension(fileExtension))
                    return ETrue;
                }
            }
        }
   
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CBavpMediaRecognizer::ValidUrl
// -----------------------------------------------------------------------------
TBool CBavpMediaRecognizer::ValidUrl(const TDesC& aUrl)
    {
    TBool ret = EFalse;
    if (aUrl.Find(KUrlRtsp) == 0)
        {
        ret = ETrue;
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CBavpMediaRecognizer::MimeTypeL
// -----------------------------------------------------------------------------
TBuf<KMaxDataTypeLength> CBavpMediaRecognizer::MimeTypeL(RFile& aFile)
    {
    if( aFile.SubSessionHandle() )
        {
        // Preferred
        User::LeaveIfError( iFileHandle.Duplicate( aFile ) ); 
        }

    // If new handle is not valid, old might still be
    if ( !FileHandleExists() )
        {
        User::Leave( KErrBadHandle );
        }

    TDataRecognitionResult fileRecognitionResult;
    RecognizeFileL( KNullDesC(), fileRecognitionResult );
    
    if (fileRecognitionResult.iConfidence >= CApaDataRecognizerType::EPossible)
        {
        return fileRecognitionResult.iDataType.Des();
        }
    return KNullDesC();
    }

// -----------------------------------------------------------------------------
// CBavpMediaRecognizer::CreateVideoFormatsArrayL
// -----------------------------------------------------------------------------
void CBavpMediaRecognizer::CreateVideoFormatsArrayL()
    {
    CMMFControllerPluginSelectionParameters* cSelect = 
            CMMFControllerPluginSelectionParameters::NewLC();
    
    CMMFFormatSelectionParameters* fSelect = 
            CMMFFormatSelectionParameters::NewLC();
    
    // Set the play and record format selection parameters to be blank.  
    // - format support is only retrieved if requested.
    cSelect->SetRequiredPlayFormatSupportL(*fSelect);
    
    // Set the media ids
    RArray<TUid> mediaIds;
    CleanupClosePushL(mediaIds);
    User::LeaveIfError(mediaIds.Append(KUidMediaTypeVideo));
    
    // Get plugins that support at least video
    cSelect->SetMediaIdsL( mediaIds, 
            CMMFPluginSelectionParameters::EAllowOtherMediaIds );
    
    // iVideoControllers contains now all plugins that support at least video
    cSelect->ListImplementationsL(iVideoControllers);           
    
    // Clean up
    CleanupStack::PopAndDestroy( 3 ); // fSelect, cSelect, mediaIds
    }

// -----------------------------------------------------------------------------
// CBavpMediaRecognizer::CreateAudioFormatsArrayL
// -----------------------------------------------------------------------------
void CBavpMediaRecognizer::CreateAudioFormatsArrayL()
    {
    CMMFControllerPluginSelectionParameters* cSelect = 
            CMMFControllerPluginSelectionParameters::NewLC();

    CMMFFormatSelectionParameters* fSelect = 
            CMMFFormatSelectionParameters::NewLC();

    // Set the play and record format selection parameters to be blank.  
    // - format support is only retrieved if requested.
    cSelect->SetRequiredPlayFormatSupportL( *fSelect );

    // Set the media ids
    RArray<TUid> mediaIds;
    CleanupClosePushL( mediaIds );
    User::LeaveIfError( mediaIds.Append(KUidMediaTypeAudio) );

    // Get plugins that supports audio only
    cSelect->SetMediaIdsL( mediaIds, 
            CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds ); 

    // iAudioControllers contains now all audio plugins that 
    // support at least audio.
    cSelect->ListImplementationsL( iAudioControllers );           

    // Clean up
    CleanupStack::PopAndDestroy( 3 ); // fSelect, cSelect, mediaIds
    }

// -----------------------------------------------------------------------------
// CBavpMediaRecognizer::RecognizeFileL
// -----------------------------------------------------------------------------
void CBavpMediaRecognizer::RecognizeFileL( const TDesC& aFileName, 
                                           TDataRecognitionResult& aResult )
    {
    aResult.Reset();
    HBufC8* fBuf = HBufC8::NewLC( iBufSize ); // fBuf in CS
    TPtr8 fileBuf = fBuf->Des();
 
    // Recognize file
    if ( FileHandleExists() )
        {
        User::LeaveIfError( iRecognizer.RecognizeData( iFileHandle, aResult ) );
        }
    else
        {
        // Read file
        User::LeaveIfError( ReadFile( aFileName, fileBuf ) );   
        User::LeaveIfError( iRecognizer.RecognizeData( aFileName, fileBuf, aResult ) ); 
        }
   
    CleanupStack::PopAndDestroy(); // fBuf
    }

// -----------------------------------------------------------------------------
// CBavpMediaRecognizer::ReadFile
// -----------------------------------------------------------------------------
TInt CBavpMediaRecognizer::ReadFile( const TDesC& aFileName, TDes8& aBuf )
    {
    RFile file;
    TInt err;

    if ( FileHandleExists() )
        {
        err = file.Duplicate( iFileHandle ); 
        }
    else
        {
        err = file.Open( CEikonEnv::Static()->FsSession(), aFileName,
                         EFileRead | EFileShareAny );
        if ( err ) 
            {
            err = file.Open( CEikonEnv::Static()->FsSession(), aFileName,
                             EFileRead | EFileShareReadersOnly );
            } 
        }

    if ( err )
        {
        // If file does not exist
        return err;
        }

    // Read the beginning of the file
    err = file.Read( 0, aBuf, iBufSize );
    file.Close();

    return err;
    }

// -----------------------------------------------------------------------------
// CBavpMediaRecognizer::FileHandleExists
// -----------------------------------------------------------------------------
TBool CBavpMediaRecognizer::FileHandleExists()
    {
    TInt size(0);
    TInt err(0);

    if ( iFileHandle.SubSessionHandle() )
        {
        err = iFileHandle.Size( size );
        }
    
    return ( !err && size ) ? ETrue : EFalse;
    }

//  End of File