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

**

** 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 HbWidgets 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 "hbdevicemessageboxsymbian.h"

#include <hbsymbianvariant.h>

#include <hbdevicedialogsymbian.h>

#include <hbdeleteguardsymbian_p.h>

#define ARG_UNUSED(x) (void)x;

enum TMessageBoxPanic {

    ETypePanic,

    EPropertyPanic,

    EButtonIdPanic

};

NONSHARABLE_CLASS(TMessageBoxProperty)

{

public:

    enum TType {

        EIntProperty,

        EStringProperty

    };

    TMessageBoxProperty(){mValue.mString = 0;}

    void Init(TType aId);

    ~TMessageBoxProperty();

    const TPtrC StringValue() const;

    TInt IntValue() const;

    void SetL(const TDesC &aValue);

    void Set(TInt aValue);

    bool Modified() const{return mFlags.mModified;}

    void SetModified(bool aModified){mFlags.mModified = aModified;}

    bool Valid() const{return mFlags.mValid;}

    void SetValid(bool aValid){mFlags.mValid = aValid;}

    bool IsNullAction() const{return mFlags.mNullAction;}

    void SetNullAction(bool aNull){mFlags.mNullAction = aNull;}

    TType Type() const{return mType;}

    void SetType(TType aType){mType = aType;}

private:

    TType mType;

    union {

        TInt mInt;

        HBufC *mString;

    } mValue;

    struct {

        bool mNullAction:1; // marks action (button) null

        bool mValid:1; // property value has has been set

        bool mModified:1; // property has been modified

    } mFlags;

};

NONSHARABLE_CLASS(CHbDeviceMessageBoxPrivate)  : public CBase, public MHbDeviceDialogObserver

{

public:

    enum TPropertyId {

        EFirstIntProperty,

        EType = EFirstIntProperty,

        EIconVisible,

        ETimeout,

        EDismissPolicy,

        ELastIntProperty = EDismissPolicy,

        EFirstStringProperty,

        EText = EFirstStringProperty,

        EIconName,

        EAcceptText,

        ERejectText,

        EAnimationDefinition,

        ELastStringProperty = EAnimationDefinition,

        ENumProperties

    };

    void ConstructL(CHbDeviceMessageBoxSymbian::TType aType,

        MHbDeviceMessageBoxObserver *aObserver);

    ~CHbDeviceMessageBoxPrivate();

    void InitProperties(CHbDeviceMessageBoxSymbian::TType aType);

    bool PropertiesModified(TInt aIgnoreMask) const;

    void SetPropertyValueL(TPropertyId aId, const TDesC &aValue);

    void SetPropertyValue(TPropertyId aId, TInt aValue);

    void SetButtonNull(CHbDeviceMessageBoxSymbian::TButtonId aButtonId, bool aValue);

    void SetButtonTextL(CHbDeviceMessageBoxSymbian::TButtonId aButtonId, const TDesC &aValue);

    void SendToServerL(bool aShow = false);

    void Close();

    bool WaitForClosed();

    static const TPtrC PropertyName(TPropertyId aId);

    static TPropertyId ButtonPropertyId(TPropertyId aId, CHbDeviceMessageBoxSymbian::TButtonId aButtonId);

    static HBufC *CreateActionDataLC(TBool aNull, const TDesC &text);

public: // MHbDeviceDialogObserver

    void DataReceived(CHbSymbianVariantMap& aData);

    void DeviceDialogClosed(TInt aCompletionCode);

public: // data

    CHbDeviceMessageBoxSymbian *q;

    TMessageBoxProperty mProperties[ENumProperties];

    CHbDeviceDialogSymbian *mDeviceDialog;

    bool mShowCalled;

    CHbDeviceMessageBoxSymbian::TButtonId mReceivedButton;

    MHbDeviceMessageBoxObserver *mObserver;

    bool *mDeleted;

    CActiveSchedulerWait mActiveSchedulerWait;

};

// Panic application

static void Panic(TInt aCode)

{

    _LIT(KCategory, "CHbDeviceMessageBoxSymbian");

    User::Panic(KCategory, aCode);

}

// Initialize property

void TMessageBoxProperty::Init(TType aType)

{

    if (mType == EStringProperty) {

        delete mValue.mString;

        // NULL string property denotes an empty string

        mValue.mString = 0;

    } else {

        mValue.mInt = 0;

    }

    mType = aType;

    mFlags.mNullAction = false;

    mFlags.mValid = false;

    mFlags.mModified = false;

}

