/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  Manages the feed related views and implements the FeedsViewBridge.

*

*/

#include <AknView.h>

#include <AknViewAppUi.h>

#include <BaUtils.h>

#include <BaDesca.h>

#include <brctlinterface.h>

#include <GulIcon.h>

#include <data_caging_path_literals.hrh>

#include <eikmenup.h>

#include <StringLoader.h>

#include <BrowserNG.rsg>

#include <brctldialogsprovider.h>

#include <browserdialogsprovider.h>

#include <brctldefs.h>

#include <internetconnectionmanager.h>

#include <FeatMgr.h>

#include <Uri16.h>

#include "Browser.hrh"

#include "BrowserAppUi.h"

#include "CommonConstants.h"

#include "BrowserWindow.h"

#include "BrowserWindowManager.h"

#include "BrowserUIVariant.hrh"

#include "Preferences.h"

#include "BrowserGotoPane.h"

#include "BrowserAdaptiveListPopup.h"

#include "FeedsFeedView.h"

#include "FeedsFolderView.h"

#include "BrowserDialogs.h"

#include "FeedsTopicView.h"

#include "BrowserUtil.h"

#include "BrowserSpecialLoadObserver.h"

#include "FeedsClientUtilities.h"

#include "BrowserBmOTABinSender.h"

// CONSTANTS

_LIT(KSupportedMimeTypes, "application/rss+xml;application/atom+xml;text/xml;application/xml");

const TInt KLastUpdateGranularity = 10;

const TInt KWmlSettingsAutomaticUpdatingNotSet = 32767;

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

// CFeedsClientUtilities::NewL

//

// Two-phased constructor.

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

//

