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

**

** 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>

#if defined(Q_OS_SYMBIAN)

#include <coemain.h>

#include <coecntrl.h>

#include <e32cmn.h>

#else

#include "hbindicatorwin32_p.h"

#endif // Q_OS_SYMBIAN

//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;

}

#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)

    ,mWindowRegion()

#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)));

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

    // dialogs when server is showing.

    mServerStatus.setStatus(HbDeviceDialogServerStatus::NoFlags);

    TRACE_EXIT

}

/*!

    \internal

    Destructor.

*/

HbDeviceDialogManagerPrivate::~HbDeviceDialogManagerPrivate()

{

    TRACE_ENTRY

    killTimer(mHousekeeperTimerId);

#if defined(Q_OS_SYMBIAN)

    mScene->removeItem(&mMousePressCatcher);

    mWindowRegion.Close();

#endif

    delete mIndicatorPluginManager;

    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;

    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);

    id = dialog.id();

    mScene->addItem(popup);

    if (info.group == HbDeviceDialogPlugin::DeviceNotificationDialogGroup) {

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

        // showing sequentially.

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

    }

    showDialogs();

    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();

        bool success = interface->setDeviceDialogParameters(parameters);

        if (!success) {

            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);

        }

        dialog.widget()->closeDeviceDialog(byClient);

        startHousekeeperTimer();

        ret = HbDeviceDialogNoError;

    }

    TRACE_EXIT

    return ret;

}

// 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)

// Move application to fore/background

void HbDeviceDialogManagerPrivate::moveToForeground(bool foreground)

{

    TRACE_ENTRY_ARGS(foreground)

    if (foreground) {

        if(!mMainWindow->isVisible()) {

            mMainWindow->showFullScreen();

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

            const int positionForeground(0);

            rootWindowGroup.SetOrdinalPosition(positionForeground,

                ECoeWinPriorityAlwaysAtFront);

        }

    } else {

        if(mMainWindow->isVisible()) {

            mMainWindow->hide();

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

            const int positionBackground(-1);

            rootWindowGroup.SetOrdinalPosition(positionBackground, ECoeWinPriorityNormal);

        }

    }

    TRACE_EXIT

}

void HbDeviceDialogManagerPrivate::updateWindowRegion() const

{

    RWindowBase *win =

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

    if (win) {

    }

}

void HbDeviceDialogManagerPrivate::resetWindowRegion() const

{

    RWindowBase *win =

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

    if (win) {

        RRegionBuf<1> windowRegion(QRectToTRect(mMainWindow->sceneRect()));

        win->SetShape(windowRegion);

    }

}

#else

// Move application to fore/background

void HbDeviceDialogManagerPrivate::moveToForeground(bool foreground)

{

    Q_UNUSED(foreground)

}

void HbDeviceDialogManagerPrivate::updateWindowRegion() const

{

}

void HbDeviceDialogManagerPrivate::resetWindowRegion() const

{

}

#endif

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

bool HbDeviceDialogManagerPrivate::showDialogs()