// Destructor

TMessageBoxProperty::~TMessageBoxProperty()

{

    if (mType == EStringProperty) {

        delete mValue.mString;

    }

}

// Get string value

const TPtrC TMessageBoxProperty::StringValue() const

{

    __ASSERT_DEBUG(mType == EStringProperty, Panic(EPropertyPanic));

    if (mValue.mString) {

        return TPtrC(*mValue.mString);

    } else {

        return TPtrC(KNullDesC);

    }

}

// Get integer value

TInt TMessageBoxProperty::IntValue() const

{

    __ASSERT_DEBUG(mType == EIntProperty, Panic(EPropertyPanic));

    return mValue.mInt;

}

// Set string value

void TMessageBoxProperty::SetL(const TDesC &aValue)

{

    __ASSERT_DEBUG(mType == EStringProperty, Panic(EPropertyPanic));

    // Check that value changes

    if (mValue.mString && *mValue.mString == aValue) {

        return;

    }

    HBufC *newValue = HBufC::NewL(aValue.Length());

    *newValue = aValue;

    delete mValue.mString;

    mValue.mString = newValue;

    mFlags.mValid = true;

    mFlags.mModified = true;

}

// Set integer value

void TMessageBoxProperty::Set(TInt aValue)

{

    __ASSERT_DEBUG(mType == EIntProperty, Panic(EPropertyPanic));

    mFlags.mValid = true;

    if (mValue.mInt == aValue) {

        return;

    }

    mValue.mInt = aValue;

    mFlags.mModified = true;

}

// Construct private

void CHbDeviceMessageBoxPrivate::ConstructL(CHbDeviceMessageBoxSymbian::TType aType,

    MHbDeviceMessageBoxObserver *aObserver)

{

    mDeviceDialog = CHbDeviceDialogSymbian::NewL();

    mReceivedButton = CHbDeviceMessageBoxSymbian::EInvalidButton;

    mObserver = aObserver;

    InitProperties(aType);

}

// Destructor

CHbDeviceMessageBoxPrivate::~CHbDeviceMessageBoxPrivate()

{

    // If no observer, remove observer from device dialog. This leaves the

    // dialog widget executing at server when client closes connection.

    if (!mObserver) {

        mDeviceDialog->SetObserver(0);

    }

    delete mDeviceDialog;

    // Set object deleted flag

    if (mDeleted) {

        // Mark the object as deleted.

        *mDeleted = true;

        mDeleted = 0;

    }

}

// Initialize properties

void CHbDeviceMessageBoxPrivate::InitProperties(CHbDeviceMessageBoxSymbian::TType aType)

{

    // Initialize all properties to default values

    for(int i = 0; i < ENumProperties; i++) {

        TMessageBoxProperty &property = mProperties[i];

        property.Init(i >= EFirstStringProperty ?

            TMessageBoxProperty::EStringProperty : TMessageBoxProperty::EIntProperty);

    }

    // Set properties to default values

    mProperties[EType].Set(aType);

    mProperties[EIconVisible].Set(ETrue);

    switch(aType) {

    case CHbDeviceMessageBoxSymbian::EInformation:

    case CHbDeviceMessageBoxSymbian::EWarning: {

        const TInt KStandardTimeout = 3000; // 3s

        mProperties[ETimeout].Set(KStandardTimeout);

        const TInt KTapAnywhere = 0x03; // HbPopup::TapAnywhere

        mProperties[EDismissPolicy].Set(KTapAnywhere);

        // Plugin has accept button by default

        mProperties[ERejectText].SetNullAction(true);

        break;

    }

    case CHbDeviceMessageBoxSymbian::EQuestion: {

        const TInt KNoTimeout = 0;

        mProperties[ETimeout].Set(KNoTimeout);

        const TInt KNoDismiss = 0; // HbPopup::NoDismiss

        mProperties[EDismissPolicy].Set(KNoDismiss);

        break;

    }

    default:

        Panic(ETypePanic);

    }

}

bool CHbDeviceMessageBoxPrivate::PropertiesModified(TInt aIgnoreMask) const

{

    for(int i = 0; i < ENumProperties; i++) {

        if (mProperties[i].Modified() && (aIgnoreMask & 1) == 0) {

            return true;

        }

        aIgnoreMask >>= 1;

    }

    return false;

}

// Set string property value

