--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/remotelock/RemoteLockEngine/Src/RemoteLock.cpp Tue Jan 26 15:20:08 2010 +0200
@@ -0,0 +1,1519 @@
+/*
+* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Implementation of RemoteLock Engine
+*
+*/
+
+
+// INCLUDE FILES
+#include <smscmds.h>
+#include <smutset.h>
+#include <smuthdr.h>
+#include <e32property.h>
+#include <PSVariables.h>
+#include <mtclreg.h> //CClientMtmRegistry
+#include <smsclnt.h> //CSmsClientMtm
+#include <txtrich.h>
+#include <bautils.h> //file system utilities
+#include <remotelock.rsg>
+#ifdef RD_MULTIPLE_DRIVE
+#include <driveinfo.h>
+#else
+#include <pathinfo.h>
+#endif //RD_MULTIPLE_DRIVE
+#include <coreapplicationuisdomainpskeys.h>
+#include <charconv.h>
+#include <ProfileEngineSDKCRKeys.h>
+#include <Profile.hrh>
+#include <stringresourcereader.h> //CStringResourceReader
+#include "RemoteLockTrace.h"
+#include "RemoteLock.h"
+
+// EXTERNAL DATA STRUCTURES
+
+// EXTERNAL FUNCTION PROTOTYPES
+
+// CONSTANTS
+
+_LIT( KRLockResourceFileName ,"z:\\Resource\\apps\\Remotelock.RSC" );
+
+//Interval of reconnecting to the message server
+const TInt KRLockTimerInterval( 10000000 );
+const TInt KRLockMaxMemoryCardPasswdLength( 8 );
+const TInt KBufLengthInUnicodeCheck = 200;
+
+// MACROS
+
+// LOCAL CONSTANTS AND MACROS
+
+// MODULE DATA STRUCTURES
+
+// LOCAL FUNCTION PROTOTYPES
+
+// FORWARD DECLARATIONS
+
+// ---------------------------------------------------------------------------
+// E32Main()
+// ---------------------------------------------------------------------------
+//
+GLDEF_C TInt E32Main()
+ {
+ __UHEAP_MARK;
+ if ( User::TrapHandler() != NULL )
+ {
+ User::SetTrapHandler( NULL );
+ }
+
+ CTrapCleanup* cleanup = CTrapCleanup::New();
+ if ( !cleanup )
+ {
+ return KErrNone;
+ }
+
+ TRAPD( err, ThreadStartL() );
+ ( void ) err;
+
+ delete cleanup;
+ __UHEAP_MARKEND;
+
+ return err;
+ }
+
+
+// ---------------------------------------------------------------------------
+// ThreadStartL()
+// ---------------------------------------------------------------------------
+//
+LOCAL_C TInt ThreadStartL()
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] Inside ThreadStartL() ");
+ CActiveScheduler *threadScheduler = new CActiveScheduler;
+
+ CleanupStack::PushL( threadScheduler );
+
+ CActiveScheduler::Install( threadScheduler );
+
+ RL_TRACE_PRINT(" [ rl.exe ] Create remotelock object ");
+
+ CRemoteLock* remoteLock = CRemoteLock::NewL();
+
+ RL_TRACE_PRINT(" [ rl.exe ] Creation of Remotelock is done" );
+
+ CleanupStack::PushL( remoteLock );
+
+ RL_TRACE_PRINT(" Doing Rendezvous...");
+ // Initialisation complete, now signal the client
+ RProcess::Rendezvous(KErrNone);
+
+ CActiveScheduler::Start();
+
+ CleanupStack::PopAndDestroy( 2 );
+
+ return KErrNone;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::NewL
+// Two-Phased constructor.
+// ---------------------------------------------------------------------------
+//
+CRemoteLock* CRemoteLock::NewL()
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] NewL()");
+
+ CRemoteLock* self = new ( ELeave ) CRemoteLock;
+
+ CleanupStack::PushL( self );
+
+ self->ConstructL();
+
+ CleanupStack::Pop();
+
+ RL_TRACE_PRINT(" [ rl.exe ] exit NewL() ");
+
+ return self;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Destructor
+// ---------------------------------------------------------------------------
+CRemoteLock::~CRemoteLock()
+ {
+ Cancel();
+ delete iRemoteLockSetting;
+ delete iRemoteLockCode;
+ delete iMemoryCardPasswd;
+ delete iStoredCode;
+ delete iStoredTrimmedCode;
+ delete iClientMtmForSending;
+ delete iMtmReg;
+ delete iMsvSession;
+ delete iObserver;
+
+ if ( iProfileNotifyHandler )
+ {
+ iProfileNotifyHandler->StopListening();
+ delete iProfileNotifyHandler;
+ }
+ delete iProfileSession;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::HandleSessionEventL
+//
+// Called by message server when new event occures.
+// ---------------------------------------------------------------------------
+//
+void CRemoteLock::HandleSessionEventL(
+ TMsvSessionEvent aEvent,
+ TAny* aArg1,
+ TAny* aArg2,
+ TAny* /*aArg3*/ )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] HandleSessionEventL() ");
+ switch ( aEvent )
+ {
+ // A new entry has been created in the message server
+ case EMsvEntriesCreated:
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] HandleSessionEventL() 1");
+ if ( !iIsEnabled )
+ {
+ // Do nothing if remote lock is disabled
+ return;
+ }
+
+ if ( *( static_cast<TMsvId*>( aArg2 ) ) !=
+ KMsvGlobalInBoxIndexEntryId )
+ {
+ // Doing nothing if not to inbox
+ return;
+ }
+
+ CMsvEntrySelection* entries =
+ static_cast<CMsvEntrySelection*>( aArg1 );
+
+ for ( TInt i = 0; i < entries->Count(); i++ )
+ {
+ TMsvEntry entryInfo;
+ TMsvId serviceId;
+ iMsvSession->GetEntry( entries->At( i ), serviceId, entryInfo );
+
+ if ( entryInfo.iMtm != KUidMsgTypeSMS ||
+ entryInfo.iDescription.Length() > KRLockMaxLockCodeLength ||
+ entryInfo.iDescription.Length() == 0)
+ {
+ // Doing nothing if not a SMS, or length not appropriate.
+ return;
+ }
+
+ // For performance reasons, lets first compare the content of
+ // the SMS (taken from the TMsvEntry, containing no extra
+ // spaces) against the saved digest of a trimmed remote lock
+ // code. This way unnecessary access to CMsvEntry is avoided
+ // if these two do not match.
+
+
+ if ( iRemoteLockSetting->CompareLockCodesL(
+ entryInfo.iDescription, *iStoredTrimmedCode ) )
+ {
+ CMsvEntry* entry =
+ iMsvSession->GetEntryL( entries->At( i ) );
+
+ // The CMsvEntry object must be deleted by the client
+ // when it is no longer required.
+ CleanupStack::PushL( entry );
+
+ TRAPD( error, HandleMessageL( entry ) );
+
+ CleanupStack::PopAndDestroy( 1 ); // entry
+
+ delete iRemoteLockCode;
+ iRemoteLockCode = NULL;
+
+ User::LeaveIfError( error );
+ } // if
+ } // for
+ break;
+ } // case
+
+ // When message server is closed and server terminated
+ case EMsvCloseSession:
+ case EMsvServerFailedToStart:
+ case EMsvServerTerminated:
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] HandleSessionEventL() 2");
+ // When server is terminated remote lock will
+ // try to reconnect it in every 10 seconds.
+ After( KRLockTimerInterval );
+ break;
+ }
+
+ default:
+ break;
+ }
+ RL_TRACE_PRINT(" [ rl.exe ] exit HandleSessionEventL() ");
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::HandleRemoteLockNotifyL
+// Function is called when remote lock setting is changed by client
+// ---------------------------------------------------------------------------
+//
+void CRemoteLock::HandleRemoteLockNotifyL()
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] HandleNotify() ");
+ CheckSettingsL();
+ RL_TRACE_PRINT(" [ rl.exe ] exit HandleNotify() ")
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::CRemoteLock
+// default constructor
+// ---------------------------------------------------------------------------
+CRemoteLock::CRemoteLock() : CTimer( CActive::EPriorityStandard )
+ {
+ iRemoteLockCode = NULL;
+ iMemoryCardPasswd = NULL;
+ iStoredCode = NULL;
+ iStoredTrimmedCode = NULL;
+ iClientMtmForSending = NULL;
+ iMtmReg = NULL;
+ iRemoteLockSetting = NULL;
+ iMsvSession = NULL;
+ iIsEnabled = EFalse;
+ iLockedByRL = EFalse;
+ iMemoryCardLockedByRL = EFalse;
+ iSubscribeProfile = EFalse;
+ iProfileSession = NULL;
+ iObserver = NULL;
+ iProfileNotifyHandler = NULL;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::ConstructL
+// Symbian 2nd phase constructor can leave.
+// ---------------------------------------------------------------------------
+//
+void CRemoteLock::ConstructL()
+ {
+ RL_TRACE_PRINT(" [ Rl.exe ] ConstructL()");
+
+ CTimer::ConstructL();
+
+ iRemoteLockSetting = CRemoteLockSettings::NewL( this );
+
+ iRemoteLockSetting->RemoteLockNotifyL( ETrue );
+
+ CheckSettingsL();
+ // Add active object into active scheduler
+ CActiveScheduler::Add( this );
+
+
+
+ RL_TRACE_PRINT(" [ rl.exe ] exit ConstructL() ");
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::HandleMessageL()
+//
+// Handles the message: checks if it really is remote lock message, and acts
+// accordingly.
+// ---------------------------------------------------------------------------
+//
+void CRemoteLock::HandleMessageL( CMsvEntry* aEntry )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() ");
+ delete iRemoteLockCode;
+ iRemoteLockCode = NULL;
+ TMsvEntry entryInfo = aEntry->Entry();
+ if ( !iMtmReg )
+ {
+ iMtmReg = CClientMtmRegistry::NewL( *iMsvSession );
+ }
+
+ // Loops 100 times to ensure the clientMtm is correctly created
+ CBaseMtm* clientMtm = NULL;
+ TInt error = 0;
+ TInt i;
+ for ( i = 0; i < 100; i++ )
+ {
+ TRAP( error, clientMtm = iMtmReg->NewMtmL( entryInfo.iMtm ));
+ if ( error == KErrNone )
+ {
+ break;
+ }
+ }
+
+ RL_TRACE_PRINT_NUM("[rl.exe] HandleMessageL() error after NewMTmL = %d", error );
+
+ User::LeaveIfError( error );
+ CleanupStack::PushL( clientMtm );
+
+ clientMtm->SwitchCurrentEntryL( entryInfo.Id() );
+
+ RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() after switch Current EntryL");
+
+ CSmsClientMtm* smsClientMTM = STATIC_CAST( CSmsClientMtm*, clientMtm );
+
+ // Change from 100 to 20. When the message storage is memory card.
+ // LoadMessageL() function return -21 when loading the message.
+ // It might be caused by slow operation, so we add 0.05 seconds pending
+ // in each loop.
+ // @ check why loading operation is slow!
+ for ( i = 0; i < 20; i++ )
+ {
+ RL_TRACE_PRINT_NUM("[rl.exe] HandleMessageL() error load message1 = %d", error );
+
+ // Loops 100 times to ensure the LoadMessageL() succeedes
+ TRAP( error, smsClientMTM->LoadMessageL() );
+
+ RL_TRACE_PRINT_NUM("[rl.exe] HandleMessageL() error load message2 = %d", error );
+
+ if ( error == KErrNone )
+ {
+ break;
+ }
+
+ const TInt KDelay = 50000; // 0.05s
+ User::After( KDelay );
+ }
+
+ RL_TRACE_PRINT_NUM("[rl.exe] HandleMessageL() error after LoadMessageL = %d", error );
+
+ User::LeaveIfError( error );
+
+ CRichText& mtmBody = smsClientMTM->Body();
+
+ // Let's then use the real content of the SMS (taken from
+ // the message body) and compare that against the
+ // saved digest of a complete (not trimmed) remote lock
+ // code. This ensures that remote locking happens only
+ // if the SMS is exactly the same as what the user has
+ // specified.
+ iRemoteLockCode = HBufC::NewL( mtmBody.DocumentLength() );
+
+ TPtr smsTextPtr = iRemoteLockCode->Des();
+ smsTextPtr.Copy( mtmBody.Read( 0, mtmBody.DocumentLength() ) );
+
+
+ // The following code is to get the current state
+ // of manuallock. If manuallock state is off, that means
+ // the owner has unlocked the phone or the phone has
+ // never been locked by both remote lock and auto lock.
+ RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() Pub&Sub Get autoLState");
+ TInt autoLState;
+ RProperty property;
+
+ #ifndef RD_STARTUP_CHANGE
+ User::LeaveIfError( property.Attach( KUidSystemCategory, KPSUidAutolockStatusValue ));
+ #else
+ User::LeaveIfError( property.Attach( KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus ));
+ #endif //RD_STARTUP_CHANGE
+ property.Get( autoLState );
+
+ #ifndef RD_STARTUP_CHANGE
+ if ( autoLState == EPSAutolockOff )
+ #else
+ if ( autoLState == EAutolockOff )
+ #endif //RD_STARTUP_CHANGE
+ {
+ //Assign iLockedByRL to EFalse to indicate that
+ //the phone is not locked by Remote lock, the
+ //reply SMS should be sent if correct remote lock
+ //code is received.
+ iLockedByRL = EFalse;
+ }
+
+ property.Close();
+
+ // If the phone receives correct lock code, the phone
+ // will be locked eventhough it may have been locked by
+ // auto lock.
+
+ if ( VerifyAndLockL() )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() After VerifyAndLockL() ");
+ // Sets remote lock sms as read
+ entryInfo.SetVisible( ETrue );
+ entryInfo.SetUnread( EFalse );
+ entryInfo.SetNew( EFalse );
+ entryInfo.SetInPreparation( EFalse );
+ entryInfo.SetReadOnly( ETrue );
+ aEntry->ChangeL( entryInfo );
+
+
+ // Locks MemoryCard drive.
+ iStateMemoryCard = SetMemoryCardPasswdL( EFalse );
+
+ if ( iClientMtmForSending )
+ {
+ // Previous reply sending is still in progress, let's not start
+ // sending new one.
+ User::Leave( KErrNone );
+ }
+
+ // The value of iLockedByRL is checked before sending SMS
+ // to make sure if the phone has been locked by remote
+ // lock. By doing this, it is able to avoid the threat where
+ // malware tries to use remote lock to keep on sending SMS.
+
+
+ if ( !iLockedByRL )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() Send re-SMS ");
+ // Replies sms
+ iLockedByRL = ETrue;
+ CSmsHeader& header = smsClientMTM->SmsHeader();
+ HBufC* recipientAddress = header.FromAddress().AllocLC();
+
+ TBool initialSendMessage = EFalse;
+ TRAP( error, initialSendMessage = InitialSendMessageL() );
+ if ( error != KErrNone )
+ {
+ delete iClientMtmForSending;
+ iClientMtmForSending = NULL;
+ User::Leave( error );
+ }
+
+ RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() Check recipientaddresslenght ");
+ if ( recipientAddress->Length() > 0 && initialSendMessage )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() before call sendMEssage ");
+ TRAP( error, SendMessageL( *recipientAddress ) );
+ if ( error != KErrNone )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() error occurs ");
+ delete iClientMtmForSending;
+ iClientMtmForSending = NULL;
+ User::Leave( error );
+ }
+ }
+ delete iClientMtmForSending;
+ iClientMtmForSending = NULL;
+
+ CleanupStack::PopAndDestroy( 1 ); // recipientAddress
+ }
+ CleanupStack::PopAndDestroy( 1 ); // clientMtm
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy( 1 ); // clientMtm
+ }
+ RL_TRACE_PRINT(" [ rl.exe ] exit HandleMessageL() ");
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::VerifyAndLockL()
+//
+// Compares if the remote lock received in SMS is correct.
+// If correct, locks the terminal.
+// ---------------------------------------------------------------------------
+//
+TBool CRemoteLock::VerifyAndLockL()
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] VerifyAndLockL() ");
+
+ User::LeaveIfNull( iRemoteLockCode );
+ User::LeaveIfNull( iStoredCode );
+
+ if ( iRemoteLockSetting->CompareLockCodesL(
+ *iRemoteLockCode, *iStoredCode ) )
+ {
+ return ActivateDeviceLock();
+ }
+ RL_TRACE_PRINT(" [ rl.exe ] exit VerifyAndLockL() ");
+ return EFalse;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::ActivateDeviceLock()
+// Activate the device lock to lock the phone
+// ---------------------------------------------------------------------------
+//
+TBool CRemoteLock::ActivateDeviceLock()
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] ActivateDeviceLock() ");
+
+ RProperty property;
+
+ TInt err = 0;
+
+ #ifndef RD_STARTUP_CHANGE
+ err = property.Attach( KUidSystemCategory,
+ KPSUidAutolockStatusValue );
+ #else
+ err = property.Attach( KPSUidCoreApplicationUIs,
+ KCoreAppUIsAutolockStatus );
+ #endif
+ if ( err != KErrNone )
+ {
+ return EFalse;
+ }
+
+ #ifndef RD_STARTUP_CHANGE
+ property.Set( EPSRemoteLocked );
+ #else
+ property.Set( ERemoteLocked );
+ #endif //RD_STARTUP_CHANGE
+
+ property.Close();
+ RL_TRACE_PRINT(" [ rl.exe ] exit ActivateDeviceLock() ");
+ return ETrue;
+ }
+
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::CheckSettingsL
+// Checks remote lock setting.
+// ---------------------------------------------------------------------------
+//
+void CRemoteLock::CheckSettingsL()
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] CheckSettingsL () ");
+ iRemoteLockSetting->GetEnabled( iIsEnabled );
+
+ delete iStoredCode;
+ iStoredCode = NULL;
+ iStoredCode = HBufC::NewL( KRLockStoredLockCodeLength );
+ TPtr storedCodePtr = iStoredCode->Des();
+
+ delete iStoredTrimmedCode;
+ iStoredTrimmedCode = NULL;
+ iStoredTrimmedCode = HBufC::NewL( KRLockStoredLockCodeLength );
+ TPtr storedTrimmedCodePtr = iStoredTrimmedCode->Des();
+
+ iRemoteLockSetting->GetLockCode( storedCodePtr, storedTrimmedCodePtr );
+
+ if ( iIsEnabled )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] CheckSettingsL() enable ");
+
+ if ( !iMsvSession )
+ {
+ TRAPD( error, iMsvSession = CMsvSession::OpenAsyncL( *this ) );
+
+ RL_TRACE_PRINT_NUM(" [ rl.exe ] CheckSettingsL() openasyncL %d ", error );
+
+ if ( error != KErrNone )
+ {
+ After( KRLockTimerInterval );
+ }
+ }
+
+ if ( !iProfileSession )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] CheckSettingsL() create session ");
+ iProfileSession = CRepository::NewL( KCRUidProfileEngine );
+ }
+ if ( !iObserver )
+ {
+ iObserver = CRLLockObserver::NewL( this );
+ }
+ if( !iSubscribeProfile )
+ {
+ ProfileNotifyL( ETrue );
+ iSubscribeProfile = ETrue;
+ }
+ }
+ else
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] CheckSettingsL() disable ");
+
+ delete iClientMtmForSending;
+ iClientMtmForSending = NULL;
+ delete iMtmReg;
+ iMtmReg = NULL;
+ delete iMsvSession;
+ iMsvSession = NULL;
+
+ RL_TRACE_PRINT(" [ rl.exe ] CheckSettingsL() delete iMsvSession ");
+
+ if ( iSubscribeProfile )
+ {
+ if ( !iProfileSession )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] CheckSettingsL() create session ");
+ iProfileSession = CRepository::NewL( KCRUidProfileEngine );
+ }
+ ProfileNotifyL( EFalse );
+ delete iProfileSession;
+ iProfileSession = NULL;
+ delete iObserver;
+ iObserver = NULL;
+ iSubscribeProfile = EFalse;
+ }
+ }
+
+ RL_TRACE_PRINT(" [ rl.exe ] exit CheckSettingsL() ");
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::IsMemoryCardLocked
+// Check MemoryCard whether it is locked or not.
+// ---------------------------------------------------------------------------
+//
+TBool CRemoteLock::IsMemoryCardLocked( const TDriveInfo& aDriveInfo ) const
+ {
+ return aDriveInfo.iMediaAtt&( KMediaAttLocked );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::HasMemoryCardPassword
+// Check MemoryCard whether it has password.
+// ---------------------------------------------------------------------------
+//
+TBool CRemoteLock::HasMemoryCardPassword( const TDriveInfo& aDriveInfo ) const
+ {
+ return aDriveInfo.iMediaAtt&( KMediaAttHasPassword );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::IsMemoryCardPresent
+// Check MemoryCard whether it is mounted into the phone and it supports locking.
+// ---------------------------------------------------------------------------
+//
+TBool CRemoteLock::IsMemoryCardPresent( const TDriveInfo& aDriveInfo ) const
+ {
+ return aDriveInfo.iDriveAtt&( KDriveAttRemovable ) &&
+ aDriveInfo.iMediaAtt&( KMediaAttLockable );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::SetMemoryCardPasswdL
+// Sets/remove the password to MemoryCard.
+// ---------------------------------------------------------------------------
+//
+TBool CRemoteLock::SetMemoryCardPasswdL( const TBool aClear )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] SetMemoryCardPasswdL() ");
+ if ( aClear )
+ {
+ if ( iMemoryCardLockedByRL && iLockedByRL )
+ {
+ //remove the password
+ if ( DoSetMemoryCardPasswdL( ETrue ) )
+ {
+ iMemoryCardLockedByRL = EFalse;
+ RL_TRACE_PRINT(" [ rl.exe ] exit SetMemoryCardPasswdL() ");
+ return ETrue;
+ }
+ else
+ {
+ //Only try to remove password once no matter success or not
+ iMemoryCardLockedByRL = EFalse;
+ }
+
+ }
+ }
+ else
+ {
+ if ( iMemoryCardLockedByRL )
+ {
+ //the memory card is locked already by rlock,
+ //just return ETrue;
+ return ETrue;
+ }
+
+ if ( !iRemoteLockCode || iRemoteLockCode->Length() == 0 )
+ {
+ return EFalse;
+ }
+ //Change the password
+ if ( DoSetMemoryCardPasswdL( EFalse ) )
+ {
+ iMemoryCardLockedByRL = ETrue;
+ RL_TRACE_PRINT(" [ rl.exe ] exit SetMemoryCardPasswdL() ");
+ return ETrue;
+ }
+
+ }
+ RL_TRACE_PRINT(" [ rl.exe ] exit SetMemoryCardPasswdL() ");
+ return EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::DoSetMemoryCardPasswdL
+// Do Sets/remove the password to MemoryCard.
+// ---------------------------------------------------------------------------
+//
+TBool CRemoteLock::DoSetMemoryCardPasswdL( TBool aClear )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] DoSetMemoryCardPasswdL() ");
+ RFs fsMemoryCard;
+ TInt err = fsMemoryCard.Connect();
+ if ( err != KErrNone )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] DoSetMemoryCardPasswdL() error");
+ return EFalse;
+ }
+
+#ifdef RD_MULTIPLE_DRIVE
+
+ // Get the removeable user visible drives
+ TDriveList driveList;
+ TInt driveCount;
+
+ //Get all removeable drive, both physically and logically
+ User::LeaveIfError( DriveInfo::GetUserVisibleDrives(
+ fsMemoryCard, driveList, driveCount, KDriveAttRemovable ) );
+ RL_TRACE_PRINT_NUM(" [ rl.exe ] DoSetMemoryCardPasswdL() driveCount = %d ", driveCount );
+
+ //boolen to indicate at least one operation(clear/add password)
+ // in the loop is ok.
+ TBool OperationSucceed = EFalse;
+
+ RArray<TInt> arrayMemoryCardIndex;
+
+ TInt max( driveList.Length() );
+
+ for ( TInt i = 0; i < max; i++ )
+ {
+ if ( driveList[ i ] )
+ {
+ TUint status;
+ DriveInfo::GetDriveStatus( fsMemoryCard, i, status );
+ //To make sure the drive is physically removeable not logically removeable
+ if( status & DriveInfo::EDriveRemovable )
+ {
+ //append all physical removable memory card index into this array
+ arrayMemoryCardIndex.Append(i);
+ RL_TRACE_PRINT_NUM(" [ rl.exe ] DoSetMemoryCardPasswdL() physically removable drive %d", i );
+ }
+ else
+ {
+ RL_TRACE_PRINT_NUM(" [ rl.exe ] DoSetMemoryCardPasswdL() logically removable drive %d", i );
+ }
+ }
+ }
+
+ //Lock/Unblock all physical removeable memory card
+ for ( TInt i = 0; i < arrayMemoryCardIndex.Count(); i++ )
+ {
+ TDriveInfo driveInfoT;
+ TInt driveIndex = arrayMemoryCardIndex[i];
+ RL_TRACE_PRINT_NUM(" [ rl.exe ] DoSetMemoryCardPasswdL() driveIndex %d", driveIndex );
+ fsMemoryCard.Drive( driveInfoT, driveIndex );
+
+ if ( IsMemoryCardPresent( driveInfoT ) )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] Memory card is present");
+ if ( aClear )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] DoSetMemoryCardPasswdL() Remove password");
+ if ( HasMemoryCardPassword( driveInfoT ) || IsMemoryCardLocked( driveInfoT ) )
+ {
+ TMediaPassword memoryCardPassword;
+
+ // Converts MemoryCardpassword
+ ConvertMemoryCardPassword( memoryCardPassword, ETrue );
+
+ err = fsMemoryCard.ClearPassword( driveIndex, memoryCardPassword );
+
+ if ( err == KErrNone )
+ {
+ OperationSucceed = ETrue;
+ }
+
+ RL_TRACE_PRINT_NUM(" [ rl.exe ] exit DoSetMemoryCardPasswdL() password for index %d is cleaned", driveIndex);
+ //Go for next
+ }
+ else
+ {
+ //Go for next
+ }
+ }
+ else
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] DoSetMemoryCardPasswdL() Set password");
+ if ( !HasMemoryCardPassword( driveInfoT ) && !IsMemoryCardLocked( driveInfoT ) )
+ {
+ TMediaPassword memoryCardPassword;
+
+ TMediaPassword nullMemoryCardPassword;
+
+ // Converts MemoryCardpassword
+ ConvertMemoryCardPassword( memoryCardPassword, EFalse );
+
+ // Locks MemoryCard drive
+ err = fsMemoryCard.LockDrive( driveIndex, nullMemoryCardPassword, memoryCardPassword, ETrue );
+
+ if ( err == KErrNone )
+ {
+ OperationSucceed = ETrue;
+ }
+
+ RL_TRACE_PRINT_NUM(" [ rl.exe ] DoSetMemoryCardPasswdL() password for index %d is set", driveIndex);
+
+ //Go for next
+ }
+ else
+ {
+ //go for next
+ }
+ }
+ } //if ( IsMemoryCardPresent( driveInfoT ) )
+ } //for
+
+
+ if ( aClear )
+ {
+ delete iMemoryCardPasswd;
+ iMemoryCardPasswd = NULL;
+ fsMemoryCard.Close();
+
+ return OperationSucceed ? ETrue : EFalse;
+ }
+ else
+ {
+
+ delete iMemoryCardPasswd;
+ iMemoryCardPasswd = NULL;
+ iMemoryCardPasswd = iRemoteLockCode->AllocL();
+ fsMemoryCard.Close();
+
+ return OperationSucceed ? ETrue : EFalse;
+ }
+#else
+
+ TInt i = 0;
+ TParsePtrC folder( PathInfo::MemoryCardRootPath() );
+ fsMemoryCard.CharToDrive( folder.Drive()[ 0 ], i );
+
+ TDriveInfo driveInfoT;
+ fsMemoryCard.Drive( driveInfoT, i );
+
+ if ( IsMemoryCardPresent( driveInfoT ) )
+ {
+ if ( aClear )
+ {
+ if ( HasMemoryCardPassword( driveInfoT ) || IsMemoryCardLocked( driveInfoT ) )
+ {
+ TMediaPassword memoryCardPassword;
+ // Converts MemoryCardpassword
+ ConvertMemoryCardPassword( memoryCardPassword, ETrue );
+ err = fsMemoryCard.ClearPassword( i, memoryCardPassword );
+
+ if( err == KErrNone )
+ {
+ delete iMemoryCardPasswd;
+ iMemoryCardPasswd = NULL;
+ }
+ fsMemoryCard.Close();
+ RL_TRACE_PRINT(" [ rl.exe ] exit DoSetMemoryCardPasswdL() clear");
+ return ( err == KErrNone );
+ }
+ else
+ {
+ fsMemoryCard.Close();
+ return ETrue;
+ }
+ }
+ else
+ {
+ if ( !HasMemoryCardPassword( driveInfoT ) && !IsMemoryCardLocked( driveInfoT ) )
+ {
+ TMediaPassword memoryCardPassword;
+ TMediaPassword nullMemoryCardPassword;
+ // Converts MemoryCardpassword
+ ConvertMemoryCardPassword( memoryCardPassword, EFalse );
+ // Locks MemoryCard drive
+ err = fsMemoryCard.LockDrive( i, nullMemoryCardPassword, memoryCardPassword, ETrue );
+ if ( err == KErrNone )
+ {
+ if ( iMemoryCardPasswd )
+ {
+ delete iMemoryCardPasswd;
+ iMemoryCardPasswd = NULL;
+ }
+ iMemoryCardPasswd = iRemoteLockCode->AllocL();
+ }
+
+ fsMemoryCard.Close();
+ RL_TRACE_PRINT(" [ rl.exe ] exit DoSetMemoryCardPasswdL() change");
+ return ( err == KErrNone );
+ }
+ else
+ {
+ fsMemoryCard.Close();
+ return EFalse;
+ }
+ }
+ }
+ fsMemoryCard.Close();
+ return EFalse;
+
+#endif //RD_MULTIPLE_DRIVE
+ }
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::ConvertMemoryCardPasswordL
+// Converts MemoryCardPassword to acceptable format.
+// ---------------------------------------------------------------------------
+//
+void CRemoteLock::ConvertMemoryCardPassword( TMediaPassword& aPassword, const TBool aClear )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] ConvertMemoryCardPassword() ");
+
+ TBuf16 < KMaxMediaPassword / 2 > memoryCardPassword;
+ // Takes left most 8 digits of lockcode as
+ // the password of MemoryCard.
+ RL_TRACE_PRINT(" [ rl.exe ] ConvertMemoryCardPassword() 1");
+
+ if ( aClear )
+ {
+ if ( iMemoryCardPasswd )
+ {
+ memoryCardPassword.Copy( iMemoryCardPasswd->Left( KRLockMaxMemoryCardPasswdLength ) );
+ }
+ }
+ else
+ {
+ if ( iRemoteLockCode )
+ {
+ memoryCardPassword.Copy( iRemoteLockCode->Left( KRLockMaxMemoryCardPasswdLength ) );
+ }
+ }
+
+ // Fills the descriptor's data area with binary zeroes, i.e. 0x00,
+ // replacing any existing data.
+ RL_TRACE_PRINT(" [ rl.exe ] ConvertMemoryCardPassword() 2");
+ aPassword.FillZ( KMaxMediaPassword );
+
+ aPassword.Zero();
+ // Sets the length of the data to zero.
+ // Copies data into this descriptor replacing any existing data.
+ // The length of this descriptor is set to reflect the new data
+ RL_TRACE_PRINT(" [ rl.exe ] ConvertMemoryCardPassword() 3");
+ aPassword.Copy( reinterpret_cast<TUint8 *>
+ ( &memoryCardPassword[ 0 ] ), memoryCardPassword.Length() * 2 );
+
+ RL_TRACE_PRINT(" [ rl.exe ] ConvertMemoryCardPassword() over ");
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::InitialSendMessageL
+// Reply SMS when the terminal is successfully locked.
+// ---------------------------------------------------------------------------
+//
+TBool CRemoteLock::InitialSendMessageL()
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] InitialSendMessageL() ");
+
+ RProperty property;
+
+ TInt err = 0;
+
+ #ifndef RD_STARTUP_CHANGE
+ err = property.Attach( KUidSystemCategory, KPSUidAutolockStatusValue );
+ #else
+ err = property.Attach( KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus );
+ #endif
+
+ if ( err != KErrNone )
+ {
+ return EFalse;
+ }
+
+ TInt state = 0;
+
+ CleanupClosePushL( property );
+
+ err = property.Get( state );
+ if ( err != KErrNone )
+ {
+ CleanupStack::PopAndDestroy( 1 );
+ return EFalse;
+ }
+
+ #ifndef RD_STARTUP_CHANGE
+ if ( state == EPSRemoteLocked )
+ #else
+ if ( state == ERemoteLocked )
+ #endif // RD_STARTUP_CHANGE
+ {
+ // message server entry id
+ TMsvId msvId = NULL;
+ // Set up a new message
+ msvId = CreateNewMessageL();
+ //Set the new message to be the current entry
+ SetEntryL( msvId );
+ CleanupStack::PopAndDestroy( 1 ); // property
+ RL_TRACE_PRINT(" [ rl.exe ] exit InitialSendMessageL() ETrue ");
+ return ETrue;
+ }
+ CleanupStack::PopAndDestroy( 1 ); // property
+ RL_TRACE_PRINT(" [ rl.exe ] exit InitialSendMessageL() ");
+ return EFalse;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::CreateNewMessageL()
+// Creates a new message server entry and set up default values.
+// Return values: TMsvId (the id of created entry)
+// ---------------------------------------------------------------------------
+//
+TMsvId CRemoteLock::CreateNewMessageL()
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] CreateNewMessageL() ");
+ TMsvEntry newEntry;
+ // The type of message is SMS
+ newEntry.iMtm = KUidMsgTypeSMS;
+ // The type of the entry: message
+ newEntry.iType = KUidMsvMessageEntry;
+ newEntry.iServiceId = KMsvLocalServiceIndexEntryId;
+ // Set the date of the entry to home time
+ newEntry.iDate.UniversalTime();
+ newEntry.SetInPreparation( ETrue );
+
+ CMsvEntry* entry = CMsvEntry::NewL( *iMsvSession,
+ KMsvDraftEntryIdValue, TMsvSelectionOrdering() );
+ CleanupStack::PushL( entry );
+ CMsvOperationWait* wait = CMsvOperationWait::NewLC();
+ wait->Start();
+
+ // Asynchronously create a new entry.
+ CMsvOperation* oper = entry->CreateL( newEntry, wait->iStatus );
+ CleanupStack::PushL( oper );
+
+ CActiveScheduler::Start();
+
+ // Keep track of the progress of the create operation.
+ TMsvLocalOperationProgress progress =
+ McliUtils::GetLocalProgressL( *oper );
+ User::LeaveIfError( progress.iError );
+
+ // Set entry context to the created one
+ // operation progress contains the ID of the created entry
+ entry->SetEntryL( progress.iId );
+
+ CleanupStack::PopAndDestroy( 3 );
+ RL_TRACE_PRINT(" [ rl.exe ] CreateNewMessageL() end ");
+ return progress.iId;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::SetEntryL(TMsvId aEntryId)
+// Set up current message entry.
+// Note: It can be useful to remember the original entry id for
+// error handling.
+// ---------------------------------------------------------------------------
+//
+void CRemoteLock::SetEntryL( TMsvId aEntryId )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] SetEntryL() ");
+ // Get the server entry from our session
+ CMsvEntry* entry = iMsvSession->GetEntryL( aEntryId );
+ CleanupStack::PushL( entry );
+ delete iClientMtmForSending;
+ iClientMtmForSending = NULL;
+
+ TInt error;
+ TInt i;
+ for ( i = 0; i < 100; i++ )
+ {
+ TRAP( error,
+ iClientMtmForSending = iMtmReg->NewMtmL( entry->Entry().iMtm ) );
+ if ( error == KErrNone )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] SetEntryL() iClientMtmForSending ");
+ break;
+ }
+ }
+
+ User::LeaveIfError( error );
+ iClientMtmForSending->SetCurrentEntryL( entry );
+
+ CleanupStack::Pop( 1 ); // entry
+ RL_TRACE_PRINT(" [ rl.exe ] exit SetEntryL() ");
+ entry = NULL;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::MoveMessageEntryL(TMsvId aTarget) const
+// Moves an entry to another parent.
+// Return values: TMsvId of the moved message
+// ---------------------------------------------------------------------------
+//
+TMsvId CRemoteLock::MoveMessageEntryL( TMsvId aTarget )
+ {
+ User::LeaveIfNull( iClientMtmForSending );
+ TMsvEntry msvEntry( ( iClientMtmForSending->Entry() ).Entry() );
+ TMsvId id = msvEntry.Id();
+
+ if ( msvEntry.Parent() != aTarget )
+ {
+ TMsvSelectionOrdering sort;
+ sort.SetShowInvisibleEntries( ETrue );
+ // Take a handle to the parent entry
+ CMsvEntry* parentEntry =
+ CMsvEntry::NewL(
+ iClientMtmForSending->Session(), msvEntry.Parent(), sort );
+
+ CleanupStack::PushL( parentEntry );
+
+ // Move original from the parent to the new location
+ CMsvOperationWait* wait = CMsvOperationWait::NewLC();
+ wait->Start();
+
+ CMsvOperation* op =
+ parentEntry->MoveL( msvEntry.Id(), aTarget, wait->iStatus );
+
+ CleanupStack::PushL( op );
+ CActiveScheduler::Start();
+ TMsvLocalOperationProgress prog=McliUtils::GetLocalProgressL( *op );
+ User::LeaveIfError(prog.iError);
+
+ id = prog.iId;
+ CleanupStack::PopAndDestroy( 3 ); // op, wait, parentEntry
+ }
+ return id;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::SendMessageL
+// Reply SMS when the terminal is successfully locked.
+// Return values: ETrue or EFalse
+// ---------------------------------------------------------------------------
+//
+TBool CRemoteLock::SendMessageL( const TDesC& aRecipientAddress )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] SendMessageL() ");
+
+ User::LeaveIfNull( iClientMtmForSending );
+
+ RL_TRACE_PRINT(" [ rl.exe ] SendMessageL() 1 ");
+
+ TMsvEntry msvEntry = ( iClientMtmForSending->Entry() ).Entry();
+
+ // We get the message body from Mtm and insert a bodytext
+ CRichText& mtmBody = iClientMtmForSending->Body();
+ mtmBody.Reset();
+
+ TFileName fileName;
+ fileName = KRLockResourceFileName;
+
+ // Use CStringResourceReader instead of StringLoader
+ // StringLoader is meant for applications in app framework
+ CStringResourceReader* resourceReader = CStringResourceReader::NewLC( fileName );
+
+ RL_TRACE_PRINT(" [ rl.exe ] SendMessageL() 3");
+
+ HBufC* retBuf = NULL;
+
+ if ( iStateMemoryCard )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] SendMessageL() memory card locked");
+ // When memory card is locked.
+ TPtrC buf;
+ buf.Set( resourceReader->ReadResourceString(R_RLOC_TI_EVERYTHING_LOCKED) );
+ retBuf = buf.AllocLC();
+ }
+ else
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] SendMessageL() only phone locked ");
+ TPtrC buf;
+ buf.Set( resourceReader->ReadResourceString(R_RLOC_TI_PHONE_LOCKED) );
+ retBuf = buf.AllocLC();
+ }
+ mtmBody.InsertL( 0, *retBuf );
+ msvEntry.iDescription.Set( *retBuf );
+
+ // Set aRecipientAddress into the Details of the entry
+ msvEntry.iDetails.Set( aRecipientAddress );
+ msvEntry.SetInPreparation( EFalse );
+
+ // Set the sending state (immediately)
+ msvEntry.SetSendingState( KMsvSendStateWaiting );
+ msvEntry.iDate.UniversalTime();
+ // To handle the sms specifics we start using SmsMtm
+ CSmsClientMtm* smsMtm = STATIC_CAST( CSmsClientMtm*,
+ iClientMtmForSending );
+ smsMtm->RestoreServiceAndSettingsL();
+
+ // SMS MTM encapsulation of an SMS message.
+ CSmsHeader& header = smsMtm->SmsHeader();
+ CSmsSettings* sendOptions = CSmsSettings::NewL();
+ CleanupStack::PushL( sendOptions );
+ // Reset existing settings
+ sendOptions->CopyL( smsMtm->ServiceSettings() );
+ // Set unicode if needed
+ if ( NeedsToBeSentAsUnicodeL( retBuf->Des() ))
+ {
+ sendOptions->SetCharacterSet( TSmsDataCodingScheme::ESmsAlphabetUCS2 );
+ }
+ // Set send options to be delivered immediately
+ sendOptions->SetDelivery( ESmsDeliveryImmediately );
+ header.SetSmsSettingsL( *sendOptions );
+
+ // let's check if there's sc address
+ if (header.Message().ServiceCenterAddress().Length() == 0)
+ {
+ // no, there isn't. Use the default SC number.
+ CSmsSettings* serviceSettings = NULL;
+ serviceSettings = &( smsMtm->ServiceSettings() );
+
+ RL_TRACE_PRINT(" [ rl.exe ] SendMessageL() Get SC number ");
+ if ( serviceSettings->ServiceCenterCount() )
+ {
+ //Set sc address to default.
+ CSmsServiceCenter& sc = serviceSettings->GetServiceCenter(
+ serviceSettings->DefaultServiceCenter() );
+ header.Message().SetServiceCenterAddressL( sc.Address() );
+ }
+ }
+
+ // Add recipient to the list.
+ smsMtm->AddAddresseeL( aRecipientAddress, msvEntry.iDetails );
+
+ CMsvEntry& entry = iClientMtmForSending->Entry();
+ entry.ChangeL( msvEntry );
+ smsMtm->SaveMessageL();
+
+ // Move message to outbox
+ TMsvId movedId;
+ TInt err;
+ for ( TInt i = 0; i < 100; i++ )
+ {
+ TRAP( err, movedId = MoveMessageEntryL(
+ KMsvGlobalOutBoxIndexEntryId ));
+ if ( err == KErrNone )
+ break;
+ }
+ RL_TRACE_PRINT(" [ rl.exe ] SendMessageL() put created message in outbox ");
+ User::LeaveIfError( err );
+ // We must create an entry selection for message copies
+ CMsvEntrySelection* selection = new ( ELeave ) CMsvEntrySelection;
+ CleanupStack::PushL( selection );
+ selection->AppendL( movedId );
+ // schedule the sending with the active scheduler
+ SetScheduledSendingStateL( selection );
+ CleanupStack::PopAndDestroy( 4 ); // resourceReader,retbuf,sendOptions,selection
+ RL_TRACE_PRINT(" [ rl.exe ] Exit SendMessageL() ");
+ return ETrue;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::SetScheduledSendingStateL
+// Schedules the message to be sent through the etel server.
+// Return values: none
+// ---------------------------------------------------------------------------
+//
+void CRemoteLock::SetScheduledSendingStateL( CMsvEntrySelection* aSelection )
+ {
+ User::LeaveIfNull( iClientMtmForSending );
+ // Add entry to task scheduler
+ TBuf8<1> dummyParams;
+ CMsvOperationWait* waiter = CMsvOperationWait::NewLC();
+ waiter->Start();
+
+ // invoking async schedule copy command on our mtm
+ CMsvOperation* op= iClientMtmForSending->InvokeAsyncFunctionL(
+ ESmsMtmCommandScheduleCopy,
+ *aSelection,
+ dummyParams,
+ waiter->iStatus );
+
+ CleanupStack::PushL( op );
+ CActiveScheduler::Start();
+
+ CleanupStack::PopAndDestroy( 2 ); // op, wait
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::RunL
+// Reconnect msg server after it is shut down
+// Return values: none
+// ---------------------------------------------------------------------------
+//
+void CRemoteLock::RunL()
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] RunL() ");
+ delete iClientMtmForSending;
+ iClientMtmForSending = NULL;
+ delete iMtmReg;
+ iMtmReg = NULL;
+ delete iMsvSession;
+ iMsvSession = NULL;
+
+ TRAPD( error, iMsvSession = CMsvSession::OpenAsyncL( *this ) );
+
+ if ( error != KErrNone )
+ {
+ After( KRLockTimerInterval );
+ }
+ RL_TRACE_PRINT(" [ rl.exe ] Exit RunL() ");
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::NeedsToBeSentAsUnicodeL
+// Check if needs to be sent as unicode
+// Return value ETrue or EFalse
+// ---------------------------------------------------------------------------
+//
+TBool CRemoteLock::NeedsToBeSentAsUnicodeL( const TDesC& aInputString ) const
+ {
+ TBool needsToBeSentAsUnicode = EFalse;
+ CCnvCharacterSetConverter* const
+ characterSetConverter = CCnvCharacterSetConverter::NewLC();
+
+ RFs fsSession;
+ TInt err = fsSession.Connect();
+ User::LeaveIfError( err );
+ CleanupClosePushL( fsSession );
+ const TUint KSmsEdSmsStrictPluginID = 0x101F85CD;
+ characterSetConverter->PrepareToConvertToOrFromL(
+ KSmsEdSmsStrictPluginID,
+ fsSession);
+
+ characterSetConverter->SetDowngradeForExoticLineTerminatingCharacters(
+ CCnvCharacterSetConverter::EDowngradeExoticLineTerminatingCharactersToJustLineFeed );
+
+ for (TPtrC remainderOfInputString( aInputString ); remainderOfInputString.Length()>0 ; )
+ {
+ TBuf8<KBufLengthInUnicodeCheck> notUsed;
+ TInt numberOfUnconvertibleCharacters = 0;
+ const TInt returnValue =
+ characterSetConverter->ConvertFromUnicode(
+ notUsed,
+ remainderOfInputString,
+ numberOfUnconvertibleCharacters );
+ if (( returnValue < 0 ) || ( numberOfUnconvertibleCharacters > 0 ))
+ // if there was an error in trying to do the conversion, or if there was an
+ // unconvertible character (e.g. a Chinese character)
+ {
+ needsToBeSentAsUnicode = ETrue;
+ break;
+ }
+
+ remainderOfInputString.Set( remainderOfInputString.Right( returnValue ));
+ }
+ CleanupStack::PopAndDestroy( 2 );
+ return needsToBeSentAsUnicode;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CRemoteLock::HandleUnlockEvent()
+// Callback function for unlocking event observer
+// ---------------------------------------------------------------------------
+void CRemoteLock::HandleUnlockEvent()
+ {
+ TRAPD( err, SetMemoryCardPasswdL( ETrue ) );
+ err = err;
+ iLockedByRL = EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CRemoteLock::ProfileNotifyL
+// Setup Profile notifier
+// Returns: ETrue if everything is OK
+// EFalse otherwise
+// -----------------------------------------------------------------------------
+//
+TBool CRemoteLock::ProfileNotifyL(
+ const TBool aNotifyEnable )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] ProfileNotifyL() ");
+
+ if ( !iProfileNotifyHandler )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] ProfileNotifyL() create notify handler");
+ iProfileNotifyHandler = CCenRepNotifyHandler::NewL( *this, *iProfileSession );
+ }
+
+ if ( aNotifyEnable )
+ {
+
+ TInt err = iProfileSession->Get( KProEngActiveProfile, iCurrentProfile );
+ User::LeaveIfError( err );
+ RL_TRACE_PRINT(" [ rl.exe ] ProfileNotifyL() startlisten");
+ iProfileNotifyHandler->StartListeningL();
+ }
+ else
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] ProfileNotifyL() stop listen ");
+ iProfileNotifyHandler->StopListening();
+
+ delete iProfileNotifyHandler;
+ iProfileNotifyHandler = NULL;
+ }
+ RL_TRACE_PRINT(" [ rl.exe ] exit ProfileNotifyL() ");
+ return ETrue;
+ }
+
+// -----------------------------------------------------------------------------
+// CRemoteLock::GetProfile
+// Get the current Profile
+// Returns: ETrue if everything is OK
+// EFalse otherwise
+// -----------------------------------------------------------------------------
+//
+TBool CRemoteLock::GetProfile( TInt& aProfile )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] GetProfile() ");
+ TInt err;
+ err = iProfileSession->Get( KProEngActiveProfile, aProfile );
+ RL_TRACE_PRINT(" [ rl.exe ] exit GetProfile() ");
+ return ( err == KErrNone );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CRemoteLock::HandleNotifyGeneric
+// Remote lock Notify handler
+//
+// -----------------------------------------------------------------------------
+//
+void CRemoteLock::HandleNotifyGeneric(
+ TUint32 /*aId*/ )
+ {
+ RL_TRACE_PRINT(" [ rl.exe ] HandleNotifyGeneric() ");
+
+ TInt profile = 0;
+ GetProfile( profile );
+
+ if ( ( profile == EProfileOffLineId ) && ( iIsEnabled ) && ( iCurrentProfile != EProfileOffLineId ))
+ {
+ ActivateDeviceLock();
+ }
+
+ iCurrentProfile = profile;
+ RL_TRACE_PRINT(" [ rl.exe ] exit HandleNotifyGeneric() ");
+ }
+
+//EOF
+