// 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:

//

/**

 @file

 @internalTechnology

*/

#include <e32cmn.h>

#include <centralrepository.h>

#include <mtp/tmtptyperequest.h>

#include <mtp/cmtpstoragemetadata.h>

#include <mtp/cmtpobjectmetadata.h>

#include <mtp/mmtpconnection.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mtpdataproviderapitypes.h>

#include <mtp/mtpprotocolconstants.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/mmtpstoragemgr.h>

#include <mtp/cmtpobjectmetadata.h>

#include <mtp/tmtptypeevent.h>

#include "cmtpimagedp.h"

#include "mtpimagedpconst.h"

#include "mtpimagedppanic.h"

#include "cmtprequestprocessor.h"

#include "mtpimagedprequestprocessor.h"

#include "cmtpimagedpthumbnailcreator.h"

#include "mtpimagedputilits.h"

#include "cmtpimagedpmdeobserver.h"

#include "cmtpimagedprenameobject.h"

#include "cmtpimagedpnewpicturesnotifier.h"

static const TInt KArrayGranularity = 3;

static const TInt KDeleteObjectGranularity = 2;

//used by hashmap & hashset class

LOCAL_C TUint32 TBuf16Hash(const TBuf<KMaxExtNameLength>& aPtr)

    {

    return DefaultHash::Des16(aPtr);

    }

LOCAL_C TBool TBuf16Ident(const TBuf<KMaxExtNameLength>& aL, const TBuf<KMaxExtNameLength>& aR)

    {

    return DefaultIdentity::Des16(aL, aR);

    }

/**

 Image data provider factory method.

 @return A pointer to a Image data provider object. Ownership is transfered.

 @leave One of the system wide error codes, if a processing failure occurs.

*/

