/*
* Copyright (c) 2007-2008 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:  Implements CAcpProvider methods
*
*/


#include <fbs.h>
#include <gulicon.h>

#include "acpprovider.h"
#include "accountcreationpluginlogger.h"

// ---------------------------------------------------------------------------
// CAcpProvider::CAcpProvider
// ---------------------------------------------------------------------------
//
CAcpProvider::CAcpProvider() 
    {
    }

// ---------------------------------------------------------------------------
// CAcpProvider::NewL
// ---------------------------------------------------------------------------
//
CAcpProvider* CAcpProvider::NewL()
    {
    CAcpProvider* self = CAcpProvider::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CAcpProvider::NewLC
// ---------------------------------------------------------------------------
//
CAcpProvider* CAcpProvider::NewLC()
    {
    CAcpProvider* self = new ( ELeave ) CAcpProvider();
    CleanupStack::PushL( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CAcpProvider::~CAcpProvider
// ---------------------------------------------------------------------------
//
CAcpProvider::~CAcpProvider()
    {
    ACPLOG( "CAcpProvider::~CAcpProvider begin" );

    delete iProviderName;
    delete iIconUrl;
    delete iSisUrl;
    delete iCreationUrl;
    delete iActivationUrl;
    delete iBitmap;
    delete iMask;
    delete iProviderDescription;
    delete iProviderType;
    delete iMimeType;

    ACPLOG( "CAcpProvider::~CAcpProvider end" );
    }

// ---------------------------------------------------------------------------
// CAcpProvider::CopyL
// Copies provider data from given parameter to member data.
// ---------------------------------------------------------------------------
//
void CAcpProvider::CopyL( const CAcpProvider& aProvider )
    {
    ACPLOG( "CAcpProvider::CopyL begin" );

    SetProviderNameL( aProvider.ProviderName() );
    SetIconUrlL( aProvider.IconUrl() );
    SetPriority( aProvider.Priority() );
    SetSisUrlL( aProvider.SisUrl() );
    SetCreationUrlL( aProvider.CreationUrl() );
    SetActivationUrlL( aProvider.ActivationUrl() );
    SetProviderTypeL( aProvider.ProviderType() );
    SetProviderDescriptionL( aProvider.ProviderDescription() );

    ACPLOG( "CAcpProvider::CopyL end" );
    }

// ---------------------------------------------------------------------------
// CAcpProvider::ProviderName
// Returns name of the provider.
// ---------------------------------------------------------------------------
//
TPtrC CAcpProvider::ProviderName() const
    {
    if ( !iProviderName )
        {
        return KNullDesC();
        }
    return *iProviderName;
    }

// ---------------------------------------------------------------------------
// CAcpProvider::SetProviderNameL
// Sets name of the provider.
// ---------------------------------------------------------------------------
//
void CAcpProvider::SetProviderNameL( const TDesC& aProviderName )
    {
    ACPLOG2( "CAcpProvider::SetProviderNameL: %S", &aProviderName );

    // Check whether the provider name defined or not.
    if ( !aProviderName.Length() )
        {
        return;
        }

    if ( !iProviderName ) 
        {
        iProviderName = HBufC::NewL( aProviderName.Length() );
        }
    else
        {
        iProviderName = iProviderName->ReAllocL( 
            iProviderName->Length() + aProviderName.Length() );
        }
    iProviderName->Des().Append( aProviderName );
    }

// ---------------------------------------------------------------------------
// CAcpProvider::IconUrl
// Returns the location of icons.
// ---------------------------------------------------------------------------
//
TPtrC8 CAcpProvider::IconUrl() const
    {
    if ( !iIconUrl )
        {
        return KNullDesC8();
        }

    return *iIconUrl;
    }

// ---------------------------------------------------------------------------
// CAcpProvider::SetIconUrlL
// Sets the location of icons.
// ---------------------------------------------------------------------------
//
void CAcpProvider::SetIconUrlL( const TDesC8& aIconUrl )
    {
    ACPLOG2( "CAcpProvider::SetIconUrlL: %S", &aIconUrl );

    // Check whether the icon address is defined or not.
    if ( !aIconUrl.Length() )
        {
        return;
        }
 
    if ( !iIconUrl )
        {
        iIconUrl = HBufC8::NewL( aIconUrl.Length() );
        }
    else
        {
        iIconUrl = iIconUrl->ReAllocL( 
            iIconUrl->Length() + aIconUrl.Length() );
        }

    iIconUrl->Des().Append( aIconUrl );
    }

// ---------------------------------------------------------------------------
// CAcpProvider::Priority
// Returns priority of the provider.
// ---------------------------------------------------------------------------
//
TInt CAcpProvider::Priority() const
    {
    return iPriority;
    }

// ---------------------------------------------------------------------------
// CAcpProvider::SetPriority
// Sets priority of the provider.
// ---------------------------------------------------------------------------
//
void CAcpProvider::SetPriority( TInt aPriority )
    {
    ACPLOG2( "CAcpProvider::SetPriority: %d", aPriority );
    iPriority = aPriority;
    }

// ---------------------------------------------------------------------------
// CAcpProvider::SisUrl
// Returns the location of SIS file.
// ---------------------------------------------------------------------------
//
TPtrC8 CAcpProvider::SisUrl() const
    {
    if ( iSisUrl )
        {
        return *iSisUrl;
        }

    return KNullDesC8();
    }

// ---------------------------------------------------------------------------
// CAcpProvider::SetSisUrlL
// Sets the location of SIS file.
// ---------------------------------------------------------------------------
//
void CAcpProvider::SetSisUrlL( const TDesC8& aSisUrl )
    {
    ACPLOG2( "CAcpProvider::SetSisUrlL: %S", &aSisUrl );

    // Check whether the SIS address defined or not.
    if ( !aSisUrl.Length() )
        {
        return;
        }

    if ( !iSisUrl )
        {
        iSisUrl = HBufC8::NewL( aSisUrl.Length() );
        }
    else
        {
        iSisUrl = iSisUrl->ReAllocL( iSisUrl->Length() + aSisUrl.Length() );
        }
    iSisUrl->Des().Append( aSisUrl );

    ACPLOG( "CAcpProvider::SetSisUrlL: end" );
    }

// ---------------------------------------------------------------------------
// CAcpProvider::CreationUrl
// Returns the location of creation URL.
// ---------------------------------------------------------------------------
//
TPtrC8 CAcpProvider::CreationUrl() const
    {
    if ( iCreationUrl )
        {
        return *iCreationUrl;
        }
    return KNullDesC8();
    }

// ---------------------------------------------------------------------------
// CAcpProvider::SetCreationUrlL
// Sets the location of creation URL.
// ---------------------------------------------------------------------------
//
void CAcpProvider::SetCreationUrlL( const TDesC8& aCreationUrl )
    {
    ACPLOG( "CAcpProvider::SetCreationUrlL: begin ");

    // Check whether the creation address defined or not
    if ( !aCreationUrl.Length() )
        {
        return;
        }

    if ( !iCreationUrl )
        {
        iCreationUrl = HBufC8::NewL( aCreationUrl.Length() );
        }
    else
        {
        iCreationUrl = iCreationUrl->ReAllocL( 
            iCreationUrl->Length() + aCreationUrl.Length() );
        }
    iCreationUrl->Des().Append( aCreationUrl );

    ACPLOG( "CAcpProvider::SetCreationUrlL end")
    }    

// ---------------------------------------------------------------------------
// CAcpProvider::ActivationUrl
// Returns the location of activation URL.
// ---------------------------------------------------------------------------
//
TPtrC8 CAcpProvider::ActivationUrl() const
    {
    if ( iActivationUrl )
        {
        return *iActivationUrl;
        }

    return KNullDesC8();
    }

// ---------------------------------------------------------------------------
// CAcpProvider::SetActivationUrlL
// Sets the location of activation URL.
// ---------------------------------------------------------------------------
//
void CAcpProvider::SetActivationUrlL( const TDesC8& aActivationUrl )
    {
    ACPLOG2( "CAcpProvider::SetActivationUrlL: %S", &aActivationUrl );

    // Check whether the activation address defined or not.
    if ( !aActivationUrl.Length() )
        {
        return;
        }

    if ( !iActivationUrl )
        {
        iActivationUrl = HBufC8::NewL( aActivationUrl.Length() );
        }
    else
        {
        iActivationUrl = iActivationUrl->ReAllocL( 
            iActivationUrl->Length() + aActivationUrl.Length() );
        }

    iActivationUrl->Des().Append( aActivationUrl ); 
    }

// ---------------------------------------------------------------------------
// CAcpProvider::ContentData
// Returns the mime type of image file.
// ---------------------------------------------------------------------------
//
TPtrC8 CAcpProvider::ContentData() const
    {
    if ( iMimeType )
        {
        return *iMimeType;
        }
    return KNullDesC8();
    }

// ---------------------------------------------------------------------------
// CAcpProvider::SetContentDataL
// Sets the content type of image file.
// ---------------------------------------------------------------------------
//
void CAcpProvider::SetContentDataL( const TDesC8& aContentData )
    {
    ACPLOG2( "CAcpProvider::SetContentDataL: %S", &aContentData );
    
    // Check whether content data defined or not.
    if ( !aContentData.Length() )
        {
        return;
        }

    if ( !iMimeType )
        {
        iMimeType = HBufC8::NewL( aContentData.Length() );
        }
    else
        {
        iMimeType = iMimeType->ReAllocL( 
            iMimeType->Length() + aContentData.Length() );
        }
    iMimeType->Des().Append( aContentData ); 
    }

// ---------------------------------------------------------------------------
// CAcpProvider::ProviderType
// Returns the provider type
// ---------------------------------------------------------------------------
//
TPtrC CAcpProvider::ProviderType() const
    {
    if ( iProviderType )
        {
        return *iProviderType;
        }
    return KNullDesC();
    }

// ---------------------------------------------------------------------------
// CAcpProvider::SetProviderTypeL
// Sets the provider type
// ---------------------------------------------------------------------------
//
void CAcpProvider::SetProviderTypeL( const TDesC& aProviderType )
    {
    ACPLOG2( "CAcpProvider::SetProviderTypeL: %S", &aProviderType );

    // Check whether provider type defined or not.
    if ( !aProviderType.Length() )
        {
        return;
        }

    if ( !iProviderType )
        {
        iProviderType = HBufC::NewL( aProviderType.Length() );
        }
    else
        {
        iProviderType = iProviderType->ReAllocL( 
            iProviderType->Length() + aProviderType.Length() );
        }
    iProviderType->Des().Append( aProviderType );
    }

// ---------------------------------------------------------------------------
// CAcpProvider::ProviderDescription
// Returns the provider description
// ---------------------------------------------------------------------------
//
TPtrC CAcpProvider::ProviderDescription() const
    {
    if ( iProviderDescription )
        {
        return *iProviderDescription; 
        }
    return KNullDesC();
    }

// ---------------------------------------------------------------------------
// CAcpProvider::SetProviderDescriptionL
// Sets the provider description
// ---------------------------------------------------------------------------
//
void CAcpProvider::SetProviderDescriptionL( const TDesC& aProviderDescription )
    {
    ACPLOG2( "CAcpProvider::SetProviderDescriptionL: %S", &aProviderDescription );

    // Check whether the provider description defined or not.
    if ( !aProviderDescription.Length() )
        {
        return;
        }

    if ( !iProviderDescription )
        {
        iProviderDescription = HBufC::NewL( aProviderDescription.Length() );
        }
    else
        {
        iProviderDescription = iProviderDescription->ReAllocL( 
            iProviderDescription->Length() + aProviderDescription.Length() );
        }

    iProviderDescription->Des().Append( aProviderDescription );
    }

// ---------------------------------------------------------------------------
// CAcpProvider::SetBitmapL
// Copies a bitmap.
// ---------------------------------------------------------------------------
//
void CAcpProvider::SetBitmapL( CFbsBitmap* aBitmap, CFbsBitmap* aMask )
    {
    ACPLOG( "CAcpProvider::SetBitmapL begin" );
    
    if ( !aBitmap ) // Mask is not needed.
        {
        User::Leave( KErrArgument );
        }
    
    const TSize bitmapSize = aBitmap->SizeInPixels();
    if ( bitmapSize.iHeight > 0 && bitmapSize.iWidth > 0 )
        {
        ACPLOG3( " - bitmap size %d x %d pixels", bitmapSize.iWidth,
            bitmapSize.iHeight );
        
        delete iBitmap;
        iBitmap = NULL;
        delete iMask;
        iMask = NULL;
        
        ACPLOG( " - deleted bitmaps" );
    
        // Create new bitmap.
        iBitmap = new (ELeave) CFbsBitmap();
        iBitmap->Create( bitmapSize, aBitmap->DisplayMode() );
        ACPLOG( " - created new bitmap" );
        
        // Calculate data length.
        TInt stride = CFbsBitmap::ScanLineLength( bitmapSize.iWidth,
            aBitmap->DisplayMode() );
        TInt length = stride * bitmapSize.iHeight;
        ACPLOG2( " - actual data length: %d", length );
    
        aBitmap->LockHeap();
        Mem::Copy( iBitmap->DataAddress(), aBitmap->DataAddress(), length );
        aBitmap->UnlockHeap();

        // Create mask if needed.
        if ( aMask )
            {
            iMask = new (ELeave) CFbsBitmap();
            iMask->Create( aMask->SizeInPixels(), aMask->DisplayMode() );
            ACPLOG( " - created new mask" );

            // Calculate data length.
            TSize maskSize = aMask->SizeInPixels();
            TInt stride = CFbsBitmap::ScanLineLength( maskSize.iWidth,
                aMask->DisplayMode() );
            TInt length = stride * maskSize.iHeight;
            ACPLOG2( " - actual mask data length: %d", length );
            
            aMask->LockHeap();
            Mem::Copy( iMask->DataAddress(), aMask->DataAddress(), length );
            aMask->UnlockHeap();
            }
        }

    ACPLOG( "CAcpProvider::SetBitmapL end" );
    }

// ---------------------------------------------------------------------------
// CAcpProvider::BitMap
// Reference to bitmap and mask.
// ---------------------------------------------------------------------------
//
void CAcpProvider::GetBitmaps( CFbsBitmap*& aBitmap, CFbsBitmap*& aMask )
    {
    aBitmap = iBitmap;
    aMask = iMask;
    }

// End of file.