// Copyright (c) 2006-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 <bautils.h>

#include <f32file.h>

#include <mtp/tmtptyperequest.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mtpprotocolconstants.h>

#include <mtp/cmtptypestring.h>

#include <mtp/mmtpobjectmgr.h>

#include "cmtpsetobjectprotection.h"

#include "mtpdpconst.h"

#include "mtpdppanic.h"

#include "cmtpdataprovidercontroller.h"

#include "mtpframeworkconst.h"

#include "rmtpdpsingletons.h"

#include "rmtputility.h"

#include "cmtpstoragemgr.h"

/**

Verification data for the SetObjectPropValue request

*/

const TMTPRequestElementInfo KMTPSetObjectProtectionPolicy[] = 

    {

        {TMTPTypeRequest::ERequestParameter1, EMTPElementTypeObjectHandle, EMTPElementAttrWrite, 0, 0, 0},      

     };

const TInt KRetryTimes = 10;

const TInt KRetryInterval = 150 * 1000; //150ms

/**

Two-phase construction method

@param aPlugin  The data provider plugin

@param aFramework   The data provider framework

@param aConnection  The connection from which the request comes

@return a pointer to the created request processor object

*/ 

EXPORT_C MMTPRequestProcessor* CMTPSetObjectProtection::NewL(

                                            MMTPDataProviderFramework& aFramework,

                                            MMTPConnection& aConnection)

    {

    CMTPSetObjectProtection* self = new (ELeave) CMTPSetObjectProtection(aFramework, aConnection);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

Destructor

*/  

EXPORT_C CMTPSetObjectProtection::~CMTPSetObjectProtection()

    {   

    delete iObjMeta;

    iSingletons.Close();

    }

/**

Standard c++ constructor

*/  

CMTPSetObjectProtection::CMTPSetObjectProtection(

                                    MMTPDataProviderFramework& aFramework,

                                    MMTPConnection& aConnection)

    :CMTPRequestProcessor(aFramework, aConnection, sizeof(KMTPSetObjectProtectionPolicy)/sizeof(TMTPRequestElementInfo), KMTPSetObjectProtectionPolicy),

    iRfs(aFramework.Fs())

    {

    }

TMTPResponseCode CMTPSetObjectProtection::CheckRequestL()

    {

    //TMTPResponseCode responseCode = CMTPRequestProcessor::CheckRequestL();

    TUint32 handle = Request().Uint32(TMTPTypeRequest::ERequestParameter1);

    iFramework.ObjectMgr().ObjectL(TMTPTypeUint32(handle), *iObjMeta);

    if (!iObjMeta )

        {

        return EMTPRespCodeInvalidObjectHandle;

        }

    if(!iSingletons.StorageMgr().IsReadWriteStorage(iObjMeta->Uint(CMTPObjectMetaData::EStorageId)))

		{

		return EMTPRespCodeAccessDenied; //EMTPRespCodeStoreReadOnly

		}

    TUint32 statusValue = Request().Uint32(TMTPTypeRequest::ERequestParameter2);

    //Currently we only support EMTPProtectionNoProtection and EMTPProtectionReadOnly

    if ( statusValue!=EMTPProtectionNoProtection && statusValue!=EMTPProtectionReadOnly )

        {

        return EMTPRespCodeInvalidParameter;

        }

    return EMTPRespCodeOK;

    }

void CMTPSetObjectProtection::ServiceL()

    {

    TUint32 handle = Request().Uint32(TMTPTypeRequest::ERequestParameter1);

    TUint32 statusValue = Request().Uint32(TMTPTypeRequest::ERequestParameter2);

    TMTPResponseCode rsp = EMTPRespCodeAccessDenied;

    //iFramework.ObjectMgr().ObjectL(TMTPTypeUint32(handle), *iObjMeta);

    switch(statusValue)

        {

        case EMTPProtectionNoProtection:

            {

            for(TInt i = 0; i < KRetryTimes; ++ i)

                {

                if(KErrNone == iRfs.SetAtt(iObjMeta->DesC(CMTPObjectMetaData::ESuid),KEntryAttNormal,KEntryAttReadOnly))

                    {

                    rsp = EMTPRespCodeOK;

                    break;

                    }

                else

                    {

                    User::After(KRetryInterval);	

                    }

                }

            }

            break;

        case EMTPProtectionReadOnly:

        case EMTPProtectionReadOnlyData:

            {

            for(TInt i = 0; i < KRetryTimes; ++ i)

                {

                if(KErrNone == iRfs.SetAtt(iObjMeta->DesC(CMTPObjectMetaData::ESuid),KEntryAttReadOnly,KEntryAttNormal))

                    {

                        rsp = EMTPRespCodeOK;

                        break;

                    }

                    else

                    {

                        User::After(KRetryInterval);	

                    }

                }

            }

            break;

        default:

            rsp = EMTPRespCodeInvalidParameter;

            break;

        }

    SendResponseL(rsp);

    }

/**

Second-phase construction

*/          

void CMTPSetObjectProtection::ConstructL()

    {   

    iObjMeta = CMTPObjectMetaData::NewL();

    iSingletons.OpenL();

    }