/****************************************************************************

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#include <hbdevicedialogpluginmanager_p.h>

#include <hbdevicedialogplugin.h>

#include <hbdevicedialoginterface.h>

#include <hbdevicedialogerrors_p.h>

#include <hbdevicedialogtrace_p.h>

#include <hbwidget.h>

#include <hbpopup_p.h>

#include "hbdevicedialogmanager_p_p.h"

#include "hbdevicedialogmanager_p.h"

#include "hbindicatorpluginmanager_p.h"

#include "hbdevicedialogscontainer_p.h"

#include <hbmainwindow.h>

#include <hbinstance.h>

#include <hbpopup.h>

#include <hbgraphicsscene.h>

#include <hbcorepskeys_r.h>

#if defined(Q_OS_SYMBIAN)

#include <coemain.h>

#include <coecntrl.h>

#include <e32cmn.h>

#else

#include "hbindicatorwin32_p.h"

#endif // Q_OS_SYMBIAN

const char* indicatorMenu = "com.nokia.hb.indicatormenu/1.0";

#ifndef Q_OS_SYMBIAN

int count = 0;

HbDeviceDialogManager *manager = 0;

QMutex mutex;

HbDeviceDialogManager* managerInstance() {

    mutex.lock();

    if (manager == 0) {

        manager = new HbDeviceDialogManager;

    }

    count++;

    mutex.unlock();

    return manager;

}

void releaseManagerInstance() {

    mutex.lock();

    count--;

    if (count == 0) {

        delete manager;

        manager = 0;

    }

    mutex.unlock();

}

#endif

//local symbian helper functions

#if defined(Q_OS_SYMBIAN)

TRect QRectToTRect(const QRectF &rect)

{

    TRect trect;

    trect.SetRect(rect.topLeft().x(), rect.topLeft().y(),

               rect.bottomRight().x() + 1, rect.bottomRight().y() + 1);

    return trect;

}

QRectF MousePressCatcher::boundingRect () const

{

    return QRectF();

}

void MousePressCatcher::paint ( QPainter */*painter*/,

                          const QStyleOptionGraphicsItem */*option*/,

                          QWidget */*widget*/)

{

}

bool MousePressCatcher::sceneEventFilter( QGraphicsItem * /*watched*/, QEvent * event )

{

    if (event->type() == QEvent::GraphicsSceneMousePress) {

        mDeviceDialogManger->resetWindowRegion();

    }

    return false;

}

bool RegionUpdateFilter::eventFilter(QObject* obj, QEvent *event)

    {

    if (event->type() ==  QEvent::QEvent::GraphicsSceneResize) {

        HbPopup *popup = qobject_cast<HbPopup*>(obj);

        if (popup) {

            HbDeviceDialogsContainer::Dialog & dialog = mDeviceDialogManger->mDialogs.find(popup);

            mDeviceDialogManger->addRegionRect(dialog.id(), rect);

        }

    }

    return false;

    }

#endif

/*!

    \internal

    Constructor.

*/

HbDeviceDialogManagerPrivate::HbDeviceDialogManagerPrivate(HbDeviceDialogManager *manager) :

    QObject(),

    q(manager),

    mIndicatorPluginManager(0),

    mDialogs(mPluginManager),

    mMainWindow(0),

    mScene(0),

    mServerStatus(true),

    mHousekeeperTimerId(0)

#if defined(Q_OS_SYMBIAN)

    ,mMousePressCatcher(this)

    ,mRegionUpdateFilter(this)

    ,mWindowRegion()

    ,mWgOrdinalPriority(ECoeWinPriorityNormal)

#endif

