bluetooth/gavdp/test/tavsrcmtupdaterdatabaseunaware.cpp
branchRCL_3
changeset 23 5b153be919d4
parent 22 786b94c6f0a4
child 24 e9b924a62a66
equal deleted inserted replaced
22:786b94c6f0a4 23:5b153be919d4
     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 "Eclipse Public License v1.0"
       
     5 // which accompanies this distribution, and is available
       
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     7 //
       
     8 // Initial Contributors:
       
     9 // Nokia Corporation - initial contribution.
       
    10 //
       
    11 // Contributors:
       
    12 //
       
    13 // Description:
       
    14 // tavsrcmtupdater.cpp
       
    15 //
       
    16 
       
    17 #include <e32property.h>
       
    18 #include <f32file.h>
       
    19 #include <e32debug.h>
       
    20 #include <barsc2.h>
       
    21 #include <remcondatabaseunawarenowplayingtarget.h>
       
    22 #include <remcondatabaseunawaremediabrowsetarget.h>
       
    23 #include <remcondatabaseunawaremedialibrarybrowse.h>
       
    24 #include <remcondatabaseunawarenowplayingbrowse.h>
       
    25 #include <remconmediaerror.h>
       
    26 #include <reftsp/reftspactiveplayerobserver.h>
       
    27 
       
    28 #include "tavsrc.h"
       
    29 #include "tavsrcmtupdaterdatabaseunaware.h"
       
    30 #include "activecallbackconsole.h"
       
    31 
       
    32 #ifdef __WINS__
       
    33 GLDEF_D TSize gUpdaterConsole(75,30);
       
    34 GLDEF_D TSize gBrowseConsole(75,30);
       
    35 #else
       
    36 GLDEF_D TSize gUpdaterConsole(KConsFullScreen,KConsFullScreen);
       
    37 GLDEF_D TSize gBrowseConsole(KConsFullScreen,KConsFullScreen);
       
    38 #endif
       
    39 
       
    40 
       
    41 #define BROWSE_CONSOLE iMtBrowseConsole
       
    42 
       
    43 const TRemConItemUid KUidMarker = 0xc0ffeeee00000000ull;
       
    44 const TRemConItemUid KFolderMarker = 0x0000000100000000ull;
       
    45 const TInt KNumberFolderItemsInFolder = 1;
       
    46 const TInt KNumberMediaItemsInFolder = 1501;
       
    47 const TInt KNumberItemsInFolder = KNumberMediaItemsInFolder + KNumberFolderItemsInFolder; 
       
    48 
       
    49 _LIT8(KFolderName, "Folder%08x");
       
    50 
       
    51 CTavsrcMtUpdater* CTavsrcMtUpdater::NewL(CRemConInterfaceSelector& aIfSel, TUint aRemConInterfaces)
       
    52 	{
       
    53 	CTavsrcMtUpdater* mt = new(ELeave)CTavsrcMtUpdater();
       
    54 	CleanupStack::PushL(mt);
       
    55 	mt->ConstructL(aIfSel, aRemConInterfaces);
       
    56 	CleanupStack::Pop();
       
    57 	return mt;
       
    58 	}
       
    59 
       
    60 struct TMediaBrowseThreadParams
       
    61 	{
       
    62 	CRemConInterfaceSelector*	iIfSel;
       
    63 	CTavsrcMtUpdater*			iUpdater;
       
    64 	};
       
    65 
       
    66 TInt CTavsrcMtUpdater::MediaBrowseThread(TAny* aPtr)
       
    67 	{
       
    68 	TMediaBrowseThreadParams* params = reinterpret_cast<TMediaBrowseThreadParams*>(aPtr);
       
    69 	
       
    70 	CTrapCleanup* cleanupStack = CTrapCleanup::New();
       
    71 	CActiveScheduler* activescheduler = new CActiveScheduler;
       
    72 	CActiveScheduler::Install(activescheduler);
       
    73 	
       
    74 	TInt err = KErrNoMemory;
       
    75 	if(cleanupStack && activescheduler)
       
    76 		{
       
    77 		CTavsrcMtUpdater* self = params->iUpdater;
       
    78 		TRAP(err, self->BrowseSetupL(*(params->iIfSel)))
       
    79 		RThread().Rendezvous(err);
       
    80 		if(err == KErrNone)
       
    81 			{
       
    82 			CActiveScheduler::Start();
       
    83 			}
       
    84 		self->BrowseCleanup();
       
    85 		}
       
    86 
       
    87 	delete activescheduler;
       
    88 	delete cleanupStack;
       
    89 
       
    90 	return err;
       
    91 	}
       
    92 
       
    93 void CTavsrcMtUpdater::BrowseSetupL(CRemConInterfaceSelector& aIfSel)
       
    94 	{
       
    95 	iMtBrowseConsole = CActiveCallBackConsole::NewL(BrowseKeyPressed, this, _L("MtBrowse"),gBrowseConsole);
       
    96 	BrowseMenu();
       
    97 	
       
    98 	iMtBrowseStopper = CStopBrowseWatcher::NewL();
       
    99 	iMediaBrowse = CRemConDatabaseUnawareMediaBrowseTarget::NewL(aIfSel, 
       
   100 			*this, *this, ETrue, iMediaBrowseInterface, 
       
   101 			iNowPlayingBrowseInterface);
       
   102 	iMtBrowseStopper->Start();
       
   103 	}
       
   104 
       
   105 void CTavsrcMtUpdater::BrowseCleanup()
       
   106 	{
       
   107 	delete iMtBrowseStopper; iMtBrowseStopper = NULL;
       
   108 	delete iMtBrowseConsole; iMtBrowseConsole = NULL;
       
   109 	}
       
   110 
       
   111 
       
   112 void CTavsrcMtUpdater::ConstructL(CRemConInterfaceSelector& aIfSel, TUint aRemConInterfaces)
       
   113 	{ 
       
   114 	if (aRemConInterfaces & EPlayerInformation)
       
   115 		{
       
   116 	iPlayerInformation = CPlayerInfoTarget::NewL(aIfSel,
       
   117 										iPlayerCapabilitiesObserver,
       
   118 										iPlayerApplicationSettingsObserver,
       
   119 										iPlayerEventsObserver,
       
   120 										*this);
       
   121 		}
       
   122 	
       
   123 	if (aRemConInterfaces & ENowPlaying)
       
   124 		{
       
   125 	iNowPlaying = CRemConDatabaseUnawareNowPlayingTarget::NewL(aIfSel, *this);
       
   126 		}
       
   127 	
       
   128 	if (aRemConInterfaces & EMediaBrowse)
       
   129 		{
       
   130 		// Create media browse thread (and wait until it is running)...
       
   131 		TMediaBrowseThreadParams params;
       
   132 		params.iIfSel = &aIfSel;
       
   133 		params.iUpdater = this;
       
   134 		TRequestStatus status;
       
   135 		User::LeaveIfError(iMediaBrowseThread.Create(KNullDesC, CTavsrcMtUpdater::MediaBrowseThread, KDefaultStackSize, NULL, &params));
       
   136 		iMediaBrowseThread.Rendezvous(status);
       
   137 		iMediaBrowseThread.Resume();
       
   138 		User::WaitForRequest(status);
       
   139 		User::LeaveIfError(status.Int());
       
   140 		iMediaBrowseThreadOpen = ETrue;
       
   141 		}
       
   142 	
       
   143 	iMtUpdaterConsole = CActiveConsole::NewL(*this,_L("MtUpdater"),gUpdaterConsole);
       
   144 		
       
   145 	// configure the PlayerInformation from resource file	
       
   146 	ReadAVRCPSettingsFile(KAVRCPSettingsResourceFilename);
       
   147 	
       
   148 	// We don't need to call AddEvent() for PlaybackStatusChanged or TrackChanged
       
   149 	// since these are mandatory events which must be supported. A KErrAlreadyExists
       
   150 	// error is returned if these are called from here.
       
   151 	(void)iNotificationEvents.InsertInOrder(ERegisterNotificationPlaybackStatusChanged);
       
   152 	(void)iNotificationEvents.InsertInOrder(ERegisterNotificationTrackChanged);
       
   153 	
       
   154 	// configure the interface with the events supported by tavsrc
       
   155 	// This cannot fail as we constructed the iNotificationEvents array to have a granularity sufficient to 
       
   156 	// contain all events without having to grow
       
   157 	User::LeaveIfError( iPlayerCapabilitiesObserver->AddEvent(ERegisterNotificationTrackReachedEnd));
       
   158 	(void)iNotificationEvents.InsertInOrder(ERegisterNotificationTrackReachedEnd);
       
   159 	
       
   160 	User::LeaveIfError( iPlayerCapabilitiesObserver->AddEvent(ERegisterNotificationTrackReachedStart));
       
   161 	(void)iNotificationEvents.InsertInOrder(ERegisterNotificationTrackReachedStart);
       
   162 	
       
   163 	User::LeaveIfError( iPlayerCapabilitiesObserver->AddEvent(ERegisterNotificationPlaybackPosChanged));
       
   164 	(void)iNotificationEvents.InsertInOrder(ERegisterNotificationPlaybackPosChanged);
       
   165 	
       
   166 	User::LeaveIfError( iPlayerCapabilitiesObserver->AddEvent(ERegisterNotificationBatteryStatusChanged));
       
   167 	(void)iNotificationEvents.InsertInOrder(ERegisterNotificationBatteryStatusChanged);
       
   168 	
       
   169 	User::LeaveIfError( iPlayerCapabilitiesObserver->AddEvent(ERegisterNotificationPlayerApplicationSettingChanged));
       
   170 	(void)iNotificationEvents.InsertInOrder(ERegisterNotificationPlayerApplicationSettingChanged);
       
   171 			
       
   172 	// save a Company ID
       
   173 	iPlayerCapabilitiesObserver->AddCompanyId(0x4321);
       
   174 	iCompanyIds.InsertInOrderL(0x4321);
       
   175 
       
   176 	// set the player events to some test values 
       
   177 	iPlayerEventsObserver->TrackReachedEnd();
       
   178 	 
       
   179 	// playing 12, which is 2:30 long with a low battery
       
   180 	iPlayerEventsObserver->PlaybackStatusChanged(MPlayerEventsObserver::EStopped);
       
   181 	iPlaybackStatus = MPlayerEventsObserver::EStopped;
       
   182 	
       
   183 	iPlayerEventsObserver->TrackChanged(12, 150*1000);
       
   184 	iLength = 150*1000;
       
   185 	
       
   186 	iPlayerEventsObserver->SetBatteryStatus(MPlayerEventsObserver::ECritical);
       
   187 	iBatteryStatus = MPlayerEventsObserver::ECritical;
       
   188 
       
   189 	// current position is 1 minute 10 secs though track 12
       
   190 	iPlayerEventsObserver->SetPlaybackPosition(70000);	
       
   191 	iPosition = 70000;
       
   192 	
       
   193 	_LIT_SECURITY_POLICY_PASS(KPassPolicy);
       
   194 	TInt err = RProperty::Define(TUid::Uid(KRefTspProperty), KRefTspActivePlayer, RProperty::EInt, KPassPolicy, KPassPolicy);
       
   195 	if(err != KErrNone && err != KErrAlreadyExists)
       
   196 		{
       
   197 		User::Leave(err);
       
   198 		}
       
   199 
       
   200 	MtMenu();
       
   201 	}
       
   202 	
       
   203 CTavsrcMtUpdater::CTavsrcMtUpdater()
       
   204 	: iNotificationEvents(ERegisterNotificationReservedLast),
       
   205 	  iUidCounter(0)
       
   206 	{
       
   207 	}
       
   208 	
       
   209 CTavsrcMtUpdater::~CTavsrcMtUpdater()
       
   210 	{
       
   211 	delete iMtUpdaterConsole;
       
   212 	iNotificationEvents.Close();
       
   213 	iCompanyIds.Close();
       
   214 	if(iMediaBrowseThreadOpen)
       
   215 		{
       
   216 		TRequestStatus status;
       
   217 		iMediaBrowseThread.Logon(status);
       
   218 		iMtBrowseStopper->Complete();
       
   219 		User::WaitForRequest(status);
       
   220 		// the browse thread should not be running now.
       
   221 		}
       
   222 	iMediaBrowseThread.Close();
       
   223 	}
       
   224 	
       
   225 void CTavsrcMtUpdater::ReadAVRCPSettingsFile(const TDesC& aResourceFileName)
       
   226 /**
       
   227  - Creates the resource reader.
       
   228  - Reads the default policy evaluator and dialog creator UIDs.
       
   229  - Reads the number of policies in the resource file.
       
   230  
       
   231 @param aRFs					The file server session used by the resource parser.
       
   232 @param aResourceFileName	The name of the AVRCP settings file to read.
       
   233 */
       
   234 	{
       
   235 	RFs rfs;
       
   236 	rfs.Connect();
       
   237 	RFile r;
       
   238 	User::LeaveIfError(r.Open(rfs, aResourceFileName, EFileRead | EFileShareReadersOnly));
       
   239 	CleanupClosePushL(r);
       
   240 	TInt size;
       
   241 	User::LeaveIfError(r.Size(size));
       
   242 	CleanupStack::PopAndDestroy(&r);
       
   243 	
       
   244 	CResourceFile* resourceFile = CResourceFile::NewLC(rfs, aResourceFileName, 0, size);
       
   245 	PlayerApplicationSettingsResourceInit::DefineAttributesL(*iPlayerApplicationSettingsObserver, *resourceFile);
       
   246 	CleanupStack::PopAndDestroy(resourceFile);
       
   247 	}
       
   248 
       
   249 void CTavsrcMtUpdater::KeyPressed(TChar aKey)
       
   250 	{
       
   251 	
       
   252 	switch(aKey)
       
   253 		{
       
   254 	case 'e':
       
   255 		{
       
   256 		AddEvent(ERegisterNotificationPlaybackPosChanged);
       
   257 		iNotificationEvents.InsertInOrder(ERegisterNotificationPlaybackPosChanged);
       
   258 		iMtUpdaterConsole->Console().Printf(_L("Add event EPlaybackPosChanged\n"));
       
   259 		break;
       
   260 		}
       
   261 	case 'c':
       
   262 		{
       
   263 		AddCompanyId(0x5678);
       
   264 		(void)iCompanyIds.InsertInOrder(0x5678);
       
   265 		iMtUpdaterConsole->Console().Printf(_L("Add CompanyId 0x5678\n"));
       
   266 		break;
       
   267 		}
       
   268 	case '1':
       
   269 		{
       
   270 		PlackbackStatusChanged(NextPlaybackStatus());
       
   271 		iMtUpdaterConsole->Console().Printf(_L("Playback status changed %d\n"),iPlaybackStatus);
       
   272 		break;
       
   273 		}
       
   274 	case '2':
       
   275 		{
       
   276 		TrackChanged(++iIndex, KDefaultLength);
       
   277 		iMtUpdaterConsole->Console().Printf(_L("Track changed\n"));
       
   278 		break;
       
   279 		}
       
   280 	case '3':
       
   281 		{
       
   282 		TrackReachedEnd();
       
   283 		iMtUpdaterConsole->Console().Printf(_L("Track reached end\n"));
       
   284 		break;
       
   285 		}
       
   286 	case '4':
       
   287 		{
       
   288 		TrackReachedStart();
       
   289 		iMtUpdaterConsole->Console().Printf(_L("Track reached end\n"));
       
   290 		break;
       
   291 		}
       
   292 	case '5':
       
   293 		{
       
   294 		iPosition += KPositionIncrement;
       
   295 		SetPlaybackPosition(iPosition);
       
   296 		iMtUpdaterConsole->Console().Printf(_L("Position %d\n"),iPosition );
       
   297 		break;
       
   298 	case '6':
       
   299 		{
       
   300 		SetBatteryStatus(NextBatteryStatus());
       
   301 		iMtUpdaterConsole->Console().Printf(_L("BatteryStatus %d\n"),iBatteryStatus );
       
   302 		break;
       
   303 		}
       
   304 		}
       
   305 	case '8':
       
   306 		{
       
   307 		// change an application setting, 
       
   308 		// increment the value if attribute ID no 1 for example
       
   309 		// CPlayerInfoTarget
       
   310 		iPlayerApplicationSettingsObserver->SetAttributeL(1, 2);
       
   311 		iMtUpdaterConsole->Console().Printf(_L("Increment the value if attribute ID no 1\n") );
       
   312 		break;
       
   313 		}
       
   314 	case '9':
       
   315 		{
       
   316 		// Update NowPlayingList 
       
   317 		iNowPlaying->NowPlayingContentChanged();
       
   318 
       
   319 		iMtUpdaterConsole->Console().Printf(_L("Now Playing List updated\n") );
       
   320 		break;
       
   321 		}
       
   322 	case '0':
       
   323 		{
       
   324 		iMediaBrowseInterface->MrcdumlbMediaLibraryStateChange();
       
   325 
       
   326 		iMtUpdaterConsole->Console().Printf(_L("UIDs changed: %d \n"), iUidCounter);
       
   327 		break;
       
   328 		}
       
   329 	case 'a':
       
   330 		{
       
   331 		SetAsActivePlayer();
       
   332 		break;
       
   333 		}
       
   334 	default:
       
   335 		iMtUpdaterConsole->Console().Printf(_L("No such command\n"));
       
   336 		break;
       
   337 		};
       
   338 		
       
   339 	MtMenu();
       
   340 	}
       
   341 		
       
   342 void CTavsrcMtUpdater::MtMenu()
       
   343 	{
       
   344 	DisplayCurrentState();
       
   345 	
       
   346 	iMtUpdaterConsole->Console().Printf(_L("e.\tAddEvent\n"));
       
   347 	iMtUpdaterConsole->Console().Printf(_L("c.\tAddCompanyId\n"));
       
   348 	iMtUpdaterConsole->Console().Printf(_L("1.\tPlaybackStatusChanged\n"));
       
   349 	iMtUpdaterConsole->Console().Printf(_L("2.\tTrackChanged\n"));
       
   350 	iMtUpdaterConsole->Console().Printf(_L("3.\tTrackReachedEnd\n"));
       
   351 	iMtUpdaterConsole->Console().Printf(_L("4.\tTrackReachedStart\n"));
       
   352 	iMtUpdaterConsole->Console().Printf(_L("5.\tPlaybackPositionChanged\n"));
       
   353 	iMtUpdaterConsole->Console().Printf(_L("6.\tSetBatteryStatus\n"));
       
   354 	iMtUpdaterConsole->Console().Printf(_L("8.\tAttributeChanged\n"));
       
   355 	iMtUpdaterConsole->Console().Printf(_L("9.\tNowPlayingContentChanged\n"));
       
   356 	iMtUpdaterConsole->Console().Printf(_L("0.\tUIDsChanged\n"));
       
   357 	iMtUpdaterConsole->Console().Printf(_L("\n"));
       
   358 	
       
   359 	iMtUpdaterConsole->RequestKey();
       
   360 	}
       
   361 
       
   362 TInt CTavsrcMtUpdater::BrowseKeyPressed(TAny* aPtr, TChar aKey)
       
   363 	{
       
   364 	TRAPD(err, static_cast<CTavsrcMtUpdater*>(aPtr)->BrowseKeyPressedL(aKey));
       
   365 	return err;
       
   366 	}
       
   367 
       
   368 void CTavsrcMtUpdater::BrowseKeyPressedL(TChar aKey)
       
   369 	{
       
   370 	switch(aKey)
       
   371 		{
       
   372 	case '0':
       
   373 		{
       
   374 		iMediaBrowseInterface->MrcdumlbMediaLibraryStateChange();
       
   375 		BROWSE_CONSOLE->Console().Printf(_L("UIDs changed: %d \n"), iUidCounter);
       
   376 		break;
       
   377 		}
       
   378 	default:
       
   379 		BROWSE_CONSOLE->Console().Printf(_L("No such command\n"));
       
   380 		break;
       
   381 		};
       
   382 		
       
   383 	BrowseMenu();
       
   384 	}
       
   385 	
       
   386 void CTavsrcMtUpdater::BrowseMenu()
       
   387 	{
       
   388 	BROWSE_CONSOLE->Console().Printf(_L("0.\tUIDsChanged\n"));
       
   389 	BROWSE_CONSOLE->Console().Printf(_L("\n"));
       
   390 	
       
   391 	BROWSE_CONSOLE->RequestKey();
       
   392 	}
       
   393 
       
   394 void CTavsrcMtUpdater::AddEvent(TRegisterNotificationEvent aEvent)
       
   395 	{
       
   396 	iPlayerCapabilitiesObserver->AddEvent(aEvent);
       
   397 	}
       
   398 	
       
   399 void CTavsrcMtUpdater::AddCompanyId(TInt aCompanyId)
       
   400 	{
       
   401 	// save a Company ID
       
   402 	iPlayerCapabilitiesObserver->AddCompanyId(aCompanyId);
       
   403 	}
       
   404 
       
   405 void CTavsrcMtUpdater::TrackReachedEnd()
       
   406 	{
       
   407 	iPlayerEventsObserver->TrackReachedEnd();
       
   408 	}
       
   409 	
       
   410 void CTavsrcMtUpdater::TrackReachedStart()
       
   411 	{
       
   412 	iPlayerEventsObserver->TrackReachedStart();
       
   413 	}
       
   414 	
       
   415 void CTavsrcMtUpdater::PlackbackStatusChanged(MPlayerEventsObserver::TPlaybackStatus aPlaybackStatus)
       
   416 	{ 
       
   417 	iPlayerEventsObserver->PlaybackStatusChanged(aPlaybackStatus);
       
   418 	}
       
   419 
       
   420 void CTavsrcMtUpdater::TrackChanged(TUint64 aIndex, TUint32 aLengthInMilliseconds)
       
   421 	{ 
       
   422 	iPlayerEventsObserver->TrackChanged(aIndex, aLengthInMilliseconds);
       
   423 	}
       
   424 	
       
   425 void CTavsrcMtUpdater::SetBatteryStatus(MPlayerEventsObserver::TTargetBatteryStatus aStatus)
       
   426 	{
       
   427 	iPlayerEventsObserver->SetBatteryStatus(aStatus);
       
   428 	}
       
   429 
       
   430 void CTavsrcMtUpdater::SetPlaybackPosition(TUint32 aPosition)
       
   431 	{	
       
   432 	iPlayerEventsObserver->SetPlaybackPosition(aPosition);
       
   433 	}
       
   434 	
       
   435 void CTavsrcMtUpdater::SetAsActivePlayer()
       
   436 	{
       
   437 	TInt err = RProperty::Set(TUid::Uid(KRefTspProperty), KRefTspActivePlayer, RProcess().Id());
       
   438 	iMtUpdaterConsole->Console().Printf(_L("Set as active player %d\n"), err);
       
   439 	}
       
   440 
       
   441 MPlayerEventsObserver::TPlaybackStatus CTavsrcMtUpdater::NextPlaybackStatus()
       
   442 	{
       
   443 	if(iPlaybackStatus == MPlayerEventsObserver::EStopped)
       
   444 		{
       
   445 		iPlaybackStatus = MPlayerEventsObserver::EPlaying;
       
   446 		}
       
   447 	else if(iPlaybackStatus == MPlayerEventsObserver::EPlaying)
       
   448 		{
       
   449 		iPlaybackStatus = MPlayerEventsObserver::EPaused;
       
   450 		}
       
   451 	else if(iPlaybackStatus == MPlayerEventsObserver::EPaused)
       
   452 		{
       
   453 		iPlaybackStatus = MPlayerEventsObserver::EFwdSeek;
       
   454 		}
       
   455 	else if(iPlaybackStatus == MPlayerEventsObserver::EFwdSeek)
       
   456 		{
       
   457 		iPlaybackStatus = MPlayerEventsObserver::ERevSeek;
       
   458 		}
       
   459 	else if(iPlaybackStatus == MPlayerEventsObserver::ERevSeek)
       
   460 		{
       
   461 		iPlaybackStatus = MPlayerEventsObserver::EStopped;
       
   462 		}
       
   463 		
       
   464 	return iPlaybackStatus;
       
   465 	}
       
   466 
       
   467 MPlayerEventsObserver::TTargetBatteryStatus CTavsrcMtUpdater::NextBatteryStatus()
       
   468 	{
       
   469 	if(iBatteryStatus == MPlayerEventsObserver::ENormal)
       
   470 		{
       
   471 		iBatteryStatus = MPlayerEventsObserver::EWarning;
       
   472 		}
       
   473 	else if(iBatteryStatus == MPlayerEventsObserver::EWarning)
       
   474 		{
       
   475 		iBatteryStatus = MPlayerEventsObserver::ECritical;
       
   476 		}
       
   477 	else if(iBatteryStatus == MPlayerEventsObserver::ECritical)
       
   478 		{
       
   479 		iBatteryStatus = MPlayerEventsObserver::EExternal;
       
   480 		}
       
   481 	else if(iBatteryStatus == MPlayerEventsObserver::EExternal)
       
   482 		{
       
   483 		iBatteryStatus = MPlayerEventsObserver::EFullCharge;
       
   484 		}
       
   485 	else if(iBatteryStatus == MPlayerEventsObserver::EFullCharge)
       
   486 		{
       
   487 		iBatteryStatus = MPlayerEventsObserver::ENormal;
       
   488 		}
       
   489 		
       
   490 	return iBatteryStatus;
       
   491 	}
       
   492 
       
   493 // from MPlayerApplicationSettingsNotify
       
   494 void CTavsrcMtUpdater::MpasnSetPlayerApplicationValueL(const RArray<TInt>& aAttributeID, const RArray<TInt>& aAttributeValue)
       
   495 
       
   496 	{
       
   497 	for (TInt i=0; i < aAttributeID.Count(); i++)
       
   498 		{
       
   499 		iMtUpdaterConsole->Console().Printf(_L("SetPlayerApplication attribute:%d value:%d \n"),aAttributeID[i], aAttributeValue[i]);	
       
   500 		}
       
   501 	}
       
   502 
       
   503 void CTavsrcMtUpdater::MrcdunptoPlayItem(const TRemConItemUid& aItem, TRemConFolderScope aScope)
       
   504 	{
       
   505 	iMtUpdaterConsole->Console().Printf(_L("* PlayItem 0x%08x%08x\t scope %d \n"), aItem>>32, aItem, aScope);
       
   506 	iNowPlaying->PlayItemResponse(0x11);
       
   507 	}
       
   508 
       
   509 void CTavsrcMtUpdater::MrcdunptoAddToNowPlaying(const TRemConItemUid& aItem, TRemConFolderScope aScope)
       
   510 	{
       
   511 	iMtUpdaterConsole->Console().Printf(_L("* AddToNowPlaying 0x%08x%08x\t scope %d\n"), aItem>>32, aItem, aScope);
       
   512 	iNowPlaying->AddToNowPlayingResponse(KErrNone);
       
   513 	}
       
   514 
       
   515 void CTavsrcMtUpdater::MrcdumlboGetFolderListing(TRemConFolderScope /*aScope*/, TUint aStartItem, TUint aEndItem)
       
   516 	{
       
   517 	// FIXME handle scopes
       
   518 	TInt err = KErrNone;
       
   519 
       
   520 	RArray<TRemConItem> folderListing;
       
   521 	for(TInt i = aStartItem; (i <= aEndItem) && (i < KNumberItemsInFolder) && !err; i++)
       
   522 		{
       
   523 		// FIXME handle erro
       
   524 		TRemConItem item;
       
   525 		item.iUid = static_cast<TRemConItemUid>(i) | KUidMarker;
       
   526 		item.iType = ERemConMediaItem;
       
   527 		if(i < KNumberFolderItemsInFolder)
       
   528 			{
       
   529 			item.iUid = static_cast<TRemConItemUid>(i) | KFolderMarker;
       
   530 			item.iType = ERemConFolderItem;
       
   531 			}
       
   532 		
       
   533 		err = folderListing.Append(item);
       
   534 		}
       
   535 	
       
   536 	if(!err)
       
   537 		{
       
   538 		BROWSE_CONSOLE->Console().Printf(_L("  Returning listing of %d items, current uid counter %d\n"), folderListing.Array().Count(), iUidCounter);	
       
   539 		}
       
   540 	else
       
   541 		{
       
   542 		BROWSE_CONSOLE->Console().Printf(_L("  Error %d getting folder listing"));	
       
   543 		}
       
   544 	iMediaBrowseInterface->MrcdumlbFolderListing(folderListing.Array(), err);
       
   545 
       
   546 	folderListing.Close();
       
   547 	}
       
   548 
       
   549 void CTavsrcMtUpdater::SetAttributeL(REAResponse& aAttribute, TRemConItemUid& aUid)
       
   550 	{
       
   551 	_LIT8(KTestTitle,     "Test Title 0x%08x%08x");
       
   552 	aAttribute.iCharset = KUtf8MibEnum;
       
   553 
       
   554 	switch(aAttribute.iAttributeId)
       
   555 		{
       
   556 		case ETitleOfMedia:
       
   557 			{
       
   558 			//buffer.Copy(KMediaTitle);
       
   559 			aAttribute.iString = HBufC8::NewL(29);
       
   560 			TPtr8 namePtr = aAttribute.iString->Des();
       
   561 			namePtr.AppendFormat(KTestTitle, (aUid >> 32), aUid);
       
   562 			aAttribute.iStringLen = namePtr.Length();
       
   563 			break;
       
   564 			}
       
   565 			/*
       
   566 		case ENameOfArtist:
       
   567 			buffer.Copy(KArtistName);
       
   568 			break;
       
   569 		case ENameOfAlbum:
       
   570 			buffer.Copy(KAlbumName);
       
   571 			break;
       
   572 		case ETrackNumber:
       
   573 			buffer.Copy(KTrackNumber);
       
   574 			break;
       
   575 		case ENumberOfTracks:
       
   576 			buffer.Copy(KNumberOfTracks);
       
   577 			break;
       
   578 		case EGenre:
       
   579 			buffer.Copy(KGenre);
       
   580 			break;
       
   581 		case EPlayingTime:
       
   582 			buffer.Copy(KPlayingTime);
       
   583 			break;
       
   584 			*/
       
   585 		default:
       
   586 		//	__DEBUGGER();
       
   587 			User::Leave(KErrNotFound);
       
   588 			break;
       
   589 		}
       
   590 	}
       
   591 
       
   592 void CTavsrcMtUpdater::MrcdumlboFolderUp()
       
   593 	{
       
   594 	TInt err = KErrNone;
       
   595 
       
   596 	if(!err && --iFolderDepth < 0)
       
   597 		{
       
   598 		iFolderDepth = 0;
       
   599 		err = KErrNotSupported;
       
   600 		}
       
   601 	
       
   602 	if(!err)
       
   603 		{
       
   604 		BROWSE_CONSOLE->Console().Printf(_L("* Folder Up\n"));
       
   605 		}
       
   606 	else
       
   607 		{
       
   608 		BROWSE_CONSOLE->Console().Printf(_L("  Error: %d\n"), err);
       
   609 		}
       
   610 	iMediaBrowseInterface->MrcdumlbFolderUpResult(KNumberItemsInFolder, err);
       
   611 	}
       
   612 
       
   613 void CTavsrcMtUpdater::MrcdumlboFolderDown(const TRemConItemUid& aFolder)
       
   614 	{
       
   615 	TInt err = KErrNone;
       
   616 	
       
   617 	if(!(aFolder & KFolderMarker))
       
   618 		{
       
   619 		err = KErrNotFound;
       
   620 		}
       
   621 	else if(!err && ++iFolderDepth > 10)
       
   622 		{
       
   623 		iFolderDepth = 10;
       
   624 		err = KErrNotSupported;
       
   625 		}
       
   626 	
       
   627 	if(!err)
       
   628 		{
       
   629 		BROWSE_CONSOLE->Console().Printf(_L("* Folder down %08x %08x\n"), aFolder >> 32, aFolder);
       
   630 		}
       
   631 	else
       
   632 		{
       
   633 		BROWSE_CONSOLE->Console().Printf(_L("  Error: %d\n"), err);
       
   634 		}
       
   635 	iMediaBrowseInterface->MrcdumlbFolderDownResult(KNumberItemsInFolder, err);
       
   636 	}
       
   637 
       
   638 void CTavsrcMtUpdater::MrcdumlboGetPath(RPointerArray<HBufC8>& aPath)
       
   639 	{
       
   640 	TInt err = KErrNone;
       
   641 	for(TInt i = 0; (i < iFolderDepth) && (err == KErrNone); i++)
       
   642 		{
       
   643 		HBufC8* name = HBufC8::NewL(14);
       
   644 		name->Des().AppendFormat(KFolderName, iFolderDepth);
       
   645 		err = aPath.Append(name);
       
   646 		}
       
   647 	
       
   648 	if(!err)
       
   649 		{
       
   650 		BROWSE_CONSOLE->Console().Printf(_L("* Player set as browsed: folder items = %d, uid counter = %d\n"), KNumberItemsInFolder, iUidCounter);
       
   651 		}
       
   652 	else 
       
   653 		{
       
   654 		BROWSE_CONSOLE->Console().Printf(_L("* Error %d setting as browsed player"), err);
       
   655 		}
       
   656 	iMediaBrowseInterface->MrcdumlbGetPathResult(KNumberItemsInFolder, err);
       
   657 	}
       
   658 
       
   659 void CTavsrcMtUpdater::MrcdumlboSearch(const TDesC8& /*aSearch*/)
       
   660 	{
       
   661 	BROWSE_CONSOLE->Console().Printf(_L("* Search (returning not supported)"));
       
   662 
       
   663 	iMediaBrowseInterface->MrcdumlbSearchResult(0, KErrNotSupported);
       
   664 	}
       
   665 
       
   666 void CTavsrcMtUpdater::DisplayCurrentState()
       
   667 	{
       
   668 	iMtUpdaterConsole->Console().Printf(_L("**************************************************\n"));
       
   669 	iMtUpdaterConsole->Console().Printf(_L("* CURRENT STATE\n*\n"));
       
   670 	
       
   671 	iMtUpdaterConsole->Console().Printf(_L("* Supported Events:\t"));
       
   672 	for(TInt i=0; i<iNotificationEvents.Count(); i++)
       
   673 		{
       
   674 		iMtUpdaterConsole->Console().Printf(_L("0x%.8x\t"), iNotificationEvents[i]);
       
   675 		}
       
   676 	iMtUpdaterConsole->Console().Printf(_L("\n"));
       
   677 		
       
   678 	iMtUpdaterConsole->Console().Printf(_L("* Supported Company Ids:\t"));
       
   679 	for(TInt i=0; i<iCompanyIds.Count(); i++)
       
   680 		{
       
   681 		iMtUpdaterConsole->Console().Printf(_L("0x%.8x\t"), iCompanyIds[i]);
       
   682 		}
       
   683 	iMtUpdaterConsole->Console().Printf(_L("\n"));
       
   684 	
       
   685 	iMtUpdaterConsole->Console().Printf(_L("* Playback Status: "));
       
   686 	switch(iPlaybackStatus)
       
   687 		{
       
   688 	case MPlayerEventsObserver::EStopped:
       
   689 		iMtUpdaterConsole->Console().Printf(_L("STOPPED\n"));
       
   690 		break;
       
   691 	case MPlayerEventsObserver::EPlaying:
       
   692 		iMtUpdaterConsole->Console().Printf(_L("PLAYING\n"));
       
   693 		break;
       
   694 	case MPlayerEventsObserver::EPaused:
       
   695 		iMtUpdaterConsole->Console().Printf(_L("PAUSED\n"));
       
   696 		break;
       
   697 	case MPlayerEventsObserver::EFwdSeek:
       
   698 		iMtUpdaterConsole->Console().Printf(_L("FWD_SEEK\n"));
       
   699 		break;
       
   700 	case MPlayerEventsObserver::ERevSeek:
       
   701 		iMtUpdaterConsole->Console().Printf(_L("REV_SEEK\n"));
       
   702 		break;
       
   703 	default:
       
   704 		ASSERT(EFalse);
       
   705 		break;
       
   706 		}
       
   707 	
       
   708 	iMtUpdaterConsole->Console().Printf(_L("* Position: %d\n"), iPosition);
       
   709 	iMtUpdaterConsole->Console().Printf(_L("* Length: %d\n"), iLength);
       
   710 	
       
   711 	iMtUpdaterConsole->Console().Printf(_L("* Battery Status: "), iBatteryStatus);
       
   712 	switch(iBatteryStatus)
       
   713 		{
       
   714 	case MPlayerEventsObserver::ENormal:
       
   715 		iMtUpdaterConsole->Console().Printf(_L("NORMAL \n"));
       
   716 		break;
       
   717 	case MPlayerEventsObserver::EWarning:
       
   718 		iMtUpdaterConsole->Console().Printf(_L("WARNING \n"));
       
   719 		break;
       
   720 	case MPlayerEventsObserver::ECritical:
       
   721 		iMtUpdaterConsole->Console().Printf(_L("CRITICAL \n"));
       
   722 		break;
       
   723 	case MPlayerEventsObserver::EExternal:
       
   724 		iMtUpdaterConsole->Console().Printf(_L("EXTERNAL \n"));
       
   725 		break;
       
   726 	case MPlayerEventsObserver::EFullCharge:
       
   727 		iMtUpdaterConsole->Console().Printf(_L("FULL CHARGE \n"));
       
   728 		break;
       
   729 	case MPlayerEventsObserver::EUnknown:
       
   730 		iMtUpdaterConsole->Console().Printf(_L("Unknown\n"));
       
   731 	default:
       
   732 		ASSERT(EFalse);
       
   733 		break;
       
   734 		}	
       
   735 	
       
   736 	iMtUpdaterConsole->Console().Printf(_L("**************************************************\n\n"));
       
   737 	}
       
   738 
       
   739 void CTavsrcMtUpdater::MrcdunpboGetFolderListing(TUint aStartItem, TUint aEndItem)
       
   740 	{
       
   741 	BROWSE_CONSOLE->Console().Printf(_L("* GetFolderItems NowPlaying start item %d, end item %d\n"), aStartItem, aEndItem);
       
   742 
       
   743 	TInt err = KErrNone;
       
   744 	
       
   745 	RArray<TRemConItem> folderListing;
       
   746 	for(TInt i = aStartItem; (i <= aEndItem) && (i < KNumberItemsInFolder) && !err; i++)
       
   747 		{
       
   748 		// FIXME handle erro
       
   749 		TRemConItem item;
       
   750 		item.iUid = static_cast<TRemConItemUid>(i) | KUidMarker;
       
   751 		item.iType = ERemConMediaItem;
       
   752 		err = folderListing.Append(item);
       
   753 		}
       
   754 	
       
   755 	if(!err)
       
   756 		{
       
   757 		BROWSE_CONSOLE->Console().Printf(_L("  Returning listing of %d items, current uid counter %d\n"), folderListing.Array().Count(), iUidCounter);	
       
   758 		}
       
   759 	else
       
   760 		{
       
   761 		BROWSE_CONSOLE->Console().Printf(_L("  Error %d getting folder listing"));	
       
   762 		}
       
   763 
       
   764 	iNowPlayingBrowseInterface->MrcdunpbFolderListing(folderListing.Array(), err);
       
   765 	}
       
   766 
       
   767 TInt CTavsrcMtUpdater::PrepareItemDataL(
       
   768 		TMediaAttributeIter& aIter,
       
   769 		const TRemConItemUid& aItemId,
       
   770 		HBufC8* &aItemName,
       
   771 		RArray<TMediaElementAttribute>& aItemAttributes)
       
   772 	{
       
   773 	/**
       
   774 	First, construct the name of the media item.
       
   775 	*/
       
   776     _LIT8(KMediaItemName,     "MediaItem 0x%08x%08x");	
       
   777 	_LIT8(KFolderItemName,     "FolderItem 0x%08x%08x");	
       
   778 	HBufC8* itemName = HBufC8::NewL(30);
       
   779     TPtr8 namePtr = itemName->Des();
       
   780 	TUint upper = aItemId >> 32;
       
   781 	TUint lower = aItemId & 0xffffffff;	
       
   782 	if (aItemId & KUidMarker)
       
   783 	    {
       
   784 	    namePtr.AppendFormat(KMediaItemName, upper, lower);
       
   785 	    }
       
   786 	else if(aItemId & KFolderMarker)
       
   787 		{
       
   788 		namePtr.AppendFormat(KFolderItemName, upper, lower);
       
   789 		}
       
   790 	else
       
   791 		{
       
   792 		ASSERT(NULL);
       
   793 		}
       
   794 	aItemName = itemName;
       
   795 	/**
       
   796 	Second, construct attributes of the item.
       
   797 	*/
       
   798 	_LIT8(KAttributeName, "Attibute 0x%02x");
       
   799 	TMediaElementAttribute attribute;
       
   800 	TMediaAttributeId id;
       
   801 	aIter.Start();
       
   802 	while(aIter.Next(id))
       
   803 		{
       
   804 		//API takes the ownership.
       
   805 		HBufC8* attributeName = HBufC8::NewL(30);
       
   806 		TPtr8 attributeNamePtr = attributeName->Des();
       
   807 		attributeNamePtr.AppendFormat(KAttributeName, id);
       
   808 		
       
   809 		attribute.iAttributeId = id;
       
   810 		attribute.iString = attributeName;
       
   811 		aItemAttributes.Append(attribute);
       
   812 		}
       
   813 	
       
   814 	return KErrNone;
       
   815 	}
       
   816 
       
   817 TInt CTavsrcMtUpdater::MrcdumlboGetItem(TRemConFolderScope aScope,
       
   818 				const TRemConItemUid& aItemId, 
       
   819 				TMediaAttributeIter& aIter)
       
   820 	{
       
   821 	//FIXME handle the error: uidcounter doesn't match
       
   822 	
       
   823 	TInt error = KErrNone;
       
   824 	RArray<TMediaElementAttribute> itemAttributes;
       
   825 	HBufC8* itemName;
       
   826 	if (aItemId & KUidMarker)
       
   827 		{
       
   828 		PrepareItemDataL(aIter, aItemId, itemName, itemAttributes);
       
   829 		iMediaBrowseInterface->MrcdumlbMediaElementItemResult(aItemId, 
       
   830 					*itemName, 
       
   831 					AvrcpBrowsing::KAudio,
       
   832 					itemAttributes.Array(), 
       
   833 					KErrNone);
       
   834 		}
       
   835 	else if(aItemId & KFolderMarker)
       
   836 		{
       
   837 		PrepareItemDataL(aIter, aItemId, itemName, itemAttributes);	
       
   838 		iMediaBrowseInterface->MrcdumlbFolderItemResult(aItemId, 
       
   839 					*itemName, 
       
   840 					EFolderPlaylists,
       
   841 					KFolderNotPlayable,
       
   842 					itemAttributes.Array(),
       
   843 					KErrNone);
       
   844 		}
       
   845 	else
       
   846 		{
       
   847 		error = KErrInvalidUid;
       
   848 		}
       
   849 	
       
   850 	delete itemName;
       
   851 	return error;
       
   852 	}
       
   853 
       
   854 TInt CTavsrcMtUpdater::MrcdunpboGetItem(const TRemConItemUid& aItemId, 
       
   855 			TMediaAttributeIter& aIter)
       
   856 	{
       
   857 	//FIXME handle the error: uidcounter doesn't match.
       
   858 	
       
   859 	TInt error = KErrNone;
       
   860 	RArray<TMediaElementAttribute> itemAttributes;
       
   861 	HBufC8* itemName;
       
   862 	if (aItemId & KUidMarker)
       
   863 		{
       
   864 		PrepareItemDataL(aIter, aItemId, itemName, itemAttributes);
       
   865 		iNowPlayingBrowseInterface->MrcdunpbMediaElementItemResult(aItemId, 
       
   866 					*itemName, 
       
   867 					AvrcpBrowsing::KAudio,
       
   868 					itemAttributes.Array(), 
       
   869 					KErrNone);
       
   870 		}
       
   871 	else
       
   872 		{
       
   873 		error = KErrInvalidUid;
       
   874 		}
       
   875 	
       
   876 	delete itemName;
       
   877 	return error;
       
   878 	}
       
   879 
       
   880 CStopBrowseWatcher* CStopBrowseWatcher::NewL()
       
   881 	{
       
   882 	CStopBrowseWatcher* self = new(ELeave) CStopBrowseWatcher;
       
   883 	CleanupStack::PushL(self);
       
   884 	self->ConstructL();
       
   885 	CleanupStack::Pop(self);
       
   886 	return self;
       
   887 	}
       
   888 
       
   889 CStopBrowseWatcher::CStopBrowseWatcher()
       
   890 	: CActive(EPriorityStandard)
       
   891 	{
       
   892 	CActiveScheduler::Add(this);
       
   893 	}
       
   894 
       
   895 void CStopBrowseWatcher::ConstructL()
       
   896 	{
       
   897 	User::LeaveIfError(iThread.Open(RThread().Id()));
       
   898 	}
       
   899 
       
   900 CStopBrowseWatcher::~CStopBrowseWatcher()
       
   901 	{
       
   902 	Cancel();
       
   903 	iThread.Close();
       
   904 	}
       
   905 
       
   906 void CStopBrowseWatcher::Start()
       
   907 	{
       
   908 	iStatus = KRequestPending;
       
   909 	SetActive();
       
   910 	}
       
   911 
       
   912 void CStopBrowseWatcher::Complete()
       
   913 	{
       
   914 	TRequestStatus* status = &iStatus;
       
   915 	iThread.RequestComplete(status, KErrNone);
       
   916 	}
       
   917 
       
   918 void CStopBrowseWatcher::RunL()
       
   919 	{
       
   920 	CActiveScheduler::Stop();
       
   921 	}
       
   922 
       
   923 void CStopBrowseWatcher::DoCancel()
       
   924 	{
       
   925 	TRequestStatus* status = &iStatus;
       
   926 	iThread.RequestComplete(status, KErrCancel);
       
   927 	}
       
   928 
       
   929