// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32\euser\us_ksvr.cpp

// 

//

#include "us_std.h"

#include "us_data.h"

#include <e32svr.h>

#include <e32uid.h>

#include <e32ldr.h>	

//#define __DEBUG_IMAGE__ 1

#if defined(__DEBUG_IMAGE__) && defined (__EPOC32__)

#define __IF_DEBUG(t) {RDebug::t;}

#else

#define __IF_DEBUG(t)

#endif

//

// class RNotifier

//

/**

Requests the extended notifier server to start the notifier identified by

the specified UID.

The request is synchronous; the call returns when the request is complete.

The notifier may not be started immediately if a higher priority notifier is

already active. In this case, the notifier is queued until it has the highest

priority outstanding request for the channel(s) it operates on.

@param aNotifierUid The UID identifying the notifier.

@param aBuffer      Data that can be passed to the notifier; the format and meaning

                    of this depends on the notifier.

@return KErrNone, if successful;

        KErrNotFound, if there is no notifier matching the specified UID;

        KErrAlreadyExists, if the notifier has already been started, or has

        an outstanding start request. It may also return with one of the other

        system-wide error codes, if the notifier cannot be started by

        the server due to low memory or it leaves from its server side

        call to StartL().

@see CServer

*/

EXPORT_C TInt RNotifier::StartNotifier(TUid aNotifierUid, const TDesC8& aBuffer)

	{

	return SendReceive(EStartNotifier, TIpcArgs(

										(TInt)aNotifierUid.iUid,

										&aBuffer,

										(TAny*)NULL // No resonse required

										));

	}

/**

Requests the extended notifier server to start the notifier identified by

the specified UID.

The request is synchronous; the call returns when the request is complete.

The notifier may not start immediately if a higher priority notifier is

already active. In this case, the notifier is queued until it has the highest

priority outstanding request for the channel(s) it operates on.

This can also cause unexpected behaviour: the function can return

before the notifier has been started with the added consequence that no response

data is written.

For this reason, this function has been deprecated. Instead, use

RNotifier::StartNotifierAndGetResponse(), or if there is no need to wait for a

response, use the two argument overload of RNotifier::StartNotifier().

@param aNotifierUid The UID identifying the notifier.

@param aBuffer      Data that can be passed to the notifier; the format and meaning

                    of this depends on the notifier.

@param aResponse    Response data; the format

                    and meaning of this depends on the notifier.

@return KErrNone, if successful;

        KErrNotFound, if there is no notifier matching the specified UID;

        KErrAlreadyExists, if the notifier has already been started, or has

        an outstanding start request. It may also return with one of the other

        system-wide error codes, if the notifier cannot be started by

        the server due to low memory or it leaves from its server side

        call to StartL().

@see CServer

@deprecated use RNotifier::StartNotifierAndGetResponse(), or if there is no

            need to wait for a response, use the two argument overload

            of RNotifier::StartNotifier()

*/

EXPORT_C TInt RNotifier::StartNotifier(TUid aNotifierUid, const TDesC8& aBuffer, TDes8& aResponse)

	{

	return SendReceive(EStartNotifier, TIpcArgs(

										(TInt)aNotifierUid.iUid,

										&aBuffer,

										&aResponse

										));

	}

/*

This function has never been implemented on any Symbian OS version.

It always returns KErrNotSupported.

@publishedPartner

@removed

*/

EXPORT_C TInt RNotifier::StartNotifier(TUid aNotifierDllUid,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse)

	{

	return SendReceive(EStartNotifierFromSpecifiedDll, TIpcArgs(

										(TInt)aNotifierUid.iUid,

										&aBuffer,

										&aResponse,

										(TInt)aNotifierDllUid.iUid

										));

	}

/**

Requests the extended notifier server to cancel the notifier identified by

the specified UID.

The request is synchronous; the call returns when the request is complete.

Any notifier that was queued pending the completion of aNotifierUid will be

automatically started.

@param  aNotifierUid The UID identifying the notifier.

@return KErrNone, if successful;

        KErrNotFound, if there is no notifier matching the specified UID.

*/