{

    TRACE_ENTRY

    mIndicatorPluginManager = new HbIndicatorPluginManager;

    connect(mIndicatorPluginManager, SIGNAL( indicatorActivated(const IndicatorClientInfo) ),

            this, SLOT(indicatorActivated(const IndicatorClientInfo)));

    connect(mIndicatorPluginManager, SIGNAL( indicatorRemoved(const IndicatorClientInfo) ),

            this, SLOT(indicatorRemoved(const IndicatorClientInfo)));

    connect(mIndicatorPluginManager, SIGNAL( indicatorUpdated(const IndicatorClientInfo) ),

            this, SLOT(indicatorUpdated(const IndicatorClientInfo)));

    connect(mIndicatorPluginManager, SIGNAL(indicatorUserActivated(QVariantMap)),

            q, SIGNAL(indicatorUserActivated(QVariantMap)));

    // Server publishes it's status. Applications use it to delay showing of notification

    // dialogs when server is showing.

    mServerStatus.setStatus(HbDeviceDialogServerStatus::NoFlags);

    qApp->installEventFilter(this);

    init();

#if defined(Q_OS_SYMBIAN)   

    _LIT_SECURITY_POLICY_PASS(KRdPolicy); // all pass

    _LIT_SECURITY_POLICY_S0(KWrPolicy, KHbPsForegroundAppOrientationCategoryUid.iUid); // pass device dialog server    

    mHbOriProperty.Define(KHbPsForegroundAppOrientationCategoryUid,

                          KHbPsForegroundAppOrientationKey,

                          RProperty::EInt, KRdPolicy, KWrPolicy);

    mHbOriProperty.Attach(KHbPsForegroundAppOrientationCategoryUid,

                          KHbPsForegroundAppOrientationKey);

#endif        

    TRACE_EXIT

}

/*!

    \internal

    Destructor.

*/

HbDeviceDialogManagerPrivate::~HbDeviceDialogManagerPrivate()

{

    TRACE_ENTRY

    if (mHousekeeperTimerId) {

        killTimer(mHousekeeperTimerId);

    }

#if defined(Q_OS_SYMBIAN)

    mScene->removeItem(&mMousePressCatcher);

    mWindowRegion.Close();

    mHbOriProperty.Close();

#endif // Q_OS_SYMBIAN

    delete mIndicatorPluginManager;

    TRACE_EXIT

}

void HbDeviceDialogManagerPrivate::init()

{

    TRACE_ENTRY

    // Performance optimization for indicator menu.

    bool recycled(true);

    int error(0);

#if defined(Q_OS_SYMBIAN)

    // Speed-up search by specifying a file name

    QString pluginBaseFileName("HbIndicatorMenuPlugin");

#else // Q_OS_SYMBIAN

    QString pluginBaseFileName;

#endif // Q_OS_SYMBIAN

    HbDeviceDialogInterface *deviceDialogIf =

        mPluginManager.createWidget(QString(indicatorMenu), QVariantMap(), pluginBaseFileName,

            QString(), recycled, error);

    if (deviceDialogIf) {

        connectIndicatorStatus(deviceDialogIf);

        mPluginManager.freeWidget(deviceDialogIf);

    }

    TRACE_EXIT

}

// Set main window. Main window is not a construct parameter as it may be

// created later than device dialog server.

void HbDeviceDialogManagerPrivate::setMainWindow(HbMainWindow *mainWindow)

{

    mMainWindow = mainWindow;

    mScene = static_cast<HbGraphicsScene*>(mainWindow->scene());

    Q_ASSERT(mScene);

    // Windows/Linux, plugin manager may outlive scene. Scene deletes all widgets when it closes

    connect(mScene, SIGNAL(destroyed(QObject*)), &mPluginManager, SLOT(allWidgetsDeleted()));

#if defined(Q_OS_SYMBIAN)

    // Scene pointer is now valid

    mScene->addItem(&mMousePressCatcher);

#endif

}

// Called by client via device dialog server to show device dialog.

int HbDeviceDialogManagerPrivate::showDeviceDialog(

    HbDeviceDialogServer::DialogParameters &parameters)

