#include <hb/hbcore/hbdevicedialogsymbian.h>    // CHbDeviceDialogSymbian

#include <securityuisprivatepskeys.h>

const TUid KSWInstHelpUid =

    {

    0x101F8512

    }; // TODO

    CSecQueryUi* self = new (ELeave) CSecQueryUi();

    CleanupStack::PushL(self);

    CleanupStack::Pop(self);

EXPORT_C TBool CSecQueryUi::InstallConfirmationQueryL(TInt aType,

        RMobilePhone::TMobilePassword& password)

 const TDesC& aAppName,

 const TDesC& aIconFile, const TDesC& aAppVersion, TInt aAppSize,

 const TDesC& aAppDetails ) */

    // this is never used. Kept as a reference

    RDEBUG("This should never be called. Obsolete aType", aType);

    return KErrAbort;

EXPORT_C TInt CSecQueryUi::SecQueryDialog(const TDesC& aCaption,

        TDes& aDataText, TInt aMinLength, TInt aMaxLength, TInt aMode)

    RDEBUG("aCaption", 0);

    RDebug::Print(aCaption);

    RDEBUG("aMode", aMode);

    TInt secUiOriginatedQuery(ESecurityUIsSecUIOriginatedUninitialized);

    TInt err = RProperty::Get(KPSUidSecurityUIs,

            KSecurityUIsSecUIOriginatedQuery, secUiOriginatedQuery);

    RDEBUG("secUiOriginatedQuery", secUiOriginatedQuery);

    if (secUiOriginatedQuery != ESecurityUIsSecUIOriginatedUninitialized)

        {

        // The query is already shown. This is valid for ESecurityUIsSecUIOriginated, and maybe for ESecurityUIsETelAPIOriginated

        // For ESecurityUIsSystemLockOriginated it means that the "lock" dialog is already present.

        // What to do? Can't dismiss the dialog because it's not owned. Can't device-unlock without asking code. Only can disable keyguard

        RDEBUG("!!!! warning: secUiOriginatedQuery", secUiOriginatedQuery);

        }

    else

        {

        // set only if not set

        err = RProperty::Set(KPSUidSecurityUIs,

                KSecurityUIsSecUIOriginatedQuery,

                ESecurityUIsETelAPIOriginated);

        RDEBUG("setting secUiOriginatedQuery", ESecurityUIsETelAPIOriginated);

        }

    ClearParamsAndSetNoteTypeL(aMode);

    AddParamL(_L("KSecQueryUiApplicationName"), aCaption);

    _LIT(KTitle, "title");

    AddParamL(KTitle, aCaption);

    AddParamL(_L("MinLength"), aMinLength);

    AddParamL(_L("MaxLength"), aMaxLength);

    _LIT(KCodeTop, "codeTop");

    _LIT(KCodeTopValue, "codeTop");

    AddParamL(KCodeTop, KCodeTopValue);

    if (aCaption.Find(_L("|")) > 0)

        {

        RDEBUG("codeBottom aMode", aMode);

        _LIT(KCodeBottom, "codeBottom");

        _LIT(KCodeBottomValue, "codeBottom");

        AddParamL(KCodeBottom, KCodeBottomValue);

        }

    if (aDataText.Length() > 0)

        {

        RDEBUG("aDataText", 1);

        _LIT(KDefaultCode, "DefaultCode");

        AddParamL(KDefaultCode, aDataText);

        }

    RDEBUG("0", 0);

    DisplayDeviceDialogL();

    TInt error = WaitUntilDeviceDialogClosed();

    RDEBUG("error", error);

    User::LeaveIfError(error);

    err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery,

            ESecurityUIsSecUIOriginatedUninitialized);

    RDEBUG("clearing secUiOriginatedQuery",

            ESecurityUIsSecUIOriginatedUninitialized);

    RDEBUG("iReturnValue", iReturnValue);

EXPORT_C void CSecQueryUi::DisplayInformationNoteL(const TDesC& aText)

    // this is never used. Kept as a reference

    RDEBUG("This should never be called. Obsolete", 0);

     ClearParamsAndSetNoteTypeL( SecQueryUiInformationNote );

     AddParamL( KNotifDeviceDialogKeyText, aText );

     AddParamL( KNotifDeviceDialogKeyTimeOut, 0 );

     iDeviceDialog->Show( KNotifDeviceDialogLiteral, *iVariantMap, this );

     User::LeaveIfError( WaitUntilDeviceDialogClosed() );

     */

