diff -r 000000000000 -r ba25891c3a9e ncdengine/provider/client/src/ncdnodeinstallproxy.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ncdengine/provider/client/src/ncdnodeinstallproxy.cpp Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,582 @@ +/* +* Copyright (c) 2006-2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Contains CNcdNodeInstallProxy class implementation +* +*/ + + +#include +#include +#include + +#include "ncdnodeinstallproxy.h" +#include "ncdnodeproxy.h" +#include "ncdnodemetadataproxy.h" +#include "ncdproviderproxy.h" +#include "ncdnodemanagerproxy.h" +#include "ncdserverreportmanagerproxy.h" +#include "ncdoperationimpl.h" +#include "ncdinstalloperationproxy.h" +#include "ncdsilentinstalloperationproxy.h" +#include "ncdoperationmanagerproxy.h" +#include "ncdoperationdatatypes.h" +#include "catalogsclientserver.h" +#include "ncdnodeidentifier.h" +#include "ncdnodefunctionids.h" +#include "ncdnodeclassids.h" +#include "catalogsinterfaceidentifier.h" +#include "catalogsutils.h" +#include "catalogsdebug.h" +#include "ncdpanics.h" +#include "catalogsconstants.h" +#include "ncdinstallinfo.h" +#include "ncdfileinfo.h" +#include "ncdinstallationservice.h" +#include "ncddeviceinteractionfactory.h" +#include "ncdinstalledapplicationimpl.h" +#include "ncdinstalledthemeimpl.h" +#include "ncdinstalledfileimpl.h" +#include "ncdinstalledcontent.h" +#include "ncderrors.h" +#include "ncdextendedinstallinfo.h" +#include "ncdnodedownloadproxy.h" + +// ======== PUBLIC MEMBER FUNCTIONS ======== + +CNcdNodeInstallProxy::CNcdNodeInstallProxy( + MCatalogsClientServer& aSession, + TInt aHandle, + CNcdNodeMetadataProxy& aMetadata ) +: CNcdInterfaceBaseProxy( aSession, aHandle, &aMetadata ), + iMetadata( aMetadata ) + { + } + + +void CNcdNodeInstallProxy::ConstructL() + { + // Register the interface + MNcdNodeInstall* interface( this ); + AddInterfaceL( + CCatalogsInterfaceIdentifier::NewL( interface, this, + MNcdNodeInstall::KInterfaceUid ) ); + + iInstallationService = + &Metadata().Node().OperationManager().InstallationServiceL(); + + InternalizeL(); + } + + +CNcdNodeInstallProxy* CNcdNodeInstallProxy::NewL( + MCatalogsClientServer& aSession, + TInt aHandle, + CNcdNodeMetadataProxy& aMetadata ) + { + CNcdNodeInstallProxy* self = + CNcdNodeInstallProxy::NewLC( aSession, aHandle, aMetadata ); + CleanupStack::Pop( self ); + return self; + } + +CNcdNodeInstallProxy* CNcdNodeInstallProxy::NewLC( + MCatalogsClientServer& aSession, + TInt aHandle, + CNcdNodeMetadataProxy& aMetadata ) + { + CNcdNodeInstallProxy* self = + new( ELeave ) CNcdNodeInstallProxy( aSession, aHandle, aMetadata ); + // Using PushL because the object does not have any references yet + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + + +CNcdNodeInstallProxy::~CNcdNodeInstallProxy() + { + DLTRACEIN(("")); + // Remove interfaces implemented by this class from the interface list. + // So, the interface list is up to date when this class object is deleted. + RemoveInterface( MNcdNodeInstall::KInterfaceUid ); + + // Delete member variables here + // Do not delete installation service, node and operation manager because + // this object does not own them. + + // Release all content objects + iContent.ResetAndDestroy(); + } + + +CNcdNodeMetadataProxy& CNcdNodeInstallProxy::Metadata() const + { + return iMetadata; + } + + +void CNcdNodeInstallProxy::InternalizeL() + { + DLTRACEIN(("")); + + HBufC8* data( NULL ); + + // Because we do not know the exact size of the data, use + // the alloc method, which creates the buffer of the right size + // and sets the pointer to point to the created buffer. + // Get all the data that is necessary to internalize this object + // from the server side. + User::LeaveIfError( + ClientServerSession(). + SendSyncAlloc( NcdNodeFunctionIds::ENcdInternalize, + KNullDesC8, + data, + Handle(), + 0 ) ); + + if ( data == NULL ) + { + DLERROR(("")); + User::Leave( KErrNotFound ); + } + + CleanupStack::PushL( data ); + + // Read the data from the stream and insert it to the member variables + RDesReadStream stream( *data ); + CleanupClosePushL( stream ); + + InternalizeDataL( stream ); + + // Closes the stream + CleanupStack::PopAndDestroy( &stream ); + CleanupStack::PopAndDestroy( data ); + + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// Checks if this item has the purpose +// --------------------------------------------------------------------------- +// +TBool CNcdNodeInstallProxy::IsPurpose( TNcdItemPurpose aPurpose ) const + { + return iPurpose & aPurpose; + } + + +// MNcdNodeInstall functions + +// --------------------------------------------------------------------------- +// Creates an install operation +// --------------------------------------------------------------------------- +// +MNcdInstallOperation* CNcdNodeInstallProxy::InstallL( + MNcdInstallOperationObserver& aObserver ) + { + DLTRACEIN(("")); + + // Create operation + + // Using proxy as the observer. Forwards callbacks to the real operation + // observer + CNcdInstallOperationProxy* op = + Metadata().Node().OperationManager().CreateInstallOperationL( + Metadata().Node(), this ); + iOperationObserver = &aObserver; + + DLTRACEOUT(("")); + + return op; + } + + +// --------------------------------------------------------------------------- +// Creates an install operation +// --------------------------------------------------------------------------- +// +MNcdInstallOperation* CNcdNodeInstallProxy::SilentInstallL( + MNcdInstallOperationObserver& aObserver, + const SwiUI::TInstallOptions& aInstallOptions ) + { + DLTRACEIN(("")); + + // Create operation + + // Using proxy as the observer. Forwards callbacks to the real operation + // observer. + // Notice that TrustedUI capabilites are checked when silent install operation is + // created in the server side. + CNcdInstallOperationProxy* op = + Metadata().Node().OperationManager().CreateSilentInstallOperationL( + Metadata().Node(), this, aInstallOptions ); + iOperationObserver = &aObserver; + + DLTRACEOUT(("")); + + return op; + } + + +// --------------------------------------------------------------------------- +// Returns installed status +// --------------------------------------------------------------------------- +// +TBool CNcdNodeInstallProxy::IsInstalledL() const + { + DLTRACEIN(("")); + if ( !iInstalled || !iContent.Count() ) + { + DLTRACEOUT(("Not installed")); + return EFalse; + } + + for ( TInt i = 0; i < iContent.Count(); ++i ) + { + if ( !iContent[i]->IsInstalledL() ) + { + DLTRACEOUT(("Not installed (entirely)")); + return EFalse; + } + } + DLTRACEOUT(("Installed")); + return ETrue; + } + + +// --------------------------------------------------------------------------- +// IsLaunchableL +// --------------------------------------------------------------------------- +// +TBool CNcdNodeInstallProxy::IsLaunchable() const + { + DLTRACEIN(("")); + for ( TInt i = 0; i < iContent.Count(); ++i ) + { + if ( iContent[i]->IsLaunchable() ) + { + DLTRACEOUT(("Item contains something launchable")); + return ETrue; + } + } + + DLTRACEOUT(("Item doesn't contain anything launchable")); + return EFalse; + } + + +// --------------------------------------------------------------------------- +// InstalledContentL +// --------------------------------------------------------------------------- +// +RCatalogsArray + CNcdNodeInstallProxy::InstalledContentL() + { + DLTRACEIN(("this-ptr: %x, refcount: %d", this, TotalRefCount() )); + RCatalogsArray array; + CleanupResetAndDestroyPushL( array ); + + array.ReserveL( iContent.Count() ); + MNcdInstalledContent* content = NULL; + for ( TInt i = 0; i < iContent.Count(); ++i ) + { + content = iContent[i]; + array.AppendL( content ); + content->AddRef(); + } + CleanupStack::Pop( &array ); + DLTRACEOUT(("this-ptr: %x, refcount: %d", this, TotalRefCount() )); + return array; + } + + +// --------------------------------------------------------------------------- +// SetAsInstalledL +// --------------------------------------------------------------------------- +// +void CNcdNodeInstallProxy::SetApplicationInstalledL( TInt aErrorCode ) + { + DLTRACEIN(("error code: %d", aErrorCode)); + + // This function can only be called if download operation has already been done. + CNcdNodeDownloadProxy* download( Metadata().Download() ); + if ( download == NULL + || !download->IsDownloadedL() ) + { + DLINFO(("download has not been done")); + User::Leave( KErrAbort ); + } + + // Handle the information in the server side. + // This will also delete the content install files if they + // still exist after succesfull installation. + CBufBase* buf = CBufFlat::NewL( KBufExpandSize ); + CleanupStack::PushL( buf ); + RBufWriteStream stream( *buf ); + CleanupClosePushL( stream ); + + stream.WriteInt32L( aErrorCode ); + + CleanupStack::PopAndDestroy( &stream ); + TPtrC8 ptr = buf->Ptr( 0 ); + + TInt tmp( 0 ); + TInt error = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdSetApplicationInstalled, + ptr, + tmp, + Handle() ); + User::LeaveIfError( error ); + + CleanupStack::PopAndDestroy( buf ); + + + CNcdNodeManagerProxy& nodeManager( + Metadata().Node().NodeManager() ); + + CNcdProviderProxy& provider( + nodeManager.Provider() ); + + // Send an error report. + // Report manager is checking if the install report list already contains the + // corresonding report and replaces an old one if necessary. But, in all the + // cases set this report. If install has been set as success or failure, + // always send the information. Even if the node state has been installed before + // this operation, send new report because this may be a new try to install + // the content for some reason. So, success and failure information is necessary + // then also. + provider.ServerReportManager().NodeSetAsInstalledL( Metadata().Node(), + aErrorCode ); + + // Internalize node and all corresponding nodes. + // This way, all their information will be up-to-date. + // For example, the installation state may have changed because of the + // settings above. + nodeManager.InternalizeRelatedNodesL( Metadata().Node() ); + } + + +// --------------------------------------------------------------------------- +// Installationservice getter +// --------------------------------------------------------------------------- +// +MNcdInstallationService& CNcdNodeInstallProxy::InstallationService() + { + return *iInstallationService; + } + + +// --------------------------------------------------------------------------- +// File session getter +// --------------------------------------------------------------------------- +// +RFs& CNcdNodeInstallProxy::FileSession() + { + return iInstallationService->FileServerSession(); + } + + +// --------------------------------------------------------------------------- +// File opener +// --------------------------------------------------------------------------- +// +RFile CNcdNodeInstallProxy::OpenFileL( TInt aFileIndex ) + { + DLTRACEIN(("")); + + // Convert index to a descriptor + HBufC8* filenumber = IntToDes8LC( aFileIndex ); + + RFile fileHandle = ClientServerSession().SendSyncFileOpenL( + NcdNodeFunctionIds::ENcdInstallOpenFile, + *filenumber, + Handle() ); + + CleanupStack::PopAndDestroy( filenumber ); + + DLTRACEOUT(("")); + return fileHandle; + } + +// --------------------------------------------------------------------------- +// Handles progress information +// --------------------------------------------------------------------------- +// +void CNcdNodeInstallProxy::InstallProgress( MNcdInstallOperation& aOperation, + TNcdProgress aProgress ) + { + DLTRACEIN(("")); + DASSERT( iOperationObserver ); + + iOperationObserver->InstallProgress( aOperation, aProgress ); + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// Handles querys +// --------------------------------------------------------------------------- +// +void CNcdNodeInstallProxy::QueryReceived( MNcdInstallOperation& aOperation, + MNcdQuery* aQuery ) + { + DLTRACEIN(("")); + DASSERT( iOperationObserver ); + iOperationObserver->QueryReceived( aOperation, aQuery ); + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// Handles operation complete callbacks +// --------------------------------------------------------------------------- +// +void CNcdNodeInstallProxy::OperationComplete( + MNcdInstallOperation& aOperation, TInt aError ) + { + DLTRACEIN(( "Error: %d", aError )); + DASSERT( iOperationObserver ); + + + if ( aError == KErrNone || aError == KNcdThemeReinstalled ) + { + // update proxy's status from the server + TRAPD( err, iMetadata.InternalizeL() ); + if ( err != KErrNone ) + { + DLERROR(("Error during internalization: %d", err)); + aError = err; + } + } + + iOperationObserver->OperationComplete( aOperation, aError ); + DLTRACEOUT(("")); + } + + + +// Other functions + +void CNcdNodeInstallProxy::InternalizeDataL( RReadStream& aStream ) + { + DLTRACEIN(("")); + + // Use catalogsutils.h functions to internalize + // memebervariables according to the data received + // from the server. + // Make sure that the variables are set here in the same + // order as they are externalized in the server side. + // Small mistake here messes up everything! + + // First read the class id. Because, it is the first thing in the stream. + TInt classId( aStream.ReadInt32L() ); + + if ( classId != NcdNodeClassIds::ENcdNodeInstallClassId ) + { + // classId is not recognized + DLERROR(("Class id was not recognized!")); + // For testing purposes assert here + DASSERT( EFalse ); + + // Otherwise leave is adequate + User::Leave( KErrCorrupt ); + } + + iPurpose = aStream.ReadInt32L(); + DLINFO(("Purpose: %u", iPurpose)); + + iInstalled = aStream.ReadInt32L(); + DLINFO(("Installed: %d", iInstalled)); + + iLaunchable = aStream.ReadInt32L(); + DLINFO(("Launchable: %d", iLaunchable)); + + iContent.ResetAndDestroy(); + + if ( iInstalled ) + { + DLTRACE(("Reading infos")); + TInt infos = aStream.ReadInt32L(); + TInt fileIndex = 0; + + CNcdExtendedInstallInfo* tempInfo = NULL; + while ( infos ) + { + tempInfo = CNcdExtendedInstallInfo::NewLC(); + tempInfo->InternalizeL( aStream ); + CreateInstalledContentL( *tempInfo, fileIndex ); + CleanupStack::PopAndDestroy( tempInfo ); + tempInfo = NULL; + --infos; + ++fileIndex; + } + } + + DLTRACEOUT(("")); + } + + +void CNcdNodeInstallProxy::CreateInstalledContentL( + const CNcdExtendedInstallInfo& aInfo, + TInt aFileIndex ) + { + DLTRACEIN(("")); + CNcdInstalledContent* content = NULL; + if ( aInfo.Filename() != KNullDesC() ) + { + DLTRACE(( _L("Installed file: %S"), &aInfo.Filename() )); + + CNcdFileInfo* fileInfo = CNcdFileInfo::NewLC( + aInfo.Filename(), aInfo.MimeType() ); + CleanupStack::Pop( fileInfo ); + + // fileInfo is deleted in CNcdInstalledFile if NewLC leaves + CNcdInstalledFile* file = + CNcdInstalledFile::NewLC( *this, fileInfo, aFileIndex ); + content = file; + } + else if ( aInfo.ApplicationUid() != TUid::Null() ) + { + DLTRACE(("Application")); + CNcdInstalledApplication* app = + CNcdInstalledApplication::NewLC( + *this, + aInfo.ApplicationUid(), + aInfo.ApplicationVersion(), + aInfo.Parameter(), + aInfo.ContentType(), + aInfo.UriExists() ); + content = app; + } + else // assume theme + { + DLTRACE(( _L("Theme: %S"), &aInfo.ThemeName() )); + CNcdInstalledTheme* theme = CNcdInstalledTheme::NewLC( + *this, aInfo.ThemeName().AllocL() ); + content = theme; + } + + DASSERT( content ); + content->AddRef(); + content->SetLaunchable( aInfo.IsLaunchable() ); + + DLTRACE(("Content refcount: %d", content->RefCount() )); + iContent.AppendL( content ); + + CleanupStack::Pop(); // file, app or theme + + DLTRACEOUT(("Content added successfully")); + }