EXPORT_C TInt RNotifier::CancelNotifier(TUid aNotifierUid)

	{

	return SendReceive(ECancelNotifier, TIpcArgs( (TInt)aNotifierUid.iUid ));

	}

/**

Requests the extended notifier server to update the active notifier identified by

the specified UID.

The request is synchronous; the call returns when the request is complete.

@param aNotifierUid The UID identifying the notifier.

@param aBuffer      Data that can be passed to the notifier; the format and meaning

                    of this depends on the notifier.

@param aResponse    Reserved for future use.

@return KErrNone, if successful;

        KErrNotFound, if there is no notifier matching the specified UID.

*/

EXPORT_C TInt RNotifier::UpdateNotifier(TUid aNotifierUid, const TDesC8& aBuffer,TDes8& aResponse)

	{

	return SendReceive(EUpdateNotifier, TIpcArgs(

										(TInt)aNotifierUid.iUid,

										&aBuffer,

										&aResponse

										));

	}

/**

Requests the extended notifier server to update the active notifier identified by

the specified UID.

This is an asynchronous request.It may be called multiple times for

some notifier implementations; see specific notifier documentation for exact details.

@param aRs          The request status. On request completion, contains:

                    KErrNone, if successful; otherwise, one of the other system

                    wide error codes.

@param aNotifierUid The UID identifying the notifier.

@param aBuffer      Data that can be passed to the notifier; the format and meaning

                    of this depends on the notifier.

@param aResponse    Reserved for future use.

*/

EXPORT_C void RNotifier::UpdateNotifierAndGetResponse(TRequestStatus& aRs, TUid aNotifierUid, const TDesC8& aBuffer, TDes8& aResponse)

	{

	SendReceive(EUpdateNotifierAndGetResponse, TIpcArgs(

										(TInt)aNotifierUid.iUid,

										&aBuffer,

										&aResponse

										), aRs);

	}

/**

Requests the extended notifier server to start the notifier identified by

the specified UID.

This is an asynchronous request.It may be called multiple times for

some notifier implementations; see specific notifier documentation for exact details.

@param aRs          The request status. On request completion, contains:

                    KErrNone, if successful; otherwise, one of the other system

                    wide error codes.

@param aNotifierUid The UID identifying the notifier.

@param aBuffer      Data that can be passed to the notifier; the format

                    and meaning of this depends on the notifier.

@param aResponse    Response data; the format

                    and meaning of this depends on the notifier.

*/

EXPORT_C void RNotifier::StartNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse)

	{

	SendReceive(EStartNotifierAndGetResponse, TIpcArgs(

										(TInt)aNotifierUid.iUid,

										&aBuffer,

										&aResponse

										), aRs);

	}

/**

@publishedPartner

@removed

This function has never been implemented on any Symbian OS version.

The request always completes with KErrNotSupported.

*/

EXPORT_C void RNotifier::StartNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierDllUid,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse)

	{

	SendReceive(EStartNotifierFromSpecifiedDllAndGetResponse, TIpcArgs(

										(TInt)aNotifierUid.iUid,

										&aBuffer,

										&aResponse,

										(TInt)aNotifierDllUid.iUid

										), aRs);

	}

/**

@publishedPartner

@removed

This function has never been implemented on any Symbian OS version.

It always returns KErrNotSupported.

*/

EXPORT_C TInt RNotifier::UnloadNotifiers(TUid /*aNotifierUid*/)

	{

	return KErrNotSupported;

	}

/**

@publishedPartner

@removed

This function has never been implemented on any Symbian OS version.

It always returns KErrNotSupported.

*/

EXPORT_C TInt RNotifier::LoadNotifiers(TUid /*aNotifierUid*/)

	{

	return KErrNotSupported;

	}

/**

Default constructor.

*/		

EXPORT_C RNotifier::RNotifier()

	:	iButtonVal(NULL,0),

		iCombinedBuffer(NULL)

	{}

/**

Connects to the extended notifier server, creating a session with that server.

Note: Notifier server is started during window server start-up sequence.

The function must be called before any other function.

@return KErrNone, if successful, otherwise one of the other system-wide error codes 

*/

