/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  ?Description

*

*/

#include <aknglobalnote.h>

#include <apgwgnam.h>

#include <hal.h>

#include <internetradio.rsg>

#include <stringloader.h>

#include <coeaui.h>

#include "ir.hrh"

#include "irdebug.h"

#include "irdocument.h"

#include "irui.h"

#include "irpubsubkeys.h"

// At least 3 MB of free RAM is needed to run the application.

const TInt KIRMinimumRAMNeeded = 3145728;

// 5 seconds inverval for memory check timer.

const TTimeIntervalMicroSeconds32 KIRMemCheckTimerInterval = 5000000;

const TInt KBufMaxSize = 255;

_LIT( KIRPlsFile, "c:\\private\\2000b499\\tempplsfile.pls" );

// ----------------------------------------------------------------------------

// CIRDocument::NewL(CEikApplication& aApp).

// returns an instance of CIRDocument.

// ----------------------------------------------------------------------------

//      

CIRDocument* CIRDocument::NewL(CEikApplication& aApp)

    {

    IRLOG_INFO( "CIRDocument::NewL - Entering" );    

    CIRDocument* self = new (ELeave) CIRDocument(aApp);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    IRLOG_DEBUG( "CIRDocument::NewL - Exiting" );    

    return self;

    }

// ----------------------------------------------------------------------------

// CIRDocument::ConstructL().

// ----------------------------------------------------------------------------

//  

void CIRDocument::ConstructL()

    {

    IRLOG_DEBUG( "CIRDocument::ConstructL - Entering" );  

	iMemCheckTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iMemCheckTimer->Start(0, KIRMemCheckTimerInterval, 

        TCallBack( CIRDocument::MemCheckTimerCallback, this ) );

    IRLOG_DEBUG( "CIRDocument::ConstructL - Exiting" );

    }    

// ----------------------------------------------------------------------------

// CIRDocument::CIRDocument(CEikApplication& aApp).

// ----------------------------------------------------------------------------

//

CIRDocument::CIRDocument(CEikApplication& aApp) : CAknDocument(aApp) 

    {

    IRLOG_DEBUG( "CIRDocument::CIRDocument" );

    }

CIRDocument::~CIRDocument()

    {

    IRLOG_DEBUG( "CIRDocument::~CIRDocument - Entering" );

    delete iMemCheckTimer;

    IRLOG_DEBUG( "CIRDocument::~CIRDocument - Exiting" );

    }

// ----------------------------------------------------------------------------

// CIRDocument::CreateAppUiL().

// Create the application user interface, and return a pointer to it,the 

// framework takes ownership of this object 

// ----------------------------------------------------------------------------

// 

CEikAppUi* CIRDocument::CreateAppUiL()

    {

    IRLOG_DEBUG( "CIRDocument::CreateAppUiL - Entering" );

    iAppUi = new (ELeave) CIRUi;

    IRLOG_DEBUG( "CIRDocument::CreateAppUiL - Exiting" );

    return iAppUi;

    }

TInt CIRDocument::MemCheckTimerCallback(TAny* /*aSelf*/)

    {

    IRLOG_DEBUG("CIRDocument::MemCheckTimerCallback(TAny*) - Entering");

    TInt val(0);

    TInt err = HAL::Get(HALData::EMemoryRAMFree, val);

    if ( err || (val < KIRMinimumRAMNeeded) )

        {

        TRAP_IGNORE(

            HBufC* errorText = StringLoader::LoadLC( R_IRAPP_MEMLO_RAM_OUT_OF_MEM );

            CAknGlobalNote* note = CAknGlobalNote::NewLC();

            note->ShowNoteL( EAknGlobalErrorNote, *errorText );

            CleanupStack::PopAndDestroy( note );

            CleanupStack::PopAndDestroy( errorText ) )

        User::Exit( KErrNoMemory );

        }

    IRLOG_DEBUG("CIRDocument::MemCheckTimerCallback(TAny*) - Exiting");

    return KErrNone;

    }

// ----------------------------------------------------------------------------

// CIRDocument::OpenFileL( TBool aDoOpen, const TDesC& aFilename, RFs& aFs )

// ----------------------------------------------------------------------------

//