void CHbDeviceMessageBoxPrivate::SetPropertyValueL(TPropertyId aId, const TDesC &aValue)

{

    mProperties[aId].SetL(aValue);

}

// Set int property value

void CHbDeviceMessageBoxPrivate::SetPropertyValue(TPropertyId aId, TInt aValue)

{

    mProperties[aId].Set(aValue);

}

// Set button null property value

void CHbDeviceMessageBoxPrivate::SetButtonNull(CHbDeviceMessageBoxSymbian::TButtonId aButtonId,

    bool aValue)

{

    TPropertyId id = ButtonPropertyId(EAcceptText, aButtonId);

    mProperties[id].SetNullAction(aValue);

    mProperties[id].SetValid(true);

    mProperties[id].SetModified(true);

}

// Set button text property

void CHbDeviceMessageBoxPrivate::SetButtonTextL(

    CHbDeviceMessageBoxSymbian::TButtonId aButtonId, const TDesC &aValue)

{

    TPropertyId id = ButtonPropertyId(EAcceptText, aButtonId);

    mProperties[id].SetL(aValue);

}

// Send properties to server. Show or update.

void CHbDeviceMessageBoxPrivate::SendToServerL(bool aShow)

{

    // If this is update but ShowL() has not been called, return.

    if (!aShow && !mShowCalled) {

      return;

    }

    // If this is update but no properties have been mofified, return

    const TInt ignoreMask = 0;

    if (!aShow && !PropertiesModified(ignoreMask)) {

        return;

    }

    CHbSymbianVariantMap *parameters = CHbSymbianVariantMap::NewL();

    CleanupStack::PushL(parameters);

    for(int i = 0; i < ENumProperties; i++) {

        TMessageBoxProperty &property = mProperties[i];

        // ShowL() send all valid properties. Update only sends modified properties.

        bool sendProperty = aShow ? property.Valid() : property.Modified();

        if (sendProperty) {

            CHbSymbianVariant* parameter;

            if (i == EAcceptText || i == ERejectText) {

                HBufC *actionData = CreateActionDataLC(property.IsNullAction(), property.StringValue());

                parameter = CHbSymbianVariant::NewL(actionData, CHbSymbianVariant::EDes);

                CleanupStack::PopAndDestroy(); // actionData

            } else if (property.Type() == TMessageBoxProperty::EIntProperty) {

                TInt value = property.IntValue();

                parameter = CHbSymbianVariant::NewL(&value, CHbSymbianVariant::EInt);

            } else {

                TPtrC value = property.StringValue();

                parameter = CHbSymbianVariant::NewL(&value, CHbSymbianVariant::EDes);

            }

            CleanupStack::PushL(parameter);

            User::LeaveIfError(parameters->Add(

                PropertyName(static_cast<TPropertyId>(i)), parameter));

            CleanupStack::Pop(); // parameter

            property.SetModified(false);

        }

    }

    _LIT(KDeviceDialogType, "com.nokia.hb.devicemessagebox/1.0");

    TInt error;

    if (aShow) {

        mReceivedButton = CHbDeviceMessageBoxSymbian::EInvalidButton;

        error = mDeviceDialog->Show(KDeviceDialogType, *parameters, this);

        mShowCalled = true;

    } else {

        error = mDeviceDialog->Update(*parameters);

    }

    CleanupStack::PopAndDestroy(); // parameters

}

// Close message box

void CHbDeviceMessageBoxPrivate::Close()

{

    mDeviceDialog->Cancel();

}

// Wait for message box to close

bool CHbDeviceMessageBoxPrivate::WaitForClosed()

{

    // Returns true if object was not deleted during wait

    if (!mShowCalled) {

        return true;

    }

    RHbDeleteGuardSymbian guard;

    guard.OpenAndPushL(&mDeleted);

    mActiveSchedulerWait.Start();

    return !guard.PopAndClose();

}

// Get property name

const TPtrC CHbDeviceMessageBoxPrivate::PropertyName(TPropertyId aId)

{

    static const wchar_t * const names[] = {

        L"type",

        L"iconVisible",

        L"timeout",

        L"dismissPolicy",

        L"text",

        L"iconName",

        L"acceptAction",

        L"rejectAction",

        L"animationDefinition"

    };

    __ASSERT_DEBUG(aId >= 0 && aId < sizeof(names)/sizeof(names[0]), Panic(EPropertyPanic));

    return TPtrC((const TUint16 *)names[aId]);

}

