const TInt KTriesToConnectServer(2);

const TInt KTimeBeforeRetryingRequest(50000);

EXPORT_C CSecurityHandler::CSecurityHandler(RMobilePhone& aPhone) :

    iPhone(aPhone), iQueryCanceled(ETrue), iSecurityDlg(NULL), iNoteDlg(NULL)

    RDEBUG("0", 0);

    TInt result = iCustomPhone.Open(aPhone);

    TRAP_IGNORE(FeatureManager::InitializeLibL()); //Shouldn't this panic if FM does not initialise??

    RDEBUG("0", 0);

    if (iDestroyedPtr)

        RMobilePhone::TMobilePhoneSecurityEvent aEvent)

    RDEBUG("0", 0);

    HandleEventL(aEvent, result);

    }

//

// ----------------------------------------------------------

// CSecurityHandler::HandleEventL()

// Handles different security events

// ----------------------------------------------------------

// qtdone

EXPORT_C void CSecurityHandler::HandleEventL(

        RMobilePhone::TMobilePhoneSecurityEvent aEvent, TBool aStartup,

        TInt& aResult)

    {

    RDEBUG("0", 0);

    iStartup = aStartup;

    HandleEventL(aEvent, aResult);

        RMobilePhone::TMobilePhoneSecurityEvent aEvent, TInt& aResult)

    RDEBUG("0", 0);

     *    Series 60 Customer / ETel

     *    Series 60  ETel API

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

    TBool wcdmaSupported(

            FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma));

    TBool upinSupported(FeatureManager::FeatureSupported( KFeatureIdUpin));

    RDEBUG("aEvent", aEvent);

    switch (aEvent)

        {

        case RMobilePhone::EPin1Required:

#if defined(_DEBUG)

            RDebug::Print(_L("(SECUI)CSecurityHandler::HandleEventL() Pin1Required"));

#endif

            aResult = Pin1RequiredL();

            break;

        case RMobilePhone::EPuk1Required:

#if defined(_DEBUG)

            RDebug::Print(_L("(SECUI)CSecurityHandler::HandleEventL() PUK1Required"));

#endif

            Puk1RequiredL();

            break;

        case RMobilePhone::EPin2Required:

            Pin2RequiredL();

            break;

        case RMobilePhone::EPuk2Required:

            Puk2RequiredL();

            break;

        case RMobilePhone::EUniversalPinRequired:

            if (wcdmaSupported || upinSupported)

                {

                aResult = UPinRequiredL();

                }

            else

                aResult = KErrNotSupported;

            break;

        case RMobilePhone::EUniversalPukRequired:

            if (wcdmaSupported || upinSupported)

                {

                aResult = UPukRequiredL();

                }

            else

                aResult = KErrNotSupported;

            break;

        case RMobilePhone::EPhonePasswordRequired:

            aResult = PassPhraseRequiredL();

            break;

        case RMobilePhone::EICCTerminated:

            SimLockEventL();

            break;

        default:

            break;

        }

    RDEBUG("aResult", aResult);

    {

     *    Series 60 Customer / ETel

     *    Series 60  ETel API

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

#if defined(_DEBUG)

#endif

    const TUid KCRUidSCPLockCode =

        {

        0x2002677B

        };

    TInt res = -1;

    TInt lAlphaSupported = 0;

    TInt lCancelSupported = 0;

    res = repository->Get(KSCPLockCodeDefaultLockCode, currentLockStatus);

    RDEBUG("res", res);

    RDEBUG("currentLockStatus", currentLockStatus);

    if (res == 0 && currentLockStatus == 1)

    RMobilePhone::TMobilePassword iSecUi_password;

    while (queryAccepted != KErrNone)

        {

        RMobilePhone::TMobilePhoneSecurityCode secCodeType;

        secCodeType = RMobilePhone::ESecurityCodePhonePassword;

        /* request PIN using QT */

        CSecQueryUi *iSecQueryUi;

        RDEBUG("CSecQueryUi", 0);

        iSecQueryUi = CSecQueryUi::NewL();

        lAlphaSupported = ESecUiAlphaSupported;

        lCancelSupported = ESecUiCancelSupported;

        TBuf<0x100> title;

        title.Zero();

        title.Append(_L("AskSecCodeL"));

        title.Append(_L("#"));

        title.AppendNum(-1);

        queryAccepted

                = iSecQueryUi->SecQueryDialog(title, iSecUi_password,

                        SEC_C_SECURITY_CODE_MIN_LENGTH,

                        SEC_C_SECURITY_CODE_MAX_LENGTH, ESecUiSecretSupported

                                | lAlphaSupported | lCancelSupported

                                | secCodeType /*aMode*/);

        RDEBUG("iSecUi_password", 0);

        RDebug::Print(iSecUi_password);

        RDEBUG("delete", 0);

        delete iSecQueryUi;

        RDEBUG("queryAccepted", queryAccepted);

        /* end request PIN using QT */

        if (queryAccepted != KErrNone)

            {

            ret = EFalse;

            return ret;

            }

        CWait* wait = CWait::NewL();

        RDEBUG("VerifySecurityCode", 0);

        iPhone.VerifySecurityCode(wait->iStatus, secCodeType,

                iSecUi_password, required_fourth);

        RDEBUG("WaitForRequestL", 0);

        status = wait->WaitForRequestL();

        RDEBUG("status", status);

        delete wait;

#ifdef __WINS__

        if(status==KErrNotSupported || status == KErrTimedOut)

            {

            RDEBUG( "status", status );

            status=KErrNone;

            }

#endif

        ret = ETrue;

        queryAccepted = KErrCancel; // because it's not yet validated

        switch (status)

            {

            case KErrNone:

                {

                if (FeatureManager::FeatureSupported(

                        KFeatureIdSapTerminalControlFw)

                        && !(FeatureManager::FeatureSupported(

                                KFeatureIdSapDeviceLockEnhancements)))

                    RDEBUG("calling RSCPClient", 0);

                    RSCPClient scpClient;

                    User::LeaveIfError(scpClient.Connect());

                    CleanupClosePushL(scpClient);

                    TSCPSecCode newCode;

                    newCode.Copy(iSecUi_password);

                    scpClient.StoreCode(newCode);

                    RDEBUG("called StoreCode", 1);

                    CleanupStack::PopAndDestroy(); //scpClient

                    queryAccepted = KErrNone;

                    }

                iQueryCanceled = ETrue; // TODO

                return ETrue;

                }

            case KErrGsmSSPasswordAttemptsViolation:

            case KErrLocked:

                {

                // security code blocked! 

                CSecuritySettings::ShowResultNoteL(R_SEC_BLOCKED,

                        CAknNoteDialog::EErrorTone);

                break;

                }

            case KErrGsm0707IncorrectPassword:

            case KErrAccessDenied:

                {

                // code was entered erroneusly

                CSecuritySettings::ShowResultNoteL(R_CODE_ERROR,

                        CAknNoteDialog::EErrorTone);

                }

            default:

                {

                CSecuritySettings::ShowResultNoteL(status,

                        CAknNoteDialog::EErrorTone);

                }

            }

EXPORT_C void CSecurityHandler::CancelSecCodeQuery()

#if defined(_DEBUG)

#endif

     *    Series 60 Customer / ETel

     *    Series 60  ETel API

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

    RDEBUG("0", 0);

#if defined(_DEBUG)

#endif

    RMobilePhone::TMobilePhoneLockSetting lockChange(

            RMobilePhone::ELockSetDisabled);

#if defined(_DEBUG)

#endif

    RDEBUG("res", res);

#if defined(_DEBUG)

#endif

        RDEBUG("period", period);

        if (period == 0)

#if defined(_DEBUG)

#endif

                RDEBUG( "0", 0 );

#ifdef _DEBUG

#endif // _DEBUG

#ifdef _DEBUG

#endif // _DEBUG

#ifdef _DEBUG

#endif // _DEBUG

            lockChange = RMobilePhone::ELockSetDisabled;

            RDEBUG("lockChange", lockChange);

            wait = CWait::NewL();

            RDEBUG("0", 0);

            // this also calls PassPhraseRequiredL ???

            RDEBUG("SetLockSetting", 1);

            iPhone.SetLockSetting(wait->iStatus, lockType, lockChange);

            res = KErrNone;

            RDEBUG("WaitForRequestL", 0);

            res = wait->WaitForRequestL();

            RDEBUG("res", res);

            delete wait;

#if defined(_DEBUG)

            RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() SetLockSetting RESULT:%d"), res);

#endif

            } // from   period == 0

            { // ask security code

#if defined(_DEBUG)

            RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() Ask sec code via notifier"));

#endif

            RDEBUG("0", 0);

            RNotifier codeQueryNotifier;

            User::LeaveIfError(codeQueryNotifier.Connect());

            CWait* wait = CWait::NewL();

            CleanupStack::PushL(wait);

            TInt queryResponse = 0;

            TPckg<TInt> response(queryResponse);

            RDEBUG("0", 0);

            TSecurityNotificationPckg params;