/*

* Copyright (c) 2002 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 class CDdEng.   

*      

*

*/

// INCLUDE FILES

#include "DdEng.h"

#include "CodData.h"

#include "CodError.h"

#include "CodPanic.h"

#include "CodStatus.h"

#include "DdParser.h"

#include "CodLogger.h"

#include "CodSaver.h"

#include "CodUtil.h"

#include "CodDefs.h"

#include <DocumentHandler.h>

#include <e32math.h>

#include <RoapDef.h>

// CONSTANTS

_LIT8( KLicenseStartTag, "<license" );

_LIT8( KLicenseEndTag, "</license>" );

const TInt KElementEnd( '>' );

/// Supported DD major version (only major number needs to be checked, 1.0)

LOCAL_D const TUint32 KDdSupportedMajorVersion = 2;

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

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

// CDdEng::NewL()

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

//

EXPORT_C CDdEng* CDdEng::NewL

( CEikProcess* aProcess, MCodLoadObserver* aObserver )

    {

    CDdEng* model = new (ELeave) CDdEng( aObserver );

    CleanupStack::PushL( model );

    model->ConstructL( aProcess );

    CleanupStack::Pop( model );

    return model;

    }

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

// CDdEng::~CDdEng()

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

//

EXPORT_C CDdEng::~CDdEng()

    {

    CLOG(( ECodEng, 2, _L("CDdEng::~CDdEng") ));

    }

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

// CDdEng::CDdEng()

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

//

CDdEng::CDdEng( MCodLoadObserver* aObserver ): CCodEngBase( aObserver )

    {

    CLOG(( ECodEng, 2, _L("CDdEng::CDdEng") ));

    }

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

// CDdEng::CheckDataL()

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

//

void CDdEng::CheckDataL()

    {

    CLOG(( ECodEng, 2, _L("-> CDdEng::CheckDataL") ));

    if( !iData->IsValid() )

        {

        // Syntactically OK, but mandatory attributes are missing.

        User::Leave( KErrCodInvalidDescriptor );

        }

    CLOG(( ECodEng, 4, _L("CDdEng::CheckDataL: data valid") ));

    CheckVersionL( iData->Version() );

    CLOG(( ECodEng, 4, _L("CDdEng::CheckDataL: version OK") ));

    CLOG(( ECodEng, 2, _L("<- CDdEng::CheckDataL") ));

    }

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

// CDdEng::ParseDataL()

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

//