{

    TRACE_ENTRY

    int id = 0;

    HbDeviceDialogPlugin::DeviceDialogInfo info;

    memset(&info, 0, sizeof(info));

    HbPopup *popup = 0;

    HbDeviceDialogInterface *deviceDialogIf = createDeviceDialog(

        parameters, info, popup);

    if (!deviceDialogIf) {

        return id;

    }

    // If there are dialogs launched by the same client, mark them as having no client.

    // They need to close within a time period.

    markNoClient(parameters.mClientTag);

    HbDeviceDialogsContainer::Dialog &dialog = mDialogs.add(deviceDialogIf, info);

    dialog.setVariable(HbDeviceDialogsContainer::Dialog::ClientTag, parameters.mClientTag);

    if (info.flags & HbDeviceDialogPlugin::SingleInstance) {

        // Only single instance of the dialog should be shown, save dialog type for later comparison

        dialog.setVariable(HbDeviceDialogsContainer::Dialog::DialogType, parameters.mType);

    }

    id = dialog.id();

    // Set popup priority

    HbDeviceDialogsContainer::Dialog::Flags flags = dialog.flags();

    setDialogPriority(popup, flags);

    if (flags & HbDeviceDialogsContainer::Dialog::NotificationGroup) {

        // Disable HbNotificationDialog sequential show feature. Server takes care of

        // showing sequentially.

        popup->setProperty("sequentialShow", false);

    }

    showDialogs();

    controlForeground();

    updateStatus();

    TRACE_EXIT

    return id;

}

// Called by client via device dialog server to update device dialog.

int HbDeviceDialogManagerPrivate::updateDeviceDialog(int id, const QVariantMap &parameters)

{

    TRACE_ENTRY

    int ret = HbDeviceDialogNotFoundError;

    HbDeviceDialogsContainer::Dialog &dialog = mDialogs.find(id);

    if (dialog.isValid()) {

        HbDeviceDialogInterface *interface = dialog.widget();

            ret = checkpluginerror(interface->deviceDialogError());

        } else {

            ret = HbDeviceDialogNoError;

        }

    }

    TRACE_EXIT

    return ret;

}

// Called by client via device dialog server to close device dialog

int HbDeviceDialogManagerPrivate::closeDeviceDialog(int id, bool byClient)

{

    TRACE_ENTRY

    int ret = HbDeviceDialogNotFoundError;

    HbDeviceDialogsContainer::Dialog::Flags closeCalled(

        HbDeviceDialogsContainer::Dialog::CloseCalled);

    HbDeviceDialogsContainer::Dialog &dialog = mDialogs.find(id);

    if (dialog.isValid() && !(dialog.flags() & closeCalled)) {

        dialog.setFlags(closeCalled);

        if (!byClient) {

            dialog.setFlags(HbDeviceDialogsContainer::Dialog::ClosedByServer);

        }

        startHousekeeperTimer();

    }

    TRACE_EXIT

    return ret;

}

// Publish current orientation to PS-key

int HbDeviceDialogManagerPrivate::publishOrientation(int orientation)

{

#if defined(Q_OS_SYMBIAN)

    int ret = mHbOriProperty.Set(orientation); 

    return ret;

#else

    Q_UNUSED(orientation)

    return 0;    

#endif    

}

// Client (session) is closing

void HbDeviceDialogManagerPrivate::deviceDialogClientClosing(quintptr clientTag)

{

    // Mark device dialogs launched by the client as having client (session) closed.

    // Housekeeper closes these after a timeout. Dialogs without a client are allowed but

    // they need to close within a timeout.

    markNoClient(clientTag);

}

/*!

    \internal

    Activate indicator

*/

int HbDeviceDialogManagerPrivate::activateIndicator(

    HbDeviceDialogServer::IndicatorParameters &parameters)

{

    QVariantMap credentials;

    addSecurityCredentials(parameters, credentials);

    int result = HbDeviceDialogNoError;

    mIndicatorPluginManager->addIndicator(parameters.mType, credentials, &result);

    if (result == HbDeviceDialogNoError) {

        if (!mIndicatorPluginManager->activateIndicator(

            parameters.mType, parameters.mData, credentials)) {

                result = HbDeviceDialogAccessDeniedError;

            }

    }

    return result;

}

/*!

    \internal

    Deactivate indicator

*/

int HbDeviceDialogManagerPrivate::deactivateIndicator(

    HbDeviceDialogServer::IndicatorParameters &parameters)