CFileStore* CIRDocument::OpenFileL( TBool /*aDoOpen*/, const TDesC& aFilename, RFs& /*aFs*/ )

    {

    IRLOG_DEBUG("CIRDocument::OpenFileL(TBool, const TDesC&, RFs&)");

    _LIT(KPlsExtension, ".pls");

    CIRUi *appui = static_cast<CIRUi *> (iAppUi);

	TParse parse;

	parse.Set(aFilename,NULL,NULL);

	TPtrC ext=parse.Ext(); // extract the extension from the filename  

	CEikonEnv* env = CEikonEnv::Static();      

	RFs& fs = env->FsSession();

	RFile plsFile;

	TInt status=plsFile.Open(fs, aFilename, EFileShareReadersOnly);

	if(status)

		{

	    OpenFileL( ETrue, aFilename, fs );

		return NULL;	

		}

	CleanupClosePushL(plsFile);

	CFileStore* fileStore;

	fileStore = NULL; //So the other OpenFileL version is not called

	if (ext.CompareF(KPlsExtension)==0) 

		{

		appui->ParsePlsDataL(fileStore,plsFile);	

		}

	CleanupStack::PopAndDestroy( &plsFile );

	//Deleting the local copy of the pls file

	fs.Delete( KIRPlsFile );	

	return NULL;

    }

// ----------------------------------------------------------------------------

// CIRDocument::OpenFileL(CFileStore*& aFileStore, RFile& aFile)

// ----------------------------------------------------------------------------

//

void CIRDocument::OpenFileL(CFileStore*& aFileStore, RFile& aFile)

    {

	IRLOG_DEBUG("CIRDocument::OpenFileL(CFileStore*&, RFile&) - Entering");

	CIRUi *appui = static_cast<CIRUi *> (iAppUi);

	aFileStore = NULL;  //So the other OpenFileL version is not called

	TBuf16<KBufMaxSize> aName;

	aFile.FullName(aName);

	CEikonEnv* env = CEikonEnv::Static();

	TApaTaskList taskList( env->WsSession() );

	// Find handler application by its UID

	RWsSession& ws = env->WsSession();

	const TInt myWgId = env->RootWin().Identifier();

	TInt wgId = 0;

	TUid uid(KUidActiveInternetRadioApp);

	// Look for another instance of this app

	while (wgId >= 0)

		{

		if (wgId && wgId != myWgId)

			{

			TApaTask FirstInstance(ws);

			TApaTask SecondInstance(ws);

			FirstInstance.SetWgId(wgId);

			SecondInstance.SetWgId(myWgId);

			SecondInstance.EndTask();  

		    //To copy the contents of .PLS file into local PLS file 

		    TInt fileSize;

		    User::LeaveIfError( aFile.Size( fileSize ) );

			HBufC8* plsData = HBufC8::NewLC( fileSize );

			TPtr8 pData8( plsData->Des() );

			User::LeaveIfError( aFile.Read( pData8 ) );

			RFile plsFile;

			RFs& fs = env->FsSession();

			TInt ret=plsFile.Open(fs, KIRPlsFile, EFileShareReadersOrWriters);

			if(ret==KErrNotFound)

				{

				TInt status=plsFile.Create(fs, KIRPlsFile, EFileShareReadersOrWriters);

				}

            plsFile.Write(pData8);

			TBuf16<KBufMaxSize> plsName;

			plsFile.FullName(plsName);

            CleanupStack::PopAndDestroy( plsData );

			User::LeaveIfError( FirstInstance.SwitchOpenFile( plsName ) );

			return;

			}

		CApaWindowGroupName::FindByAppUid(uid, ws, wgId);

		}

	_LIT(KPlsExtension, ".pls");

	TParse parse;

	parse.Set(aName,NULL,NULL);

	TPtrC ext=parse.Ext(); // extract the extension from the filename

	if (ext.CompareF(KPlsExtension)==0) 

		{

		appui->ParsePlsDataL(aFileStore,aFile);	

		}

	IRLOG_DEBUG("CIRDocument::OpenFileL - Exiting."); 

    }

// ---------------------------------------------------------------------------

// From CEikDocument; Hide the application from the tasklist

// ---------------------------------------------------------------------------

//    

void CIRDocument::UpdateTaskNameL( CApaWindowGroupName* aWgName )

    {

    IRLOG_INFO("CIRDocument::UpdateTaskNameL - Hiding InternetRadio from grid - Entering");

    CAknDocument::UpdateTaskNameL( aWgName );

#ifndef __DISABLE_RADIO_LAUNCHER

    aWgName->SetHidden( EFalse );

    IRLOG_DEBUG("CIRDocument::UpdateTaskNameL - Exiting."); 

#endif

    }