/*

* Copyright (c) 2004 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:    DM Fota Adapter

*

*/

// INCLUDE FILES

#include <implementationproxy.h> // For TImplementationProxy definition

//#ifdef RD_OMADMAPPUI_UI_EVOLUTION

#include <DevManInternalCRKeys.h>

//#endif

#include <SyncMLClient.h>

#include <SyncMLClientDM.h>

#include <e32property.h>

#include <centralrepository.h>

#include "fotaadapterCRKeys.h"

#include "NSmlPrivateAPI.h"

#include "nsmldmimpluids.h"

#include "nsmldmfotaadapter.h"

#include "nsmldmconst.h"

#include "nsmldebug.h"

#include "FotaSrvDebug.h"

#include "nsmldmtreedbclient.h"

#include <nsmldmconst.h>

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

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

// CNSmlDmFotaAdapter* CNSmlDmFotaAdapter::NewL()

// Creates new instance of CNSmlDmFotaEngine and returns a pointer to it.

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

//

CNSmlDmFotaAdapter* CNSmlDmFotaAdapter::NewL( MSmlDmCallback* aDmCallback )

    {

    _DBG_FILE("CNSmlDmFotaAdapter::NewL(): begin");

    FLOG(_L("CNSmlDmFotaAdapter::NewL >>"));

    CNSmlDmFotaAdapter* self = NewLC( aDmCallback );

    CleanupStack::Pop( self );

    _DBG_FILE("CNSmlDmFotaAdapter::NewL(): end");

    FLOG(_L("CNSmlDmFotaAdapter::NewL <<"));

    return self;

    }

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

// CNSmlDmFotaAdapter* CNSmlDmFotaAdapter::NewLC()

// Creates new instance of CNSmlDmFotaEngine and returns a pointer to it. 

// Leaves the pointer onto the CleanupStack.

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

//

CNSmlDmFotaAdapter* CNSmlDmFotaAdapter::NewLC( MSmlDmCallback* aDmCallback )

    {

    _DBG_FILE("CNSmlDmFotaAdapter::NewLC(): begin");

    CNSmlDmFotaAdapter* self = new (ELeave) CNSmlDmFotaAdapter( aDmCallback );

    CleanupStack::PushL( self );

    self->ConstructL();

    _DBG_FILE("CNSmlDmFotaAdapter::NewLC(): end");

    return self;

    }

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

// CNSmlDmFotaAdapter::CNSmlDmFotaAdapter()

// Constructor.

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

//

CNSmlDmFotaAdapter::CNSmlDmFotaAdapter( TAny* aEcomArguments )

    : CSmlDmAdapter( aEcomArguments ), iPkgId( KNSmlDMFotaNullPkgId )

    {

    _DBG_FILE("CNSmlDmFotaAdapter::CNSmlDmFotaAdapter(): begin");

    _DBG_FILE("CNSmlDmFotaAdapter::CNSmlDmFotaAdapter(): end");

    }

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

// CNSmlDmFotaAdapter::ConstructL()

// Second phase construction.

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

//

void CNSmlDmFotaAdapter::ConstructL()

    {

    // Check if Fota feature is defined

    TInt value( 0 );

    CRepository * rep = CRepository::NewLC( KCRUidFotaAdapter );

	TInt err = rep->Get( KCRFotaAdapterEnabled, value );

	CleanupStack::PopAndDestroy( rep );

	if ( err != KErrNone || value == 0 )

    	{

    	User::Leave( KErrNotSupported );

    	}    

    iFotaDb = CNSmlDmFotaAdapterDb::NewL();

    }

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

// CNSmlDmFotaAdapter::~CNSmlDmFotaAdapter()

// Destructor.

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

//