TAny* CMTPImageDataProvider::NewL(TAny* aParams)

    {

    CMTPImageDataProvider* self = new (ELeave) CMTPImageDataProvider(aParams);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

 Standard C++ constructor

 @param aParams  pointer to MMTPDataProviderFramework

*/

CMTPImageDataProvider::CMTPImageDataProvider(TAny* aParams) :

    CMTPDataProviderPlugin(aParams),

    iActiveProcessors(KArrayGranularity),

    iFormatMappings(&TBuf16Hash, &TBuf16Ident),

    iMimeMappings(&TBuf16Hash, &TBuf16Ident),

    iActiveProcessor(-1),

    iEnumerated(EFalse),

	iDeleteObjectsArray(KDeleteObjectGranularity)

    {

    }

/**

Second-phase construction

*/

void CMTPImageDataProvider::ConstructL()

    {

    iNewPicNotifier = CMTPImageDpNewPicturesNotifier::NewL();

    //Setup central repository connection

    const TUint32 KUidMTPImageRepositoryValue(0x2001FCA2);

    const TUid KUidMTPImageRepository = {KUidMTPImageRepositoryValue};

    iRepository = CRepository::NewL(KUidMTPImageRepository);    

    //Initialize hash map of extention to format code

    TInt count(sizeof(KMTPValidCodeExtensionMappings) / sizeof(KMTPValidCodeExtensionMappings[0]));

    for(TInt i(0); i<count; i++)

        {

        iFormatMappings.Insert(KMTPValidCodeExtensionMappings[i].iExtension, KMTPValidCodeExtensionMappings[i].iFormatCode);

        }    

    //Initialize hash map of extension to mime type

    count = sizeof(KMTPExtensionMimeTypeMappings) / sizeof(KMTPExtensionMimeTypeMappings[0]);

    for(TInt i(0); i<count; i++)

        {

        iMimeMappings.Insert(KMTPExtensionMimeTypeMappings[i].iExtension, KMTPExtensionMimeTypeMappings[i].iMimeType);

        }     

    //Define RProperty of new pictures for status data provider

	RProcess process;

	TUid tSid = process.SecureId();

    _LIT_SECURITY_POLICY_PASS(KAllowReadAll);

    TInt error = RProperty::Define(tSid, KMTPNewPicKey, RProperty::EInt, KAllowReadAll, KAllowReadAll);

    if (error != KErrNone && error != KErrAlreadyExists)

        {

        }    

    iEnumerationNotified = ETrue;

    }

/**

 Destructor

*/

CMTPImageDataProvider::~CMTPImageDataProvider()

    {

    // delete all processor instances

    TUint count(iActiveProcessors.Count());

    while (count--)

        {

        iActiveProcessors[count]->Release();

        }

    iActiveProcessors.Close();

    // image dp unsubscribe from MDS

    if(iMdeObserver)

        {

        TRAP_IGNORE(iMdeObserver->UnsubscribeForChangeNotificationL());

        delete iMdeObserver;

        }        

    delete iThumbnailManager;

    delete iPropertyMgr;       

    delete iRepository;   

    delete iRenameObject;

    delete iNewPicNotifier;

    iFormatMappings.Close();

    iMimeMappings.Close();

    //Try to delete objects in array

    HandleDeleteObjectsArray();

    iDeleteObjectsArray.ResetAndDestroy();

    iNewPicHandles.Reset();

    }

void CMTPImageDataProvider::Cancel()

    {

    }

/**

 Process the event from initiator

 @param aEvent       The event to be processed

 @param aConnection  The connection from which the event comes

*/

void CMTPImageDataProvider::ProcessEventL(const TMTPTypeEvent& aEvent, MMTPConnection& aConnection)

    {

    //Try to delete objects in array

    HandleDeleteObjectsArray();

    TInt idx(LocateRequestProcessorL(aEvent, aConnection));

    if (idx != KErrNotFound)

        {

        iActiveProcessors[idx]->HandleEventL(aEvent);

        }

    }

/**

Process the notification from framework

@param aNotification  The notification to be processed

@param aParams        Notification parmenter

*/

void CMTPImageDataProvider::ProcessNotificationL(TMTPNotification aNotification, const TAny* aParams)

    {

    switch (aNotification)

        {

    case EMTPSessionClosed:

        SessionClosedL(*reinterpret_cast<const TMTPNotificationParamsSessionChange*>(aParams));

        break;

    case EMTPSessionOpened:

        SessionOpenedL(*reinterpret_cast<const TMTPNotificationParamsSessionChange*>(aParams));

        break;

    case EMTPRenameObject:

        RenameObjectL(*reinterpret_cast<const TMTPNotificationParamsHandle*>(aParams));

        break;

    default:

        // Ignore all other notifications.

        break;

        }

    }

/**

 Process the request from initiator

 @param aPhase       The request transaction phase

 @param aRequest     The request to be processed

 @param aConnection  The connection from which the request comes

*/   

void CMTPImageDataProvider::ProcessRequestPhaseL(TMTPTransactionPhase aPhase, const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)

    {    

    //Try to handle objects which need to be deleted

    HandleDeleteObjectsArray();

    TInt idx(LocateRequestProcessorL(aRequest, aConnection));

    __ASSERT_DEBUG((idx != KErrNotFound), Panic(EMTPImageDpNoMatchingProcessor));

    MMTPRequestProcessor* processor(iActiveProcessors[idx]);

    iActiveProcessor = idx;

    iActiveProcessorRemoved = EFalse;    

    TBool result(processor->HandleRequestL(aRequest, aPhase));

    if (iActiveProcessorRemoved)

        {

        processor->Release(); // destroy the processor

        }    

    else if (result)    //destroy the processor

        {

        processor->Release();

        iActiveProcessors.Remove(idx);

        }

    iActiveProcessor = -1;

    }

/**

 Starts the enumeration of the image dp

*/

void CMTPImageDataProvider::StartObjectEnumerationL(TUint32 aStorageId, TBool /*aPersistentFullEnumeration*/)

    {

    TBool isComplete = ETrue;

    iEnumerationNotified = EFalse;

    if (aStorageId == KMTPStorageAll)

        {

        /*

         * framework notify data provider to enumerate

         * 

         */

        if (iPropertyMgr == NULL)

            {

            iPropertyMgr = CMTPImageDpObjectPropertyMgr::NewL(Framework(), *this);

            isComplete = EFalse;

            }

        iEnumerated = ETrue;

        }

    if (isComplete)

        {

        NotifyEnumerationCompleteL(aStorageId, KErrNone);

        }

    }

/**

Starts enumerate imagedp storage, just declare complete

*/

void CMTPImageDataProvider::StartStorageEnumerationL()

    {

    }

/**

Defines the supported operations and formats of the data provider

@param aCategory Defines what MTP is quering the DP about

@param aArray Supported() edits array to append supported features

*/

void CMTPImageDataProvider::Supported(TMTPSupportCategory aCategory, RArray<TUint>& aArray) const

    {

    switch (aCategory) 

        {        

    case EEvents:

        {

        TInt count(sizeof(KMTPImageDpSupportedEvents) / sizeof(KMTPImageDpSupportedEvents[0]));

        for (TInt i(0); (i < count); i++)

            {

            aArray.Append(KMTPImageDpSupportedEvents[i]);

            }  

        }

        break;

    case EObjectPlaybackFormats: // formats that can be placed on the device

	/*intentional fall through*/ 

    case EObjectCaptureFormats: // formats the device generates

        {

        TInt count(sizeof(KMTPValidCodeExtensionMappings) / sizeof(KMTPValidCodeExtensionMappings[0]));

        for(TInt i(0); (i < count); i++)

            {

            if(aArray.Find(KMTPValidCodeExtensionMappings[i].iFormatCode)==KErrNotFound) // KMTPValidCodeExtensionMappings may contain format code more than once

                {

                aArray.Append(KMTPValidCodeExtensionMappings[i].iFormatCode);

                }

            }

        }

        break;

    case EObjectProperties:

        {

        TInt count(sizeof(KMTPImageDpSupportedProperties) / sizeof(KMTPImageDpSupportedProperties[0]));

        for (TInt i(0); (i < count); i++)

            {

            aArray.Append(KMTPImageDpSupportedProperties[i]);

            }   

        }

        break; 

    case EOperations:

        {

        TInt count(sizeof(KMTPImageDpSupportedOperations) / sizeof(KMTPImageDpSupportedOperations[0]));

        for (TInt i(0); (i < count); i++)

            {

            aArray.Append(KMTPImageDpSupportedOperations[i]);

            }   

        }

        break;  

    case EStorageSystemTypes:

        aArray.Append(CMTPStorageMetaData::ESystemTypeDefaultFileSystem);

        break; 

    default:    

        // Unrecognised category, leave aArray unmodified.

        break;

        }

    }

/**

Defines the supported vendor extension info of the data provider

@param aCategory Defines what MTP is quering the DP about

@param aStrings Supported() edits array to append supported vendor info

*/

void CMTPImageDataProvider::SupportedL(TMTPSupportCategory aCategory, CDesCArray& aStrings) const

    {

    switch (aCategory) 

        {

    case EFolderExclusionSets:

        {

        //do nothing

        }

        break;

    case EFormatExtensionSets:

        {

        _LIT(KFormatExtensionJpg, "0x3801:jpg:::3");//3 means file dp will enumerate all image files instead of image dp.

        aStrings.AppendL(KFormatExtensionJpg);

        _LIT(KFormatExtensionJpe, "0x3801:jpe:::3");

        aStrings.AppendL(KFormatExtensionJpe);

        _LIT(KFormatExtensionJpeg, "0x3801:jpeg:::3");

        aStrings.AppendL(KFormatExtensionJpeg);

        /*

         * bmp files

         */

        _LIT(KFormatExtensionBmp, "0x3804:bmp:::3");

        aStrings.AppendL(KFormatExtensionBmp);

        /*

         * gif files

         */

        _LIT(KFormatExtensionGif, "0x3807:gif:::3");

        aStrings.AppendL(KFormatExtensionGif);

        /*

         * png files

         */

        _LIT(KFormatExtensionPng, "0x380B:png:::3");

        aStrings.AppendL(KFormatExtensionPng);

        /*

         * tif, tiff files

         */

        /*

        _LIT(KFormatExtensionTif, "0x380D:tif::3");

        aStrings.AppendL(KFormatExtensionTif);

        _LIT(KFormatExtensionTiff, "0x380D:tiff::3");

        aStrings.AppendL(KFormatExtensionTiff);

        */                 

        }

        break;

    default:

        // Unrecognised category, leave aArray unmodified.

        break;

        }

    }

/**

Notify framework the image dp has completed enumeration

*/

void CMTPImageDataProvider::NotifyStorageEnumerationCompleteL()

    {

    }

CMTPImageDpThumbnailCreator* CMTPImageDataProvider::ThumbnailManager()

    {

    if(NULL == iThumbnailManager)

        {

        TRAP_IGNORE(iThumbnailManager = CMTPImageDpThumbnailCreator::NewL(*this));

        }

    return iThumbnailManager;

    }

CMTPImageDpObjectPropertyMgr& CMTPImageDataProvider::PropertyMgr()const

	{

	__ASSERT_DEBUG(iPropertyMgr, User::Invariant());

	return *iPropertyMgr;	

	}

CRepository& CMTPImageDataProvider::Repository() const

    {

    __ASSERT_DEBUG(iRepository, User::Invariant());

    return *iRepository;

    }

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

// 

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

//

void CMTPImageDataProvider::NotifyEnumerationCompleteL(TUint32 aStorageId, TInt aError)

#else

void CMTPImageDataProvider::NotifyEnumerationCompleteL(TUint32 aStorageId, TInt /*aError*/)

    {

    if (!iEnumerationNotified)

        {

        iEnumerationNotified = ETrue;

        Framework().ObjectEnumerationCompleteL(aStorageId);

        }

    }

/**

Find or create a request processor that can process the request

@param aRequest    The request to be processed

@param aConnection The connection from which the request comes