/*
* Copyright (c) 2005 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:  Container of the one reactive authorization request
*
*/

// INCLUDE FILES
#include    "CPEngAuthorizationRequest.h"
#include 	"MPEngAuthorizationRequest.h"
#include 	"MPEngAuthorizationManagerSet.h"

#include    <e32std.h>
#include    <s32strm.h>


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

// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::CPEngAuthorizationRequest()
// -----------------------------------------------------------------------------
//
CPEngAuthorizationRequest::CPEngAuthorizationRequest( TInt& aSize )
        : CPEngAuthorizationItem( aSize ),
        iState( EPEngAuthPending ),
        iResponseType( MPEngAuthorizationRequest::EPEngAuthUndefined )
    {
    // state, response type, 2 array count, 4bytes each
    iSize += 16;
    }

// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::ConstructL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::ConstructL( const TDesC& aUserId )
    {
    CPEngAuthorizationItem::ConstructL( aUserId );
    }

// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::NewLC()
// -----------------------------------------------------------------------------
//
CPEngAuthorizationRequest* CPEngAuthorizationRequest::NewLC( const TDesC& aUserId,
                                                             TInt& aSize )
    {
    CPEngAuthorizationRequest* self = new( ELeave )
    CPEngAuthorizationRequest( aSize );

    CleanupStack::PushL( self );
    self->ConstructL( aUserId );

    return self;
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::NewLC()
// -----------------------------------------------------------------------------
//
CPEngAuthorizationRequest* CPEngAuthorizationRequest::NewLC( RReadStream& aStream,
                                                             TInt& aSize )
    {
    CPEngAuthorizationRequest* self = new( ELeave )
    CPEngAuthorizationRequest( aSize );

    CleanupStack::PushL( self );
    self->InternalizeL( aStream );

    return self;
    }


// Destructor
CPEngAuthorizationRequest::~CPEngAuthorizationRequest()
    {
    // state, response type, 4bytes each
    iSize -= ( 8 + SizeOfArray( iRequestedAttr ) + SizeOfArray( iAuthorizedAttr ) );
    iRequestedAttr.Reset();
    iAuthorizedAttr.Reset();
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::UpdateLocalFlags()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::DoUpdateLocalFlags(
    const CPEngAuthorizationItem& aSource )
    {
    const CPEngAuthorizationRequest& source =
        static_cast< const CPEngAuthorizationRequest&> ( aSource );
    if ( ( source.AuthorizationState() == AuthorizationState() ) &&
         ( source.AuthorizationResponse() == AuthorizationResponse() ) )
        {
        iLocalFlags = source.LocalFlags();
        }
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::UserId()
// -----------------------------------------------------------------------------
//
const TDesC& CPEngAuthorizationRequest::UserId() const
    {
    return Id();
    }

// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::RequestedAttributes()
// -----------------------------------------------------------------------------
//
const RArray<TUint32>& CPEngAuthorizationRequest::RequestedAttributes() const
    {
    return iRequestedAttr;
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::AuthorizationState()
// -----------------------------------------------------------------------------
//
MPEngAuthorizationRequest::TPEngAuthorizationRequestState
CPEngAuthorizationRequest::AuthorizationState() const
    {
    return iState;
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::AuthorizationResponse()
// -----------------------------------------------------------------------------
//
MPEngAuthorizationRequest::TPEngAuthorizationResponseType
CPEngAuthorizationRequest::AuthorizationResponse()const
    {
    return iResponseType;
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::AuthorizedAttributes()
// -----------------------------------------------------------------------------
//
const RArray<TUint32>& CPEngAuthorizationRequest::AuthorizedAttributes() const
    {
    return iAuthorizedAttr;
    }


// =============================================================================
// ========== Functions for authorization response setting =====================
// =============================================================================

// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::SetAuthorizedAttributesL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::SetAuthorizedAttributesL(
    TArray<TUint32>& aAttributes,
    TBool aKeepOldAuthorization /* ETRue */ )
    {
    iAuthManager->SetAuthorizedAttributesL( *this,
                                            aAttributes,
                                            aKeepOldAuthorization );
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::DenyAuthorizationL
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::DenyAuthorizationL()
    {
    if ( iState != MPEngAuthorizationRequest::EPEngAuthPending )
        {
        User::Leave( KErrNotReady );
        }
    iAuthManager->DenyAuthorizationL( Id() );
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::CancelAuthorizationL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::CancelAuthorizationL()
    {
    if ( iState == MPEngAuthorizationRequest::EPEngAuthPending )
        {
        User::Leave( KErrNotReady );
        }

    iAuthManager->CancelAuthorizationL( Id() );
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::RemoveAuthorizationResponse
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::RemoveAuthorizationResponse()
    {
    iAuthManager->RemoveAuthorizationResponse( Id() );
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::SetAuthorizationManager()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::SetAuthorizationManager(
    MPEngAuthorizationManagerSet* aAuthManager )
    {
    iAuthManager = aAuthManager;
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::SetAuthState()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::SetAuthState(
    TPEngAuthorizationRequestState aState )
    {
    iState = aState;
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::SetAuthState()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::SetAuthResponse(
    TPEngAuthorizationResponseType aResponse )
    {
    iResponseType = aResponse;
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::UpdateAuthorizedAttributesL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::UpdateAuthorizedAttributesL(
    const RArray<TUint32>& aAuthorizedAttr )
    {
    // 4 bytes per each attribute
    iSize -= 4 * iAuthorizedAttr.Count();
    iAuthorizedAttr.Reset();
    iSize += CopyArrayContentL( iAuthorizedAttr, aAuthorizedAttr.Array() );
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::UpdateRequestedAttributesL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::UpdateRequestedAttributesL(
    const RArray<TUint32>& aRequestedAttr )
    {
    // 4 bytes per each attribute
    iSize -= 4 * iRequestedAttr.Count();
    iRequestedAttr.Reset();
    iSize +=  CopyArrayContentL( iRequestedAttr, aRequestedAttr.Array() );
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::AddRequestedAttributeL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::AddRequestedAttributeL( TUint32 aAttribute )
    {
    iSize += AddAttributeToArrayL( iRequestedAttr, aAttribute );
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::ExternalizeL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::ExternalizeL( RWriteStream& aStream ) const
    {
    // base class
    CPEngAuthorizationItem::ExternalizeL( aStream );

    // state, response type
    aStream.WriteInt32L( iState );
    aStream.WriteInt32L( iResponseType );

    ExternalizeArrayL( aStream, iRequestedAttr );
    ExternalizeArrayL( aStream, iAuthorizedAttr );
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::ExternalizeCachedL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationRequest::InternalizeL( RReadStream& aStream )
    {
    // base class
    CPEngAuthorizationItem::InternalizeL( aStream );

    // state, response type
    iState =
        static_cast<TPEngAuthorizationRequestState>( aStream.ReadInt32L() );

    iResponseType =
        static_cast<TPEngAuthorizationResponseType>( aStream.ReadInt32L() );

    InternalizeArrayL( aStream, iRequestedAttr, iSize );
    InternalizeArrayL( aStream, iAuthorizedAttr, iSize );
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationRequest::Compare()
// -----------------------------------------------------------------------------
//
TInt CPEngAuthorizationRequest::Compare( const CPEngAuthorizationRequest& aFirst,
                                         const CPEngAuthorizationRequest& aSecond )
    {
    return aFirst.Id().CompareF( aSecond.Id() );
    }


//  End of File