CFeedsClientUtilities* CFeedsClientUtilities::NewL(CAknViewAppUi& aAppUI, MApiProvider& aApiProvider)

    {

    CFeedsClientUtilities* self = new (ELeave) CFeedsClientUtilities(aAppUI, aApiProvider);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CFeedsClientUtilities::CFeedsClientUtilities

//

// C++ default constructor.

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

//

CFeedsClientUtilities::CFeedsClientUtilities(CAknViewAppUi& aAppUI, MApiProvider& aApiProvider):

		iAppUI(aAppUI), iApiProvider(aApiProvider), iIsUpdatingFeed(EFalse), iWaitDialog(0),

		iEnteredURL(0), iFolderView(0), iTopicView(0), iFeedView(0), 

        iIsConnected(EFalse), iItemIds(20), iItemStatus(20), iMimeTypes(0),

        iFeedUpdateTimeIds(KLastUpdateGranularity), iFeedUpdateTimeTimestamps(KLastUpdateGranularity),

        iPendingFolderItemTitle(NULL), iPendingFolderItemUrl(NULL), iExportFileName(NULL),

	    iSearchAgent(NULL),

    	iSearchOptList(NULL),

    	iFeedImportRequested(EFalse),

    	iRequestCanceled(EFalse),

        iIsWaitDialogDisplayed(EFalse), 

        iFeedsInterface(*this,0),

        iCanceledRequest(CTransaction::ENone)

	{

	}

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

// CFeedsClientUtilities::ConstructL

//

// Symbian 2nd phase constructor can leave.

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

//

void CFeedsClientUtilities::ConstructL()

    {

	iApiProvider.Preferences().AddObserverL( this );

	// Set up MimeTypes

	iMimeTypes = HBufC::NewL( KSupportedMimeTypes().Length() + 1 );

    TPtr ptr( iMimeTypes->Des() );

    ptr.Append( KSupportedMimeTypes() );

    ptr.ZeroTerminate();

    iWaitDialog = CFeedsWaitDialog::NewL(*this);

    }

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

// CFolderItem::Search

//

// Searches for a FolderItem with the given name.  If "this"

// isn't a folder it only checks whether or not it matches

// the given name.  If "this" is a folder it also checks 

// all embedded items.

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

//

const CFeedsEntity* CFeedsClientUtilities::Search(const TDesC& aName,const CFeedsEntity& aFolder) const

    {

    TPtrC title;

    if (aFolder.GetType() == EFolder)

        {

        aFolder.GetStringValue(EFolderAttributeTitle,title);	

        }

    else

        {

        aFolder.GetStringValue(EFeedAttributeTitle,title);	

        }

    if (aName.CompareF(title) == 0)

        {

    	return &aFolder;

        }

    if (aFolder.GetType() == EFolder)

        {

    	for(TInt i=0;i<aFolder.GetChildren().Count();i++)

    	    {

    		const CFeedsEntity *item;

    		CFeedsEntity *child = aFolder.GetChildren()[i];

    		if((item = Search(aName,*child)) != NULL)

    		    {

    			return item;

    		    }

    	    }

        }

    // Otherwise no match was found.

    return NULL;

    }

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

// CFolderItem::Search

//

// Searches for a FolderItem with the given id.  If "this"

// isn't a folder it only checks whether or not it matches

// the given id.  If "this" is a folder it also checks 

// all embedded items.

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

//

const CFeedsEntity* CFeedsClientUtilities::Search(TInt aFolderItemId,const CFeedsEntity& aFolder) const

    {

    if (aFolderItemId == aFolder.GetId())

        {

    	return &aFolder;

        }

    if (aFolder.GetType() == EFolder)

        {

    	for(TInt i=0;i<aFolder.GetChildren().Count();i++)

    	    {

    		const CFeedsEntity *item;

    		CFeedsEntity *child = aFolder.GetChildren()[i];

    		if ((item = Search(aFolderItemId,*child)) != NULL)

    		    {

    			return item;

    		    }

    	    }

        }

    // Otherwise no match was found.

    return NULL;

    }

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

// CFeedsClientUtilities::~CFeedsClientUtilities

//

// Deconstructor.

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

//

CFeedsClientUtilities::~CFeedsClientUtilities()

    {

    DisconnectFromServer();

    iApiProvider.Preferences().RemoveObserver( this );

    delete iWaitDialog;   

    delete iMimeTypes;

    iFeedUpdateTimeIds.Close();

    iFeedUpdateTimeTimestamps.Close(); 

    delete iPendingFolderItemTitle;

    delete iPendingFolderItemUrl;

    delete iExportFileName;

    delete iEnteredURL;

    delete iSearchAgent;

    iItemIds.Close();

    iItemStatus.Close();

    iItemStatusOrig.Close();    

    }

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

// CFeedsClientUtilities::RequestCompleted()

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

//

void CFeedsClientUtilities::RequestCompleted(CTransaction* aTrans,TInt /*aEvent*/)

{

TInt status = aTrans->GetStatusCode();

switch (aTrans->Type())

    {

    	case CTransaction::EFetchRootFolderItem:

   	        FolderItemRequestCompleted(status, CTransaction::EFetchRootFolderItem);

    	    break;

    	case CTransaction::EWatchForChanges:

    	    break;

    	case CTransaction::EExportOPML:

    	case CTransaction::EImportOPML:

    	    FolderItemRequestCompleted(status, aTrans->Type());

    	    break;

        case CTransaction::EAddFolderItem:

        case CTransaction::EDeleteFolderItem:

        case CTransaction::EChangeFolderItem:

        case CTransaction::EMoveFolderItem:

        case CTransaction::EMoveFolderItemTo:

        case CTransaction::EUpdateFolderItem:

    	    FolderItemRequestCompleted(status, aTrans->Type());

    	    break;

        case CTransaction::EChangeSettings:

            break;

    	case CTransaction::EFetchFeed:

   	        FeedRequestCompleted(status);

    	    break;

    	case CTransaction::EUpdateItemStatus:

            break;

        default:

            FolderItemRequestCompleted(status, aTrans->Type());

            break;

    }

}

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

// CFeedsClientUtilities::NetworkConnectionNeededL()

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

//

void CFeedsClientUtilities::NetworkConnectionNeededL(

        TInt* aConnectionPtr, TInt& aSockSvrHandle,

        TBool& aNewConn, TApBearerType& aBearerType )

    {

    iApiProvider.SpecialLoadObserver().NetworkConnectionNeededL(

        aConnectionPtr, &aSockSvrHandle, &aNewConn, &aBearerType );

     //Wait dialog is shown only in the case of a new connection.

     if ( aNewConn )

         {

         iWaitDialog->ShowWaitDialogL(R_FEEDS_UPDATING_FEED);

         iIsWaitDialogDisplayed = ETrue;

         }

    }

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

// CFeedsClientUtilities::HandlePreferencesChangeL()

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

//

void CFeedsClientUtilities::HandlePreferencesChangeL(

        const TPreferencesEvent aEvent,

        TPreferencesValues& aValues,

        TBrCtlDefs::TBrCtlSettings aSettingType )

    {

    // no specific TBrCtlDefs::TBrCtlSettings are defined for FeedsSettings

    // so we trigger for an Unknown setting

    if(   (EPreferencesItemChange == aEvent || EPreferencesDeactivate == aEvent)  &&

          (TBrCtlDefs::ESettingsUnknown == aSettingType ) )

        {

        SetPreferencesToFeedL( aValues );

        }

    }

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

// CFeedsClientUtilities::SetPreferencesToFeedL()

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

//

void CFeedsClientUtilities::SetPreferencesToFeedL( const TPreferencesValues& aValues )

    {

    if ( iIsWaitDialogDisplayed )

        {

    	return;

        }    

    TFeedsServerSetting setting;

    // always set to 32767 in the case of feed level auto updating.

    //setting.iAutoUpdate = KWmlSettingsAutomaticUpdatingNotSet;

    setting.iAutoUpdate = EFalse;

    setting.iAutoUpdateFreq = KWmlSettingsAutomaticUpdatingNotSet;

  setting.iAutoUpdateWhileRoaming = aValues.iAutomaticUpdatingWhileRoaming;

    TUint32 autoUpdatingAP( 0 );

#ifndef __WINSCW__

    if (aValues.iAutomaticUpdatingAP != KWmlNoDefaultAccessPoint)

        {

        autoUpdatingAP = Util::IapIdFromWapIdL( iApiProvider, aValues.iAutomaticUpdatingAP );

        }

#endif //__WINSCW__

	setting.iAutoUpdateAP = autoUpdatingAP;

    SetFeedsServerSettingsL( setting );

    }

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

// CFeedsClientUtilities::DisconnectManualUpdateConnectionL()

//

// Disconnect connection provided by client for manual update.

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

//

void CFeedsClientUtilities::DisconnectManualUpdateConnectionL()

    {

    if ( iIsConnected )

        {

        // Ensure that the connection is available.

        ConnectToServerL(EFalse);

        // Pass the updated settings to the server.

        iFeedsInterface.DisconnectManualUpdateConnectionL();

        }

    }

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

// CFeedsClientUtilities::DisconnectFeedsViewL()

//

// Disconnect connection used by FeedsView.

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

//

void CFeedsClientUtilities::DisconnectFeedsViewL()

    {

    if( iFeedView )

        {

        iFeedView->DisconnectL();

        }

    }

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

// CFeedsClientUtilities::LoadUrlL()

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

//

void CFeedsClientUtilities::LoadUrlL( const TDesC& aUrl )

    {

    if( iApiProvider.IsPageLoaded() &&

		iApiProvider.Preferences().UiLocalFeatureSupported( KBrowserMultipleWindows ) &&

    	!iApiProvider.Preferences().UiLocalFeatureSupported( KBrowserMinimalMultipleWindows ))

	    {	    

	    // there is already a window, so create a new one if not over the max number of windows allowed

	    if(iApiProvider.WindowMgr().WindowCount() == iApiProvider.WindowMgr().MaxWindowCount())

	    	{

	    	// Show warning to user

            TBrowserDialogs::ErrorNoteL( R_BROWSER_NOTE_MAX_WINDOWS );

		  	return;

	    	}

	    if(iApiProvider.WindowMgr().WindowCount() < iApiProvider.WindowMgr().MaxWindowCount())

	    	{

		    CBrowserWindow *win = iApiProvider.WindowMgr().CreateWindowL( 0, &KNullDesC );

		    if (win != NULL)

    		    {

    		    CleanupStack::PushL( win );

    		    iApiProvider.WindowMgr().SwitchWindowL( win->WindowId() );

    		    CleanupStack::Pop();  // win		        

    		    }

	    	}

	    }

	iApiProvider.WindowMgr().CurrentWindow()->SetHasFeedsContent(ETrue);

	iApiProvider.FetchL( aUrl );

    }

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

// CFeedsClientUtilities::ShowFolderViewL

//

// Shows the folder view, loading the folder list from the FeedsServer if need be.

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

//

void CFeedsClientUtilities::ShowFolderViewL(TUid aCalledFromView /*= KUidBrowserBookmarksViewId*/)

    {

    if ( iIsWaitDialogDisplayed )

        {

    	return;

        }

   	// Record the view from which feeds was launched.

   	// If this function is not called with an argument,

   	// its default value "KUidBrowserBookmarksViewId" is used.

   	// This is specified in the header FeedsClientUtilities.h 

   	SetCalledFromView(aCalledFromView);    	 

    // Ensure that "this" is ready for uses.

    LazyInitL(EFalse);

    // Show wait dialog.

    iWaitDialog->ShowWaitDialogL(R_FEEDS_OPENING_FEED);

    iIsWaitDialogDisplayed = ETrue;

    // Set the view to show once the folder is ready.

    iNextViewId = KUidBrowserFeedsFolderViewId;

    iIsUpdatingFeed = EFalse;   

    // Get the root folder.

    FetchRootFolderL();

    iCurrentRequest = CTransaction::EFetchRootFolderItem;

    }

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

// CFeedsClientUtilities::ShowTopicViewL

//

// Shows the topic view, loading the given feed associated with the given folder item.

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

//

void CFeedsClientUtilities::ShowTopicViewL(const CFeedsEntity& aFolderItem)

    {

    TTime timestamp;

    if ( iIsWaitDialogDisplayed )

        {

    	return;

        }    

    // Ensure that "this" is ready for uses.

    LazyInitL(EFalse);

    // Show wait dialog.

    timestamp = aFolderItem.GetTimeValue(EFeedAttributeTimestamp,timestamp);

    if ( timestamp.Int64() == 0 )

        {

    	if ( iApiProvider.Connection().Connected() )

        	{

    		iWaitDialog->ShowWaitDialogL(R_FEEDS_UPDATING_FEED);

        	}

        }

    else

        {

    	iWaitDialog->ShowWaitDialogL(R_FEEDS_OPENING_FEED);

        }

    iIsWaitDialogDisplayed = ETrue;   

    // Set the view to show once the feed is ready.

    iNextViewId = KUidBrowserFeedsTopicViewId;

    iIsUpdatingFeed = EFalse;

    // Fetch the feed.

    FetchFeedL(aFolderItem);

    iCurrentRequest = CTransaction::EFetchFeed;

    }

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

// CFeedsClientUtilities::SupportedMimeTypesL

//

// Returns the feed related mime-types supported by the bridge.  This makes 

// for a clean way to pass downloaded feeds content from the client to the FeedsServer 

// (via CFeedsClientUtilities::HandleFeedL).

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

//

TPtrC CFeedsClientUtilities::SupportedMimeTypesL()

    {

    return iMimeTypes->Des();

    }

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

// CFeedsClientUtilities::SubscribeToL

//

// Shows the folder view and subscribes to the given feed.

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

//

void CFeedsClientUtilities::SubscribeToL(const TDesC& aTitle, const TDesC& aUrl)

    {  

   	SetCalledFromView(KUidBrowserContentViewId); 

    // If the root folder is available then Add the feed.

    if (iFeedsInterface.RootFolder() != NULL)

        {        

        // Ensure that "this" is ready for uses.  

        LazyInitL( EFalse );

		CFeedsMap* temp = CFeedsMap::NewL();

		temp->SetStringAttribute(EFeedAttributeTitle,aTitle);

        temp->SetStringAttribute(EFeedAttributeLink,aUrl);

        temp->SetIntegerAttribute(EFeedAttributeAutoUpdateFreq,0);

        // Set the next view to show after the new add folder item is added.

        iNextViewId = KUidBrowserFeedsFolderViewId; 

        iFeedsInterface.AddL(EFeed,*temp, *(iFeedsInterface.RootFolder()));

		delete temp;

        // Ensure the Folder View shows the root-folder when AddFolderItemL completes.

        iFolderView->SetCurrentFolder(*(iFeedsInterface.RootFolder()), ETrue);

        }

    // Otherwise queue the folder item until the root folder is fetched (see above).