EXPORT_C TInt RNotifier::Connect()

	{

	return CreateSession(__NOTIFIER_NAME,TVersion(KNotifierMajorVersionNumber,KNotifierMinorVersionNumber,KNotifierBuildVersionNumber),-1);

	}

/**

Launches a simple two line dialog that displays two lines of text.

This is an asynchronous request that completes when the dialog exits.

@param aLine1     A descriptor containing the first line of text to be displayed.

@param aLine2     A descriptor containing the second line of text to be displayed.

@param aBut1      A descriptor containing text to be displayed in the first button.

@param aBut2      A descriptor containing text to be displayed in the (optional) second button.

@param aButtonVal An integer value which is set when the dialog exits. It is set to:

                  0, if the first button is selected;

                  1, if the second button is selected.

@param aStatus    The request status object. If the request completes normally, this is set to KErrNone.

*/

EXPORT_C void RNotifier::Notify(const TDesC& aLine1,const TDesC& aLine2,const TDesC& aBut1,const TDesC& aBut2, TInt& aButtonVal, TRequestStatus& aStatus)

	{

	const TInt requiredLengthOfCombinedBuffer=aLine1.Length()+aLine2.Length()+aBut1.Length()+aBut2.Length();

	if ((iCombinedBuffer!=NULL) && (iCombinedBuffer->Des().MaxLength()<requiredLengthOfCombinedBuffer))

		{

		delete iCombinedBuffer;

		iCombinedBuffer=NULL;

		}

	if (iCombinedBuffer==NULL)

		{

		iCombinedBuffer=HBufC::New(requiredLengthOfCombinedBuffer);

		}

	if (iCombinedBuffer==NULL)

		{

		// report the error back via the TRequestStatus

		TRequestStatus* status=&aStatus;

		User::RequestComplete(status,KErrNoMemory);

		}

	else

		{

		TPtr combinedBufferForNotify(iCombinedBuffer->Des());

		combinedBufferForNotify = aLine1;

		combinedBufferForNotify.Append(aLine2);

		combinedBufferForNotify.Append(aBut1);

		combinedBufferForNotify.Append(aBut2);

		iButtonVal.Set(REINTERPRET_CAST(TUint8*,&aButtonVal),sizeof(TInt),sizeof(TInt));

		__ASSERT_ALWAYS(((aLine1.Length()|aLine2.Length()|aBut1.Length()|aBut2.Length())&~KMaxTUint16)==0,Panic(ENotifierTextTooLong)); // check that all of the descriptor lengths are less than or equal to KMaxTUint16

		SendReceive(ENotifierNotify,TIpcArgs(&iButtonVal,iCombinedBuffer,(aLine1.Length()<<16)|aLine2.Length(),(aBut1.Length()<<16)|aBut2.Length()),aStatus);

		}

	}

/**

Not implemented by the server.

*/

EXPORT_C void RNotifier::NotifyCancel()

	{

	SendReceive(ENotifierNotifyCancel,TIpcArgs()); // ignores any returned error

	}

/**

Closes the notifier.

*/

EXPORT_C void RNotifier::Close()

	{

	delete iCombinedBuffer;

	iCombinedBuffer=NULL;

	RSessionBase::Close();

	}

/**

@internalAll

*/

EXPORT_C TInt RNotifier::InfoPrint(const TDesC& aDes)

	{

	return SendReceive(ENotifierInfoPrint, TIpcArgs(&aDes));

	}

//

// Class TChunkCreateInfo

//

/**

Default constructor. 

This defaults the chunk to be created to be local, to have no attributes set

and to use the default clear byte.

A local chunk is private to the process creating it and is not 

intended for access by other user processes.

*/

EXPORT_C TChunkCreateInfo::TChunkCreateInfo() :

	// Specifing individual initialisers for members instead of using memclear

	// so that Coverity doesn't complain about uninitialised local variables in

	// calls to e.g., TChunkCreateInfo::SetPaging().

	iVersionNumber(0),

	iType(TChunkCreate::ENormal),

    iGlobal(EFalse),

    iMaxSize(0),

    iOwnerType(EOwnerProcess),

    iName(NULL),

    iInitialBottom(0),

    iInitialTop(0),

    iAttributes(TChunkCreate::EPagingUnspec),

	iClearByte(KChunkClearByteDefault)

	{

	}