{

    // Traverse list and show dialog widgets. Notifications are shown one at a time.

    // Other dialogs are shown on top of each other.

    // Shorthands for flags

    const HbDeviceDialogsContainer::Dialog::Flags notificationGroup(

        HbDeviceDialogsContainer::Dialog::NotificationGroup);

    const HbDeviceDialogsContainer::Dialog::Flags securityGroup(

        HbDeviceDialogsContainer::Dialog::SecurityGroup);

    const HbDeviceDialogsContainer::Dialog::Flags showing(

        HbDeviceDialogsContainer::Dialog::Showing);

    const HbDeviceDialogsContainer::Dialog::Flags closeCalled(

        HbDeviceDialogsContainer::Dialog::CloseCalled);

    const HbDeviceDialogsContainer::Dialog::Flags noFlags(0);

    // Check if any notification dialogs are showing

    const HbDeviceDialogsContainer::Dialog start;

    bool showingNotification = mDialogs.next(start, notificationGroup|showing,

        notificationGroup|showing).isValid();

    // Initialize variables to determine display lights control

    bool showingSecurity = mDialogs.next(start, securityGroup|showing,

        securityGroup|showing).isValid();

    HbDeviceDialogsContainer::Dialog::Flags newDialogs(0);

    // Loop over not showing dialogs

    HbDeviceDialogsContainer::Dialog *current = &mDialogs.next(start, noFlags,

        showing | closeCalled);

    while(current->isValid()) {

        if (current->flags() & notificationGroup) {

            if (!showingNotification) {

                showingNotification = true;

                current->setFlags(showing);

                HbPopup *popup = current->widget()->deviceDialogWidget();

                popup->show();

                newDialogs |= current->flags();

#if defined(Q_OS_SYMBIAN)

                popup->installSceneEventFilter(&mMousePressCatcher);

#endif //Q_OS_SYMBIAN

            }

        } else { // generic dialog

            current->setFlags(showing);

            current->widget()->deviceDialogWidget()->show();

            newDialogs |= current->flags();

        }

        // Find next one that is not showing

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

    }

    current = 0;

    // Lights control. If security layer is active, only security group or critical group turn lights on.

    // Otherwise lights turned on every time a dialog is shown.

    int lightsMask = HbDeviceDialogsContainer::Dialog::SecurityGroup |

        HbDeviceDialogsContainer::Dialog::CriticalGroup;

    if (!showingSecurity) {

        lightsMask |= HbDeviceDialogsContainer::Dialog::GenericGroup |

            HbDeviceDialogsContainer::Dialog::NotificationGroup |

            HbDeviceDialogsContainer::Dialog::IndicatorGroup;

    }

    if (newDialogs & lightsMask) {

        refreshDisplayLightsTime();

    }

    // RWindow region control.

    // Check if any non-notification dialogs are showing.

    const HbDeviceDialogsContainer::Dialog &nonNotificationDialog =

        mDialogs.next(start, showing, notificationGroup|showing);

    bool dialogsShowing = showingNotification || nonNotificationDialog.isValid();

    if (dialogsShowing) {

        if (!nonNotificationDialog.isValid()) {

            // Only showing (one or more) modeless, non-interruptive notification dialogs.

            // Pointer events catched only inside dialog area, other events gets passed to

            // the application beneath.

            updateWindowRegion();

            enableReceiptOfFocus(false); // call before moving to foreground.

        } else {

            resetWindowRegion();

            enableReceiptOfFocus(true);

        }

    } else {

        resetWindowRegion();

        enableReceiptOfFocus(true);

    }

    moveToForeground(dialogsShowing);

}

/*!

    \internal

    Create a device dialog widget

*/

HbDeviceDialogInterface *HbDeviceDialogManagerPrivate::createDeviceDialog(

    HbDeviceDialogServer::DialogParameters &parameters,

    HbDeviceDialogPlugin::DeviceDialogInfo &deviceDialogInfo, HbPopup *&popup)

{

    parameters.mError = HbDeviceDialogNoError;

    if (!mPluginManager.loadPlugin(parameters.mType)) {

        parameters.mError = HbDeviceDialogNotFoundError;

        return 0;

    }

    const HbDeviceDialogPlugin &plugin = mPluginManager.plugin(parameters.mType);

    if (!plugin.deviceDialogInfo(parameters.mType, parameters.mData, &deviceDialogInfo)) {

        // Ensure plugin returns valid error code

        parameters.mError = checkpluginerror(plugin.error());

        mPluginManager.unloadPlugin(parameters.mType);

        return 0;

    }

    if (!checkDialogInfo(deviceDialogInfo)) {

        parameters.mError = HbDeviceDialogGeneralError;

        mPluginManager.unloadPlugin(parameters.mType);

        return 0;

    }

    // Plugin may request security check of the client

    if (deviceDialogInfo.flags & HbDeviceDialogPlugin::SecurityCheck) {

        QVariantMap credentials;

        addSecurityCredentials(parameters, credentials);

        if (!plugin.accessAllowed(parameters.mType, parameters.mData, credentials)) {

            parameters.mError = HbDeviceDialogAccessDeniedError;

            return 0;

        }

    }

    // Performance optimization for indicator menu. Device dialog widget is reused after the

    // first time it's shown.

    bool recycled = (deviceDialogInfo.group == HbDeviceDialogPlugin::IndicatorGroup);

    HbDeviceDialogInterface *deviceDialogIf =

        mPluginManager.createWidget(parameters.mType, parameters.mData, recycled,

            parameters.mError);

    // Decrease plugin reference count increased by loadPlugin() above. Unload takes place when

    // device dialog widget is deleted.

    mPluginManager.unloadPlugin(parameters.mType);

    if (!deviceDialogIf){

        parameters.mError = checkpluginerror(parameters.mError);

        return deviceDialogIf;

    }

    popup = deviceDialogIf->deviceDialogWidget();

    // Check that: The widget exists, it is a HbPopup and it's not visible yet (we call show())

    if (!popup || qobject_cast<HbPopup*>(popup) == 0 || popup->isVisible()) {

        parameters.mError = HbDeviceDialogGeneralError;

        mPluginManager.freeWidget(deviceDialogIf);

        deviceDialogIf = 0;

        return deviceDialogIf;

    }