EXPORT_C void CSecQueryUi::DisplayWarningNoteL(const TDesC& aText)

EXPORT_C void CSecQueryUi::DisplayErrorNoteL(const TDesC& aText)

EXPORT_C void CSecQueryUi::DisplayPermanentNoteL(const TDesC& aText)

EXPORT_C void CSecQueryUi::DisplayProgressNoteL(const TDesC& aText,

        TInt aFinalValue)

    /*

     ClearParamsAndSetNoteTypeL( ESecQueryUiProgressNoteType );

     AddParamL( KSecQueryUiProgressNoteText, aText );

     AddParamL( KSecQueryUiProgressNoteFinalValue, aFinalValue );

     DisplayDeviceDialogL();

     */}

EXPORT_C void CSecQueryUi::UpdateProgressNoteValueL(TInt aNewValue)

    /*

     ClearParamsAndSetNoteTypeL( ESecQueryUiProgressNoteType );

     AddParamL( KSecQueryUiProgressNoteValue, aNewValue );

     DisplayDeviceDialogL();

     */}

EXPORT_C void CSecQueryUi::DisplayWaitNoteL(const TDesC& aText,

        TRequestStatus& aStatus)

EXPORT_C void CSecQueryUi::LaunchHelpL(const TDesC& aContext,

        const TUid& aUid)

EXPORT_C void CSecQueryUi::LaunchHelpL(const TDesC& aContext)

    LaunchHelpL(aContext, KSWInstHelpUid);

    RDEBUG("0", 0);

    if (iWait && iWait->IsStarted() && iWait->CanStopNow())

    RDEBUG("0", 0);

    RDEBUG("0", 0);

    if (iWait)

    RDEBUG("0", 0);

