/*

 * 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: Implementation of applicationmanagement components

 *

 */

#include "AMDownload.h"

#include "AMDeploymentComponent.h"

#include "debug.h"

#include <e32debug.h>

#include <s32mem.h>

#include <featmgr.h>

#include "amprivateCRKeys.h"

//#include "aminstalloptions.h"

#include <ssl.h>	

#ifdef __SERIES60_30__

#include <CMenuClient.h>

#endif

#include "amsmlhelper.h"

#include "APGCLI.H"

#include "APMREC.h"

#include "APMSTD.H"

using namespace NApplicationManagement;

_LIT8( KAMDCDataSuffix, "_D.txt");

_LIT8( KAMDCMetaDataSuffix, "_M.txt");

/***************************************************

 // CDeploymentComponent

 ***************************************************/

CDeploymentComponent* CDeploymentComponent::NewLC(TInt aInternalId,

        const TDCUserId &aUserId)

    {

    CDeploymentComponent *self = new ( ELeave ) CDeploymentComponent( aInternalId );

    CleanupStack::PushL(self) ;

    self->ConstructL(aUserId) ;

    return self;

    }

CDeploymentComponent* CDeploymentComponent::NewL(TInt aInternalId,

        const TDCUserId &aUserId)

    {

    CDeploymentComponent *self = NewLC(aInternalId, aUserId);

    CleanupStack::Pop(self) ;

    return self;

    }

CDeploymentComponent* CDeploymentComponent::LoadLC(TInt aInternalId,

        const TDesC8 &aBuffer)

    {

    CDeploymentComponent *self = new ( ELeave ) CDeploymentComponent(aInternalId);

    CleanupStack::PushL(self) ;

    self->ConstructLoadL(aBuffer) ;

    return self;

    }

CDeploymentComponent* CDeploymentComponent::LoadL(TInt aInternalId,

        const TDesC8 &aBuffer)

    {

    CDeploymentComponent *self = LoadLC(aInternalId, aBuffer);

    CleanupStack::Pop(self) ;

    return self;

    }

CDeploymentComponent::CDeploymentComponent(TInt aInternalId) :

iInternalId(aInternalId), iPkgVersion( 3), iOwner( -1),

iOwnerProfile( -1)

        {

        iUninstallOpts.iKillApp = SwiUI::EPolicyAllowed;

        SwiUI::TInstallOptions &opts = iInstallOpts.iOptions;

        opts.iUpgrade = SwiUI::EPolicyNotAllowed;

        opts.iOptionalItems = SwiUI::EPolicyNotAllowed;

        opts.iOCSP = SwiUI::EPolicyNotAllowed;

        opts.iIgnoreOCSPWarnings = SwiUI::EPolicyNotAllowed;

        //    iIgnoreOtherWarnings = SwiUI::EPolicyNotAllowed;

        opts.iUntrusted = SwiUI::EPolicyNotAllowed;

        opts.iPackageInfo = SwiUI::EPolicyNotAllowed;

        opts.iCapabilities = SwiUI::EPolicyNotAllowed;

        opts.iKillApp = SwiUI::EPolicyNotAllowed;

        opts.iOverwrite = SwiUI::EPolicyNotAllowed;

        opts.iDownload = SwiUI::EPolicyNotAllowed;

        opts.iDrive = SwiUI::EPolicyNotAllowed;

        opts.iLang = ELangNone;

        opts.iUsePhoneLang = EFalse;

        }

CDeploymentComponent::~CDeploymentComponent()

    {

    RDEBUG8_3( "CDeploymentComponent::~CDeploymentComponent 0x%X - 0x%X",

            reinterpret_cast<TUint>(this), reinterpret_cast<TUint>(this)+sizeof( CDeploymentComponent ) );

    delete iData;

    iData = NULL;

    delete iMetaData;

    iMetaData = NULL;

    }

