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

**

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

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

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

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

    _LIT_SECURITY_POLICY_PASS(KRdPolicy); // all pass

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

    int error = mHbOriProperty.Define(KHbPsForegroundAppOrientationCategoryUid,

                                      KHbPsForegroundAppOrientationKey,

                                      RProperty::EInt, KRdPolicy, KWrPolicy);

    if (error == KErrNone) {

        mHbOriProperty.Attach(KHbPsForegroundAppOrientationCategoryUid,

                              KHbPsForegroundAppOrientationKey);

    }

#endif        

    TRACE_EXIT

}

/*!

    \internal

    Destructor.

*/

HbDeviceDialogManagerPrivate::~HbDeviceDialogManagerPrivate()

{

    TRACE_ENTRY

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

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

}

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

{

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

}

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

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

        win->SetShape(windowRegion);

    }

}

#else

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

{

    Q_UNUSED(foreground)

    Q_UNUSED(priority)            

}

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