Symaptic: os/mm/devsoundextensions/telephonyaudiorouting/Server/src/TelephonyAudioRoutingServerSession.cpp@bde4ae8d615e

     1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   Server-side session implementation

    15 *

    16 */

    20 #include <e32std.h>

    21 #include <e32svr.h>

    22 #include <s32mem.h>  // for stream classes

    23 #include "TelephonyAudioRoutingServerSession.h"

    25 const TInt KMaxNumberOfOutputs = 100;

    27 // ============================ MEMBER FUNCTIONS ===============================

    29 // -----------------------------------------------------------------------------

    30 // CTelephonyAudioRoutingServerSession::CTelephonyAudioRoutingServerSession

    31 // C++ default constructor can NOT contain any code, that

    32 // might leave.

    33 // -----------------------------------------------------------------------------

    34 //

    35 CTelephonyAudioRoutingServerSession::CTelephonyAudioRoutingServerSession(

    36 	TInt aSessionId)

    37     :iSessionId(aSessionId),

    38     iMessageArray()

    39 	{

    40 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::CTelephonyAudioRoutingServerSession "),this);

    41 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t iMessageArrayCount = %d "),iMessageArray.Count());

    43 	}

    45 // Destructor

    46 CTelephonyAudioRoutingServerSession::~CTelephonyAudioRoutingServerSession()

    47 	{

    49 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::~CTelephonyAudioRoutingServerSession "),this);

    51     if	(&Server() != NULL)

    52 		{

    53 		Server().RemoveSession(iSessionId);

    54 		}

    56 	iSessionAvailableOutputs.Close();

    57 	iMessageArray.Close();

    59 	}

    61 // -----------------------------------------------------------------------------

    62 // CTelephonyAudioRoutingServerSession::Server

    63 // Creates the server.

    64 // (other items were commented in a header).

    65 // -----------------------------------------------------------------------------

    66 //

    67 CTelephonyAudioRoutingServer& CTelephonyAudioRoutingServerSession::Server()

    68 	{

    69 	return *static_cast<CTelephonyAudioRoutingServer*>(const_cast<CServer2*>(CSession2::Server()));

    70 	}

    72 // -----------------------------------------------------------------------------

    73 // CTelephonyAudioRoutingServerSession::ServiceError

    74 // Handle an error from ServiceL

    75 // (other items were commented in a header).

    76 // -----------------------------------------------------------------------------

    77 //

    78 void CTelephonyAudioRoutingServerSession::ServiceError(

    79 	const RMessage2& aMessage,

    80 	TInt aError)

    81 	{

    82 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::ServiceError - %d "), aError);

    83 	PanicClient (aMessage, EPanicIllegalFunction);

    84 	}

    86 // -----------------------------------------------------------------------------

    87 // CTelephonyAudioRoutingServerSession::ServiceL

    88 // Handles the servicing of a client request that has been passed to the server.

    89 // (other items were commented in a header).

    90 // -----------------------------------------------------------------------------

    91 //

    92 void CTelephonyAudioRoutingServerSession::ServiceL (

    93 	const RMessage2& aMessage)

    94 	{

    96     switch (aMessage.Function())

    97 		{

    98 		case ETelAudRtngServDoSetOutput:

    99 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServDoSetOutput "),this);

   100 			DoSetOutputL(aMessage);

   101 			break;

   103 		case ETelAudRtngServNotifyIfOutputChanged:

   104 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServNotifyIfOutputChanged "),this);

   105 			NotifyIfOutputChangedL(aMessage);

   106 			break;

   108 		case ETelAudRtngServNotifyIfAvailOutputsChanged:

   109 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServNotifyIfAvailOutputsChanged "),this);

   110 			NotifyIfAvailOutputsChangedL(aMessage);

   111 			break;

   113 		case ETelAudRtngServGetNoOutputs:

   114 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServGetNoOutputs "),this);

   115 			GetNoOfAvailableOutputs(aMessage);

   116 			break;

   118 		case ETelAudRtngServGetAvailableOutputs:

   119 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServGetAvailableOutputs "),this);

   120 			GetAvailableOutputsL(aMessage);

   121 			break;

   123 		case ETelAudRtngServMonitorOutputChange:

   124 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServMonitorOutputChange "),this);

   125 			MonitorOutputChangeL(aMessage);

   126 			break;

   128 		case ETelAudRtngServSetPolicySessionId:

   129 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServSetPolicySessionId "),this);

   130 			SetPolicySessionId(aMessage);

   131 			break;

   133 		case ETelAudRtngServOutputChangeComplete:

   134 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServOutputChangeComplete "),this);

   135 			OutputChangeCompleteL(aMessage);

   136 			break;

   138 		case ETelAudRtngDoAvailableOutputsChanged:

   139 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngDoAvailableOutputsChanged "),this);

   140 			DoAvailableOutputsChangedL(aMessage);

   141 			break;

   143 		case ETelAudRtngServCancelRequest:

   144 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServCancelRequest "),this);

   145 			CancelRequestL(aMessage);

   146 			break;

   148 		case ETelAudRtngServInitialize:

   149 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServInitialize "),this);

   150 			InitializeL(aMessage);

   151 			break;

   153 		case ETelAudRtngServOutputChangedByPolicy:

   154 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServOutputChangedByPolicy "),this);

   155 			OutputChangedL(aMessage);

   156 			break;

   158 		case ETelAudRtngServGetDefaultValues:

   159 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServGetDefaultValues "),this);

   160 			GetDefaultValuesL(aMessage);

   161 			break;

   163 		default:

   164 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - default !! "),this);

   165 			PanicClient (aMessage, EPanicIllegalFunction);

   166 		}

   167 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL EXIT"), this);

   168 	}

   170 // -----------------------------------------------------------------------------

   171 // CTelephonyAudioRoutingServerSession::InitializeL

   172 // Session initialization.

   173 // (other items were commented in a header).

   174 // -----------------------------------------------------------------------------

   175 //

   176 void CTelephonyAudioRoutingServerSession::InitializeL(

   177 	const RMessage2& aMessage)

   178 	{

   179 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::IntitializeL enter"),this);

   180 	iConnected = ETrue;

   181 	Server().AddSession();

   182 	aMessage.Complete(KErrNone);

   183 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::IntitializeL exit"),this);

   184 	}

   186 // -----------------------------------------------------------------------------

   187 // CTelephonyAudioRoutingServerSession::CancelRequestL

   188 // Cancel the outstanding request.

   189 // (other items were commented in a header).

   190 // -----------------------------------------------------------------------------

   191 //

   192 void CTelephonyAudioRoutingServerSession::CancelRequestL(

   193 	const RMessage2& aMessage)

   194 	{

   195 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::CancelRequestL"),this);

   196 	TTelAudRtngServRqst req;

   197 	req = (TTelAudRtngServRqst) aMessage.Int1();

   198 	TPckgBuf<TInt> count;

   199 	aMessage.ReadL( 0, count);

   200 	req = (TTelAudRtngServRqst)count();

   201 	aMessage.Complete(KErrNone);

   202 	TInt messageCount = iMessageArray.Count();

   203 	TInt messageIndex = 0;

   205 	if(messageCount > 0)

   206 		{

   207 		for(TInt i=0;i< messageCount; i++)

   208 			{

   209 			if(iMessageArray[i].Function()== req)

   210 				{

   211 				messageIndex=i;

   212 				break;

   213 				}

   215 			}

   216 		iMessageArray[messageIndex].Complete(KErrCancel);

   217 		iMessageArray.Remove(messageIndex);

   218 		}

   219 	}

   221 // -----------------------------------------------------------------------------

   222 // CTelephonyAudioRoutingServerSession::DoSetOutputL

   223 // Send a request to audio policy to set audio output.

   224 // (other items were commented in a header).

   225 // -----------------------------------------------------------------------------

   226 //

   227 void CTelephonyAudioRoutingServerSession::DoSetOutputL (

   228 	const RMessage2& aMessage)

   229 	{

   230 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::DoSetOutputL "),this);

   231 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t Appending aMessage to iMessageArray. Current count = %d "),iMessageArray.Count());

   232 	iMessageArray.AppendL(aMessage);

   233 	Server().DoSetOutputL(iSessionId,aMessage);

   234     }

   236 // -----------------------------------------------------------------------------

   237 // CTelephonyAudioRoutingServerSession::NotifyIfOutputChangedL

   238 // Add a message to message queue. Complete the message when output changes

   239 // (other items were commented in a header).

   240 // -----------------------------------------------------------------------------

   241 //

   242 void CTelephonyAudioRoutingServerSession::NotifyIfOutputChangedL (

   243 	const RMessage2& aMessage)

   244 	{

   245 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::NotifyIfOutputChangedL "),this);

   246 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t Appending aMessage to iMessageArray. Current count = %d "),iMessageArray.Count());

   247     iMessageArray.AppendL(aMessage);

   248 	}

   250 // -----------------------------------------------------------------------------

   251 // CTelephonyAudioRoutingServerSession::NotifyIfAvailOutputsChangedL

   252 // Add a message to message queue. Complete the message when available audio

   253 // outputs change

   254 // (other items were commented in a header).

   255 // -----------------------------------------------------------------------------

   256 //

   257 void CTelephonyAudioRoutingServerSession::NotifyIfAvailOutputsChangedL (

   258 	const RMessage2& aMessage)

   259 	{

   260 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::NotifyIfAvailOutputsChangedL "),this);

   261 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t Appending aMessage to iMessageArray. Current count = %d "),iMessageArray.Count());

   262     iMessageArray.AppendL(aMessage);

   263 	}

   265 // -----------------------------------------------------------------------------

   266 // CTelephonyAudioRoutingServerSession::SetPolicySessionId

   267 // Set the policy session Id.

   268 // (other items were commented in a header).

   269 // -----------------------------------------------------------------------------

   270 //

   271 void CTelephonyAudioRoutingServerSession::SetPolicySessionId(

   272 	const RMessage2& aMessage)

   273 	{

   274 	if(!iPolicyFlag)

   275 		{

   276 		Server().SetPolicySessionId(iSessionId);

   277 		iPolicyFlag = ETrue;

   278 		}

   280 	aMessage.Complete(KErrNone);

   281 	}

   283 // -----------------------------------------------------------------------------

   284 // CTelephonyAudioRoutingServerSession::OutputChangeCompleteL

   285 // Used by policy session to indicate that the SetOutput request is complete.

   286 // (other items were commented in a header).

   287 // -----------------------------------------------------------------------------

   288 //

   289 void CTelephonyAudioRoutingServerSession::OutputChangeCompleteL(

   290 	const RMessage2& aMessage)

   291 	{

   292 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::OutputChangeCompleteL "),this);

   293 	TPckgBuf<CTelephonyAudioRouting::TAudioOutput> xPackage;

   294 	aMessage.ReadL( 0, xPackage);

   295    	CTelephonyAudioRouting::TAudioOutput audioOutput = xPackage();

   297 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChangeComplete: AudioOutput = %d"), audioOutput);

   299  	TPckgBuf<TInt> errPkg;

   300   	aMessage.ReadL(1, errPkg);

   301    	TInt err = errPkg();

   303   	if (Server().CurrentAudioOutput() != CTelephonyAudioRouting::ENone)

   304 	{

   305 		Server().PreviousAudioOutput() = Server().CurrentAudioOutput();

   307 		TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChangeComplete: iPreviousAudioOutput set to: %d"), Server().PreviousAudioOutput());

   308 	}

   310 	Server().CurrentAudioOutput() = audioOutput;

   312    	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChangeCompleteL: Server will be sent audioOutput = %d"), audioOutput);

   313 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChangeCompleteL: previousAudioOutput = %d"), Server().PreviousAudioOutput());

   314 	aMessage.Complete(KErrNone);

   315 	Server().SetOutputCompleteL(audioOutput, err);

   316 	}

   318 // -----------------------------------------------------------------------------

   319 // CTelephonyAudioRoutingServerSession::MonitorOutputChangeL

   320 // Used by policy session to listen to any SetOutput request from other sessions.

   321 // (other items were commented in a header).

   322 // -----------------------------------------------------------------------------

   323 //

   324 void CTelephonyAudioRoutingServerSession::MonitorOutputChangeL (

   325 	const RMessage2& aMessage)

   326 	{

   327 		TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::MonitorOutputChangeL "),this);

   328 		TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t Appending aMessage to iMessageArray. Current count = %d "),iMessageArray.Count());

   330 		TRAPD(err, iMessageArray.AppendL(aMessage));

   331 		if (err != KErrNone)

   332 		{

   333 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t MonitorOutputChangeL ERROR: %d "),err);

   334 			PanicClient (aMessage, EPanicIllegalFunction);

   335 		}

   336 	}

   338 // -----------------------------------------------------------------------------

   339 // CTelephonyAudioRoutingServerSession::GetNoOfAvailableOutputs

   340 // Returns the number of available outputs to client-side session.

   341 // (other items were commented in a header).

   342 // -----------------------------------------------------------------------------

   343 //

   344 void CTelephonyAudioRoutingServerSession::GetNoOfAvailableOutputs (

   345 	const RMessage2& aMessage)

   346 	{

   347 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::GetNoOfAvailableOutputs"),this);

   348 	TPckgBuf<TInt> xPackage;

   349 	xPackage() = (Server().AvailableOutputs()).Count();

   351 	TInt res = aMessage.Write(0, xPackage);

   352     if (res != KErrNone)

   353     	{

   354 		TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t GetNoOfAvailableOutputs WRITE ERROR: %d"),res);

   355     	PanicClient(aMessage, EPanicIllegalFunction);

   356     	}

   358     else

   359  		aMessage.Complete(KErrNone);

   361 	}

   363 // -----------------------------------------------------------------------------

   364 // CTelephonyAudioRoutingServerSession::GetAvailableOutputsL

   365 // Returns the available audio outputs to client-side session.

   366 // (other items were commented in a header).

   367 // -----------------------------------------------------------------------------

   368 //

   369 void CTelephonyAudioRoutingServerSession::GetAvailableOutputsL (

   370 	const RMessage2& aMessage)

   371 	{

   372 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::GetAvailableOutputsL "),this);

   373 	TInt KBufExpandSize8 = 8;//two TInts

   374 	CBufFlat* dataCopyBuffer = CBufFlat::NewL(KBufExpandSize8);

   375 	CleanupStack::PushL(dataCopyBuffer);

   376 	RBufWriteStream stream;

   377 	stream.Open(*dataCopyBuffer);

   378 	CleanupClosePushL(stream);

   380 	// Write out server's available outputs to caller:

   381 	CTelephonyAudioRouting::TAudioOutput output;

   382 	TInt count = (Server().AvailableOutputs()).Count();

   383 	for (TInt i=0;i<count;i++)

   384 		{

   385 		output = ( Server().AvailableOutputs() )[i];

   386 		stream.WriteInt32L(output);

   387 		}

   388 	aMessage.WriteL(0, dataCopyBuffer->Ptr(0));

   389 	stream.Close();

   390 	CleanupStack::PopAndDestroy(2); // dataCopyBuffer, stream

   392 	aMessage.Complete(KErrNone);

   394 	}

   396 // -----------------------------------------------------------------------------

   397 // CTelephonyAudioRoutingServerSession::DoAvailableOutputsChangedL

   398 // Notify the client-side session that available outputs have changed.

   399 // (other items were commented in a header).

   400 // -----------------------------------------------------------------------------

   401 //

   402 void CTelephonyAudioRoutingServerSession::DoAvailableOutputsChangedL (

   403 	const RMessage2& aMessage)

   404 {

   405 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::DoAvailableOutputsChangedL"),this);

   406 	TInt err(KErrNone);

   407 	TBool validData(ETrue);

   408 	TPckgBuf<TInt> count;

   409 	TRAP(err,aMessage.ReadL( 0, count));

   410 	if (err != KErrNone)

   411 	{

   412 		TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t DoAvailableOutputsChangedL(1) ERROR: %d "),err);

   413 		PanicClient (aMessage, EPanicIllegalFunction);

   414 		return;

   415 	}

   417 	if ((count() <0) || (count() > KMaxNumberOfOutputs))

   418 	{

   419 		validData = EFalse;

   420 		iSessionAvailableOutputs.Reset();

   421 	}

   423 	if (validData)

   424 	{

   425 		HBufC8* buf = HBufC8::NewLC(count()*sizeof(CTelephonyAudioRouting::TAudioOutput));

   426 		TPtr8 ptr = buf->Des();

   428 		TRAP(err,aMessage.ReadL(1, ptr ));

   429 		if (err != KErrNone)

   430 		{

   431 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t DoAvailableOutputsChangedL(2) ERROR: %d "),err);

   432 			PanicClient (aMessage, EPanicIllegalFunction);

   433 			return;

   434 		}

   436 		RDesReadStream stream(ptr);

   437 		CleanupClosePushL(stream);

   438 		iSessionAvailableOutputs.Reset();

   439 		TInt element(0);

   441 		for (TInt i=0; i<count(); i++)

   442 		{

   444 	   		TRAP(err, element = stream.ReadInt16L());

   445 			if (err != KErrNone)

   446 			{

   447 				TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t DoAvailableOutputsChangedL(3) ERROR: %d "),err);

   448 				PanicClient (aMessage, EPanicIllegalFunction);

   449 				return;

   450 			}

   452 			err = iSessionAvailableOutputs.Append((CTelephonyAudioRouting::TAudioOutput)element);

   453 			if (err)

   454 			{

   455 				TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t DoAvailableOutputsChangedL(4) ERROR: %d "),err);

   456 				iSessionAvailableOutputs.Reset();

   457 				PanicClient (aMessage, EPanicIllegalFunction);

   458 				return;

   459 			}

   461 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t DoAvailableOutputsChanged: Avail Outputs to be sent to server: iSessionAvailableOutputs[i] = %d "),iSessionAvailableOutputs[i]);

   462 		} // end For

   464 		stream.Close();

   465 		CleanupStack::PopAndDestroy(2); // buf, stream

   467 	} // end if

   469 	aMessage.Complete(KErrNone);

   470 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t [%x]DoAvailableOutputsChangedL: calling Server::AvailableOutputsChanged"),this);

   471 	Server().AvailableOutputsChangedL(iSessionAvailableOutputs.Array());

   472 }

   474 // -----------------------------------------------------------------------------

   475 // CTelephonyAudioRoutingServerSession::SetOutputComplete

   476 // Notifies the client-side session that the SetOutput request is complete.

   477 // (other items were commented in a header).

   478 // -----------------------------------------------------------------------------

   479 //

   480 void CTelephonyAudioRoutingServerSession::SetOutputComplete(

   481 	CTelephonyAudioRouting::TAudioOutput aOutput,

   482 	TInt aError,

   483 	TBool aShowNote)

   484 	{

   485 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::SetOutputComplete "),this);

   487 	TPckgBuf<CTelephonyAudioRouting::TAudioOutput> xPackage;

   488 	xPackage() = aOutput;

   491 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::SetOutputComplete: iPreviousAudioOutput Write out: %d"), Server().PreviousAudioOutput());

   493 	TPckgBuf<CTelephonyAudioRouting::TAudioOutput> yPackage;

   494 	yPackage() = Server().PreviousAudioOutput();

   496 	TPckgBuf<TInt> errorPackage;

   497 	errorPackage() = aError;

   499 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::SetOutputComplete: ShowNote Val to pass to client: %d"), aShowNote);

   500 	TPckgBuf<TBool> showNotePackage;

   501 	showNotePackage() = aShowNote;

   503 	TInt messageCount = iMessageArray.Count();

   504 	TInt messageIndex = -1;

   505 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t iMessageArrayCount = %d "),iMessageArray.Count());

   507 	for(TInt i=0;i< messageCount; i++)

   508 		{

   509 		if(iMessageArray[i].Function()== ETelAudRtngServDoSetOutput)

   510 			{

   511 				messageIndex = i;

   512 				break;

   513 			}

   514 		}

   516 	if (messageIndex != -1)

   517 		{

   518 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t Current Index = %d "), messageIndex);

   520 			TInt res = iMessageArray[messageIndex].Write(0, xPackage);

   521 			TInt res2 = iMessageArray[messageIndex].Write(1, yPackage);

   522 			TInt res3 = iMessageArray[messageIndex].Write(2, errorPackage);

   523 			TInt res4 = iMessageArray[messageIndex].Write(3, showNotePackage);

   525 			if ( (res != KErrNone) || (res2 != KErrNone) || (res3 != KErrNone) || (res4 != KErrNone))

   526     			{

   527     				PanicClient(iMessageArray[messageIndex], EPanicIllegalFunction);

   528     			}

   529     		else

   530     		{

   531     			iMessageArray[messageIndex].Complete(ETelAudRtngServSetOutputComplete);

   532     			iMessageArray.Remove(messageIndex);

   533     		}

   534     	}

   535 	}

   537 // -----------------------------------------------------------------------------

   538 // CTelephonyAudioRoutingServerSession::OutputChangeRequested

   539 // Notification that client is requesting to change audio output

   540 // (other items were commented in a header).

   541 // -----------------------------------------------------------------------------

   542 //

   543 void CTelephonyAudioRoutingServerSession::OutputChangeRequested(

   544 	CTelephonyAudioRouting::TAudioOutput aOutput)

   545 	{

   546 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::OutputChangeRequested"),this);

   548 	TPckgBuf<CTelephonyAudioRouting::TAudioOutput> xPackage;

   549 	xPackage() = aOutput;

   551 	TInt messageCount = iMessageArray.Count();

   552 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t iMessageArrayCount = %d "),iMessageArray.Count());

   554 	TInt messageIndex = -1;

   556 	for(TInt i=0;i< messageCount; i++)

   557 		{

   558 		if(iMessageArray[i].Function()== ETelAudRtngServNotifyIfOutputChanged && !iPolicyFlag)

   559 			{

   560 				messageIndex=i;

   561 				break;

   562 			}

   564 		if(iMessageArray[i].Function()== ETelAudRtngServMonitorOutputChange && iPolicyFlag)

   565 			{

   566 				messageIndex=i;

   567 				break;

   568 			}

   569 		}

   571 	if (messageIndex != -1) // Don't perform if message not found

   572 		{

   573 			TInt res = iMessageArray[messageIndex].Write(0, xPackage);

   574 			if (res != KErrNone)

   575     			{

   576      				PanicClient(iMessageArray[messageIndex], EPanicIllegalFunction);

   577     			}

   579     		else

   580     		{

   581 				iMessageArray[messageIndex].Complete(ETelAudRtngServOutputChangeRequested);

   582     			iMessageArray.Remove(messageIndex);

   583     		}

   584 		}

   585 #ifdef  _DEBUG

   586 	else

   587 		{

   588 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::OutputChangeRequested: ServerSession NOT Handling this msg! "),this);

   589 		}

   590 #endif

   592 	}

   594 // -----------------------------------------------------------------------------

   595 // CTelephonyAudioRoutingServerSession::OutputChangedL

   596 // Telephony Audio Routing Manager uses to notify TAR that policy has initiated an output change.

   597 // (other items were commented in a header).

   598 // -----------------------------------------------------------------------------

   599 //

   600 void CTelephonyAudioRoutingServerSession::OutputChangedL(

   601 	const RMessage2& aMessage)

   602 	{

   603 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::OutputChangedL Enter"),this);

   605 	TPckgBuf<CTelephonyAudioRouting::TAudioOutput> xPackage;

   607 	aMessage.ReadL( 0, xPackage);

   608    	CTelephonyAudioRouting::TAudioOutput audioOutput = xPackage();

   610 	Server().PreviousAudioOutput() = Server().CurrentAudioOutput();

   612 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChangedL: iCurrentAudioOutput was: %d"), Server().CurrentAudioOutput());

   613 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChangedL: iPreviousAudioOutput set to: %d"), Server().PreviousAudioOutput());

   615 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChangedL: iCurrentAudioOutput set to: %d"), audioOutput);

   616 	Server().CurrentAudioOutput() = audioOutput;

   617 	Server().SetShowNoteMode(ETrue);  // Always set if output changes initiated by adaptation

   619     aMessage.Complete(KErrNone);

   621   	// Server needs to send notification of output change to clients

   622 	Server().OutputChanged(audioOutput);

   624 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::OutputChangedL Exit"),this);

   626 	}

   628 // -----------------------------------------------------------------------------

   629 // CTelephonyAudioRoutingServerSession::OutputChanged

   630 // Notification to be sent to all clients about the change of audio output.

   631 // (other items were commented in a header).

   632 // -----------------------------------------------------------------------------

   633 //

   634 void CTelephonyAudioRoutingServerSession::OutputChanged(

   635 	CTelephonyAudioRouting::TAudioOutput aOutput,

   636 	TBool aShowNote)

   637 	{

   638 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::OutputChanged"), this);

   640 	TPckgBuf<CTelephonyAudioRouting::TAudioOutput> xPackage;

   641 	TPckgBuf<CTelephonyAudioRouting::TAudioOutput> yPackage;

   643 	TPckgBuf<TInt> errorPackage;

   644 	errorPackage() = KErrNone;

   646 	TPckgBuf<TBool> zPackage;

   648 	xPackage() = aOutput;

   650 	// Provide client with previous output value:

   651 	CTelephonyAudioRouting::TAudioOutput prevOutput = Server().PreviousAudioOutput();

   652 	yPackage() = prevOutput;

   654 	// Provide client with showNote:

   655 	zPackage() = aShowNote;

   657 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChanged Current output: %d"), aOutput);

   658 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChanged Previous output: %d"), yPackage());

   659 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChanged aShowNote: %d"), zPackage());

   661 	TInt messageCount = iMessageArray.Count();

   662 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t iMessageArrayCount = %d "),iMessageArray.Count());

   664 	TInt messageIndex = -1;

   666 	for(TInt i=0;i< messageCount; i++)

   667 		{

   668 		if(iMessageArray[i].Function()== ETelAudRtngServNotifyIfOutputChanged)

   669 			{

   670 				messageIndex = i;

   671 				break;

   672 			}

   673 		}

   675 	if (messageIndex != -1)

   676 	{

   677 		TInt res = iMessageArray[messageIndex].Write(0, xPackage);

   678 		TInt res2 = iMessageArray[messageIndex].Write(1, yPackage);

   679 		TInt res3 = iMessageArray[messageIndex].Write(2, errorPackage);

   680 		TInt res4 = iMessageArray[messageIndex].Write(3, zPackage);

   682 		if ( (res != KErrNone) || (res2 != KErrNone) || (res3 != KErrNone) || (res3 != KErrNone) )

   683     	{

   684     		PanicClient(iMessageArray[messageIndex], EPanicIllegalFunction);

   685     	}

   687 		else

   688 		{

   689     		iMessageArray[messageIndex].Complete(ETelAudRtngServOutputChanged);

   690     		iMessageArray.Remove(messageIndex);

   691 		}

   692 	}

   693 #ifdef _DEBUG

   694 	else

   695 		{

   696 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::OutputChanged: ServerSession NOT Handling this msg! "),this);

   697 		}

   698 #endif

   700 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::OutputChanged Exit"), this);

   701 	}

   702 // -----------------------------------------------------------------------------

   703 // CTelephonyAudioRoutingServerSession::AvailableOutputsChanged

   704 // Notifies the client-side session that available audio outputs have changed.

   705 // (other items were commented in a header).

   706 // -----------------------------------------------------------------------------

   707 //

   708 void CTelephonyAudioRoutingServerSession::AvailableOutputsChanged(

   709 	const TArray<CTelephonyAudioRouting::TAudioOutput>& aOutputs)

   710 	{

   711 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::AvailableOutputsChanged Enter "),this);

   712     TInt count = aOutputs.Count();

   713     iSessionAvailableOutputs.Reset();

   715     for(TInt i=0;i<count;i++)

   716     	iSessionAvailableOutputs.Append(aOutputs[i]);

   718 	TInt messageCount = iMessageArray.Count();

   719 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t iMessageArrayCount = %d "),iMessageArray.Count());

   721 	TInt messageIndex = -1;

   723 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::AvailableOutputsChanged: Find msg "),this);

   725 	for(TInt i=0;i< messageCount; i++)

   726 		{

   727 		if(iMessageArray[i].Function()== ETelAudRtngServNotifyIfAvailOutputsChanged)

   728 			{

   729 				messageIndex=i;

   730 				break;

   731 			}

   732 		}

   734 	if (messageIndex != -1) // Don't perform if message not found

   735 		{

   736 			iMessageArray[messageIndex].Complete(ETelAudRtngServAvailableOutputsChanged);

   737     		iMessageArray.Remove(messageIndex);

   738 		}

   740 #ifdef _DEBUG

   741 	else

   742 		{

   743 			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::AvailableOutputsChanged: ServerSession NOT Handling this msg! "),this);

   744 		}

   745 #endif

   747 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::AvailableOutputsChanged Exit "),this);

   749 	}

   751 TInt CTelephonyAudioRoutingServerSession::SessionId()

   752 	{

   753 	return iSessionId;

   754 	}

   756 // -----------------------------------------------------------------------------

   757 // CTelephonyAudioRoutingServerSession::GetDefaultValuesL

   758 // Gets default values from server for the client-side session

   759 // (other items were commented in a header).

   760 // -----------------------------------------------------------------------------

   761 //

   762 void CTelephonyAudioRoutingServerSession::GetDefaultValuesL(

   763 	const RMessage2& aMessage)

   764 	{

   765 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::GetDefaultValuesL "),this);

   767 	TTelephonyAudioRoutingDefaultParams defaultParams;

   769 	// Fill class with default values from server:

   770 	defaultParams.iCurrentAudio = Server().CurrentAudioOutput();

   771 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t GetDefaultValuesL: Current audio output = %d"),defaultParams.iCurrentAudio);

   773 	defaultParams.iPreviousAudio = Server().PreviousAudioOutput();

   774 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t GetDefaultValuesL: Previous audio output = %d"),defaultParams.iPreviousAudio);

   776 	defaultParams.iShowNoteMode = Server().ShowNoteMode();

   777 	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t GetDefaultValuesL: Show Note Mode = %d"),defaultParams.iShowNoteMode);

   779 	// Package default params and write out:

   780 	TPckgBuf<TTelephonyAudioRoutingDefaultParams> defaultParamsPkg;

   781 	defaultParamsPkg() = defaultParams;

   782 	aMessage.WriteL(0, defaultParamsPkg);

   783 	aMessage.Complete(KErrNone);

   785 	}

   788 // End of file.

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--