CDeploymentComponent &CDeploymentComponent::operator=( const CDeploymentComponent &aData )

    {

    if( &aData != this )

        {

        *iData = aData.Data();

        *iMetaData = aData.MetaData();

        iId = aData.ComponentId();

        iName = aData.ComponentName();

        iVersion = aData.iVersion;

        iState = aData.State();

        iInternalId = aData.InternalId();

        iUid = aData.Uid();

        iUserId = aData.iUserId;

        iOwner = aData.iOwner;

        iInstallOpts = aData.InstallOpts();

        iPkgID = aData.PkgId();

        iDescription = aData.Description();

        iPkgIDRef = aData.PkgIDRef();

        iPkgType = aData.PkgType();

        iRemovableApp = aData.AppRemovable();

        iInstallOptsSet = aData.InstallOptsSet();

        iPkgVersion = aData.iPkgVersion;

        iDownloadStatus = aData.iDownloadStatus;

        iDownloadURI = aData.iDownloadURI;

        iUninstallOpts = aData.UninstallOpts();

        iOwnerProfile = aData.OwnerProfile();

        }

    return *this;

    }

void CDeploymentComponent::PersistL(CRepository &aRepository) const

    {

    CBufBase *buf = CBufFlat::NewL( 32);

    CleanupStack::PushL(buf);

    TInt length(SerializedFormLength() );

    buf->ExpandL(0, length+1);

    TPtr8 p3(buf->Ptr(0) );

    RDesWriteStream stream(p3);

    TInt len(SerializedFormL(stream) );

    TBuf8< NCentralRepositoryConstants::KMaxBinaryLength> tbuf;

    TInt err(aRepository.Get(iInternalId, tbuf) );

    if (err == KErrNotFound)

        {

        err = aRepository.Create(iInternalId, buf->Ptr(0) );

        RDEBUG_3( "CDeploymentComponent::PersistL:  Created %d to centrep with status %d", iInternalId, err );

        }

    else

        {

        User::LeaveIfError(err) ;

        err = aRepository.Set(iInternalId, buf->Ptr(0) );

        RDEBUG_3( "CDeploymentComponent::PersistL:  Persisted %d to centrep with status %d", iInternalId, err );

        }

    User::LeaveIfError(err) ;

    CleanupStack::PopAndDestroy(buf);

    RFs fs;

    User::LeaveIfError(fs.Connect() );

    CleanupClosePushL(fs);

    iData->PersistL(fs);

    iMetaData->PersistL(fs);

    CleanupStack::PopAndDestroy( &fs) ;

    }

void CDeploymentComponent::CopyStateTo(TDeploymentComponent &aInfo) const

    {

    aInfo.iId = iId;

    aInfo.iName = iName;

    aInfo.iVersion = iVersion;

    aInfo.iDescription = iDescription;

    aInfo.iPkgID = iPkgID;

    aInfo.iPkgIDRef = iPkgIDRef;

    aInfo.iPkgType = iPkgType;

    aInfo.iState = iState;

    aInfo.iOldState = iOldState;

    }

TBool CDeploymentComponent::IsJavaMimeL(const TDesC8& aMime)

    {

    FeatureManager::InitializeLibL();

    TBool supported = EFalse;

    if (FeatureManager::FeatureSupported(KFeatureIdJavaMIDP20) )

        {

        supported = ((aMime == SwiUI::KJarMIMEType || aMime

                == SwiUI::KJadMIMEType || aMime == SwiUI::KJarxMIMEType

                || aMime == SwiUI::KJavaMIMEType) ? ETrue : EFalse );

        }

    FeatureManager::UnInitializeLib();

    return supported;

    }

TBool CDeploymentComponent::IsSisMimeL(const TDesC8& aMime)

    {

    TBool supported = EFalse;

    supported = ((aMime == SwiUI::KSisxMimeType || aMime

                == SwiUI::KSisMimeType || aMime == SwiUI::KPipMimeType) ? ETrue : EFalse );

    return supported;

    }

