diff -r c742e1129640 -r aa33c2cb9a50 omadmadapters/fota/src/nsmldmfotaadapter.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/omadmadapters/fota/src/nsmldmfotaadapter.cpp Tue Jul 06 14:06:19 2010 +0300 @@ -0,0 +1,1605 @@ +/* +* 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 // For TImplementationProxy definition +//#ifdef RD_OMADMAPPUI_UI_EVOLUTION +#include +//#endif +#include +#include +#include +#include +#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 + +// =========================== 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 + 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(); + + // /PkgName + MSmlDmDDFObject& name = rtPkg.AddChildObjectL( KNSmlDMFotaNodeName ); + accessTypes.SetAdd(); + accessTypes.SetGet(); + accessTypes.SetReplace(); + FillNodeInfoL( name, + accessTypes, + MSmlDmDDFObject::EZeroOrOne, + MSmlDmDDFObject::EDynamic, + MSmlDmDDFObject::EChr, + KNSmlDMFotaNodeNameDescription ); + + // /PkgVersion + MSmlDmDDFObject& version = rtPkg.AddChildObjectL( KNSmlDMFotaNodeVersion ); + FillNodeInfoL( version, + accessTypes, + MSmlDmDDFObject::EZeroOrOne, + MSmlDmDDFObject::EDynamic, + MSmlDmDDFObject::EChr, + KNSmlDMFotaNodeVersionDescription ); + + accessTypes.Reset(); + + // /Download + MSmlDmDDFObject& download = + rtPkg.AddChildObjectL( KNSmlDMFotaNodeDownload ); + + accessTypes.SetGet(); + accessTypes.SetExec(); + FillNodeInfoL( download, + accessTypes, + MSmlDmDDFObject::EZeroOrOne, + MSmlDmDDFObject::EDynamic, + MSmlDmDDFObject::ENode, + KNSmlDMFotaNodeDownloadDescription ); + + accessTypes.Reset(); + + // /Download/PkgURL + MSmlDmDDFObject& dlUrl = + download.AddChildObjectL( KNSmlDMFotaNodeDownloadUrl ); + + accessTypes.SetGet(); + accessTypes.SetReplace(); + FillNodeInfoL( dlUrl, + accessTypes, + MSmlDmDDFObject::EOne, + MSmlDmDDFObject::EDynamic, + MSmlDmDDFObject::EChr, + KNSmlDMFotaNodeDownloadUrlDescription ); + + accessTypes.Reset(); + + + // /DownloadAndUpdate + MSmlDmDDFObject& dlAndUpdate = + rtPkg.AddChildObjectL( KNSmlDMFotaNodeDownloadAndUpdate ); + + accessTypes.SetGet(); + accessTypes.SetExec(); + FillNodeInfoL( dlAndUpdate, + accessTypes, + MSmlDmDDFObject::EZeroOrOne, + MSmlDmDDFObject::EDynamic, + MSmlDmDDFObject::ENode, + KNSmlDMFotaNodeDownloadAndUpdateDescription ); + + accessTypes.Reset(); + + // /DownloadAndUpdate/PkgURL + MSmlDmDDFObject& dlAndUpdateUrl = + dlAndUpdate.AddChildObjectL( KNSmlDMFotaNodeDownloadAndUpdateUrl ); + + accessTypes.SetGet(); + accessTypes.SetReplace(); + FillNodeInfoL( dlAndUpdateUrl, + accessTypes, + MSmlDmDDFObject::EOne, + MSmlDmDDFObject::EDynamic, + MSmlDmDDFObject::EChr, + KNSmlDMFotaNodeDownloadAndUpdateUrlDescription ); + + accessTypes.Reset(); + + // /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 ); + session.GetAclL( KNSmlDMFotaNode,*acl,EFalse ); + + 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 temp; + GetPredefinedNodeL(temp); + TBuf8 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& 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//Download + result->InsertL( 0, KNSmlDMFotaNodeDownloadUrl ); + } + else if ( lastSeg == KNSmlDMFotaNodeDownloadAndUpdate && aLUID.Length() > 0 ) + { + // target is ./FUMO//DownloadAndUpdate + result->InsertL( 0, KNSmlDMFotaNodeDownloadAndUpdateUrl ); + } + else if ( ( aURI.Match( KNSmlDMFotaRuntimeMatch ) != KErrNotFound ) + && ( TableExistsL( aLUID ) ) ) + { + // target is ./FUMO/ + 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 + result->InsertL( result->Size(), + aPreviousURISegmentList[ childCount - 1 ].iURISeg ); + } + + } + else + { + // invalid target + status = CSmlDmAdapter::ENotFound; + } + + // set result, if it was found + if ( status == CSmlDmAdapter::EOk ) + { + Callback().SetResultsL( aResultsRef, *result, mimeType ); + } + + Callback().SetStatusL( aStatusRef, status ); + + CleanupStack::PopAndDestroy( result ); + + _DBG_FILE("CNSmlDmFotaAdapter::ChildURIListL(): end"); + FLOG(_L("CNSmlDmFotaAdapter::ChildURIListL <<")); + } + + + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::TableExistsL(const TDesC8& aLUID) const +// Checks if table exists +// --------------------------------------------------------------------------- +// +TBool CNSmlDmFotaAdapter::TableExistsL(const TDesC8& aLUID) const + { + TBool ret = EFalse; + if(aLUID.Length()>0) + { + TNSmlDmFwObjectId luid = DesToInt( aLUID ); + TSmlProfileId profileId = iFotaDb->ProfileIdL(luid); + if (profileId!=KErrNotFound) + { + ret = ETrue; + } + } + return ret; + } + +// +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::AddNodeObjectL() +// Adds new row to firmware object table in Fota database. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::AddNodeObjectL( const TDesC8& aURI, + const TDesC8& aParentLUID, + const TInt aStatusRef ) + { + _DBG_FILE("CNSmlDmFotaAdapter::AddNodeObjectL(): begin"); + + CSmlDmAdapter::TError status = CSmlDmAdapter::EOk; + + // Luid specified and it's a valid luid => already exists + if ( TableExistsL( aParentLUID ) ) + { + // the object has already been created and mapping set to DM Framework + status = CSmlDmAdapter::EAlreadyExists; + } + else if ( aURI.Match( KNSmlDMFotaRuntimeMatch ) != KErrNotFound ) + { + 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 ); + } + + + // add new FW object to db + TNSmlDmFwObjectId newId = KErrNotFound; + TRAP( err, newId = iFotaDb->AddFwObjectL() ); + + if ( err == KErrNone ) + { + // added ok + TBuf8 newLUID; + newLUID.AppendNum( newId ); + + Callback().SetMappingL( aURI, newLUID ); + } + else + { + status = MapErrorToStatus( err ); + } + + } + else + { + // error, invalid uri + status = CSmlDmAdapter::ENotFound; + } + + Callback().SetStatusL( aStatusRef, status ); +// if(status==CSmlDmAdapter::EOk) +// { +// TSmlProfileId profId = KErrNotFound; +// HBufC8* serverId = NULL; +// +// GetServerInfoL( profId, serverId ); +// +// if(serverId) +// { +// CleanupStack::PushL( serverId ); +// +// _LIT( KFotaAclAdd, "Add="); +// _LIT( KFotaAclGet, "Get="); +// _LIT( KFotaAclReplace, "Replace="); +// _LIT( KFotaAclDelete, "Delete="); +// _LIT( KFotaAclExec, "Exec="); +// _LIT( KFotaAclSeparator, "&"); +// _LIT( KFotaAclForAll, "*"); +// +// const TUint length = KFotaAclAdd().Length() + +// KFotaAclGet().Length() + +// KFotaAclReplace().Length() + +// KFotaAclDelete().Length() + +// KFotaAclExec().Length() + +// serverId->Length()*4 + +// 5; /* 4*'&'+ ''*' */ +// +// HBufC8* acl = HBufC8::NewLC(length); +// TPtr8 acltPtr = acl->Des(); +// acltPtr.Append(KFotaAclAdd); +// acltPtr.Append(*serverId); +// acltPtr.Append(KFotaAclSeparator); +// +// acltPtr.Append(KFotaAclGet); +// acltPtr.Append(*serverId); +// acltPtr.Append(KFotaAclSeparator); +// +// acltPtr.Append(KFotaAclReplace); +// acltPtr.Append(*serverId); +// acltPtr.Append(KFotaAclSeparator); +// +// acltPtr.Append(KFotaAclDelete); +// acltPtr.Append(KFotaAclForAll); +// acltPtr.Append(KFotaAclSeparator); +// +// acltPtr.Append(KFotaAclExec); +// acltPtr.Append(*serverId); +// +// RNSmlDMCallbackSession session; +// User::LeaveIfError( session.Connect() ); +// CleanupClosePushL(session); +// session.UpdateAclL(aURI,*acl); +// CleanupStack::PopAndDestroy( &session ); +// CleanupStack::PopAndDestroy( acl ); +// CleanupStack::PopAndDestroy( serverId ); +// } +// } + + _DBG_FILE("CNSmlDmFotaAdapter::AddNodeObjectL(): end"); + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::UpdateLeafObjectL() +// Updates a leaf object using streaming. In Fota adapter this method is used +// only to update PkgData of a firmware object. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::UpdateLeafObjectL( const TDesC8& aURI, + const TDesC8& aLUID, + RWriteStream*& aStream, + const TDesC8& /*aType*/, + const TInt aStatusRef ) + { + _DBG_FILE("CNSmlDmFotaAdapter::UpdateLeafObjectL(stream): begin"); + FLOG(_L("CNSmlDmFotaAdapter::UpdateLeafObjectL >>")); + CSmlDmAdapter::TError status = CSmlDmAdapter::ENotFound; + + + Callback().SetStatusL( aStatusRef, status ); + + _DBG_FILE("CNSmlDmFotaAdapter::UpdateLeafObjectL(stream): end"); + FLOG(_L("CNSmlDmFotaAdapter::UpdateLeafObjectL <<")); + } + +// --------------------------------------------------------------------------- +// void CNSmlDmFotaAdapter::FetchLeafObjectSizeL() +// Fetches data object and returns its size. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, + const TDesC8& aLUID, + const TDesC8& aType, + const TInt aResultsRef, + const TInt aStatusRef ) + { + _DBG_FILE("CNSmlDmFotaAdapter::FetchLeafObjectSizeL(): begin"); + FLOG(_L("CNSmlDmFotaAdapter::FetchLeafObjectSizeL >>")); + // buffer for result + CBufBase* result = CBufFlat::NewL( KNSmlDMFotaResultBufferExpandSize ); + CleanupStack::PushL( result ); + + // fetch data + CSmlDmAdapter::TError status = DoFetchObjectL( aURI, aLUID, *result ); + if ( status == CSmlDmAdapter::EOk ) + { + // get size and form a string representation + TInt size = result->Size(); + TBuf8 sizeStr; + sizeStr.AppendNum( size ); + + // insert size to result + result->Reset(); + result->InsertL( 0, sizeStr ); + + Callback().SetResultsL( aResultsRef, *result, aType ); + } + + CleanupStack::PopAndDestroy( result ); + + Callback().SetStatusL( aStatusRef, status ); + + _DBG_FILE("CNSmlDmFotaAdapter::FetchLeafObjectSizeL(): end"); + FLOG(_L("CNSmlDmFotaAdapter::FetchLeafObjectSizeL <<")); + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::ExecuteCommandL() +// Executes Update, Download or DownloadAndUpdate command depending on aURI. +// If aURI does not match to any of these, ENotFound is set as status. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::ExecuteCommandL( const TDesC8& aURI, + const TDesC8& aLUID, + const TDesC8& aArgument, + const TDesC8& /*aType*/, + const TInt aStatusRef ) + { + _DBG_FILE("CNSmlDmFotaAdapter::ExecuteCommandL(): begin"); + FLOG(_L("CNSmlDmFotaAdapter::ExecuteCommandL >>")); + //#ifdef RD_OMADMAPPUI_UI_EVOLUTION + TInt configFlags( 0 ); + CRepository* centrep = NULL; + TRAPD( err, centrep = CRepository::NewL( KCRUidDeviceManagementInternalKeys ) ); + if ( centrep ) + { + centrep->Get( KDevManSessionType, configFlags ); + } + if ( err != KErrNone ) + { + User::Leave( err ); + } + else + { + configFlags = 1; + centrep->Set( KDevManSessionType, configFlags ); + } + if( centrep ) + { + delete centrep; + } + //#endif + CSmlDmAdapter::TError status = CSmlDmAdapter::ENotFound; + + if ( aLUID.Length() > 0 ) + { + TNSmlDmFwObjectId id = DesToInt( aLUID ); + + // uri should target Update, Download or DownloadAndUpdate + TPtrC8 lastSeg = LastURISeg( aURI ); + if ( lastSeg == KNSmlDMFotaNodeDownload || + lastSeg == KNSmlDMFotaNodeDownloadAndUpdate ) + { + + // save information about the execution and get profile id of + // currently running DM session + TSmlProfileId profId = 0; + TRAPD( err, profId = SaveExecInfoL( aURI, id, aArgument ) ); + + if ( err == KErrNone ) + { + if ( lastSeg == KNSmlDMFotaNodeDownload ) + { + // download + status = DoExecDownloadL( id, profId, EFalse ); + } + else if ( lastSeg == KNSmlDMFotaNodeDownloadAndUpdate ) + { + // download and update + status = DoExecDownloadL( id, profId, ETrue ); + } + + } + else + { + status = MapErrorToStatus( err ); + } + } + + } +#ifndef __WINS__ + Callback().SetStatusL( aStatusRef, status ); +#endif + _DBG_FILE("CNSmlDmFotaAdapter::ExecuteCommandL(): end"); + FLOG(_L("CNSmlDmFotaAdapter::ExecuteCommandL <<")); + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::ExecuteCommandL() +// Not supported. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::ExecuteCommandL( const TDesC8& /*aURI*/, + const TDesC8& /*aLUID*/, + RWriteStream*& /*aStream*/, + const TDesC8& /*aType*/, + const TInt aStatusRef ) + { + _DBG_FILE("CNSmlDmFotaAdapter::ExecuteCommandL(): begin"); + FLOG(_L("CNSmlDmFotaAdapter::ExecuteCommandL >>")); + Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError ); + FLOG(_L("CNSmlDmFotaAdapter::ExecuteCommandL <<")); + _DBG_FILE("CNSmlDmFotaAdapter::ExecuteCommandL(): end"); + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::CopyCommandL() +// Not supported. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::CopyCommandL( const TDesC8& /*aTargetURI*/, + const TDesC8& /*aTargetLUID*/, + const TDesC8& /*aSourceURI*/, + const TDesC8& /*aSourceLUID*/, + const TDesC8& /*aType*/, + TInt aStatusRef ) + { + _DBG_FILE("CNSmlDmFotaAdapter::CopyCommandL(): begin"); + + Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError ); + + _DBG_FILE("CNSmlDmFotaAdapter::CopyCommandL(): end"); + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::StartAtomicL() +// Not supported. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::StartAtomicL() + { + _DBG_FILE("CNSmlDmFotaAdapter::StartAtomicL(): begin"); + _DBG_FILE("CNSmlDmFotaAdapter::StartAtomicL(): end"); + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::CommitAtomicL() +// Not supported. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::CommitAtomicL() + { + _DBG_FILE("CNSmlDmFotaAdapter::CommitAtomicL(): begin"); + _DBG_FILE("CNSmlDmFotaAdapter::CommitAtomicL(): end"); + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::RollbackAtomicL() +// Not supported. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::RollbackAtomicL() + { + _DBG_FILE("CNSmlDmFotaAdapter::RollbackAtomicL(): begin"); + _DBG_FILE("CNSmlDmFotaAdapter::RollbackAtomicL(): end"); + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::StreamingSupport() +// Returns whether or not streaming is supported in this adapter. +// In Fota this method is also used to enquire whether or not a large object +// whose size is given in aItemSize fits to disk (OOD check using Fota Engine), +// and to acknowledge that Generic Alerts have been sent succesfully to remote +// server. If aItemSize is larger that 0, OOD check feature is executed. +// If aItemSize equals to KNSmlDMResetGenAlerts, Generic Alerts are marked +// sent. Otherwise aItemSize is set to a treshold value, which is used by +// DM Host Server to determineif streaming should be used (large object) +// or not. +// --------------------------------------------------------------------------- +// +TBool CNSmlDmFotaAdapter::StreamingSupport( TInt& aItemSize ) + { + _DBG_FILE("CNSmlDmFotaAdapter::StreamingSupport(): begin"); + FLOG(_L("CNSmlDmFotaAdapter::StreamingSupport, ITEM = %d >>"), aItemSize); + TBool ret (EFalse); + if ( aItemSize == KNSmlDMResetGenAlerts ) + { + // generic alerts have been sent successfully to this server + TRAPD( err, MarkGenericAlertsSentL() ); + if(err) + { + _DBG_FILE("CNSmlDmFotaAdapter::StreamingSupport(): error in MarkGenricAlertSentL()"); + } + ret = ETrue; + } + + _DBG_FILE("CNSmlDmFotaAdapter::StreamingSupport(): end"); + FLOG(_L("CNSmlDmFotaAdapter::StreamingSupport <<")); + return ret; + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::StreamCommittedL() +// Notification method used by DM Host Server. All data has been written to +// stream successfully and stream has been committed and closed. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::StreamCommittedL() + { + _DBG_FILE("CNSmlDmFotaAdapter::StreamCommittedL(): begin"); + + _DBG_FILE("CNSmlDmFotaAdapter::StreamCommittedL(): end"); + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::CompleteOutstandingCmdsL() +// Not supported. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::CompleteOutstandingCmdsL() + { + _DBG_FILE("CNSmlDmFotaAdapter::CompleteOutstandingCmdsL(): begin"); + _DBG_FILE("CNSmlDmFotaAdapter::CompleteOutstandingCmdsL(): end"); + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::DoFetchObjectL() +// Fetches the data identified by aURI in FW object aLUID. Writes the data +// to aObject and returns status code according to the success of the fetch. +// --------------------------------------------------------------------------- +// +CSmlDmAdapter::TError CNSmlDmFotaAdapter::DoFetchObjectL( const TDesC8& aURI, + const TDesC8& aLUID, + CBufBase& aObject ) + { + CSmlDmAdapter::TError status = CSmlDmAdapter::ENotFound; + + if ( aLUID.Length() > 0 ) + { + HBufC8* data = NULL; + TNSmlDmFwObjectId id = DesToInt( aLUID ); + + // get correct data according to the last segment of the uri + TPtrC8 lastSeg = LastURISeg( aURI ); + if ( lastSeg == KNSmlDMFotaNodeName ) + { + data = iFotaDb->PkgNameL( id ); + } + else if ( lastSeg == KNSmlDMFotaNodeVersion ) + { + data = iFotaDb->PkgVersionL( id ); + } + else if ( lastSeg == KNSmlDMFotaNodeDownloadUrl || + lastSeg == KNSmlDMFotaNodeDownloadAndUpdateUrl ) + { + data = iFotaDb->PkgUrlL( id ); + } + else if ( lastSeg == KNSmlDMFotaNodeState ) + { + // state is fetched from fota engine + RFotaEngineSession::TState state = FotaEngineL().GetState( id ); + data = HBufC8::NewL( KNSmlFwMgmtObjectIntegerLength ); + data->Des().AppendNum( state ); + } + + // if data is fetched ok, set results + if ( data ) + { + CleanupStack::PushL( data ); + + aObject.InsertL( 0, *data ); + status = CSmlDmAdapter::EOk; + + CleanupStack::PopAndDestroy( data ); + } + } + + return status; + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::DoExecUpdateL() +// Gets needed data for Update from Fota DB and notifies Fota Engine that +// Update should be executed. Returns status according to the success of +// the method. +// --------------------------------------------------------------------------- +// +CSmlDmAdapter::TError CNSmlDmFotaAdapter::DoExecUpdateL( + const TNSmlDmFwObjectId aLUID, + const TSmlProfileId aProfile ) + { + CSmlDmAdapter::TError status = CSmlDmAdapter::EOk; + + // get needed data from db for fota engine + HBufC8* pkgName = iFotaDb->PkgNameL( aLUID ); + CleanupStack::PushL( pkgName ); + + HBufC8* pkgVersion = iFotaDb->PkgVersionL( aLUID ); + CleanupStack::PushL( pkgVersion ); + + TInt error = KErrNone; + + if ( pkgName && pkgVersion ) + { + // notify fota engine to start update + error = FotaEngineL().Update( aLUID, aProfile, *pkgName, *pkgVersion ); + + // if immediate error occured, set final result to corresponding + // value so that generic alert is not sent + if ( error == KErrNotFound ) + { + // binary update package has not been downloaded yet -> not + // possible to update + status = CSmlDmAdapter::ENotFound; + iFotaDb->SetFinalResultL( KNSmlDMFotaUndefinedError, aLUID ); + } + else if ( error != KErrNone ) + { + // other error + status = CSmlDmAdapter::EError; + iFotaDb->SetFinalResultL( KNSmlDMFotaUndefinedError, aLUID ); + } + } + else + { + // fw object was not found + status = CSmlDmAdapter::ENotFound; + } + + CleanupStack::PopAndDestroy( pkgVersion ); + CleanupStack::PopAndDestroy( pkgName ); + + return status; + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::DoExecDownloadL() +// Gets needed data for Download or DownloadAndUpdate from Fota DB and +// notifies Fota Engine that Download or DownloadAndUpdate should be executed. +// Returns status according to the success of the method. +// --------------------------------------------------------------------------- +// +CSmlDmAdapter::TError CNSmlDmFotaAdapter::DoExecDownloadL( + const TNSmlDmFwObjectId aLUID, + const TSmlProfileId aProfile, + TBool aUpdate ) + { + CSmlDmAdapter::TError status = CSmlDmAdapter::EOk; + + // get needed data from db for fota engine + HBufC8* url = iFotaDb->PkgUrlL( aLUID ); + CleanupStack::PushL( url ); + + HBufC8* pkgName = iFotaDb->PkgNameL( aLUID ); + CleanupStack::PushL( pkgName ); + + HBufC8* pkgVersion = iFotaDb->PkgVersionL( aLUID ); + CleanupStack::PushL( pkgVersion ); + + TInt error = KErrNone; + + if ( url && pkgName && pkgVersion ) + { + TBool silent (EFalse); + TInt value (ENonSilent); + RProperty::Get(KPSUidNSmlSOSServerKey, KNSmlDMSilentJob, value); + + if (value == ESilent) + { + silent = ETrue; + FLOG(_L("Session type is silent")); + } + if ( aUpdate ) + { + // notify fota engine to start download and update + error = FotaEngineL().DownloadAndUpdate( aLUID, *url, aProfile, *pkgName, *pkgVersion,silent ); + } + else + { + // notify fota engine to start download + error = FotaEngineL().Download( aLUID, *url, aProfile, *pkgName, *pkgVersion, silent ); + } + + // if immediate error occured, set final result to corresponding value so that + // generic alert is not sent + if ( error == KErrArgument ) + { + // url incorrectly formed + status = CSmlDmAdapter::EInvalidObject; + iFotaDb->SetFinalResultL( KNSmlDMFotaBadUrl, aLUID ); + } + else if ( error != KErrNone ) + { + // other error + status = CSmlDmAdapter::EError; + iFotaDb->SetFinalResultL( KNSmlDMFotaUndefinedError, aLUID ); + } + } + else + { + // fw object was not found + status = CSmlDmAdapter::ENotFound; + } + + CleanupStack::PopAndDestroy( pkgVersion ); + CleanupStack::PopAndDestroy( pkgName ); + CleanupStack::PopAndDestroy( url ); + + return status; + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::SaveExecInfoL() +// Saves the values needed when starting an exec command. Returns the saved +// profile id. +// --------------------------------------------------------------------------- +// +TSmlProfileId CNSmlDmFotaAdapter::SaveExecInfoL( const TDesC8& aURI, + const TNSmlDmFwObjectId aLUID, + const TDesC8& aCorrelator ) + { + // set final result (null), uri and correlator to fota db + User::LeaveIfError( iFotaDb->SetFinalResultL( KNSmlFotaNullResult, aLUID ) ); + User::LeaveIfError( iFotaDb->SetMgmtUriL( aURI, aLUID ) ); + User::LeaveIfError( iFotaDb->SetCorrelatorL( aCorrelator, aLUID ) ); + + // fetch profile id and server id of the currently running dm session + TSmlProfileId profId = KErrNotFound; + HBufC8* serverId = NULL; + + GetServerInfoL( profId, serverId ); + CleanupStack::PushL( serverId ); + + // save profile id and server id to fota db + User::LeaveIfError( iFotaDb->SetServerInfoL( profId, *serverId, aLUID ) ); + + CleanupStack::PopAndDestroy( serverId ); + + return profId; + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::GetServerInfoL() +// Fetches profile id and server id of the currently running dm session. +// Data is fetched using Client API and set to the references given as +// parameters. Reallocates server id to aServerId. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::GetServerInfoL( TSmlProfileId& aProfId, + HBufC8*& aServerId ) const + { + // Open session + RSyncMLSession session; + session.OpenL(); + CleanupClosePushL( session ); + + // get current job's id (and usage type) + TSmlJobId jobId = KErrNotFound; + TSmlUsageType type = ESmlDevMan; + session.CurrentJobL( jobId, type ); + + // open currently running job + RSyncMLDevManJob dmJob; + dmJob.OpenL( session, jobId ); + CleanupClosePushL( dmJob ); + + // get job's profile id + aProfId = dmJob.Profile(); + + // open profile using id in read-only mode + RSyncMLDevManProfile dmProf; + dmProf.OpenL( session, aProfId, ESmlOpenRead ); + CleanupClosePushL( dmProf ); + + // get profile's server id + aServerId = dmProf.ServerId().AllocL(); + + // close handles + CleanupStack::PopAndDestroy( &dmProf ); + CleanupStack::PopAndDestroy( &dmJob ); + CleanupStack::PopAndDestroy( &session ); + } +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::CheckAndAddPredefinedNodeL() +// Checks if predefined node for FUMO is in tree if not add to the tree +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::CheckAndAddPredefinedNodeL() + { + + TBuf8 temp; + GetPredefinedNodeL(temp); + if (temp.Length()) + { + RNSmlDMCallbackSession session; + User::LeaveIfError( session.Connect() ); + CleanupClosePushL(session); + TBuf8 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++) + { + TBuf8 temp1; + temp1.Zero(); + temp1.Copy(KNSmlDMFotaNode); + temp1.Append(KNSmlDMFotaSeparatorDes); + temp1.Append(node[i]); + HBufC8* luid = session.GetLuidAllocL( KNSmlDMFotaAdapterImplUid,temp1); + CleanupStack::PushL(luid); + if ( luid->Length() > 0 ) + { + CleanupStack::PopAndDestroy( luid ); + CleanupStack::PopAndDestroy( &session ); + return; + } + else + { + // Add the mapping + TNSmlDmFwObjectId newId = KErrNotFound; + TRAPD( err, newId = iFotaDb->AddFwObjectL() ); + + if ( err == KErrNone ) + { + // added ok + TBuf8 newLUID; + newLUID.AppendNum( newId ); + session.AddMappingInfoL(KNSmlDMFotaAdapterImplUid, temp1, newLUID ); + } + } + CleanupStack::PopAndDestroy( luid ); + } + CleanupStack::PopAndDestroy( &session ); + } + } +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::GetPredefinedNodeL() +// Gets predefined node for FUMO from cenrep +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::GetPredefinedNodeL(TDes8& aNode) + { + CRepository* centrep( NULL); + aNode.Zero(); + centrep = CRepository::NewLC( TUid::Uid(0x101F9A0A) ); + + if ( centrep ) + { + TFullName temp; + + if (centrep->Get( KDevManFUMOPredefinedNodes, temp )==KErrNone && temp.Length() ) + { + temp.Trim(); + aNode.Copy(temp); + } + CleanupStack::PopAndDestroy(centrep); + } + } +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::MakeGenericAlertsL() +// Checks whether or not there are fw objects whose final result should be +// sent to the remote server which is involved with the current DM session. +// If there are such objects, notifies private api using the data needed for +// generic alert generation. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::MakeGenericAlertsL() + { + FLOG(_L("CNSmlDmFotaAdapter::MakeGenericAlertsL >>")); + // search for fw objects that have empty final result + RNSmlDmFwObjectArray ids; + CleanupClosePushL( ids ); + + iFotaDb->GetEmptyFinalResultsL( ids ); + if ( ids.Count() == 0 ) + { + // none found, no need for generic alerts + CleanupStack::PopAndDestroy( &ids ); + FLOG(_L("CNSmlDmFotaAdapter::MakeGenericAlertsL 1")); + return; + } + + // get information of the remote DM server + TSmlProfileId profId = 0; + HBufC8* serverId = NULL; + GetServerInfoL( profId, serverId ); + CleanupStack::PushL( serverId ); + + // open handle to private api + RNSmlPrivateAPI privateAPI; + FLOG(_L("CNSmlDmFotaAdapter::MakeGenericAlertsL 2")); + privateAPI.OpenL(); + CleanupClosePushL( privateAPI ); + + // go through all objects in ids + for ( TInt i = 0; i < ids.Count(); ++i ) + { + // check that server ids match. if not, move to next entry + FLOG(_L("CNSmlDmFotaAdapter::MakeGenericAlertsL 3")); + HBufC8* fwServerId = iFotaDb->ServerIdL( ids[i] ); + CleanupStack::PushL( fwServerId ); + FLOG(_L("CNSmlDmFotaAdapter::MakeGenericAlertsL 4")); + if ( *serverId == *fwServerId ) + { + // check that mgmt uri is not empty string. if it is, + // move to next entry + HBufC8* fwMgmtUri = iFotaDb->MgmtUriL( ids[i] ); + FLOG(_L("CNSmlDmFotaAdapter::MakeGenericAlertsL 5")); + CleanupStack::PushL( fwMgmtUri ); + + if ( *fwMgmtUri != KNullDesC8 ) + { + // check that update has reached its final result + FLOG(_L("CNSmlDmFotaAdapter::MakeGenericAlertsL 6")); + TInt finalResult = FotaEngineL().GetResult( ids[i] ); + + RFotaEngineSession::TState finalState = FotaEngineL().GetState( ids[i] ); + + if ( finalResult != KErrNotFound && finalState != RFotaEngineSession::EStartingUpdate) + { + // get fw object's correlator + HBufC8* fwCorrelator = iFotaDb->CorrelatorL( ids[i] ); + CleanupStack::PushL( fwCorrelator ); + + // add generic alert to dm message + TPtrC8 metaType = GetMetaType( *fwMgmtUri ); + FLOG(_L("CNSmlDmFotaAdapter::MakeGenericAlertsL 7")); + privateAPI.AddDMGenericAlertRequestL( *fwMgmtUri, metaType, KNSmlDMFotaMetaFormat, finalResult, *fwCorrelator ); + FLOG(_L("CNSmlDmFotaAdapter::MakeGenericAlertsL 8")); + CleanupStack::PopAndDestroy( fwCorrelator ); + } + } + + CleanupStack::PopAndDestroy( fwMgmtUri ); + } + + CleanupStack::PopAndDestroy( fwServerId ); + } + + CleanupStack::PopAndDestroy( &privateAPI ); + CleanupStack::PopAndDestroy( serverId ); + CleanupStack::PopAndDestroy( &ids ); + FLOG(_L("CNSmlDmFotaAdapter::MakeGenericAlertsL <<")); + + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::MarkGenericAlertsSentL() +// Puts a final result value to those fw objects, that are +// associated with current DM session's remote server, have +// been a target to an exec command and the exec command has +// finished. I.e. Generic Alert has been sent to remote server +// reporting the results of these exec commands --> not needed to +// send Generic Alert anymore in next DM session. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::MarkGenericAlertsSentL() + { + + FLOG(_L("CNSmlDmFotaAdapter::MarkGenericAlertsSentL >>")); + + // search for fw objects that have empty final result + RNSmlDmFwObjectArray ids; + CleanupClosePushL( ids ); + + // get information of the remote DM server + TSmlProfileId profId = 0; + HBufC8* serverId = NULL; + GetServerInfoL( profId, serverId ); + CleanupStack::PushL( serverId ); + + FLOG(_L("CNSmlDmFotaAdapter::MarkGenericAlertsSentL 1")); + iFotaDb->GetEmptyFinalResultsL( ids, *serverId ); + + // go through all objects in ids + for ( TInt i = 0; i < ids.Count(); ++i ) + { + // check that update has reached its final result + FLOG(_L("CNSmlDmFotaAdapter::MarkGenericAlertsSentL 2")); + TInt finalResult = FotaEngineL().GetResult( ids[i] ); + if ( finalResult != KErrNotFound ) + { + // set final result thus setting generic alert sent + FLOG(_L("CNSmlDmFotaAdapter::MarkGenericAlertsSentL 3")); + iFotaDb->SetFinalResultL( finalResult, ids[i] ); + + // also notify fota engine, that generic alert has been + // successfully sent, thus enabling possible cleanup + FLOG(_L("CNSmlDmFotaAdapter::MarkGenericAlertsSentL, %d"), ids[i]); + FotaEngineL().GenericAlertSentL( ids[i] ); + } + } + + CleanupStack::PopAndDestroy( serverId ); + CleanupStack::PopAndDestroy( &ids ); + FLOG(_L("CNSmlDmFotaAdapter::MarkGenericAlertsSentL <<")); + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::GetMetaType() +// Determines by the given uri which meta/type should be used in generic +// alert.Returns the correct type, or KNullDesC8 if uri does not match to +// exec targets. +// --------------------------------------------------------------------------- +// +TPtrC8 CNSmlDmFotaAdapter::GetMetaType( const TDesC8& aURI ) const + { + TPtrC8 lastSeg = LastURISeg( aURI ); + + if ( lastSeg == KNSmlDMFotaNodeDownload ) + { + return KNSmlDMFotaDownloadMetaType(); + } + else if ( lastSeg == KNSmlDMFotaNodeDownloadAndUpdate ) + { + return KNSmlDMFotaDownloadAndUpdateMetaType(); + } + + return KNullDesC8(); + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::MapStatusToError() +// Returns a status code corresponding to the system error code given +// as parameter. +// --------------------------------------------------------------------------- +// +CSmlDmAdapter::TError CNSmlDmFotaAdapter::MapErrorToStatus( TInt aError ) const + { + CSmlDmAdapter::TError err = CSmlDmAdapter::EError; + + switch( aError ) + { + case KErrNone: + err = CSmlDmAdapter::EOk; + break; + case KErrNotFound: + err = CSmlDmAdapter::ENotFound; + break; + case KErrDiskFull: + err = CSmlDmAdapter::EDiskFull; + break; + case KErrOverflow: + err = CSmlDmAdapter::ETooLargeObject; + break; + default: + break; + } + + return err; + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::DesToInt() +// Converts a 8 bit descriptor to an integer. +// --------------------------------------------------------------------------- +// +TInt CNSmlDmFotaAdapter::DesToInt( const TDesC8& aLUID ) const + { + TLex8 lex( aLUID ); + TInt value = KErrNotFound; + lex.Val( value ); + + return value; + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::LastURISeg() +// Returns the last segment of the given uri. +// --------------------------------------------------------------------------- +// +TPtrC8 CNSmlDmFotaAdapter::LastURISeg( const TDesC8& aURI ) const + { + TInt pos = aURI.LocateReverse( KNSmlDMFotaSeparatorDes()[0] ); + if( pos == KErrNotFound ) + { + return aURI; + } + else + { + return aURI.Mid( pos + 1 ); + } + } + +// --------------------------------------------------------------------------- +// CNSmlDmFotaAdapter::FillNodeInfoL() +// Fills the DDF node info. +// --------------------------------------------------------------------------- +// +void CNSmlDmFotaAdapter::FillNodeInfoL( MSmlDmDDFObject& aNode, + const TSmlDmAccessTypes& aAccTypes, + MSmlDmDDFObject::TOccurence aOccurrence, + MSmlDmDDFObject::TScope aScope, + MSmlDmDDFObject::TDFFormat aFormat, + const TDesC8& aDescription ) const + { + aNode.SetAccessTypesL( aAccTypes ); + aNode.SetOccurenceL( aOccurrence ); + aNode.SetScopeL( aScope ); + aNode.SetDFFormatL( aFormat ); + + if( aFormat != MSmlDmDDFObject::ENode ) + { + aNode.AddDFTypeMimeTypeL( KNSmlDMFotaTextPlain ); + } + + aNode.SetDescriptionL( aDescription ); + } + +RFotaEngineSession& CNSmlDmFotaAdapter::FotaEngineL() + { + FLOG(_L("CNSmlDmFotaAdapter::FotaEngineL >>")); + if (!iFotaEngine.Handle()) + { + FLOG(_L("Opening fota engine...")); + iFotaEngine.OpenL(); + } + + FLOG(_L("CNSmlDmFotaAdapter::FotaEngineL <<")); + return iFotaEngine; + } +// --------------------------------------------------------------------------- +// TImplementationProxy ImplementationTable[] +// Needed because of ECOM architecture. +// --------------------------------------------------------------------------- +// +#ifndef IMPLEMENTATION_PROXY_ENTRY +#define IMPLEMENTATION_PROXY_ENTRY(aUid, aFuncPtr) {{aUid},(aFuncPtr)} +#endif + +const TImplementationProxy ImplementationTable[] = + { + IMPLEMENTATION_PROXY_ENTRY(KNSmlDMFotaAdapterImplUid, CNSmlDmFotaAdapter::NewL) + }; + + +// ========================== OTHER EXPORTED FUNCTIONS ========================= + +// --------------------------------------------------------------------------- +// ImplementationGroupProxy() +// Needed because of ECOM architecture. +// --------------------------------------------------------------------------- +// +EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount ) + { + _DBG_FILE("ImplementationGroupProxy() for CNSmlDmFotaAdapter: begin"); + aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy); + _DBG_FILE("ImplementationGroupProxy() for CNSmlDmFotaAdapter: end"); + return ImplementationTable; + } + + +// End of file +