void CDdEng::ParseDataL()

    {

    CLOG(( ECodEng, 2, _L("-> CDdEng::ParseDataL") ));

    __ASSERT_DEBUG( iCodBuf, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( iData, CodPanic( ECodInternal ) );

    TDdParser parser;

    TBool isLicenseTag (EFalse);

    parser.ParseL( *iCodBuf, *iData, iIsDd2, isLicenseTag );

    if (isLicenseTag && iIsDd2)

	{	

	  iIsLicense = ETrue;

	  CreateSaverL(KDd2DataType);

	  ParseLicenseL();

	}

    CLOG(( ECodEng, 4, _L("CDdEng::SetL: parsed OK") ));

    CLOG(( ECodEng, 2, _L("<- CDdEng::ParseDataL") ));

    }

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

// CDdEng::StatusCode

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

//

TInt CDdEng::StatusCode( TInt aError, TState aState ) const

    {

    // Meaningless to fiddle with statuses after we are done.

    __ASSERT_DEBUG( aState <= ENotify, CodPanic( ECodInternal ) );

    TInt code( KHttp954LoaderError );

    switch( aError )

        {

        case KErrNone:

            {

            code = KHttp900Success;

            break;

            }

        case KErrNoMemory:

        case KErrDiskFull:

            {

            code = KHttp910NoMemory;

            break;

            }

        case KErrCodInsufficientSpace:

            {

            code = KHttp901InsufficientMemory;

            break;

            }

        case KErrCancel:

        case KErrAbort:

            {

            code = KHttp902UserCancelled;

            break;

            }

        case KErrCodInvalidDescriptor:

            {

            code = KHttp906InvalidDescriptor;

            break;

            }

        case KErrCodInvalidType:

            {

            code = KHttp907InvalidType;

            break;

            }

        case KErrCodUnsupportedVersion:

            {

            code = KHttp951InvalidDdVersion;

            break;

            }

        case KErrCodAttributeMismatch:

            {

            code = KHttp905AttributeMismatch;

            break;

            }

        case KBadMimeType:

        case KMimeNotSupported:

            {

            code = aState == ESet ?

                KHttp952DeviceAborted :      // ESet -> COD MIME bad.

                KHttp953NonAcceptableContent;// EFetch -> content MIME bad.

            break;

            }

        case KErrCodHttpLicenseFailed:

        case KErrRoapGeneral:

        case KErrRoapUnsupported:

        case KErrRoapServer:

        case KErrRoapServerFatal:

        case KErrRoapDevice:

        case KErrRoapInvalidDomain:

        case KErrRoapDomainFull:

        case KErrRoapNotRegistered:

            {

            code = KHttp957LicenseFailed;

            break;

            }

        case KErrTimedOut:

        case KErrCodHttpCommsFailed:

        case KErrCodHttpNoResponse:

            {

            code = KHttp903LossOfService;

            break;

            }

        case KErrCodHttpRequestedRangeNotSatisfiable:

            {

            code = KHttp909RequestedRangeNotSatisfiable;

            break;

            }

        case KErrCodHttpPreconditionFailed:

            {

            code = KHttp955PreconditionFailed;

            break;

            }

       	case KErrCodHttpBadUrl:

        default:

            {

            code = KHttp954LoaderError;

            break;

            }

        }

    return code;

    }

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

// CDdEng::StatusText()

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

//

const TDesC8& CDdEng::StatusText( TInt aCode ) const

    {

    switch ( aCode )

        {

        case KHttp900Success:              return KText900Success;

        case KHttp901InsufficientMemory:   return KText901InsufficientMemory;

        case KHttp902UserCancelled:        return KText902UserCancelled;

        case KHttp903LossOfService:        return KText903LossOfService;

        case KHttp905AttributeMismatch:    return KText905AttributeMismatch;

        case KHttp906InvalidDescriptor:    return KText906InvalidDescriptor;

        case KHttp907InvalidType:          return KText907InvalidType;

        case KHttp951InvalidDdVersion:     return KText951InvalidDdVersion;

        case KHttp952DeviceAborted:        return KText952DeviceAborted;

        case KHttp953NonAcceptableContent: return KText953NonAcceptableContent;

        case KHttp954LoaderError:          return KText954LoaderError;

        case KHttp956LicenseSuccess:       return KText956LicenseSuccess;

        case KHttp957LicenseFailed:        return KText957LicenseFailed;

        case KHttp910NoMemory:             return KText910NoMemory;

        case KHttp955PreconditionFailed:   return KText955MediaObjectUpdated;

        case KHttp970MixedStatus:          return KText970MixedStatus; 

        case KHttp981DownloadCompletion:   return KText981DownloadCompletion; 

        default:                           CodPanic( ECodInternal );

        }

    return KNullDesC8;  /* NOTREACHED */

    }

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

// CDdEng::CheckVersionL()

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

//

void CDdEng::CheckVersionL( const TDesC& aVersion ) const

    {

    TUint32 majorVer = 1;   // If version is not specified, it defaults to 1.0.

    if( aVersion.Length() )

        {

        // Version is specified, parse it to get get major version.

        TLex lex( aVersion );

        TReal realVer;

        TInt32 intVer;

        if( lex.Val( realVer ) != KErrNone )

            {

            // Could not parse version as a real number, this indicates that

            // the DD-Version is some rubbish string.

            User::Leave( KErrCodInvalidDescriptor );

            }

        User::LeaveIfError( Math::Int( intVer, realVer ) );

        if( intVer < 0 )

            {

            // Negative DD-Version?

            User::Leave( KErrCodInvalidDescriptor );

            }

        majorVer = STATIC_CAST( TUint32, intVer );

        }

    // For code clarity, we always check major version (even if not given and

    // defaults to supported 1.0).

    if( majorVer > KDdSupportedMajorVersion )

        {

        User::Leave( KErrCodUnsupportedVersion );

        }

    }

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

// CDdEng::ParseLicenseL()

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

//

void CDdEng::ParseLicenseL()

{

	HBufC8* descriptorBuf = CodUtil::ConvertLC( iCodBuf->Des());

	TPtrC8 license;

	TPtrC8 descriptor (descriptorBuf->Ptr());

	TInt startTag = descriptor.Find(KLicenseStartTag); // "<license"

	if (startTag != KErrNotFound)

	{

		descriptor.Set(descriptor.Right(descriptor.Length()- startTag -1));

		TInt endTag = descriptor.Locate(KElementEnd); //'>'

		if (endTag != KErrNotFound)

		{

			license.Set(descriptor.Right(descriptor.Length()-endTag-1));

			TInt licenseTagEnd = license.Find(KLicenseEndTag); // "</license"

			if (licenseTagEnd != KErrNotFound)

			{

				license.Set(license.Left(licenseTagEnd));

			}

		}

	}

	iSaver->AppendData( license );

	CleanupStack::PopAndDestroy( descriptorBuf );

}