void CDeploymentComponent::ConstructL(const TDCUserId &aUserId)

    {

    iUserId = aUserId;

    RFs fs;

    User::LeaveIfError(fs.Connect() );

    CleanupClosePushL(fs);

    TInt e(fs.CreatePrivatePath(KDefaultDrive) );

    User::LeaveIfError(e);

    TBuf<30> privatePath;

    fs.PrivatePath(privatePath);

    CleanupStack::PopAndDestroy( &fs);

    TInt privPathLength(privatePath.Length() );

    TBuf8<10> buf;

    buf.NumFixedWidth(iInternalId, EHex, 10);

    TBuf8 <30> path;

    path.Copy(privatePath);

    HBufC8 *afilename = HBufC8::NewLC(privPathLength + 10 + KAMDCDataSuffix().Length());

    *afilename = path;

    TPtr8 afn(afilename->Des() );

    afn.Append(buf);

    afn.Append(KAMDCDataSuffix) ;

    iData = CDeploymentComponentData::NewL(CDeploymentComponentData::EData,

            KNullDesC8, KNullDesC8, afn);

    afn.Replace(privPathLength + 10, KAMDCMetaDataSuffix().Length(), KAMDCMetaDataSuffix);

    iMetaData = CDeploymentComponentData::NewL(

            CDeploymentComponentData::EMetaData, KNullDesC8, KNullDesC8, afn);

    CleanupStack::PopAndDestroy(afilename);

    }

TInt CDeploymentComponent::SerializedFormLength() const

    {

    //   0			1		2		3		4		5			6			7	8			9			10		11

    // iUserId , iState, iPkgVer, iUid, iIdLen, iNameLen, iVersLen, iDownState, iOwner, iOldState ,iDownUriLen, iInstallOptsset

    return (20*4)+iUserId.Length() + iId.Length() + iName.Length()

            + iVersion.Length() +

    iMidletName.Length() + iMideltVendorName.Length()

            + iMidletVersion.Length()+ iDownloadURI.Length()

            + iDescription.Length()+ iPkgID.Length()+iPkgIDRef.Length()

            +iPkgType.Length()+ sizeof(iRemovableApp) + iData->SerializedFormLength()

            + iMetaData->SerializedFormLength() + sizeof(TAMInstallOptions);

    }

TInt CDeploymentComponent::SerializedFormL(RWriteStream &aBuffer) const

    {

#ifdef _DEBUG

    RDEBUG_2( "Offset before uint: %d", aBuffer.Sink()->TellL( MStreamBuf::EWrite ).Offset() );

#endif

    aBuffer.WriteUint32L(iPkgVersion);

#ifdef _DEBUG

    RDEBUG_2( "Offset after uint: %d" , aBuffer.Sink()->TellL( MStreamBuf::EWrite ).Offset() );

#endif

    aBuffer.WriteUint32L(iState);

    aBuffer.WriteUint32L(iStatus);

    aBuffer.WriteUint32L(iUid.iUid);

    aBuffer.WriteUint32L(iUserId.Length() );

    aBuffer.WriteL(iUserId);

    aBuffer.WriteUint32L(iId.Length() );

    aBuffer.WriteL(iId);

    aBuffer.WriteUint32L(iName.Length() );

    aBuffer.WriteL(iName);

    aBuffer.WriteUint32L(iVersion.Length() );

    aBuffer.WriteL(iVersion);

    aBuffer.WriteUint32L(iMidletName.Length() );

    aBuffer.WriteL(iMidletName);

    aBuffer.WriteUint32L(iMideltVendorName.Length() );

    aBuffer.WriteL(iMideltVendorName);

    aBuffer.WriteUint32L(iMidletVersion.Length() );

    aBuffer.WriteL(iMidletVersion);

    aBuffer.WriteInt32L(iDownloadStatus);

    aBuffer.WriteInt32L(iOwner);

    aBuffer.WriteUint32L(iOldState);

    aBuffer.WriteUint32L(iDownloadURI.Length() );

    aBuffer.WriteL(iDownloadURI);

    aBuffer.WriteUint32L(iDescription.Length() );

    aBuffer.WriteL(iDescription);

    aBuffer.WriteUint32L(iPkgID.Length() );

    aBuffer.WriteL(iPkgID);

    aBuffer.WriteUint32L(iPkgIDRef.Length() );

    aBuffer.WriteL(iPkgIDRef);

    aBuffer.WriteUint32L(iPkgType.Length() );

    aBuffer.WriteL(iPkgType);

    aBuffer.WriteUint32L(iRemovableApp);

    iData->SerializedFormL(aBuffer);

    iMetaData->SerializedFormL(aBuffer);

    aBuffer.WriteUint32L(iInstallOptsSet);

    TPckg<TAMInstallOptions> opts(iInstallOpts);

    aBuffer.WriteL(opts);

    return aBuffer.Sink()->TellL( MStreamBuf::EWrite ).Offset();

    }

