1 /*

     2 * Copyright (c) 2009 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:

    15 *

    16 */

    17 

    18 /* ---------------------------------------------------------------------------

    19 *  Version history:

    20 *  Template version:

    21 *  <ccm_history>

    22 *

    23 *  Version: 2, Tue Feb 28 18:00:00 2008 by Rohit/Kranthi

    24 *  Ref:

    25 *  Added Workaround in CIRUi::ConstructL() to force display of IAP list.

    26 *  MIRCtrlCmdObserver::MCtrlCommand() function signature changed (Merged IRv1.0 Engine code changes)

    27 *

    28 *  </ccm_history>

    29 * ============================================================================

    30 */

    31 

    32 /* ---------------------------------------------------------------------------

    33 *  Version history:

    34 *  Template version:

    35 *  <ccm_history>

    36 *

    37 *  Version: 3, Tue Mar 19 18:00:00 2008 by Rohit

    38 *  Ref:

    39 *  Implemented change request to display Byte Counter in KB till 0.1 MB, and in MB threrafter

    40 *

    41 *  </ccm_history>

    42 * ============================================================================

    43 */

    44 #include "internetradioconfigurationflags.hrh"

    45 #include <akniconarray.h>

    46 #include <aknkeylock.h>

    47 #include <aknlayout2scalabledef.h>

    48 #include <aknlayoutfont.h>

    49 #include <aknnavi.h>

    50 #include <aknnavide.h>

    51 #include <akntitle.h>

    52 #include <aknvolumecontrol.h>

    53 #include <alf/alfdisplay.h>

    54 #include <alf/alfenv.h>

    55 #include <apgcli.h>

    56 #include <apgtask.h>

    57 #include <bautils.h>

    58 #include <featmgr.h>

    59 #include <features.hrh>

    60 #include <hlplch.h>

    61 #include <pstransaction.h>

    62 #include <stringloader.h>

    63 #include <uriutils.h>

    64 #include <aknutils.h>

    65 #include <internetradio.rsg>

    66 #include <commdb.h>

    67 #include <commsdattypesv1_1.h>

    68 #include <data_caging_path_literals.hrh>

    69 #include <hwrmpowerstatesdkpskeys.h>

    70 #include <aknwaitdialog.h>

    71 #include <ctsydomainpskeys.h>

    72 #include <utf.h>

    73 #include <proengfactory.h>

    74 #include <mproengnotifyhandler.h>

    75 /* no need to change to lower case  */

    76 #include <MProEngNotifyHandler.h>

    77 #include <profileenginesdkcrkeys.h>

    78 

    79 //For IAD

    80 #include <publicruntimeids.hrh>

    81 #ifdef FF_IAUPDATE

    82 #include <iaupdate.h>

    83 #include <iaupdateparameters.h>

    84 #include <iaupdateresult.h>

    85 #endif

    86 

    87 

    88 

    89 #include "ircommon.h"

    90 #include "irui.h"

    91 #include "irnowplayingview.h"

    92 #include "ir.hrh"

    93 #include "irmainview.h"

    94 #include "irmaincontainer.h"

    95 

    96 #include "irautomatedbitrateselection.h"

    97 #include "iralarmobserver.h"

    98 //#include "irmessageobserver.h"

    99 #include "ircommon.h"

   100 #include "irctrlcmdobserver.h"

   101 #include "irdataproviderconstants.h"

   102 #include "irdebug.h"

   103 #include "irdocument.h"

   104 #include "irfavoritesdb.h"

   105 #include "irhistory.h"

   106 #include "iriconloader.h"

   107 #include "irisdspreset.h"

   108 #include "irmediaclient.h"

   109 #include "irmetadata.h"

   110 #include "irnetworkcontroller.h"

   111 #include "irnwinfoobserver.h"

   112 #include "irpubsub.h"

   113 #include "irsessionlogger.h"

   114 #include "irsettings.h"

   115 #include "irstreamsource.h"

   116 #include "irstreamsourceerrors.h"

   117 #include "irui.h"

   118 #include "isdsclientdll.h"

   119 #include "irbrowsechannelitems.h"

   120 #include "irbrowsecatagoryitems.h"

   121 #include <internetradio.mbg>

   122 #include "irhistorylistview.h"

   123 #include "irsearchresultsview.h"

   124 #include "irIsdsWrapper.h"

   125 #include "irviewstack.h"

   126 #include "irstationdirectoryview.h"

   127 #include "irstationinformationdata.h"

   128 #include "ircategoryview.h"

   129 #include "irstationsview.h"

   130 #include "irtopstationsview.h"

   131 #include "irplsplaylist.h"

   132 #include "irplsplaylistitem.h"

   133 #include  "irplsview.h"

   134 #include "irfirsttimeview.h"

   135 #include "iraddmanuallystationview.h"

   136 #include "irsystemeventcollector.h" //For system events

   137 #include "irnowplayingwrapper.h"

   138 #include "ircostwarningview.h"

   139 #include "irstationinfoview.h"

   140 #include "irdatatransferobserver.h"

   141 #include "irdataprovider.h"

   142 #include "irhttpdataprovider.h"

   143 #include "irlogodownloadengine.h"

   144 #include "iriconloader.h"

   145 #include "irapplication.h"

   146 #include <remconcoreapitarget.h>

   147 #include <remconinterfaceselector.h>

   148 

   149 

   150 #ifdef FF_IAUPDATE

   151 _LIT( KIRParamExec, "InternetRadio.exe" );

   152 #endif

   153 

   154 #ifdef __IRA_FEATURE_BACKSTEPPING_SERVICE

   155 #include "irbacksteppingservicewrapper.h"

   156 #endif

   157 

   158 const TInt KFour = 4;

   159 

   160 //static variable declaration

   161 TInt CIRUi::iFindInMusicStoreCount = 0;

   162 

   163 

   164 //Added by Snigdha for HomeScreen

   165 _LIT8( KIRCommandLineActionHandler, "-a" );

   166 _LIT8( KIRCommandLineActionHandlerCommandStartNowPlayingView, "startnowplaying" );

   167 const TChar KIRCommandLineOptionPrefix = '-';

   168 

   169 // ---------------------------------------------------------------------------

   170 // CIRUi::ConstructL(const TRect& aRect)

   171 // Second phase constructor

   172 // ---------------------------------------------------------------------------

   173 //

   174 void CIRUi::ConstructL()

   175 	{

   176 	IRLOG_INFO( "CIRUi::ConstructL - Entering" );

   177 	CIRApplication *app = static_cast<CIRApplication*>(Document()->Application());

   178 	if(app->GetInstanceFlag())

   179 		{

   180     	BaseConstructL(ENoAppResourceFile);

   181     	return;

   182 		}

   183 	BaseConstructL(EAknEnableSkin);

   184 	UpdateLandscapeInformation();

   185 	iProfileId=DetermineCurrentProfile();

   186 	iSystemEventCollector = CIRSystemEventCollector::NewL();

   187 	iSystemEventCollector->AddObserverL( this );

   188 

   189 	iIRSettings =CIRSettings::OpenL();

   190     iSecondInstanceFlag = EFalse;

   191 	UpdateSubscriberIdL();

   192 

   193 	User::LeaveIfError(iFsSession.Connect());

   194 	//Instantiate NowPlaying View

   195 	iAlfEnv = CAlfEnv::NewL();

   196 	// Switch the layout to flat so that Alf will use right layout on Now playing view

   197     StatusPane()->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT );

   198 	TRect layoutRect;

   199 	AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, layoutRect );

   200 	CAlfDisplay& disp = iAlfEnv->NewDisplayL( layoutRect, CAlfEnv::ENewDisplayAsCoeControl );

   201 	disp.SetClearBackgroundL( CAlfDisplay::EClearWithSkinBackground );

   202 

   203 	//Whether The Station is Editiable or not

   204 	iIsEditStation = EFalse;

   205 	//Index of the Preset to Edit

   206 	iEditStationIndex = 0;

   207 

   208 	TParse parse;

   209 	parse.Set( KMIFFILE, &KDC_APP_RESOURCE_DIR, NULL );

   210 	iMifFilePath = parse.FullName();

   211 	CompleteWithAppPath( iMifFilePath );

   212 

   213 	//Create the instance of iconprovider

   214 	iIconProvider = CIconFileProvider::NewL(iMifFilePath);

   215 

   216 

   217 	// Network Controller Component

   218 	iNetworkController = CIRNetworkController::OpenL(this);

   219 	iNetworkController->DataTransferTracker().SetObserver( this );

   220     iIsOffline=iNetworkController->IsOfflineMode();

   221 	// Timer for Network indicator animation

   222 	iNetworkIndicatorTimer = CPeriodic::NewL(CPeriodic::EPriorityStandard);

   223 

   224 	iDialogLauncher = CIRDialogLauncher::NewL();

   225 

   226 	iFavPresets=CIRFavoritesDb::NewL();

   227 

   228 	iIsdsWrapper = CIRIsdsWrapper::NewL(*iIRSettings,*iFavPresets);

   229 	iNowPlayingWrapper = CIRNowPlayingWrapper::NewL(*this,*iIRSettings,*iIsdsWrapper);

   230  	RAknKeyLock keylock;

   231     User::LeaveIfError( keylock.Connect() );

   232     if ( keylock.IsKeyLockEnabled() )

   233         {

   234         BringToForeground();

   235         }

   236     keylock.Close();

   237 	// Display access points only if user has accepted Terms & Conditions

   238 /*	if( iIRSettings->IsFlagTermsAndConditionsL() )

   239 		{

   240 		iNetworkController->ChooseAccessPointL();

   241 		}

   242 */

   243 	//playing is terminated by call

   244 	iPlayTerminated = EFalse;

   245 	//checks whether call is active or not

   246 	iCallActive = EFalse;

   247 

   248 	//Call observer

   249 

   250 

   251 	// Create Channel list view

   252 	iLastPlayed = CIRLastPlayedStationInfo::NewL();

   253 	iMainView = CIRMainView::NewL();

   254 	AddViewL( iMainView );

   255 

   256 #ifdef __IRA_FEATURE_BACKSTEPPING_SERVICE

   257     // Create Back Stepping Service wrapper.

   258     iBsWrapper = CIRBackSteppingServiceWrapper::NewL( TUid::Uid( KUIDIRAPP ) );

   259 #endif

   260 

   261 	// Check whether phone is in low memory

   262 	TBool bIgnore = CheckAndNotifyLowDiskSpaceL();

   263 

   264 	iNowPlayingView = CIRNowPlayingView::NewL( *iAlfEnv );

   265 	AddViewL( iNowPlayingView );

   266 	//Instantiate AlarmObserver

   267 	iAlarmObserver = CIRAlarmObserver::NewL(this);

   268 	iAlarmObserver->Start();

   269 //	iMessageObserver = CIRMessageObserver::NewL(this);

   270 	if( iCallActive )

   271 		{

   272 		IRLOG_WARNING( "CIRUi::ConstructL - Call active during start up " );

   273 		}

   274 

   275 	//Create SearchResults View

   276 	iSearchResultsView = CIRSearchResultsView::NewL();

   277 	AddViewL( iSearchResultsView );

   278 

   279 	//Instantiate PublishSubscribe class

   280 	iPubSubManager = CIRPubSub::NewL();

   281 	iPubSubManager->PublishApplicationRunningStateL(EIRPSApplicationRunning);

   282 

   283 	// Create history list view

   284 	iHistoryListView = CIRHistoryListView::NewL();

   285 	AddViewL( iHistoryListView );

   286 

   287 

   288 	// Create Station Directory View

   289 	iStationdirView = CIRStationDirectoryView::NewL();

   290 	AddViewL( iStationdirView );

   291 

   292 	// Create Category View

   293 	iCategoryView = CIRCategoryView::NewL();

   294 	AddViewL( iCategoryView );

   295 

   296 	// Create Stations View

   297 	iStationsView = CIRStationsView::NewL();

   298 	AddViewL( iStationsView );

   299 

   300 	// Create TopStations View

   301 	iTopStationsView = CIRTopStationsView::NewL();

   302 	AddViewL( iTopStationsView );

   303 

   304 	iViewStack = CIRViewStack::NewL();

   305 

   306 	//Create First Time View

   307 	iFirstTimeView = CIRFirstTimeView::NewL();

   308 	AddViewL(iFirstTimeView);

   309 

   310 	//Create Add Manually View

   311 	iIRAddManually = CIRAddManuallyStationView::NewL( ApplicationRect() );

   312 	AddViewL(iIRAddManually);

   313 

   314 	// Create Settings view

   315 	CIRSettingsView* iSettingsView = CIRSettingsView::NewL();

   316 	AddViewL( iSettingsView );

   317 

   318 	//Plsveiw enabled flag set to False by default.

   319 	iPlsactivated = EFalse;

   320 

   321 	if (!iIRSettings->IsFlagTermsAndConditionsL() ||!iIRSettings->IsFlagCostWarningL())

   322 		{

   323 		iCostWarningView = CIRCostWarningView::NewL(ApplicationRect());

   324 		AddViewL( iCostWarningView );

   325 		SetDefaultViewL(*iCostWarningView);

   326 		}

   327 	else

   328 		{

   329 		if(iStartUpInNowPlayingView)

   330 			{

   331 		    //iViewStack->PushL(KIRMainChoiceViewID)

   332 			SetDefaultViewL(*iNowPlayingView);

   333 			iStartUpInNowPlayingView = EFalse;

   334 			}

   335 		else

   336 			{

   337 			if (IsFirstTime() && (!IsFlagIfAnyFavL()))

   338 				{

   339 				SetDefaultViewL(*iFirstTimeView);

   340 				}

   341 			else

   342 				{

   343 				SetDefaultViewL( *iMainView );

   344 				}

   345 			}

   346 		}

   347 

   348 	// Create Station Info view

   349 	iStationInfoView = CIRStationInfoView::NewL( ApplicationRect() );

   350 	AddViewL( iStationInfoView );

   351 

   352 	//call is answered

   353 	iCallConnected = EFalse;

   354 

   355 	iNwObserver = CIRNwInfoObserver::NewL(this);

   356 

   357 	//getting current thread's id

   358 	RThread thread;

   359 	iCurrentThreadID = thread.Id();

   360 	//Handle Background and foreground of the views.

   361 	iCoeEnv->AddForegroundObserverL(*this);

   362 	// Subscriber for bitrate value

   363 	iBitrateSubscriber = CIRPropertyObserver::NewL(*this,

   364 	KUidActiveInternetRadioApp,KIRPSBitrate,RProperty::EInt);

   365 

   366 	// Subscriber for Simultaneous play handling

   367 	iMultiplePlayHandler = CIRPropertyObserver::NewL(*this,

   368 	KUidActiveInternetRadioApp,KIRPSMultiplePlay,RProperty::EInt);

   369 	iMultiplePlayHandler->Subscribe();

   370 

   371 	//Storing the view to be actiavted when in Background.

   372 	iActivationPending = KNullUid;

   373 

   374 	//Set only when going to backgroung when keypad lock.

   375 	iBgWhenLock = EFalse;

   376 

   377 	//For nowplaying view

   378 ///*************testing*****************************

   379 

   380 	iSelector=CRemConInterfaceSelector::NewL();

   381 	iTarget = CRemConCoreApiTarget::NewL( *iSelector, *this );

   382 	iSelector->OpenTargetL();

   383 	iIsDisconnected = EFalse;

   384 	//****************offlineProfile***************//

   385 

   386 	iNotifyHandler = ProEngFactory::NewNotifyHandlerL();

   387     User::LeaveIfError( iNotifyHandler->

   388        RequestProfileActivationNotificationsL( *this ));

   389 

   390 	/**

   391      * Initialize feature manager, for IAD

   392      */

   393     IRRDEBUG2("CIRUi::ConstructL - Initializing FeatureManager Lib", KNullDesC);

   394     FeatureManager::InitializeLibL();

   395     iFeatureManagerInitialized = ETrue;

   396     IRRDEBUG2("CIRUi::ConstructL - Initialed FeatureManager Lib", KNullDesC);

   397 	IRRDEBUG2("CIRUi::ConstructL - Checking feature KFeatureIdIAUpdate", KNullDesC);

   398 #ifdef FF_IAUPDATE

   399     if (FeatureManager::FeatureSupported( KFeatureIdIAUpdate))

   400 		{

   401 		IRRDEBUG2("CIRUi::ConstructL - KFeatureIdIAUpdate Supporting", KNullDesC);

   402 		iUpdate = CIAUpdate::NewL(*this);

   403 		IRRDEBUG2("CIRUi::ConstructL  - CIAUpdate NewL", KNullDesC);

   404 

   405        	iParameters = CIAUpdateParameters::NewL();

   406         IRRDEBUG2("CIRUi::ConstructL  - CIAUpdateParameters::NewL()", KNullDesC);

   407 

   408         // Use SIS package UID

   409         iParameters->SetUid( TUid::Uid( KUIDIRAPP) );

   410         IRRDEBUG2("CIRUi::ConstructL  - Setting Package Uid", KNullDesC);

   411 

   412         /**

   413          * We want InternetRadio.exe to be started after update is finished

   414          */

   415         iParameters->SetCommandLineExecutableL( KIRParamExec );

   416         IRRDEBUG2("CIRUi::ConstructL - Setting CommandLineExecutableL", KNullDesC);

   417 

   418         iUpdate->CheckUpdates(*iParameters );

   419         IRRDEBUG2("CIRUi::ConstructL  - After CheckUpdates", KNullDesC);

   420 

   421         }

   422 #endif // FF_IAUPDATE

   423 

   424 

   425 		iControlEventObserver = CIRControlEventObserver::

   426     	NewL( *this, KUidActiveInternetRadioApp, KIRPSControlSetPlayState ,

   427     	RProperty::EInt);

   428 

   429     	iControlEventObserver->SecondConstructL();

   430 	IRLOG_DEBUG( "CIRUi::ConstructL - Exiting." );

   431 	}

   432 

   433 // ---------------------------------------------------------------------------

   434 // Returns pointer to the view stack.

   435 // ---------------------------------------------------------------------------

   436 //

   437 CIRViewStack& CIRUi::ViewStack()

   438     {

   439     IRLOG_INFO( "CIRUi::ViewStack" );

   440     return *iViewStack;

   441     }

   442 // ---------------------------------------------------------------------------

   443 // CIRUi::ForwardBackCommandToBSWrapperL

   444 // ---------------------------------------------------------------------------

   445 //

   446 TBool CIRUi::ForwardBackCommandToBsWrapperL()

   447 	{

   448 	IRLOG_DEBUG( "CIRUi::ForwardBackCommandToBsWrapperL - Entering" );

   449 	TBool retVal( EFalse ); // By default BS Service doesn't handle back command

   450 

   451 #ifdef __IRA_FEATURE_BACKSTEPPING_SERVICE

   452 	// Get active view UID.

   453 	TVwsViewId activeViewId; // Contains both view UID and app UID

   454 	GetActiveViewId( activeViewId );

   455 

   456 	// Let Back Stepping Service handle the event.

   457 	retVal = iBsWrapper->HandleBackCommandL( activeViewId );

   458 #endif

   459 	IRLOG_DEBUG( "CIRUi::ForwardBackCommandToBsWrapperL - Exiting" );

   460 	return retVal;

   461 	}

   462 

   463 

   464 // ---------------------------------------------------------------------------

   465 // CIRUi::ActiveView

   466 // ---------------------------------------------------------------------------

   467 //

   468 TUid CIRUi::ActiveView() const

   469     {

   470     IRLOG_INFO( "CIRUi::ActiveView" );

   471     return iView ? iView->Id() : KNullUid;

   472     }

   473 

   474 

   475 // ---------------------------------------------------------------------------

   476 // CIRUi::CIRUi()

   477 // Default constructor

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

   479 //

   480 CIRUi::CIRUi()

   481 	{

   482 	IRLOG_DEBUG( "CIRUi::CIRUi - Entering" );

   483 	iIndex = 0;

   484 	iSelect = ETrue;

   485 	iCount = 0;

   486 	iCurrentPresetId = 0;

   487 	iSelectedBrowsingCategory = KErrNotFound;

   488 	iFeatureManagerInitialized = EFalse;

   489 	iMainViewLaunch = EFalse ;

   490 	iDialogLauncher = NULL;

   491 	iStartUpInNowPlayingView = EFalse;

   492 	IRLOG_DEBUG( "CIRUi::CIRUi - Exiting" );

   493 	}

   494 

   495 // ---------------------------------------------------------------------------

   496 // CIRUi::~CIRUi()

   497 // Destructor

   498 // ---------------------------------------------------------------------------

   499 //

   500 CIRUi::~CIRUi()

   501 	{

   502 	IRLOG_INFO( "CIRUi::~CIRUi - Entering" );

   503 

   504 	iStationsViewTitleString.Close();

   505 	if(iSystemEventCollector)

   506 		{

   507 		iSystemEventCollector->RemoveObserver( this );

   508 		delete iSystemEventCollector; iSystemEventCollector=NULL;

   509 		}

   510 	//singleton deletion

   511 	if ( iIRSettings )

   512 		{

   513 		iIRSettings->Close();

   514 		}

   515 

   516 #ifdef __IRA_FEATURE_BACKSTEPPING_SERVICE

   517         // Back Stepping FW is used, delete wrapper.

   518         delete iBsWrapper;

   519 #endif

   520 

   521 	delete iViewStack;

   522 	delete iIconProvider;

   523 	iFsSession.Close();

   524 	delete iAlarmObserver;

   525 //	delete iMessageObserver;

   526 	delete iAlfEnv;

   527 	if(iIsdsWrapper)

   528 		{

   529 		delete iIsdsWrapper;

   530 		iIsdsWrapper = NULL;

   531 		}

   532 	iPlsLength.Close();

   533 	if(iLastPlayed)

   534 		{

   535 		delete iLastPlayed;

   536 		iLastPlayed = NULL;

   537 		}

   538 	if(iNowPlayingWrapper)

   539 		{

   540 		delete iNowPlayingWrapper;

   541 		iNowPlayingWrapper = NULL;

   542 		}

   543 	delete iFavPresets;

   544 	delete iSettingsView;

   545 	delete iNwObserver;

   546 	delete iPubSubManager;

   547 

   548 	if (iNetworkController)

   549 		{

   550 		iNetworkController->Close();

   551 		//iNetworkController = NULL

   552 		}

   553 	// Cancel the network indicator timer

   554 	if( iNetworkIndicatorTimer )

   555 		{

   556 		if( iNetworkIndicatorTimer->IsActive() )

   557 			{

   558 			iNetworkIndicatorTimer->Cancel();

   559 			}

   560 		delete iNetworkIndicatorTimer;

   561 		}

   562 	delete iBitrateSubscriber;

   563 	delete iMultiplePlayHandler;

   564 

   565 	iURLs.ResetAndDestroy();

   566 	iURLs.Close();

   567 	iIsPresetSaved.Close();

   568 	iPlsPresetSaved.Close();

   569 	delete iSelector;

   570 

   571 #ifdef FF_IAUPDATE

   572 	delete iUpdate;

   573     delete iParameters;

   574 #endif

   575 

   576     if ( iFeatureManagerInitialized )

   577     	{

   578         /**

   579          *  We can safely call UnInitializeLib as we have really intialized it

   580          */

   581         FeatureManager::UnInitializeLib();  // Decreases ref.count

   582         }

   583 delete iNotifyHandler;

   584 

   585 	if( iDialogLauncher )

   586 		{

   587 		delete iDialogLauncher;

   588 		iDialogLauncher = NULL;

   589 		}

   590 

   591 	if(iControlEventObserver)

   592 		{

   593 		delete iControlEventObserver;

   594 		iControlEventObserver = NULL;

   595 		}

   596 

   597 	IRLOG_DEBUG( "CIRUi::~CIRUi - Exiting" );

   598 	}

   599 

   600 // ---------------------------------------------------------------------------

   601 // CIRUi::HandleCommandL(TInt aCommand)

   602 // Command handling function

   603 // ---------------------------------------------------------------------------

   604 //

   605 void CIRUi::HandleCommandL(TInt aCommand)

   606 	{

   607 	IRLOG_INFO2( "CIRUi::HandleCommandL (%d) ", aCommand );

   608 	switch(aCommand)

   609 		{

   610 		case EIRDelayedPlayStation:

   611 			{

   612 			if ( !CheckAndNotifyLowDiskSpaceL() )

   613 				{

   614 				iNowPlayingWrapper->DoPlayL();

   615 				}

   616 			}

   617 		break;

   618 		// Activate the AddStationManually View

   619 		case EAddStationManuallyCmd:

   620 			{

   621 			if ( !CheckAndNotifyLowDiskSpaceL() )

   622 				{

   623 				if ( IsForeground() || iBgWhenLock)

   624 					{

   625 					ActivateLocalViewL(KIRAddManuallyStationViewID);

   626 					iActivationPending = KNullUid ;

   627 					}

   628 				else

   629 					{

   630 					iActivationPending = KIRAddManuallyStationViewID;

   631 					}

   632 				}

   633 		}

   634 		break;

   635 		//Go to now playing view

   636 		case EGotoNowPlayingViewCmd:

   637 			{

   638 			if( ( iNowPlayingView ) && ( !iNowPlayingView->HasBeenActivated() ) )

   639 				{

   640 	    		// For the case that NP view is force-activated,

   641 	    		// but nothing should actually be played yet.

   642 	    	    *iNowPlayingWrapper->iNowPlayingPreset = *iLastPlayed->iLastPlayedStation;

   643 				}

   644 			if(iHistory)

   645 				{

   646 					ActivateLocalViewL( KIRNowPlayingViewID,

   647 					KHistoryLaunch,KIRNowPlayingViewCustomMessagePlayAfterActivation);

   648 

   649 				}

   650 			else if(iMainViewLaunch)

   651 				{

   652 				    _LIT8(KNull,"");

   653 					ActivateLocalViewL( KIRNowPlayingViewID,KNowPlayingFrmMainView,KNull);

   654 					iMainViewLaunch = EFalse ;

   655 

   656 				}

   657 			else

   658 			{

   659 			if ( IsForeground() || iBgWhenLock )

   660 					{

   661 					ActivateLocalViewL(KIRNowPlayingViewID);

   662 					iActivationPending = KNullUid ;

   663 					}

   664 				else

   665 					{

   666 					iActivationPending = KIRNowPlayingViewID;

   667 			}

   668 				}

   669 			}

   670 			break;

   671 		//violates PC lint  Warning 616

   672 		case EEikCmdExit:

   673 		case EExitCmd:  //lint -fallthrough

   674 		case EIRExit:

   675 		case EAknSoftkeyExit:

   676 			{

   677 			//This API is not there in 3.0

   678 			//Removing all the local item definitions set using setlocalitemdefL()

   679 			#ifndef __SERIES60_30__

   680 			AknsUtils::SkinInstance()->RemoveLocalItemDefs();

   681 			#endif

   682 			//needed only for 3.2

   683 			//part of active idle

   684 			#ifdef __SERIES60_32__

   685 			if ( iPubSubManager )

   686 				{

   687 				iPubSubManager->PublishApplicationRunningStateL

   688 				(EIRPSApplicationClosing);

   689 				}

   690 			#endif

   691 			if(iNowPlayingWrapper)

   692 			{

   693 			if( iNowPlayingWrapper->GetSessionStartState() )

   694 				{

   695 				TTerminationStatus terminationstatus = EUserTerminated;

   696 				iNowPlayingWrapper->GetReportGeneratorInstance()->UpdateTerminatedBy(terminationstatus);

   697 				iNowPlayingWrapper->GetReportGeneratorInstance()->SessionEndL(EFalse);

   698 				iNowPlayingWrapper->SetSessionStartState(EFalse);

   699 				}

   700 				}

   701 			Exit();

   702 			}

   703 		break;

   704 		default:

   705 			{

   706 			//No implementation

   707 			}

   708 		break;

   709 		}

   710 	IRLOG_DEBUG( "CIRUi::HandleCommandL - Exiting" );

   711 	}

   712 

   713 

   714 // ---------------------------------------------------------------------------

   715 // CIRUi::IRHandleCommandL().

   716 // Command handling function

   717 // Saves currently selected index from the listbox

   718 // ---------------------------------------------------------------------------

   719 //

   720 void CIRUi::IRHandleCommandL(TInt aIndex,TInt aCommand)

   721 	{

   722 	IRLOG_INFO3( "CIRUi::IRHandleCommandL (aIndex=%d, aCommand=%d)", aIndex, aCommand );

   723 	//Save the currently selected index from the listbox

   724 	iIndex = aIndex;

   725 	HandleCommandL(aCommand);

   726 	IRLOG_DEBUG( "CIRUi::IRHandleCommandL - Exiting" );

   727 	}

   728 

   729 // ---------------------------------------------------------------------------

   730 // CIRUi::SavePrevIDL(..).

   731 // Saves the previous View's Id

   732 // ---------------------------------------------------------------------------

   733 //

   734 void CIRUi::SavePrevIDL(const TUid& aPrevID,TInt aCommand)

   735 	{

   736 	IRLOG_DEBUG( "CIRUi::SavePrevIDL - Entering" );

   737 	//Save the previous view iD of NowPlaying View

   738 	iNPPrevViewId = aPrevID;

   739 	HandleCommandL(aCommand);

   740 	IRLOG_DEBUG( "CIRUi::SavePrevIDL - Exiting." );

   741 	}

   742 

   743 // ---------------------------------------------------------------------------

   744 // CIRUi::HandleStatusPaneSizeChange().

   745 // Handles resource changes, called by UI framework

   746 // ---------------------------------------------------------------------------

   747 //

   748 void CIRUi::HandleStatusPaneSizeChange()

   749 	{

   750 	IRLOG_INFO( "CIRUi::HandleStatusPaneSizeChange" );

   751 

   752 	}

   753 

   754 // ---------------------------------------------------------------------------

   755 // CIRUi::HandleKeyEventL().

   756 // Handles key events.

   757 // ---------------------------------------------------------------------------

   758 //

   759 TKeyResponse CIRUi::HandleKeyEventL(const TKeyEvent& /*aKeyEvent*/

   760 	,TEventCode /*aType*/)

   761  	{

   762  	IRLOG_DEBUG( "CIRUi::HandleKeyEventL" );

   763 	return EKeyWasNotConsumed;

   764  	}

   765 

   766 

   767 // ---------------------------------------------------------------------------

   768 // CIRUi::GetMifFilePath().

   769 // Returns the full path of mif file.

   770 // ---------------------------------------------------------------------------

   771 //

   772 TFileName CIRUi::GetMifFilePath() const

   773 	{

   774     IRLOG_DEBUG( "CIRUi::GetMifFilePath" );

   775     return iMifFilePath;

   776 	}

   777 

   778 // ---------------------------------------------------------------------------

   779 // CIRUi::GetPrivatePath().

   780 // Returns the full path of mif file. .

   781 // ---------------------------------------------------------------------------

   782 //

   783 TFileName CIRUi::GetPrivatePath() const

   784 	{

   785 	IRLOG_DEBUG( "CIRUi::GetPrivatePath" );

   786     return iIRSettings->PrivatePath();

   787 	}

   788 

   789 

   790 

   791 // ---------------------------------------------------------------------------

   792 // CIRUi::OpenFileL().

   793 // Open the file using Document's instance

   794 // ---------------------------------------------------------------------------

   795 //

   796 void CIRUi::OpenFileL(const TDesC& aFileName)

   797 	{

   798 	IRLOG_DEBUG( "CIRUi::OpenFileL - Entering" );

   799 	// File changed. Open new file with documents OpenFileL method.

   800 	iSecondInstanceFlag=ETrue;

   801 	CIRDocument* doc = static_cast<CIRDocument*> (Document());

   802 	doc->OpenFileL( ETrue, aFileName, iEikonEnv->FsSession() );

   803 	IRLOG_DEBUG( "CIRUi::OpenFileL - Exiting" );

   804 	}

   805 

   806 // ---------------------------------------------------------------------------

   807 // CIRUi::IsEmbedded().

   808 // ---------------------------------------------------------------------------

   809 //

   810 TBool CIRUi::IsEmbedded() const

   811     {

   812     IRLOG_DEBUG( "CIRUi::IsEmbedded" );

   813     return iEikonEnv->StartedAsServerApp();

   814     }

   815 

   816 

   817 // ---------------------------------------------------------------------------

   818 // CIRUi::UpdateCurrentNetwork

   819 // Updates the current network status

   820 // ---------------------------------------------------------------------------

   821 //

   822 void CIRUi::UpdateCurrentNetwork(const TDesC& aCurrentNetworkMCC

   823 	,const TDesC& aCurrentNetworkMNC)

   824 	{

   825 	IRLOG_INFO3( "CIRUi::UpdateCurrentNetwork (MCC=%S, MNC=%S)", &aCurrentNetworkMCC, &aCurrentNetworkMNC );

   826 	#ifdef __WINS__

   827 	iCurrentNetwork.Copy(aCurrentNetworkMCC);

   828 	iCurrentNetwork.Append(aCurrentNetworkMNC);

   829 	iCurrentOperator = 0;

   830 	#else

   831 	//updates the current network MCC+MNC

   832 	iCurrentNetwork.Copy(aCurrentNetworkMCC);

   833 	iCurrentNetwork.Append(aCurrentNetworkMNC);

   834 	TLex currentnetwork(iCurrentNetwork);

   835 	TInt error = currentnetwork.Val(iCurrentOperator);

   836 	if(error)

   837 		{

   838 		IRLOG_ERROR2( "CIRUi::UpdateCurrentNetwork - extracting operator value failed (error=%d)", error );

   839 		iCurrentOperator = 0;

   840 		}

   841 	#endif

   842 	iNowPlayingWrapper->GetReportGeneratorInstance()->UpdateCurrentBrowseNetwork(iCurrentOperator);

   843 	IRLOG_DEBUG( "CIRUi::UpdateCurrentNetwork - Exiting." );

   844 	}

   845 

   846 // ---------------------------------------------------------------------------

   847 // CIRUi::UpdateHomeNetwork

   848 // Updates the home network status

   849 // ---------------------------------------------------------------------------

   850 //

   851 void CIRUi::UpdateHomeNetwork(const TDesC& aCurrentNetworkMCC,

   852 	const TDesC& aCurrentNetworkMNC)

   853 	{

   854 	IRLOG_INFO3( "CIRUi::UpdateHomeNetwork (MCC=%S, MNC=%S)", &aCurrentNetworkMCC, &aCurrentNetworkMNC );

   855 	#ifdef __WINS__

   856 	iHomeNetwork.Copy(aCurrentNetworkMCC);

   857 	iHomeNetwork.Append(aCurrentNetworkMNC);

   858 	iHomeOperator = 0;

   859 	#else

   860 	//updates the home network MCC+MNC

   861 	iHomeNetwork.Copy(aCurrentNetworkMCC);

   862 	iHomeNetwork.Append(aCurrentNetworkMNC);

   863 	TLex currentnetwork(iHomeNetwork);

   864 	TInt error = currentnetwork.Val(iHomeOperator);

   865 	if(error)

   866 		{

   867 		IRLOG_ERROR2( "CIRUi::UpdateHomeNetwork - extracting operator value failed (error=%d)", error );

   868 		iHomeOperator = 0;

   869 		}

   870 

   871 	#endif

   872 	IRLOG_DEBUG( "CIRUi::UpdateHomeNetwork - Exiting." );

   873 	}

   874 

   875 // ---------------------------------------------------------------------------

   876 // CIRUi::SetCurrentNetworkType(..)

   877 // Sets the Current Network Type

   878 // ---------------------------------------------------------------------------

   879 //

   880 void CIRUi::SetCurrentNetworkType()

   881 	{

   882 	IRLOG_DEBUG( "CIRUi::SetCurrentNetworkType - Entering" );

   883 	switch(iNetworkController->IdentifyConnectionType())

   884 		{

   885 		case EGprs://GPRS

   886 			{

   887 			iConnectionType.Copy(KGprs);

   888 			//start monitoring network for operator change

   889 			iNwObserver->IRStartNwMonitor();

   890 			}

   891 		break;

   892 

   893 		case EEdge: // Edge

   894 			{

   895 			iConnectionType.Copy(KEdge);

   896 			//start monitoring network for operator change

   897 			iNwObserver->IRStartNwMonitor();

   898 			}

   899 		break;

   900 		case EWcdma:

   901 		case ECdma2000:

   902 			{

   903 			iConnectionType.Copy(K3G);

   904 			//start monitoring network for operator change

   905 			iNwObserver->IRStartNwMonitor();

   906 			}

   907 		break;

   908 

   909 		case EWiFi:

   910 			{

   911 			iConnectionType.Copy(KWiFi);

   912 			//start monitoring network for operator change

   913 			iNwObserver->IRStartNwMonitor();

   914 			}

   915 		break;

   916 		}

   917 	iNowPlayingWrapper->GetReportGeneratorInstance()->UpdateConnectionType(iConnectionType);

   918 	IRLOG_DEBUG( "CIRUi::SetCurrentNetworkType - Exiting." );

   919 	}

   920 

   921 // ---------------------------------------------------------------------------

   922 // CIRUi::GetCurrentNetworkType(..)

   923 // Returns the Current Network Type

   924 // ---------------------------------------------------------------------------

   925 //

   926 TDesC& CIRUi::GetCurrentNetworkType()

   927 {

   928 IRLOG_DEBUG( "CIRUi::GetCurrentNetworkType - Entering" );

   929 IRLOG_DEBUG( "CIRUi::GetCurrentNetworkType - Exiting." );

   930 return iConnectionType;

   931 }

   932 // CIRUi::MrccatoCommand()

   933 // This is call back function which observes hardware key events

   934 // ---------------------------------------------------------------------------

   935 //

   936 void CIRUi::MrccatoCommand(TRemConCoreApiOperationId aOperationId,

   937 	TRemConCoreApiButtonAction aButtonAct)

   938 	{

   939 	IRLOG_INFO3( "CIRUi::MrccatoCommand(aOperationId=%d, aButtonAct=%d)", aOperationId, aButtonAct );

   940 

   941 	IRLOG_DEBUG2("CIRUi::MrccatoCommand - MrccatoCommand()",

   942 	KNullDesC );

   943 	switch( aOperationId )

   944 		{

   945 

   946 		case ERemConCoreApiVolumeUp:   // -fall through

   947 		case ERemConCoreApiVolumeDown:

   948 			{

   949 			if(iNowPlayingWrapper->iPlaying ||iView->Id() == KIRNowPlayingViewID )

   950 				{

   951 				//volume is increased or reduced

   952 				if ( (ERemConCoreApiVolumeUp == aOperationId )|| (aOperationId == ERemConCoreApiVolumeDown))

   953 					{

   954 

   955 					TRAPD(err,iNowPlayingView->HandleMediaKeysL(aOperationId,aButtonAct);)

   956 					if(err!=KErrNone)

   957 						{

   958 						return;

   959 						}

   960 					}

   961 				}

   962 			}

   963 		break;

   964 		case ERemConCoreApiStop:

   965 			{

   966 			if(iNowPlayingView)

   967 				{

   968 				iNowPlayingView->MrccatoCommand(ERemConCoreApiStop,aButtonAct);

   969 				}

   970 			}

   971 		break;

   972 

   973 		default:

   974 		if (iNowPlayingView )

   975 			{

   976 			iNowPlayingView->MrccatoCommand( aOperationId, aButtonAct );

   977 			}

   978 		break;

   979 

   980 		}

   981 	IRLOG_DEBUG( "CIRUi::MrccatoCommand - Exiting." );

   982 	}

   983 

   984 // ---------------------------------------------------------

   985 // CIRUi::MrccatoPlay()

   986 // ---------------------------------------------------------

   987 //

   988 void CIRUi::MrccatoPlay(TRemConCoreApiPlaybackSpeed aSpeed, TRemConCoreApiButtonAction aButtonAct)

   989     {

   990     IRLOG_INFO3( "CIRUi::MrccatoPlay(aSpeed=%d, aButtonAct=%d)", aSpeed, aButtonAct );

   991 

   992     if( iView->Id() != KIRCostWarningViewId )

   993         {

   994         if(iNowPlayingView )

   995             {

   996             iNowPlayingView->MrccatoPlay( aSpeed, aButtonAct );

   997             }

   998         }

   999 

  1000     IRLOG_DEBUG( "CIRUi::MrccatoPlay - Exiting." );

  1001     }

  1002 

  1003 

  1004 // ---------------------------------------------------------------------------

  1005 // CIRUi::IsCallActive()

  1006 // Function returns whether the call is active or not

  1007 // ---------------------------------------------------------------------------

  1008 //

  1009 TBool CIRUi::IsCallActive()

  1010 	{

  1011 	IRLOG_DEBUG( "CIRUi::IsCallActive" );

  1012 	//returns whether call is active or not

  1013 	return iCallActive;

  1014 	}

  1015 

  1016 //-----------------------------------------------------------------------------

  1017 // GetWrapperInstance()

  1018 // Returns the instance of the IsdsWrapper class

  1019 //-----------------------------------------------------------------------------

  1020 CIRIsdsWrapper* CIRUi::GetWrapperInstance()

  1021 	{

  1022 	IRLOG_DEBUG( "CIRUi::GetWrapperInstance" );

  1023 	return iIsdsWrapper;

  1024 	}

  1025 

  1026 //-----------------------------------------------------------------------------

  1027 // GetNowPlayingWrapperInstance()

  1028 // Returns the instance of the NowPlayingWrapper class

  1029 //-----------------------------------------------------------------------------

  1030 CIRNowPlayingWrapper* CIRUi::GetNowPlayingWrapperInstance()

  1031 	{

  1032 	IRLOG_DEBUG( "CIRUi::GetNowPlayingWrapperInstance" );

  1033 	return iNowPlayingWrapper;

  1034 	}

  1035 // ---------------------------------------------------------------------------

  1036 // CIRUi::GetSystemEventCollector()

  1037 // returns the iSystemEventCollector

  1038 // ---------------------------------------------------------------------------

  1039 //

  1040 CIRSystemEventCollector& CIRUi::SystemEventCollector()

  1041     {

  1042     IRLOG_DEBUG( "CIRUi::SystemEventCollector" );

  1043     return *iSystemEventCollector;

  1044     }

  1045 

  1046 // ---------------------------------------------------------------------------

  1047 // CIRUi::IRNetworkEventL()

  1048 // network connection events

  1049 // ---------------------------------------------------------------------------

  1050 //

  1051 void CIRUi::IRNetworkEventL(TIRNetworkEvent aEvent)

  1052 	{

  1053 	IRLOG_INFO2("CIRUi::IRNetworkEventL( aEvent=%d)", aEvent );

  1054     IRRDEBUG2("CIRUi::IRNetworkEventL - Entering(aEvent=%d)", aEvent );

  1055 	switch(aEvent)

  1056 		{

  1057 		case ENetworkConnectionConnecting:

  1058 		    {

  1059 			// This value indicates the network icon blink duration

  1060 		    const TInt KNetworkIndicatorAnimation = 500000;

  1061 			// This value indicates the network icon blink duration

  1062             TTimeIntervalMicroSeconds32 interval(KNetworkIndicatorAnimation);

  1063             // Cancel the network indicator timer

  1064             iNetworkIndicatorTimer->Cancel();

  1065             // Start the network animation timer

  1066             iNetworkIndicatorTimer->Start(interval,interval,TCallBack(

  1067 			CIRUi::NetworkAnimationTimerExpired,this));

  1068 		    }

  1069 		    break;

  1070 

  1071 		case ENetworkConnectionEstablished:

  1072 			{

  1073             iNetworkIndicatorTimer->Cancel();

  1074             iIsDisconnected = EFalse;

  1075 			SetCurrentNetworkType();

  1076 			iIsdsWrapper->GetISDSInstance()->IRGetIRIDL();

  1077 			iNetworkController->NotifyActiveNetworkObserversL(ENetworkConnectionEstablished);

  1078 			}

  1079 		break;

  1080 

  1081 		case ENetworkConnectionDisconnected:

  1082 			{

  1083 			IRRDEBUG2("IRNetworkEventL Network DisConnected",KNullDesC);

  1084 

  1085 			//network got disconnected

  1086 				iNetworkIndicatorTimer->Cancel();

  1087 				//connection status is reset in network controller

  1088 				iNetworkController->ResetConnectionStatus();

  1089 	            if ( iIsdsWrapper->GetISDSInstance() )

  1090 	                {

  1091 	                if(iIsdsWrapper->GetListenRequest()||(iNowPlayingWrapper->iSyncPreset))

  1092 				  		{

  1093 						iNowPlayingWrapper->DestroyWaitDialogL();

  1094 				  		}

  1095 	                iIsdsWrapper->DestroyWaitDialogL();

  1096            			iIsdsWrapper->GetISDSInstance()->IRISDSCancelRequest();

  1097 	 			    iIsdsWrapper->GetISDSInstance()->ReleaseResources();

  1098 	                }

  1099             	if(iNowPlayingWrapper->iPlaying && (!iNowPlayingWrapper->IsProgress()))

  1100 					{

  1101 					iNowPlayingWrapper->StopNow();

  1102 					}

  1103 				else

  1104 					{

  1105 			        if(iNowPlayingWrapper->GetConnectToServerState() && !iNowPlayingWrapper->IsProgress())

  1106 						{

  1107 						iNowPlayingWrapper->CancelNetworkRequestL();

  1108 						iNowPlayingWrapper->DestroyWaitDialogL();

  1109 						}

  1110 					//player is stopped

  1111 					if( iNowPlayingWrapper->IsProgress() )

  1112 						{

  1113 						//if in progress bar view, progress bar is cancelled

  1114 						iNowPlayingWrapper->ProgressBarCancel();

  1115 						iNowPlayingWrapper->DestroyWaitDialogL();

  1116 						}

  1117 					}

  1118 

  1119 				iIsDisconnected = ETrue;

  1120 				}

  1121 

  1122 

  1123 		break;

  1124 

  1125 		case EDisplayNetworkMessageNoConnectivity:

  1126 			{

  1127 			if(iNowPlayingView->iContainer && iNowPlayingView->GetRequestPendingForNextOrPreV())

  1128 				{

  1129 				 	iNowPlayingView->SetRockerIndex(

  1130 					iNowPlayingView->GetPreviousIndex());

  1131 				}

  1132 			//display a message on no network connectivity

  1133 			DisplayErrorNoteL(R_IRAPP_NW_NOCONN_ERROR);

  1134 			iIsDisconnected = ETrue;