/*
* Copyright (c) 2007 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: Skin server's active data owner in backup/restore.
*
*/
#ifndef C_AKNSSRVACTIVEBACKUPDATACLIENT_H
#define C_AKNSSRVACTIVEBACKUPDATACLIENT_H
#include <e32base.h> // CBase
#include <connect/abclient.h>
/**
* Skin server's active data owner in backup/restore.
*
* Backed up files are not restored:
* - if same file exists in system folder (cannot overwrite)
* - if the same file exists in private directory
* - if no matching .skn-file is found from private directory.
*
* If file is restored, it is re-created to the skin's private directory.
*
* @lib aknskinsrv.dll
* @since S60 v3.1
*/
NONSHARABLE_CLASS( CAknsSrvActiveBackupDataClient ) : public CBase,
public conn::MActiveBackupDataClient
{
public:
enum TAknsSrvBackupState
{
// initial state; open a file for processing
EBackupNoFileOpen = 0,
// nothing sent for current file - send the file header info
EBackupOpenNothingSent,
// part of the header info sent - need to send the rest of the header
EBackupOpenPartHeaderSent,
// need to send data from the current file
EBackupOpenAllHeaderSent,
// At the end of the current file.
EBackupEndOfFile
};
enum TAknsSrvRestoreState
{
// initial state; expecting number of files to restore.
ERestoreNumberOfFiles = 0,
// expecting checksum of 16 bytes
ERestoreExpectChecksum,
// continue reading checksum; it didn't fit completely in
// one read
ERestoreExpectMoreChecksum,
// expecting to read file size of 16 bytes
ERestoreExpectFileSize,
// file size didn't fit into read buffer in one read.
ERestoreExpectMoreFileSize,
// the size of the filename to restore
ERestoreExpectFileNameSize,
// filename size didn't fit into read buffer in one read.
ERestoreExpectMoreFileNameSize,
// the filename to restore
ERestoreExpectFileName,
// filename didn't fit into read buffer in one read.
ERestoreExpectMoreFileName,
// the content of the file to restore
ERestoreExpectData,
// file content didn't fit into read buffer in one read.
ERestoreExpectMoreData,
// At the end of current file. Creates missing files to
// restored directory.
ERestoreComplete
};
static CAknsSrvActiveBackupDataClient* NewL( RFs& aFsSession );
virtual ~CAknsSrvActiveBackupDataClient();
/**
* This method is called when a backup or restore operation is
* starting. Preparations can be done to prepare for BUR.
*
* @param aBackupStateValue the value of the current backup state
*/
void PrepareForBURL( TInt aBackupStateValue );
// from base class MActiveBackupDataClient
/**
* This method informs the active backup data client that all
* snapshots have been supplied. If the client has not
* received a snapshot then it should perform a base backup
*/
virtual void AllSnapshotsSuppliedL();
/**
* This method receives all or part of a snapshot of data to allow
* calculation of an incremental backup. The snapshot is one that
* was previously supplied by the data owner. The snapshot data
* should be read from the location supplied. The snapshot data may
* be larger than the location supplied in which case the routine
* will be called repeatedly until all data has been supplied.
*
* Snapshot data will also be supplied as part of a restore operation
*
* @param aDrive the drive being backed up
* @param aBuffer a pointer to the base of the location from whence
* data can be copied.
* @param aLastSection ETrue if this is the last section of snapshot
* data, else EFalse.
*/
virtual void ReceiveSnapshotDataL(
TDriveNumber aDrive, TDesC8& aBuffer, TBool aLastSection);
/**
* This method returns the expected size of backup data that will be
* supplied. If an incremental backup is underway then this method
* then this method will not be called until after
* ReceiveSnapshotDataL(). The size data will be used for the purpose
* of tracking progess during a backup. If it is inaccurate then the
* user may see irregular progress but the actual backup data will
* not be affected so it is acceptable to return an estimated value.
*
* @param aDrive the drive being backed up.
* @return the size of the data that will be returned
*/
virtual TUint GetExpectedDataSize(TDriveNumber aDrive);
/**
* This method returns a snapshot of data to accompany a backup. The
* snapshot is expected to contain details on files / data being
* backed up. The format of the snapshot is only meaningful to the
* data owner. The snapshot will be supplied if the data owner is
* asked for an incremental backup and for a restore operation. The
* snapshot data should be copied to the location supplied.
*
* The snapshot data may be larger than the location supplied in
* which case the routine will be called repeatedly until all data
* has been retrieved.
*
* @param aDrive the drive being backed up
* @param aBuffer a pointer to the base of the location where data
* can be copied.
* @param aFinished on return ETrue if all data has been returned
* for this drive, else EFalse.
*/
virtual void GetSnapshotDataL(
TDriveNumber aDrive, TPtr8& aBuffer, TBool& aFinished);
/**
* This method prepares the implementor to return backup data. It
* will be followed by a sequence of calls to request the actual
* data.
*
* @param aDrive the drive being backed up.
*/
virtual void InitialiseGetBackupDataL(TDriveNumber aDrive);
/**
* This method requests a section of backup data.
* InitialiseGetBackupDataL() will have been called previously to
* specify the drive concerned. The data returned may be base or
* incremental depending on the type of backup and the capability of
* the data owner.
*
* @param aBuffer a pointer to the base of the location where data
* can be copied.
* @param aFinished on return ETrue if all data has been returned
* for this drive, else EFalse.
*/
virtual void GetBackupDataSectionL(TPtr8& aBuffer, TBool& aFinished);
/**
* This method prepares the implementor to receive base restore data
* for a drive. It will be followed by a sequence of calls to supply
* the actual data.
*
* @param aDrive the drive being restored.
*/
virtual void InitialiseRestoreBaseDataL(TDriveNumber aDrive);
/**
* This method receives a section of base restore data.
* InitialiseRestoreBaseDataL() will have been called previously to
* specify the drive concerned.
*
* @param aBuffer a pointer to the base of the location whence data
* can be read.
* @param aFinished ETrue if all data has been returned for this
* drive, else EFalse.
*/
virtual void RestoreBaseDataSectionL(TDesC8& aBuffer, TBool aFinished);
/**
* This method prepares the implementor to receive incremental
* restore data for a drive. It will be followed by a sequence
* of calls to supply the actual data. If multiple increments
* are supplied then this methid will be called before each increment
*
* @param aDrive the drive being restored.
*/
virtual void InitialiseRestoreIncrementDataL(TDriveNumber aDrive);
/**
* This method receives a section of increment restore data.
* InitialiseRestoreIncrementDataL() will have been called
* previously to specify the drive concerned.
*
* @param aBuffer a pointer to the base of the location whence data
* can be read.
* @param aFinished ETrue if all data has been returned for this
* increment, else EFalse.
*/
virtual void RestoreIncrementDataSectionL(TDesC8& aBuffer, TBool aFinished);
/**
* This method is called when all data to be restored has been
* supplied.
*
* @param aDrive the drive being restored.
*/
virtual void RestoreComplete(TDriveNumber aDrive);
/**
* This method is called if copying of data is terminated prematurely
* to allow the implementor to tidy up. The same method applies to
* all types of data and to backup and restore.
*/
virtual void TerminateMultiStageOperation();
/**
* Gets a 32-bit checksum for its private data.
* This routine is for test purposes. It must be implemented but an
* invariant checksum value can be provided. Some tests may cause
* checksum values to be compared.
*
* @param aDrive the drive containing data being checksummed
* @return the 32-bit checksum
*/
virtual TUint GetDataChecksum(TDriveNumber aDrive);
/**
* This method prepares the implementor to return backup data on behalf of another data owner.
* It will be followed by a sequence of calls to request the actual data. This method is only
* for use by a proxy data manager that backs up data on behalf of other data owners. There
* is no corresponding method for snapshots as it is assumed that a proxy data manager will
* only handle base data.
*
* @param aSID the data owner whose data is to be backed up
* @param aDrive the drive being backed up.
*/
virtual void InitialiseGetProxyBackupDataL(TSecureId aSID, TDriveNumber aDrive);
/**
This method prepares the implementor to receive base restore data for another data owner
for a drive. It will be followed by a sequence of calls to supply the actual data.
This method is only for use by a proxy data manager that restores up data on behalf of
other data owners. There is no corresponding method for incremental data as it is assumed
that a proxy data manager will only handle base data.
@param aSID the data owner whose data is to be restored
@param aDrive the drive being restored.
*/
virtual void InitialiseRestoreProxyBaseDataL(TSecureId aSID, TDriveNumber aDrive);
private:
/* Checks file integrity after restoration. */
TUint64 CheckSumL(const RFile& aOpenFile) const;
/* Scans the .skn-files in the private directory. */
void ScanDirectoryForSkinFilesL( const TDesC& aRootDir );
/* Re-creates backed-up file to private directory.
Also verifies that a matching .skn-file exists.*/
TInt RestoreFileInPrivateDirectoryL( const TDesC& aFileName );
CAknsSrvActiveBackupDataClient( RFs& aFsSession );
void ConstructL();
/* Initialise backup data. */
void DoInitialiseGetBackupDataL( TDriveNumber aDrive );
private: // data
/**
* Index of currently handled file in filename array.
*/
TInt iFileIndex;
/**
* Backup statemachine state.
*/
TAknsSrvBackupState iBackupState;
/**
* Restore statemachine state.
*/
TAknsSrvRestoreState iRestoreState;
/**
* Number of bytes sent from file header.
*/
TInt iHeaderSent;
/**
* Array of files to backup/restore.
*/
RArray<TParse> iFileArray;
/**
* "persistent" buffer.
*/
HBufC* iBuffer;
/**
* Currently handled file.
*/
RFile iFile;
/**
* Has any data been restored.
*/
TBool iDataRestored;
/**
* Checksum of backup file. Used by Restore.
*/
TUint32 iChecksum;
/**
* Size of file. Used by Restore.
*/
TUint32 iFileSize;
/**
* Lenght of filename. Used by Restore.
*/
TUint32 iFileNameSize;
/*
* File system session.
*/
RFs& iFsSession;
/*
* Number of files handled by Restore.
* Note that actual number of restored files might be less than this,
* since already existing files are not restored and orphaned files
* (.skn-file missing) are not restored either.
*/
TInt iFilesRestored;
/*
* Number of files supposed to restore.
*/
TUint32 iNumberofFiles;
/*
* Indicates that there is an issue with current file.
* All received Restore streams will be ignored, until a new file
* is received.
*/
TBool iFileOpenError;
};
#endif // C_AKNSSRVACTIVEBACKUPDATACLIENT_H