--- /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 <bamdesca.h>
+#include <bautils.h>
+#include <s32mem.h>
+
+#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<MNcdInstalledContent>
+ CNcdNodeInstallProxy::InstalledContentL()
+ {
+ DLTRACEIN(("this-ptr: %x, refcount: %d", this, TotalRefCount() ));
+ RCatalogsArray<MNcdInstalledContent> 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"));
+ }