CNSmlDmFotaAdapter::~CNSmlDmFotaAdapter()

    {

    _DBG_FILE("CNSmlDmFotaAdapter::~CNSmlDmFotaAdapter(): begin");

    FLOG(_L("CNSmlDmFotaAdapter::~CNSmlDmFotaAdapter >>"));

    if (iFotaEngine.Handle())

        iFotaEngine.Close();

    delete iFotaDb;

    FLOG(_L("CNSmlDmFotaAdapter::~CNSmlDmFotaAdapter <<"));

    _DBG_FILE("CNSmlDmFotaAdapter::~CNSmlDmFotaAdapter(): end");

    }

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

//  CNSmlDmFotaAdapter::DDFVersionL()

//  Returns the DDF version of the adapter.

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

//

void CNSmlDmFotaAdapter::DDFVersionL( CBufBase& aDDFVersion )

    {

    _DBG_FILE("CNSmlDmFotaAdapter::DDFVersionL(TDes& aDDFVersion): begin");

    aDDFVersion.InsertL( 0, KNSmlDMFotaDDFVersion );

    _DBG_FILE("CNSmlDmFotaAdapter::DDFVersionL(TDes& aDDFVersion): end");

    }

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

//  CNSmlDmFotaAdapter::DDFStructureL()

//  Builds the DDF structure of adapter.

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

//

void CNSmlDmFotaAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

    _DBG_FILE("CNSmlDmFotaAdapter::DDFStructureL(): begin");

    FLOG(_L("CNSmlDmFotaAdapter::DDFStructureL >>"));

    TSmlDmAccessTypes accessTypes;

    // fota root

    MSmlDmDDFObject& FUMO = aDDF.AddChildObjectL( KNSmlDMFotaNode );

    accessTypes.SetAdd();

    accessTypes.SetGet();

    FillNodeInfoL(  FUMO, 

                    accessTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::ENode,

                    KNSmlDMFotaNodeDescription );

    accessTypes.Reset();

    // run time node <X>

    MSmlDmDDFObject& rtPkg = FUMO.AddChildObjectGroupL();

    rtPkg.AddDFTypeMimeTypeL( KNSmlDMFotaRunTimeMimeType );

    accessTypes.SetAdd();

    accessTypes.SetDelete();

    accessTypes.SetGet();

    //accessTypes.SetReplace();

    FillNodeInfoL(  rtPkg, 

                    accessTypes,

                    MSmlDmDDFObject::EZeroOrMore, 

                    MSmlDmDDFObject::EDynamic, 

                    MSmlDmDDFObject::ENode, 

                    KNSmlDMFotaRunTimeNodeDescription );

    accessTypes.Reset();

    // <X>/PkgName

    MSmlDmDDFObject& name = rtPkg.AddChildObjectL( KNSmlDMFotaNodeName );

    accessTypes.SetAdd();

    accessTypes.SetGet();

    accessTypes.SetReplace();

    FillNodeInfoL(  name,

                    accessTypes,

                    MSmlDmDDFObject::EZeroOrOne,

                    MSmlDmDDFObject::EDynamic,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMFotaNodeNameDescription );

    // <X>/PkgVersion

    MSmlDmDDFObject& version = rtPkg.AddChildObjectL( KNSmlDMFotaNodeVersion );

    FillNodeInfoL(  version,

                    accessTypes,

                    MSmlDmDDFObject::EZeroOrOne,

                    MSmlDmDDFObject::EDynamic,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMFotaNodeVersionDescription );

    accessTypes.Reset();

    // <X>/Download

    MSmlDmDDFObject& download = 

    rtPkg.AddChildObjectL( KNSmlDMFotaNodeDownload );

    accessTypes.SetGet();

    accessTypes.SetExec();

    FillNodeInfoL(  download,

                    accessTypes,

                    MSmlDmDDFObject::EZeroOrOne,

                    MSmlDmDDFObject::EDynamic,

                    MSmlDmDDFObject::ENode,

                    KNSmlDMFotaNodeDownloadDescription );

    accessTypes.Reset();

    // <X>/Download/PkgURL

    MSmlDmDDFObject& dlUrl = 

    download.AddChildObjectL( KNSmlDMFotaNodeDownloadUrl );

    accessTypes.SetGet();

    accessTypes.SetReplace();

    FillNodeInfoL(  dlUrl,

                    accessTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EDynamic,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMFotaNodeDownloadUrlDescription );

    accessTypes.Reset();

    // <X>/DownloadAndUpdate

    MSmlDmDDFObject& dlAndUpdate = 

    rtPkg.AddChildObjectL( KNSmlDMFotaNodeDownloadAndUpdate );

    accessTypes.SetGet();

    accessTypes.SetExec();

    FillNodeInfoL(  dlAndUpdate,

                    accessTypes,

                    MSmlDmDDFObject::EZeroOrOne,

                    MSmlDmDDFObject::EDynamic,

                    MSmlDmDDFObject::ENode,

                    KNSmlDMFotaNodeDownloadAndUpdateDescription );

    accessTypes.Reset();

    // <X>/DownloadAndUpdate/PkgURL

    MSmlDmDDFObject& dlAndUpdateUrl = 

    dlAndUpdate.AddChildObjectL( KNSmlDMFotaNodeDownloadAndUpdateUrl );

    accessTypes.SetGet();

    accessTypes.SetReplace();

    FillNodeInfoL(  dlAndUpdateUrl,

                    accessTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EDynamic,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMFotaNodeDownloadAndUpdateUrlDescription );

    accessTypes.Reset();

    // <X>/State

    MSmlDmDDFObject& state = rtPkg.AddChildObjectL( KNSmlDMFotaNodeState );

    accessTypes.SetGet();

    FillNodeInfoL(  state,

                    accessTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EDynamic,

                    MSmlDmDDFObject::EInt,

                    KNSmlDMFotaNodeStateDescription );

    //Check cenrep for predefined node and add if its not in DB

    CheckAndAddPredefinedNodeL();

    // check if there is need to make generic alert(s), 

    // and generate them if there are

    MakeGenericAlertsL();

    // Set ACL for fota root, if not yet set

    RNSmlDMCallbackSession session;

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

    CleanupClosePushL(session);

    CBufBase* acl=CBufFlat::NewL(10);

    CleanupStack::PushL( acl );

    TInt err = session.GetAclL( KNSmlDMFotaNode,*acl,EFalse );

		if ( err == KErrNone)

		{

    	if( acl->Size() == 0 )

        {

        _LIT8(KACLForAll, "Add=*&Get=*&Delete=*&Exec=*&Replace=*");

        session.UpdateAclL( KNSmlDMFotaNode, KACLForAll);

        }

    }

    CleanupStack::PopAndDestroy( acl );

    CleanupStack::PopAndDestroy( &session );

    _DBG_FILE("CNSmlDmFotaAdapter::DDFStructureL(): end");

    FLOG(_L("CNSmlDmFotaAdapter::DDFStructureL <<"));

    }

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

// CNSmlDmFotaAdapter::UpdateLeafObjectL()

// Updates value of leaf object.

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

//