void CDeploymentComponent::ConstructLoadL(const TDesC8 &aBuffer)

    {

    RDEBUG( "CDeploymentComponent::ConstructLoadL ");

    TDeploymentComponent aRes;

    TMimeType aType;

    RDesReadStream stream(aBuffer);

    iPkgVersion = stream.ReadUint32L();

    iState = static_cast<TDeploymentComponentState>(stream.ReadUint32L() );

    iStatus = static_cast<TSCOMOStatusNodeStates>(stream.ReadUint32L() );

    iUid.iUid = stream.ReadUint32L();

    TUint32 len(stream.ReadUint32L() );

    stream.ReadL(iUserId, len);

    len = stream.ReadUint32L();

    stream.ReadL(iId, len);

    len = stream.ReadUint32L();

    stream.ReadL(iName, len);

    len = stream.ReadUint32L();

    stream.ReadL(iVersion, len);

    len = stream.ReadUint32L();

    stream.ReadL(iMidletName, len);

    len = stream.ReadUint32L();

    stream.ReadL(iMideltVendorName, len);

    len = stream.ReadUint32L();

    stream.ReadL(iMidletVersion, len);

    iDownloadStatus = stream.ReadInt32L();

    if (iPkgVersion > 1)

        {

        iOwner = stream.ReadInt32L();

        }

    if (iPkgVersion > 2)

        {

        iOldState = TDeploymentComponentState(stream.ReadUint32L() );

        }

    len = stream.ReadUint32L() ;

    stream.ReadL(iDownloadURI, len);

    len = stream.ReadUint32L();

    stream.ReadL(iDescription, len);

    len = stream.ReadUint32L();

    stream.ReadL(iPkgID, len);

    len = stream.ReadUint32L();

    stream.ReadL(iPkgIDRef, len);

    len = stream.ReadUint32L();

    stream.ReadL(iPkgType, len);

    iRemovableApp = stream.ReadUint32L();

    iData = CDeploymentComponentData::LoadL(stream);

    iMetaData = CDeploymentComponentData::LoadL(stream);

    //using namespace SwiUI;

    iInstallOptsSet = stream.ReadUint32L();

    TAMInstallOptionsPckg opts(iInstallOpts);

    stream.ReadL(opts, opts.Length() );

    RDEBUG( "CDeploymentComponent::ConstructLoadL end");

    }

CDeploymentComponentData &CDeploymentComponent::Data()

    {

    return *iData;

    }

const CDeploymentComponentData &CDeploymentComponent::Data() const

    {

    return *iData;

    }

CDeploymentComponentData &CDeploymentComponent::MetaData()

    {

    return *iMetaData;

    }

const CDeploymentComponentData &CDeploymentComponent::MetaData() const

    {

    return *iMetaData;

    }

