// Copyright (c) 2003-2009 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:

//

#include <msvids.h>

#include <push/unknownmimedefs.h>

#include <bautils.h>		// Bafl

#include <barsc.h>		// RResourceFile

#include <barsread.h>		// TResourceReader

#include <wappushunknown.rsg>

#include <push/cunknownpushmsgentry.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "PushEntryPanic.h"

#endif//SYMBIAN_ENABLE_SPLIT_HEADERS

#ifdef __MESSAGING_API_V2__

#include "CAsyncWaiter.h"

#include <cmsvattachment.h>

#include <mmsvattachmentmanager.h>

#endif // __MESSAGING_API_V2__

_LIT(KContentResourceFile, "\\system\\data\\wappushunknown.rsc");

GLDEF_C TPtrC16 LimitStringSize(const TPtrC16& aString, TInt aMaxSize);

/**

Allocates and constructs a new Unknown WAP Push message object. 

@return	CUnknownPushMsgEntry*	

New Unknown WAP Push message object.

*/

EXPORT_C CUnknownPushMsgEntry* CUnknownPushMsgEntry::NewL()

	{

	CUnknownPushMsgEntry* self = new (ELeave) CUnknownPushMsgEntry();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/**

Allocates and constructs a new Unknown WAP Push message object, specifying the AppId 

as a string.

@param	aAppURI					

AppId value as a string. 

@return	CUnknownPushMsgEntry*	

New Unknown WAP Push message object.

*/

EXPORT_C CUnknownPushMsgEntry* CUnknownPushMsgEntry::NewL(const TPtrC8& aAppURI)

	{

	CUnknownPushMsgEntry* self = new (ELeave) CUnknownPushMsgEntry();

	CleanupStack::PushL(self);

	self->ConstructL(aAppURI);

	CleanupStack::Pop();

	return self;

	}

/**

Allocates and constructs a new Unknown WAP Push message object, 

specifying the AppId as a number. 

@param	aAppID					

AppId value as a number.

@return CUnknownPushMsgEntry*	

New Unknown WAP Push message object.

*/

EXPORT_C CUnknownPushMsgEntry* CUnknownPushMsgEntry::NewL(TInt& aAppID)

	{

	CUnknownPushMsgEntry* self = new (ELeave) CUnknownPushMsgEntry();

	CleanupStack::PushL(self);

	self->ConstructL(aAppID);

	CleanupStack::Pop();

	return self;

	}

/**

Destructor.

*/

EXPORT_C CUnknownPushMsgEntry::~CUnknownPushMsgEntry()

	{

	iRFs.Close();

	delete iMessageData;

	delete iContentType;

	delete iFilename;

	}

/**

Sets the Content Type of the message.

@param	aContentType	

The content type of the message

*/ 

EXPORT_C void CUnknownPushMsgEntry::SetContentTypeL(const TDesC& aContentType)

	{

	HBufC* tempBuf = aContentType.AllocL();

	delete iContentType;

	iContentType  = tempBuf;

	}

EXPORT_C const TDesC8& CUnknownPushMsgEntry::MessageData() const

/**

Gets the message data. 

If the buffer for the message data does not exist, a null descriptor is returned.

@return	

Message data

*/

	{

	if (iMessageData)

		return *iMessageData;

	else

		return KNullDesC8;

	}

/**

Sets the message data.

@param	aMessageData	

Message data

*/

EXPORT_C void CUnknownPushMsgEntry::SetMessageDataL(const TDesC8& aMessageData)

	{

	HBufC8* tempBuf = aMessageData.AllocL();

	delete iMessageData; 

	iMessageData = tempBuf;

	}

/**

Gets the content filename of the message. Content Filename is the name of the file where the 

Push message content is stored.

If filename does not exist then a default filename is returned, which is defined in wappushunknown.rss file.

Note the function will return the filename in memory which may not necessarily be the filename stored in the 

message store. RetrieveL should be called before calling this function to get the filename stored in the 

message store. 

@code

	// Create an unknown push message object.

	CUnknownPushMsgEntry* entry = CUnknownPushMsgEntry::NewL();

	CleanupStack::PushL(entry);

	// Retrieve the required message from the message store.

	entry->RetrieveL(session, messageId);

	// Get file name

	TFileName fileName = entry->ContentFileNameL();

	CleanupStack::PopAndDestroy(entry);

@endcode

@return	

The content filename of the message.

@see CUnknownPushMsgEntry::RetrieveL()

*/

EXPORT_C const TDesC& CUnknownPushMsgEntry::ContentFileNameL()

	{

	if (iFilename && iFilename->Length()>0 && iFilename->Length() <= KMaxFileName)

		{

		// filename has been set

		return *iFilename;

		}

	else

		{

		TFileName filename = iDefaultBaseFilename;

		// append the extension based on the content type

		filename.Append(ContentTypeExtension(ContentType()));

		SetContentFileNameL(filename);

		return *iFilename;

		}

	}

/**

Sets the content filename of the message. Content Filename is the name of the file where the 

Push message content is stored.

Note the function will only save the filename in memory. SaveL or UpdateL will have 

to be called to commit the changes to the message store.

@code

	// Create an unknown push message object.

	CUnknownPushMsgEntry* entry = CUnknownPushMsgEntry::NewL();

	CleanupStack::PushL(entry);

	// Retrieve the required message from the message store.

	entry->RetrieveL(session, messageId);

	// Set file name

	_LIT(KFilename, "image.jpg");

	entry->SetContentFileNameL(KFilename);

	// Commit the changes to the message store.

	entry->UpdateL(session);

	CleanupStack::PopAndDestroy(entry);

@endcode

@param	aFilename		

The content filename.

@leave	KErrBadName  aFilename is not a valid Symbian OS file name.

@leave	TDesC::AllocL()	

*/	

EXPORT_C void CUnknownPushMsgEntry::SetContentFileNameL(const TDesC& aFilename)

	{

	// Check for valid filname.

	if (!iRFs.IsValidName(aFilename))

		User::Leave(KErrBadName);

	HBufC* tempBuf = aFilename.AllocL();

	delete iFilename; 

	iFilename = tempBuf;

	}

/**

Constructor.

Simply connects to the File Server before calling base class ConstructL(). 

*/

void CUnknownPushMsgEntry::ConstructL()

	{

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

	CPushMsgEntryBase::ConstructL();

	SetDefaultBaseFileNameL();

	}

/**

Constructor.

Simply connects to the File Server before calling base class ConstructL(). 

@param	

aAppURI set this value if AppId is in string form (must set aIsAnInt to EFalse).

*/

void CUnknownPushMsgEntry::ConstructL(const TPtrC8& aAppURI)

	{

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

	CPushMsgEntryBase::ConstructL(aAppURI);

	SetDefaultBaseFileNameL();

	}

/**

Constructor.

Simply connects to the File Server before calling base class ConstructL(). 

@param	

aAppID set this value if AppId is a number (must set aIsAnInt to ETrue).

*/

void CUnknownPushMsgEntry::ConstructL(TInt& aAppID)

	{

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

	CPushMsgEntryBase::ConstructL(aAppID);

	SetDefaultBaseFileNameL();

	}

/**

Constructor.

*/

CUnknownPushMsgEntry::CUnknownPushMsgEntry()

	{

	}

/**

Opens wappushunknown.rss resource file for reading.

@param	aFile			

A resource file.

*/	

void CUnknownPushMsgEntry::OpenResourceFileL(RResourceFile& aFile)

	{

	// open resource file

	TFileName fileName;

	Dll::FileName(fileName);

	TParse parse;

	parse.Set(KContentResourceFile, &fileName, 0);

	fileName=parse.FullName();

	BaflUtils::NearestLanguageFile(iRFs, fileName);

	aFile.OpenL(iRFs, fileName);

	}

/**

Sets default content base filename

*/	

void CUnknownPushMsgEntry::SetDefaultBaseFileNameL()

	{

	// generate default filename from the wappushunknown resource file. 

	RResourceFile resourceFile;

	OpenResourceFileL(resourceFile);

	CleanupClosePushL(resourceFile);

	HBufC8* buf = resourceFile.AllocReadLC(CONTENT);

	TResourceReader reader;

	reader.SetBuffer(buf);

	iDefaultBaseFilename.Copy(reader.ReadTPtrC());		

	CleanupStack::PopAndDestroy(2,&resourceFile); // buf, resourceFile

	}

/**

Stores the Unknown Push message in the message store.

Saves the message data in a new attachment file. This makes it more efficient for the UI

to read the data.

@param	aSession		

Message server session

@param	aParent	

ID of the parent for the new entry. It is the caller's responsibility to ensure 

that the parent ID is correct.

@return	

ID of the new message server entry.

@see	CPushMsgEntryBase::SaveL()

*/

EXPORT_C TMsvId CUnknownPushMsgEntry::SaveL(CMsvSession& aSession, TMsvId aParent)

	{

	CMsvEntry* entryPtr = aSession.GetEntryL(KMsvRootIndexEntryId);

	CleanupStack::PushL(entryPtr);

	// This tidies itself up

	TMsvId newEntry = CPushMsgEntryBase::SaveL(aSession, aParent);

#ifdef __MESSAGING_API_V2__

	TRAPD(

		saveError,

		TFileName fileName = ContentFileNameL();

		entryPtr->SetEntryL(newEntry);

		CMsvStore* store = entryPtr->EditStoreL();

		CleanupStack::PushL(store);

		SaveMessageBodyL(store->AttachmentManagerL(), fileName);

		store->CommitL();

		CleanupStack::PopAndDestroy(store);

		)

#else

	TRAPD(

		saveError,

		TFileName fileName = ContentFileNameL();

		entryPtr->SetEntryL(newEntry);

		SaveMessageBodyL(*entryPtr, fileName);

		)

#endif // __MESSAGING_API_V2__

	if (saveError != KErrNone)

		{

		aSession.RemoveEntry(iEntry.Id());

		User::Leave(saveError);

		}

	CleanupStack::PopAndDestroy(); //entryPtr

	return newEntry;

	}

#ifdef __MESSAGING_API_V2__

void CUnknownPushMsgEntry::SaveMessageBodyL(MMsvAttachmentManager& aAttachManager, const TDesC& aFileName)

#else	

/**

Stores the Push message body data in an attachment file in the message store.

@param	aEntry			

Reference to the message entry.

@param	aFileName		

The name of the file where the message body data is to be stored.

*/

void CUnknownPushMsgEntry::SaveMessageBodyL(const CMsvEntry& aEntry, TFileName& aFileName)

#endif // __MESSAGING_API_V2__

	{

#ifdef __MESSAGING_API_V2__

	// Create an empty file attachment store the data

	CAsyncWaiter* waiter = CAsyncWaiter::NewL();

	CleanupStack::PushL(waiter);

	CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);

	CleanupStack::PushL(attachment);

	attachment->SetAttachmentNameL(aFileName);

	RFile file;

	aAttachManager.CreateAttachmentL(aFileName, file, attachment, waiter->iStatus);

	CleanupStack::Pop(attachment); // ownership passed

	waiter->StartAndWait();

	User::LeaveIfError(waiter->Result());

	CleanupStack::PopAndDestroy(waiter);

	CleanupClosePushL(file);

	// write the data to the attachment file, if message data exists

	if( iMessageData )

		User::LeaveIfError(file.Write(*iMessageData));

	CleanupStack::PopAndDestroy(&file);

#else

	TFileName filePath;

	// create directory path for current entry, to put file into

	aEntry.GetFilePath(filePath);

	// check the path and file name is not too long... 

	TParse parse;

	if (parse.Set(aFileName, &filePath, NULL) != KErrNone)

		{

		// Try with the default file name as the file name the client set may be too long.

		// If this leaves then the entry path is probably too long.  Not much we

		// can do about that.

		TFileName defaultFileName;

		defaultFileName.Copy(iDefaultBaseFilename);

		defaultFileName.Append(ContentTypeExtension(ContentType()));

		User::LeaveIfError(parse.Set(defaultFileName, &filePath, NULL));

		};

	RFile file;

	User::LeaveIfError(file.Replace(iRFs, parse.FullName(), EFileWrite|EFileShareExclusive|EFileStream));

	CleanupClosePushL(file);

	// Got this far, so it worked - write data to it

	TInt fileErr = KErrNone;

	if (iMessageData)

		{

		fileErr = file.Write(*iMessageData);

		}

	if(fileErr!=KErrNone)

		{

		iRFs.Delete(parse.FullName());

		User::Leave(fileErr);

		}

	CleanupStack::PopAndDestroy(&file); // file	

#endif // __MESSAGING_API_V2__

	}