void CNSmlDmFotaAdapter::UpdateLeafObjectL( const TDesC8& aURI, 

                                            const TDesC8& aLUID, 

                                            const TDesC8& aObject, 

                                            const TDesC8& /*aType*/, 

                                            const TInt aStatusRef )

    {

    _DBG_FILE("CNSmlDmFotaAdapter::UpdateLeafObjectL(): begin");

    FLOG(_L("CNSmlDmFotaAdapter::UpdateLeafObjectL >>"));

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    if ( aLUID.Length() > 0 )

        {

        TInt res = KErrNotFound;

        TNSmlDmFwObjectId id = DesToInt( aLUID );

        TPtrC8 lastSeg = LastURISeg( aURI );

        if ( lastSeg == KNSmlDMFotaNodeName )

            {

            res = iFotaDb->SetPkgNameL( aObject, id );

            }

        else if ( lastSeg == KNSmlDMFotaNodeVersion )

            {

            res = iFotaDb->SetPkgVersionL( aObject, id );

            }

        else if ( lastSeg == KNSmlDMFotaNodeDownloadUrl || 

                  lastSeg == KNSmlDMFotaNodeDownloadAndUpdateUrl )

            {

            TInt configFlags( KErrNone );        

            CRepository* centrep = NULL;

            TRAPD( err, centrep = CRepository::NewL( KCRUidDeviceManagementInternalKeys ) );    	

            if ( err == KErrNone && centrep ) 

                {

                configFlags = 2; //means fota operation

                centrep->Set( KDevManSessionType, configFlags );

                delete centrep;

                centrep = NULL;

                }

            else

                {

                User::Leave( err );

                }

            res = iFotaDb->SetPkgUrlL( aObject, id );

            }

        // map error

        status = MapErrorToStatus( res );

        }

    else

        {

        // cannot update, object unknown

        status = CSmlDmAdapter::ENotFound;

        }

#ifdef __WINS__

TInt pos=-1;

pos = aURI.Find(KNSmlDMFotaNodeDownload);

if (status == CSmlDmAdapter::EOk && pos != KErrNotFound)

	{

	if ( aURI.Find(KNSmlDMFotaNodeDownloadAndUpdate) !=KErrNotFound)

		ExecuteCommandL(_L8("./FUMO/FWUpdate/DownloadAndUpdate"),aLUID,aObject,_L8(""),status);

	else

		ExecuteCommandL(_L8("./FUMO/FWUpdate/Download"),aLUID,aObject,_L8(""),status);

	}

#endif    

    Callback().SetStatusL( aStatusRef, status );

    _DBG_FILE("CNSmlDmFotaAdapter::UpdateLeafObjectL(): end");

    FLOG(_L("CNSmlDmFotaAdapter::UpdateLeafObjectL <<"));

    }

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

// CNSmlDmFotaAdapter::DeleteObjectL()

// Deletes a firmware object from Fota database.

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

//

void CNSmlDmFotaAdapter::DeleteObjectL( const TDesC8& aURI, 

                                        const TDesC8& aLUID, 

                                        const TInt aStatusRef )

    {

    _DBG_FILE("CNSmlDmFotaAdapter::DeleteLeafObjectL( ): begin");

    FLOG(_L("CNSmlDmFotaAdapter::DeleteObjectL >>"));

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    if ( ( aURI.Match( KNSmlDMFotaRuntimeMatch ) != KErrNotFound ) && 

         ( aLUID.Length() > 0 ) )

        {

		TBuf8<KMaxFullName> temp;

		GetPredefinedNodeL(temp);

		TBuf8<KMaxName> node[4];

    	TInt location = temp.LocateReverse(',');

    	node[0].Copy(temp.Mid(location+1));

    	TInt newLocation = (temp.Left(location-1)).LocateReverse(',');

    	node[1].Copy(temp.Mid(newLocation+1,location-(newLocation+1)));

    	location = newLocation;

    	newLocation = (temp.Left(location-1)).LocateReverse(',');

    	node[2].Copy(temp.Mid(newLocation+1,location-(newLocation+1)));

    	node[3].Copy(temp.Mid(0,newLocation ));

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

    	{    		

    		if (node[i].Length() && aURI.Find( node[i] ) != KErrNotFound)

            {

            status = CSmlDmAdapter::ENotAllowed;

            Callback().SetStatusL( aStatusRef, status );

            return;

            }

    	}

        // delete object identified by aLUID

        TNSmlDmFwObjectId id = DesToInt( aLUID );

        TInt res = iFotaDb->DeleteFwObjectL( id );

        if ( res == KErrNone )

            {

            // deletion was successful, delete also from Fota Engine

            FotaEngineL().DeleteUpdatePackage( id );

            }

        else

            {

            status = MapErrorToStatus( res );

            }

        }

    else

        {

        // object unknown

        status = CSmlDmAdapter::ENotFound;

        }

    Callback().SetStatusL( aStatusRef, status );

    _DBG_FILE("CNSmlDmFotaAdapter::DeleteLeafObjectL( ): end");

    FLOG(_L("CNSmlDmFotaAdapter::DeleteObjectL <<"));

    }

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

