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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Symbian Foundation License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Implementation of Test Harness request handler component.

    15 // 

    16 //

    17 

    18 

    19 #include <e32base.h>

    20 #include "ctlbsagpshandler.h"

    21 

    22 const TInt KBufferedMsgMaxCount = 6;

    23 

    24 CT_LbsAGpsHandler::CT_LbsAGpsHandler(MT_ResponseObserver* aObserver) : 

    25 	CActive(EPriorityStandard),

    26 	iObserver(aObserver)

    27 	{

    28 	}

    29 	

    30 CT_LbsAGpsHandler::~CT_LbsAGpsHandler()

    31 	{

    32 	Cancel();

    33 	iTHChannel.Close();

    34 	iMsgBuffer.ResetAndDestroy();

    35 	}

    36 

    37 EXPORT_C CT_LbsAGpsHandler* CT_LbsAGpsHandler::NewL(MT_ResponseObserver* aObserver)

    38 	{

    39 	CT_LbsAGpsHandler* self = new (ELeave) CT_LbsAGpsHandler(aObserver);

    40 	CleanupStack::PushL(self);

    41 	self->ConstructL();

    42 	CleanupStack::Pop(self);

    43 	return self;

    44 	}

    45 	

    46 void CT_LbsAGpsHandler::ConstructL()

    47 	{

    48     RT_LbsChannel::InitializeL(RT_LbsChannel::EChannelTH2TAGPS);

    49 	iMsgBuffer.ReserveL(KBufferedMsgMaxCount);

    50 	iTHChannel.OpenL(RT_LbsChannel::EChannelTH2TAGPS, *this);

    51 	CActiveScheduler::Add(this);

    52 	}

    53 

    54 EXPORT_C void CT_LbsAGpsHandler::SendRequestUpdateInitMsg(const TDesC& aConfigFileName, 

    55 												 		  const TDesC& aConfigSection)

    56 	{

    57   	TT_LbsAGpsRequestUpdateInitMsg* aMsg = new TT_LbsAGpsRequestUpdateInitMsg(aConfigFileName, aConfigSection);

    58  	 	

    59  	BufferMessage(aMsg);		

    60 	}

    61 

    62 EXPORT_C void CT_LbsAGpsHandler::SendRequestTimeOutMsg(const TTimeIntervalMicroSeconds& aTimeOut) 

    63 	{

    64  	TT_LbsAGpsRequestTimeOut* aMsg = new TT_LbsAGpsRequestTimeOut(aTimeOut);

    65  	 	

    66  	BufferMessage(aMsg);		

    67 	}

    68 

    69 EXPORT_C void CT_LbsAGpsHandler::SendRequestSetAllModuleOptions()

    70 	{

    71  	TT_LbsAGpsRequestOptions* aMsg = new TT_LbsAGpsRequestOptions(ELbsHybridModuleOptions_SetAll);

    72 	 	

    73  	BufferMessage(aMsg);		

    74 	}	

    75 

    76 EXPORT_C void CT_LbsAGpsHandler::SendRequestClearAllModuleOptions()

    77 	{

    78  	TT_LbsAGpsRequestOptions* aMsg = new TT_LbsAGpsRequestOptions(EHybridModuleOptions_ClearAll);

    79 	 	

    80  	BufferMessage(aMsg);		

    81 	}

    82 	

    83 EXPORT_C void CT_LbsAGpsHandler::SendRequestModuleOption(TLbsHybridModuleOptions aOption, TBool aValue)

    84 	{

    85  	TT_LbsAGpsRequestOptions* aMsg = new TT_LbsAGpsRequestOptions(aOption, aValue);

    86  	 	

    87  	BufferMessage(aMsg);	

    88 	}

    89 

    90 EXPORT_C void CT_LbsAGpsHandler::SendRequestForcedUpdate()

    91 	{

    92 	TT_LbsAGpsRequestForcedUpdate* msg = new TT_LbsAGpsRequestForcedUpdate();

    93  	 	

    94  	BufferMessage(msg);

    95 	}

    96 	

    97 EXPORT_C void CT_LbsAGpsHandler::SendRequestError(TInt aError)

    98 	{

    99  	TT_LbsAGpsRequestError* aMsg = new TT_LbsAGpsRequestError(aError);

   100  	 	

   101  	BufferMessage(aMsg);		

   102 	}

   103 

   104 

   105 void CT_LbsAGpsHandler::RunL()

   106 	{

   107 	User::LeaveIfError(iStatus.Int());

   108 	

   109 	if (iMsgBuffer.Count() > 0)

   110 		{	

   111 		SendRequestMessage(iMsgBuffer[0]);

   112 		iMsgBuffer.Remove(0);

   113 		}

   114 	}

   115 

   116 void CT_LbsAGpsHandler::DoCancel()

   117 	{

   118 	iTHChannel.CancelSendMessageNotification();

   119 	}

   120 	

   121 TInt CT_LbsAGpsHandler::RunError(TInt aError)

   122 	{

   123 	return aError;

   124 	}

   125 

   126 void CT_LbsAGpsHandler::SendRequestMessage(const TT_LbsMsgBase* aMessage)

   127 	{

   128 	iTHChannel.SendMessage(*aMessage, iStatus);

   129 	// The msg has now been sent to the channel. We can now delete it.

   130 	delete(aMessage);

   131 	SetActive();

   132 	}

   133 	

   134 void CT_LbsAGpsHandler::BufferMessage(const TT_LbsMsgBase* aMessage)

   135 	{	

   136 	if (!IsActive())

   137 		{

   138 		// The AO is not active, so there should be no buffered messages.

   139 		__ASSERT_DEBUG(iMsgBuffer.Count() == 0, User::Invariant());

   140 		

   141 		// Immediately send the new message.

   142 		SendRequestMessage(aMessage);

   143 		}

   144 	else

   145 		{

   146 		__ASSERT_ALWAYS(iMsgBuffer.Count() < KBufferedMsgMaxCount, User::Invariant());

   147 

   148 		// Still waiting for acknowledgement that a previous message

   149 		// was read, so buffer this new message.

   150 		iMsgBuffer.Append(aMessage);

   151 		}

   152 	}				

   153 

   154 void CT_LbsAGpsHandler::ProcessChannelMessage(RT_LbsChannel::TT_LbsChannelId /*aChannelId*/, 

   155 												 const TT_LbsMsgBase& aMessage)

   156 	{

   157 

   158 	switch (aMessage.Type())

   159 		{

   160 		case TT_LbsMsgBase::EModuleResponse:

   161 			{

   162 			const TT_LbsAGpsResponseMsg& msg = static_cast<const TT_LbsAGpsResponseMsg&>(aMessage);

   163 			iObserver->ProcessAGpsResponseMessage(msg.ResponseType());

   164 			break;

   165 			}

   166 		default:

   167 			//LBSLOG_ERR2(ELogP2, "Unexpected message type: %d \n", aMessage.Type());

   168 			break;

   169 		}

   170 	}