/*

* Copyright (c) 2009 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 <hbapplication.h>

#include <hbview.h>

#include <hbmenu.h>

#include <hbaction.h>

#include <hbtoolbar.h>

#include <hbstyleloader.h>

#include <QtDebug>

#include <Qt>

#include <qstringlist.h>

#include <qmessagebox.h>

#include <glxmediamodel.h>

#include <glxviewsfactory.h>

#include <glxviewids.h>

#include <glxview.h>

#include <glxgridview.h>

#include <glxmodelparm.h>

#include <glxaiwservicehandler.h>

#include <glxcollectionpluginall.hrh>

#include <glxcollectionpluginimageviewer.hrh>

#include <xqserviceutil.h>

#include <glxstatemanager.h>

#include <glximageviewermanager.h>

#include <glxexternalutility.h>

#include "glxlocalisationstrings.h"

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

// GlxAiwServiceHandler()

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

//

GlxAiwServiceHandler::GlxAiwServiceHandler() :

    HbMainWindow(), mModel(NULL), mView(NULL), mService(NULL),

            mStateMgr(NULL),mFSView(NULL),mFetcherContextMenu(NULL)

    {

    mService = new GlxGetImageService(this);

    mImageViewerService = new GlxImageViewerService(this);

#ifdef _DEBUG

	QString t;

	QStringList args = QApplication::arguments();

    foreach (QString arg, args)

        {

        t += "GlxAiwServiceHandler::cmdline arg=" + arg + "\n";

        }

	qDebug()<< t;

#endif

    }

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

// ~GlxAiwServiceHandler()

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

//

GlxAiwServiceHandler::~GlxAiwServiceHandler()

    {

    HbStyleLoader::unregisterFilePath(":/data/photos.css");

    if (mView)

        {

        removeView(mView);

        }

    delete mView;

	delete mFSView;

    delete mModel;

    delete mService;

    }

void GlxAiwServiceHandler::handleClientDisconnect()

    {

    // Just quit application

    qApp->quit();

    }

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

// itemSelected()

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

//

void GlxAiwServiceHandler::itemSelected(const QModelIndex & index)

    {

    qDebug() << "GlxFetcher::itemSelected";

    if (mService->isActive())

        {

        qDebug() << "GlxFetcher::itemSelected :: SERVICE ACTIVE";

        QVariant variant = mModel->data(index, GlxUriRole);

        if (variant.isValid())

            {

            QString itemPath = variant.value<QString> ();

            qDebug() << "GlxFetcher::itemSelected :: VALID URI -->" << itemPath;

            QStringList list = (QStringList() << itemPath);

            mService->complete(list);

            }

        }

    }	

void GlxAiwServiceHandler::launchFetcher()

    {

    HbStyleLoader::registerFilePath(":/data/photos.css");

    GlxModelParm modelParm(KGlxCollectionPluginAllImplementationUid, 0);

    mModel = new GlxMediaModel(modelParm);

    if ( this->orientation() == Qt::Horizontal ) {

        mModel->setData(QModelIndex(), (int)GlxContextLsFs, GlxContextRole );

    }

    else {

        mModel->setData(QModelIndex(), (int)GlxContextPtFs, GlxContextRole );

    }    

    mView = GlxViewsFactory::createView(GLX_GRIDVIEW_ID, this);

    mView->activate();

    mView->setModel(mModel);

    addView(mView);

    connect(mView, SIGNAL(gridItemSelected(const QModelIndex &)), this,

            SLOT( itemSelected(const QModelIndex &)));

	connect ( mView, SIGNAL(itemSpecificMenuTriggered(qint32,QPointF ) ),

			this, SLOT( itemSpecificMenuTriggered(qint32,QPointF ) ),

			Qt::QueuedConnection );

    }

void GlxAiwServiceHandler::itemSpecificMenuTriggered(qint32 viewId,QPointF pos)

	{

    mFetcherContextMenu = new HbMenu();

	HbAction *action = mFetcherContextMenu->addAction(GLX_MENU_OPEN);

	connect(action, SIGNAL(triggered()), this, SLOT(openFSView()));

	connect(this, SIGNAL(aboutToChangeOrientation ()), mFetcherContextMenu, SLOT(close()));

	connect( mFetcherContextMenu, SIGNAL( aboutToClose () ), this, SLOT( closeContextMenu() ) );

	mFetcherContextMenu->setPreferredPos( pos );

	mFetcherContextMenu->show();

 	}

void GlxAiwServiceHandler::closeContextMenu()

    {

    disconnect( this, SIGNAL( aboutToChangeOrientation () ), mFetcherContextMenu, SLOT( close() ) );

    disconnect( mFetcherContextMenu, SIGNAL( aboutToClose () ), this, SLOT( closeContextMenu() ) ); 

    mFetcherContextMenu->deleteLater();

    mFetcherContextMenu = NULL;

    }

void GlxAiwServiceHandler::openFSView()

	{

    HbAction* selectAction = new HbAction(GLX_BUTTON_SELECT);

	connect(selectAction, SIGNAL(triggered()), this, SLOT(handleFSSelect()));

    HbToolBar* toolBar = new HbToolBar();

    toolBar->setOrientation( Qt::Horizontal );

    toolBar->setVisible(true);

	toolBar->addAction(selectAction);

	mModel->setData( QModelIndex(), FETCHER_S, GlxSubStateRole );

    mFSView = GlxViewsFactory::createView(GLX_FULLSCREENVIEW_ID, this);

    //ownership transfered to view

	mFSView->setToolBar(toolBar);

    mFSView->activate();

    mFSView->setModel(mModel);

    addView(mFSView);

    setCurrentView(mFSView,false);

	}

void GlxAiwServiceHandler::handleFSSelect()

	{

	QModelIndex selectedIndex = mModel->index(mModel->data(mModel->index(0,0),GlxFocusIndexRole).value<int>(),0);

	itemSelected(selectedIndex);

    }

void GlxAiwServiceHandler::launchImageViewer()

    {

    qApp->setApplicationName("Image Viewer");

    GlxExternalUtility* util = GlxExternalUtility::instance();

    util->setMainWindow(this);

    delete mStateMgr;

    mStateMgr = NULL;

    mStateMgr = new GlxStateManager();

    mStateMgr->launchFromExternal();

    if (mImageViewerService && mImageViewerService->asyncRequest())

        {

        connect(mImageViewerService, SIGNAL(returnValueDelivered()), this,

                SLOT(handleAnswerDelivered()));

        mImageViewerService->complete(true);

        }

    return;

    }

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

// GlxGetImageService()

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

//

GlxGetImageService::GlxGetImageService(GlxAiwServiceHandler* parent) :

            XQServiceProvider(

                    QLatin1String("com.nokia.services.media.Image"), parent),

            mServiceApp(parent)

    {

    mImageRequestIndex = -1;

    publishAll();

    connect(this, SIGNAL(clientDisconnected()), mServiceApp,

            SLOT(handleClientDisconnect()));

    }

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

// ~GlxGetImageService()

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

//

GlxGetImageService::~GlxGetImageService()

    {

    }

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

// fetchFailed()

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

//

void GlxGetImageService::fetchFailed(int errorCode)

    {

    QStringList filesList;

    filesList.insert(0, QString::number(errorCode));//result

    doComplete(filesList);

    }

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

// complete()

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

//

void GlxGetImageService::complete(QStringList filesList)

    {

    doComplete(filesList);

    }

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

// doComplete()

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

//

void GlxGetImageService::doComplete(QStringList filesList)

    {

    if (isActive())

        {

        completeRequest(mImageRequestIndex, filesList);

        mImageRequestIndex = -1;

        connect(this, SIGNAL(returnValueDelivered()), qApp, SLOT(quit()));

        }

    }

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

// isActive()

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

//

bool GlxGetImageService::isActive()

    {

    return mImageRequestIndex > -1;

    }

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

// fetch()

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

//

void GlxGetImageService::fetch(QVariantMap filter, QVariant flag)

    {

    Q_UNUSED(filter)

    Q_UNUSED(flag)

    mImageRequestIndex = setCurrentRequestAsync();

    mServiceApp->launchFetcher();

    }

// ----------GlxImageViewerService---------------

GlxImageViewerService::GlxImageViewerService(GlxAiwServiceHandler* parent) :

    XQServiceProvider(QLatin1String(

            "com.nokia.services.media.com.nokia.symbian.IFileView"), parent),

            mServiceApp(parent), mAsyncReqId(-1), mAsyncRequest(false),

            mImageViewerInstance(NULL)

    {

    publishAll();

    connect(this, SIGNAL(clientDisconnected()), mServiceApp,

            SLOT(handleClientDisconnect()));

    }

GlxImageViewerService::~GlxImageViewerService()

    {

    if (mImageViewerInstance)

        {

        mImageViewerInstance->Close();

        }

    }

void GlxImageViewerService::complete(bool ok)

    {

    if (mAsyncReqId == -1)

        return;

    completeRequest(mAsyncReqId, QVariant(ok));

    }

bool GlxImageViewerService::view(QString file)

    {

    XQRequestInfo info = requestInfo();

    mAsyncRequest = !info.isSynchronous();

    if (!mImageViewerInstance)

        {

        mImageViewerInstance = CGlxImageViewerManager::InstanceL();

        }

    file.replace(QString("/"), QString("\\"));

    TPtrC16 str(reinterpret_cast<const TUint16*> (file.utf16()));

    HBufC* uri = str.Alloc();

    mImageViewerInstance->SetImageUriL(*uri);

    if (mAsyncRequest)

        {

        mAsyncReqId = setCurrentRequestAsync();

        }

    mServiceApp->launchImageViewer();

    return true;

    }

bool GlxImageViewerService::view(XQSharableFile sf)

    {

    if (!mImageViewerInstance)

        {

        mImageViewerInstance = CGlxImageViewerManager::InstanceL();

        }

    RFile file;

    bool ok = sf.getHandle(file);

    if (ok)

        {

        mImageViewerInstance->SetImageFileHandleL(file);

        sf.close();

        }

    mServiceApp->launchImageViewer();

    mAsyncRequest = !XQServiceUtil::isEmbedded();

    if (mAsyncRequest)

        {

        mAsyncReqId = setCurrentRequestAsync();

        connect(this, SIGNAL(clientDisconnected()), this,

                SLOT(handleClientDisconnect()));

        }

    return true;

    }