/**	

Sets the chunk to be created to have a committed region that always starts at the 

bottom of the reserved region.

@param aSize    The number of bytes committed to this chunk.

@param aMaxSize The maximum size to which the reserved region of this chunk 

                can grow.

@see RChunk::CreateLocal()

*/

EXPORT_C void TChunkCreateInfo::SetNormal(TInt aInitialSize, TInt aMaxSize)

	{

	iType = TChunkCreate::ENormal | TChunkCreate::EData;

	iInitialBottom = 0;

	iInitialTop = aInitialSize;

	iMaxSize = aMaxSize;

	}

/**

Sets the chunk to be created to be user writable and to be marked by the kernel

as containing code.

This can only be set on local chunks.

@param aInitialSize	The number of bytes committed to this chunk.

@param aMaxSize 	The maximum size to which the reserved region of this chunk

                	can grow.

@see RChunk::CreateLocalCode()

*/

EXPORT_C void TChunkCreateInfo::SetCode(TInt aInitialSize, TInt aMaxSize)

	{

	iType = TChunkCreate::ENormal | TChunkCreate::ECode;

	iInitialBottom = 0;

	iInitialTop = aInitialSize;

	iMaxSize = aMaxSize;

	}

/**	

Sets the chunk to be created to have a commited region that that can be any 

contiguous subset of the reserved region.

@param aInitialBottom The offset of the bottom of the new committed region 

                      from the base of the chunk's reserved region.

@param aInitialTop    The offset of the top of the new committed region from

                      the  base of the chunk's reserved region. 

@param aMaxSize       The maximum size to which the reserved region of

                      this chunk can grow.

@see RChunk::CreateDoubleEndedLocal()

*/

EXPORT_C void TChunkCreateInfo::SetDoubleEnded(TInt aInitialBottom, TInt aInitialTop, TInt aMaxSize)

	{

	iType = TChunkCreate::EDoubleEnded | TChunkCreate::EData;

	iInitialBottom = aInitialBottom;

	iInitialTop = aInitialTop;

	iMaxSize = aMaxSize;

	}

/** 

Set the chunk to be created to have a committed region consisting of an 

arbitrary set of MMU pages within the reserved region.

@param aInitialBottom 	The offset of the bottom of the new committed region 

                      	from the base of the chunk's reserved region.

@param aInitialTop		The offset of the top of the new committed region 

						from the  base of the chunk's reserved region. 

@param aMaxSize       	The maximum size to which the reserved region of

                      	this chunk can grow.

@see RChunk::CreateDisconnectedLocal()

*/

EXPORT_C void TChunkCreateInfo::SetDisconnected(TInt aInitialBottom, TInt aInitialTop, TInt aMaxSize)

	{

	iType = TChunkCreate::EDisconnected | TChunkCreate::EData;

	iInitialBottom = aInitialBottom;

	iInitialTop = aInitialTop;

	iMaxSize = aMaxSize;

	}

/**	

Sets the chunk to be created to be a thread heap chunk.

For internal use only.

@param aInitialSize	The number of bytes committed to this chunk.

@param aMaxSize 	The maximum size to which the reserved region of this chunk 

                	can grow.

@param aName		The name to be given to the chunk to be created

@internalComponent

*/

void TChunkCreateInfo::SetThreadHeap(TInt aInitialSize, TInt aMaxSize, const TDesC& aName)

	{

	iType = TChunkCreate::ENormal | TChunkCreate::EData;

	iInitialBottom = 0;

	iInitialTop = aInitialSize;

	iMaxSize = aMaxSize;

	iAttributes |= TChunkCreate::ELocalNamed;

	iName = &aName;

	iOwnerType = EOwnerThread;

	}

/** 

Sets the owner of the chunk to be created.

@param aType	The owner of the chunk to be created.

*/

EXPORT_C void TChunkCreateInfo::SetOwner(TOwnerType aType)

	{

	iOwnerType = aType;

	}

/** 

Sets the chunk to be created to be global, i.e. it is potentially visible

to all processes and is intended for access by other user processes.