void CSecQueryUi::DataReceived(CHbSymbianVariantMap& aData)

    RDEBUG("0", 0);

    const CHbSymbianVariant* acceptedVariant = aData.Get(_L("accepted")); // KSecQueryUiQueryAccepted

    RDEBUG("0", 0);

    if (acceptedVariant)

        RDEBUG("0", 0);

        TInt* acceptedValue = acceptedVariant->Value<TInt> ();

        RDEBUG("acceptedValue", acceptedValue);

        RDEBUG("*acceptedValue", *acceptedValue);

        if (acceptedValue)

    const CHbSymbianVariant* acceptedVariantTop = aData.Get(_L("codeTop")); // KSecQueryUiQueryAccepted

    RDEBUG("0", 0);

    if (acceptedVariantTop)

        TPtrC acceptedValueTop = *acceptedVariantTop->Value<TDesC> ();

        RDEBUG("acceptedValueTop", 0);

        RDebug::Print(acceptedValueTop);

        iPassword.Copy(acceptedValueTop);

        if (iReturnValue == KErrCompletion) // the user didn't OK. It was send automatically because validating new lock code through TARM

            {

            _LIT(KInvalidNewLockCode, "invalidNewLockCode");

            _LIT(KInvalidNewLockCode0, "invalidNewLockCode#0");

            _LIT(KInvalidNewLockCode1, "invalidNewLockCode#1");

            _LIT(KInvalidNewLockCode2, "invalidNewLockCode#2");

            AddParamL(KInvalidNewLockCode, KInvalidNewLockCode0); // for starter

            newCode.Copy(acceptedValueTop);

            RDEBUG("scpClient.Connect", 0);

            if (scpClient.Connect() == KErrNone)

                 RArray<TDevicelockPolicies> aFailedPolicies;

                 TDevicelockPolicies failedPolicy;

                 TInt retLockcode = KErrNone;

                 RDEBUG( "scpClient.VerifyNewLockcodeAgainstPolicies", 0 );

                 retLockcode = scpClient.VerifyNewLockcodeAgainstPolicies( newCode, aFailedPolicies );

                 RDEBUG( "retLockcode", retLockcode );

                 RDEBUG( "aFailedPolicies.Count()", aFailedPolicies.Count() );

                 for(TInt i=0; i<aFailedPolicies.Count(); i++)

                 {

                 failedPolicy = aFailedPolicies[i];

                 RDEBUG( "failedPolicy", failedPolicy );

                 TBuf<0x100> KInvalidNewLockCodeX;   KInvalidNewLockCodeX.Zero();    KInvalidNewLockCodeX.Append(_L("invalidNewLockCode"));  KInvalidNewLockCodeX.Append(_L("#"));

                 KInvalidNewLockCodeX.AppendNum(failedPolicy);

                 AddParamL( KInvalidNewLockCode, KInvalidNewLockCodeX );

                 }

                 */

                // TODO this should be able to modify MinLenght, MaxLenght

                }

            RDEBUG("iDeviceDialog->Update", 0);

            iDeviceDialog->Update(*iVariantMap);

            } // KErrCompletion

        if (acceptedValueTop.Length() <= 4) // TODO store aMinLenght and check it here, instead of "4"

            {

            RDEBUG("CPhCltEmergencyCall", 0);

            CPhCltEmergencyCall* emergencyCall = CPhCltEmergencyCall::NewL(

                    NULL);

            RDEBUG("PushL", 0);

            CleanupStack::PushL(emergencyCall);

            TPhCltEmergencyNumber emNumber;

            // this relies on the fact that emergency has 3 digits, and password needs at least 4

            TBool isEmergency(EFalse);

            RDEBUG("calling IsEmergencyPhoneNumber", 0);

            TInt error = emergencyCall->IsEmergencyPhoneNumber(

                    acceptedValueTop, isEmergency);

            RDEBUG("error", error);

            RDEBUG("emNumber", 0);

            RDEBUG("isEmergency", isEmergency);

#ifdef __WINS__

            RDEBUG( "__WINS__ checking", 0 );

            if(!acceptedValueTop.CompareF(_L("112")) || !acceptedValueTop.CompareF(_L("911")) || !acceptedValueTop.CompareF(_L("555")) )

                {

                isEmergency = ETrue;

                error = KErrNone;

                RDEBUG( "__WINS__ isEmergency", isEmergency );

                }

#endif

            if (!error) // oddly enough, missing capabilities also gives KErrNone

                {

                if (iReturnValue == KErrAbort) // the user didn't OK. It was send automatically because short code

                    {

                    _LIT(KEmergency, "emergency");

                    _LIT(KEmergencyValueYes, "emergencyYes");

                    _LIT(KEmergencyValueNo, "emergencyNo");

                    if (isEmergency)

                        {

                        RDEBUG("KEmergencyValueYes", 1);

                        AddParamL(KEmergency, KEmergencyValueYes);

                        }

                    else

                        {

                        RDEBUG("KEmergencyValueNo", 0);

                        AddParamL(KEmergency, KEmergencyValueNo);

                        }

                    iDeviceDialog->Update(*iVariantMap);

                    }

                else if (iReturnValue == KErrNone)

                    { // user pressed Call and number is valid

                    if (isEmergency)

                        {

                        RDEBUG("DialEmergencyCallL", isEmergency);

                        emergencyCall->DialEmergencyCallL(emNumber);

                        iReturnValue = KErrAbort; // this means emergency call

                        }

                    }

                } // if !error

            RDEBUG("0", 0);

            CleanupStack::PopAndDestroy(emergencyCall);

            } // lenght<3

        } // acceptedVariantTop

    RDEBUG("iReturnValue", iReturnValue);

void CSecQueryUi::DeviceDialogClosed(TInt aCompletionCode)

    RDEBUG("aCompletionCode", aCompletionCode);

    TRequestStatus* status(&iStatus);

    RDEBUG("0", 0);

    User::RequestComplete(status, KErrNone);

    RDEBUG("0", 0);

CSecQueryUi::CSecQueryUi() :

    CActive(CActive::EPriorityStandard)

    RDEBUG("0", 0);

    CActiveScheduler::Add(this);

    RDEBUG("0", 0);

    iWait = new (ELeave) CActiveSchedulerWait;

    RDEBUG("0", 0);

    if (iVariantMap)