const TAMInstallOptions &CDeploymentComponent::InstallOpts() const

    {

    return iInstallOpts;

    }

const SwiUI::TUninstallOptions &CDeploymentComponent::UninstallOpts() const

    {

    return iUninstallOpts;

    }

TBool CDeploymentComponent::InstallOptsSet() const

    {

    return iInstallOptsSet;

    }

TBool CDeploymentComponent::AppRemovable() const

    {

    return iRemovableApp;

    }

void CDeploymentComponent::SetMetaDataL(const TDesC8 &aMimeType)

    {

    iMetaData->DataFileName();

    iMetaData->SetDataL(aMimeType);

    }

void CDeploymentComponent::SetMetaDataL(const TDesC8 &aMetaData,

        const TDesC8 &aMimeType)

    {

    iMetaData->SetDataL(aMetaData, aMimeType);

    }

void CDeploymentComponent::SetAppRemovableStatus(const TBool &aRemovable)

    {

    iRemovableApp = aRemovable;

    }

void CDeploymentComponent::SetInstallOptsL(const TDesC8 &aInstallOpts)

    {

    using namespace SwiUI;

    if (aInstallOpts != KNullDesC8)

        {

        RDEBUG8_2( "CDeploymentComponent::SetInstallOptsL: '%S'", &aInstallOpts );

        TInt tmpIAP(iInstallOpts.iIAP);

        TAMInstallOptionsPckg pckg(iInstallOpts);

        pckg.Copy(aInstallOpts);

        iInstallOptsSet= ETrue;

        if (iInstallOpts.iIAP == -1 && tmpIAP > -1)

            {

            RDEBUG8_2( "CDeploymentComponent::SetInstallOptsL: using IAPid %d", tmpIAP );

            iInstallOpts.iIAP = tmpIAP;

            }

        }

    }

void CDeploymentComponent::ResetDataL(RFs &aFs)

    {

    iData->ResetData(aFs);

    iMetaData->ResetData(aFs);

    }

void CDeploymentComponent::SetAttr(TDes8 &aAttr, const TDesC8 &aNewVal) const

    {

    if (aNewVal.Length() > aAttr.MaxLength() )

        {

        aAttr = aNewVal.Left(aAttr.MaxLength() );

        }

    else

        {

        aAttr = aNewVal;

        }

    }

void CDeploymentComponent::SetIdL(const TDesC8 &aId)

    {

    SetAttr(iId, aId);

    }

void CDeploymentComponent::SetNameL(const TDesC8 &aName)

    {

    if (iName != aName)

        {

        SetAttr(iName, aName);

        }

    }

void CDeploymentComponent::SetVersionL(const TDesC8 &aVersion)

    {

    SetAttr(iVersion, aVersion);

    }

void CDeploymentComponent::SetMimeTypeL( const TDesC8 &aMimeType )

{

	iData->SetMimeTypeL(aMimeType);

}

void CDeploymentComponent::SetDescriptionL(const TDesC8 &aDescription)

    {

    SetAttr(iDescription, aDescription);

    }

void CDeploymentComponent::SetPkgIDL(const TDesC8 &aPkgID)

    {

    // PkgID and PkgIDRef should be same and Get done on PkgID

    // when state is in Download or Delivered and PkgIDRef is

    // returned when state is in Deployed state

    SetAttr(iPkgID, aPkgID);

    SetAttr(iPkgIDRef, aPkgID);

    }

void CDeploymentComponent::SetPkgTypeL(const TDesC8 &aPkgType)

    {

    SetAttr(iPkgType, aPkgType);

    }

void CDeploymentComponent::SetMidletNameL(const TDesC8 &aMidletName)

    {

    SetAttr(iMidletName, aMidletName);

    }

void CDeploymentComponent::SetMidletVendorL(const TDesC8 &aMidletVendor)