/**

Updates an existing message server entry.

The functionality is similiar to SaveL(), except no new entry is created. Before calling 

this function, the existing entry must be loaded into the object using RetrieveL(). 

@param	aSession	

Message server session

@see	CUnknownPushMsgEntry::SaveL()

@see	CUnknownPushMsgEntry::RetrieveL()

@see	CPushMsgEntryBase::UpdateL()

*/

EXPORT_C void CUnknownPushMsgEntry::UpdateL(CMsvSession& aSession)

	{

	if (iHasServerEntry ==EFalse )

		User::Leave(KWPushNoMsgIndexEntry);

	CMsvEntry* msvEntry = aSession.GetEntryL(iEntry.Id());

	CleanupStack::PushL(msvEntry);

	//Can only overwrite a pushmessage of the same type 

	// Mtm & Push Type Uid   must be correct

	__ASSERT_ALWAYS( msvEntry->Entry().iMtm == KUidMtmWapPush, 

					User::Panic(KPushPanicMoniker, EPushEntryWrongMTMtype));

	__ASSERT_ALWAYS( msvEntry->Entry().iBioType == PushMsgType(), 

					User::Panic(KPushPanicMoniker, EPushEntryWrongMsgtype));

	// Remove existing contents of stream and store new data

	CMsvStore* store = msvEntry->EditStoreL();

	CleanupStack::PushL(store);

	TUid streamId;

	streamId.iUid = PushMsgType();

	RMsvWriteStream out;

	out.AssignLC(*store, streamId);

	ExternalizeL(out);

#ifdef __MESSAGING_API_V2__

	// remove all previous attachments

	MMsvAttachmentManager& manager = store->AttachmentManagerL();

	CAsyncWaiter* waiter = CAsyncWaiter::NewL();

	CleanupStack::PushL(waiter);

	TInt attachCount = manager.AttachmentCount();

	for( TInt ii=attachCount-1; ii>=0; --ii )

		{

		manager.RemoveAttachmentL(ii, waiter->iStatus);

		waiter->StartAndWait();

		User::LeaveIfError(waiter->Result());

		}

	CleanupStack::PopAndDestroy(waiter);

	// the message body data as an attachment

	TFileName dataFile = ContentFileNameL();

	SaveMessageBodyL(manager, dataFile);

	// update the entry

	iEntry.iMtm = KUidMtmWapPush;

	SetPushMsgType();

	msvEntry->ChangeL(iEntry);	

#else

	TFileName tempfile;

	tempfile.Copy(KTempUnknownFileName);

	tempfile.Append(ContentTypeExtension(ContentType()));

	SaveMessageBodyL(*msvEntry, tempfile); // NB this tidies up if it leaves