//  CNSmlDmFotaAdapter::FetchLeafObjectL()

//  Fetches the values of leaf objects.

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

//

void CNSmlDmFotaAdapter::FetchLeafObjectL( const TDesC8& aURI, 

                                           const TDesC8& aLUID,

                                           const TDesC8& aType,

                                           const TInt aResultsRef,

                                           const TInt aStatusRef )

    {

    _DBG_FILE("CNSmlDmFotaAdapter::FetchLeafObjectL(): begin");

    FLOG(_L("CNSmlDmFotaAdapter::FetchLeafObjectL >>"));

    // buffer for result

    CBufBase* result = CBufFlat::NewL( KNSmlDMFotaResultBufferExpandSize );

    CleanupStack::PushL( result );

    // fetch data

    CSmlDmAdapter::TError status = DoFetchObjectL( aURI, aLUID, *result );

    if ( status == CSmlDmAdapter::EOk )

        {

        Callback().SetResultsL( aResultsRef, *result, aType );

        }

    CleanupStack::PopAndDestroy( result );

    Callback().SetStatusL( aStatusRef, status );

    _DBG_FILE("CNSmlDmFotaAdapter::FetchLeafObjectL(): end");

    FLOG(_L("CNSmlDmFotaAdapter::FetchLeafObjectL <<"));

    }

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

//  CNSmlDmFotaAdapter::ChildURIListL()

//  Returns the list of children of a node.

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

//

void CNSmlDmFotaAdapter::ChildURIListL( const TDesC8& aURI,

                                        const TDesC8& aLUID, 

                                        const CArrayFix<TSmlDmMappingInfo>& aPreviousURISegmentList, 

                                        const TInt aResultsRef, 

                                        const TInt aStatusRef )

    {

    _DBG_FILE("CNSmlDmFotaAdapter::ChildURIListL(): begin");

    FLOG(_L("CNSmlDmFotaAdapter::ChildURIListL >>"));

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    TPtrC8 mimeType( KNullDesC8 );

    // buffer for result

    CBufBase* result = CBufFlat::NewL( KNSmlDMFotaResultBufferExpandSize );

    CleanupStack::PushL( result );

    TPtrC8 lastSeg = LastURISeg( aURI );

    if ( lastSeg == KNSmlDMFotaNodeDownload && aLUID.Length() > 0 )

        {

        // target is ./FUMO/<x>/Download

        result->InsertL( 0, KNSmlDMFotaNodeDownloadUrl );

        }

    else if ( lastSeg == KNSmlDMFotaNodeDownloadAndUpdate && aLUID.Length() > 0 )

        {

        // target is ./FUMO/<x>/DownloadAndUpdate

        result->InsertL( 0, KNSmlDMFotaNodeDownloadAndUpdateUrl );

        }

    else if ( ( aURI.Match( KNSmlDMFotaRuntimeMatch ) != KErrNotFound ) 

        && ( TableExistsL( aLUID ) ) )

        {

        // target is ./FUMO/<x>

        result->InsertL( 0, KNSmlDMFotaRunTimeChildren );

        mimeType.Set( KNSmlDMFotaRunTimeMimeType );

        }

    else if ( aURI.Match( KNSmlDMFotaRootMatch ) != KErrNotFound )

        {

        // target is ./FUMO

        // return the children listed in aPreviousURISegmentList

        TInt childCount = aPreviousURISegmentList.Count();

        for ( TInt i = 0; i < childCount - 1; ++i )

            {

            result->InsertL( result->Size(), aPreviousURISegmentList[i].iURISeg );

            result->InsertL( result->Size(), KNSmlDMFotaSeparatorDes );

            }

        if ( childCount )

            {

            // insert last child without separator