{

    QVariantMap credentials;

    addSecurityCredentials(parameters, credentials);

    bool success = mIndicatorPluginManager->deactivateIndicator(

        parameters.mType, parameters.mData, credentials);

    return success ? HbDeviceDialogNoError : HbDeviceDialogAccessDeniedError;

}

QList<IndicatorClientInfo> HbDeviceDialogManagerPrivate::indicatorClientInfoList() const

{

    return mIndicatorPluginManager->indicatorClientInfoList();

}

#if defined(Q_OS_SYMBIAN)

void HbDeviceDialogManagerPrivate::doMoveToForeground(bool foreground, int priority)

{

    if (priority == ECoeWinPriorityNormal) { 

        if (mMainWindow->isVisible()) {

            mMainWindow->hide();

        }

    } else {

        if (!mMainWindow->isVisible() || !mMainWindow->isActiveWindow()) {

            mMainWindow->showFullScreen();

        }

    }

    const int position = foreground ? 0 : -1;

    RWindowGroup &rootWindowGroup = CCoeEnv::Static()->RootWin();                

    rootWindowGroup.SetOrdinalPosition(position, priority);

    mWgOrdinalPriority = priority;

}

// Move application fore/background and adjust window group priorities

void HbDeviceDialogManagerPrivate::controlForeground(ForegroundControl control)

{

    const HbDeviceDialogsContainer::Dialog::Flags showing(

        HbDeviceDialogsContainer::Dialog::Showing);

    const HbDeviceDialogsContainer::Dialog start;

    int numShowing = 0;

    int numSecurity = 0;

    int numCritical = 0;

    // Loop over showing dialogs

    const HbDeviceDialogsContainer::Dialog *current = &mDialogs.next(start, showing, showing);

    while(current->isValid()) {

        HbDeviceDialogsContainer::Dialog::Flags flags = current->flags();

        numShowing++;

        numSecurity += (flags & HbDeviceDialogsContainer::Dialog::SecurityLevel) ? 1 : 0;

        numCritical += (flags & HbDeviceDialogsContainer::Dialog::CriticalLevel) ? 1 : 0;

        current = &mDialogs.next(*current, showing, showing);

    }

    const int wgBackground = ECoeWinPriorityNormal;

    const int wgForeground = ECoeWinPriorityAlwaysAtFront;

    const int wgForegroundCritical = ECoeWinPriorityAlwaysAtFront + 50;

    if (numShowing == 0) {

        doMoveToForeground(false, wgBackground);

        return;

    }

    switch(control) {

    case FgControlNone:

        doMoveToForeground(true, numCritical ? wgForegroundCritical : wgForeground);

        break;

    case FgControlSecurityCriticalClosed:

        // Security or critical dialog closed. If there is only one security dialog active,

        // Give change to other apps at alwaysAtFront priority to come foreground.

        if (numCritical == 0 && numSecurity == 1) {

            doMoveToForeground(false, wgForeground);

        } else {

            doMoveToForeground(true, numCritical ? wgForegroundCritical : wgForeground);

        }

        break;

    }

}

void HbDeviceDialogManagerPrivate::updateWindowRegion() const

{

    RWindowBase *win =

        static_cast<RWindowBase*>(mMainWindow->effectiveWinId()->DrawableWindow());

    if (win) {

        win->SetShape(mWindowRegion);

    }

}

void HbDeviceDialogManagerPrivate::resetWindowRegion() const

{

    RWindowBase *win =

        static_cast<RWindowBase*>(mMainWindow->effectiveWinId()->DrawableWindow());

    if (win) {

        win->SetShape(windowRegion);

    }

}

#else

void HbDeviceDialogManagerPrivate::doMoveToForeground(bool foreground, int priority)

{

    Q_UNUSED(foreground)

    Q_UNUSED(priority)            

}

void HbDeviceDialogManagerPrivate::controlForeground(ForegroundControl control)

{

    Q_UNUSED(control)

}

void HbDeviceDialogManagerPrivate::updateWindowRegion() const

{

}

void HbDeviceDialogManagerPrivate::resetWindowRegion() const

{

}

#endif

// Show next dialog. Return true if any dialogs are showing

bool HbDeviceDialogManagerPrivate::showDialogs()