// Modify property id according to button

CHbDeviceMessageBoxPrivate::TPropertyId CHbDeviceMessageBoxPrivate::ButtonPropertyId(

    TPropertyId aId, CHbDeviceMessageBoxSymbian::TButtonId aButtonId)

{

    __ASSERT_DEBUG(aButtonId == CHbDeviceMessageBoxSymbian::EAcceptButton ||

        aButtonId == CHbDeviceMessageBoxSymbian::ERejectButton, Panic(EButtonIdPanic));

    switch(aId) {

    case EAcceptText:

        return aButtonId == CHbDeviceMessageBoxSymbian::EAcceptButton ? EAcceptText : ERejectText;

    default:

        Panic(EPropertyPanic);

        return aId; // suppress warning

    }

}

// Pack into a string a data for a button

HBufC *CHbDeviceMessageBoxPrivate::CreateActionDataLC(TBool aNull, const TDesC &text)

{

    HBufC *actionData;

    if (aNull) {

        actionData = HBufC::NewL(0);

    } else {

        _LIT(KtextTag, "t:");

        actionData = HBufC::NewL(text.Length() + KtextTag().Length());

        TPtr ptr = actionData->Des();

        ptr.Append(KtextTag);

        ptr.Append(text);

    }

    CleanupStack::PushL(actionData);

    return actionData;

}

// Observer, data received from device message box

void CHbDeviceMessageBoxPrivate::DataReceived(CHbSymbianVariantMap& aData)

{

    _LIT(KKey, "act");

    const CHbSymbianVariant* variant = aData.Get(KKey);

    if (variant) {

        const TDesC *value = variant->Value<const TDesC>();

        if (value) {

            _LIT(KPrimary, "p");

            if (*value == KPrimary) {

                mReceivedButton = CHbDeviceMessageBoxSymbian::EAcceptButton;

            } else {

                mReceivedButton = CHbDeviceMessageBoxSymbian::ERejectButton;

            }

        }

    }

}

// Observer, device message box closed

void CHbDeviceMessageBoxPrivate::DeviceDialogClosed(TInt aCompletionCode)

{

    ARG_UNUSED(aCompletionCode)

    mShowCalled = false;

    if (mObserver) {

        RHbDeleteGuardSymbian guard;

        guard.OpenAndPushL(&mDeleted);

        mObserver->MessageBoxClosed(q, mReceivedButton);

        if (guard.PopAndClose()) {

            return; // observer callback deleted this object. Do not touch it anymore.

        }

    }

    if (mActiveSchedulerWait.IsStarted()) {

        mActiveSchedulerWait.AsyncStop();

    }

}

/*!

    \class CHbDeviceMessageBoxSymbian

    \brief CHbDeviceMessageBoxSymbian is a Symbian implementation of HbDeviceMessageBox.

    CHbDeviceMessageBoxSymbian is intended for use by servers that don't run Qt event loop

    and cannot use HbDeviceMessageBox.

    It displays a message box with text, icon or animation and two optional buttons,

    accept and reject.

    It provides a similar interface as HbDeviceMessageBox. The main

    differences are:

    - Signals are replaced by an observer interface

    - HbAction/QAction is replaced by button information.

    - Function parameters whose type is a Qt or Hb enumeration are replaced by an integer.

      As suitable default values are set at construction, it is assumed that application rarely

      needs to use these.

    Device message box is a modal dialog. It is shown on top of applications by device dialog

    server. CHbDeviceMessageBoxSymbian is a client of the server.

    Three predefined message boxes are provided or a custom one can be constructed using the API.

    Predefined message boxes are:

    - Information

    - Question

    - Warning

    ShowL() displays a message box asynchronously. The function returns immediately. The launched

    dialog can be updated by setters and then calling UpdateL(). Closing can be observed by a

    callback. Because each UpdateL() after the ShowL() requires interprocess communication,

    it's advisable to fully construct the device message box before displaying it.

    A device message box is launched synchronously by ExecL() function. The function returns when

    the dialog is closed and return value indicates the button selected. The function uses

    active scheduler wait to wait for the message box to close. ExecL() should be used

    carefully as application event processing continues during the wait and program state may

    change, e.g. objects may get deleted. Preferred way is to use asynchoronous ShowL() instead.

    Device message box is closed when user dismisses it, when Close()

    is called, timeout triggers or system closes the dialog. Default return value is a reject