diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/common_tsy/commontsy/src/mmcustomtsy/CMmSIMTsy.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/common_tsy/commontsy/src/mmcustomtsy/CMmSIMTsy.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,1304 @@ +// Copyright (c) 2006-2009 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: +// + + + +// INCLUDE FILES +#include "CMmSIMTsy.h" +#include +#include + +// ======== MEMBER FUNCTIONS ======== + +CMmSIMTsy::CMmSIMTsy() + { + } + +void CMmSIMTsy::ConstructL( + CMmCustomTsy* aMmCustomTsy ) + { +TFLOGSTRING("TSY: CMmSIMTsy::ConstructL"); + iMmCustomTsy = aMmCustomTsy; + + // Create req handle store +#ifdef REQHANDLE_TIMER + iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( iMmCustomTsy, + iMmCustomTsy->iMmPhoneTsy, ESIMRequestTypeMaxNumOfRequests, + iSIMReqHandles ); +#else + iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( + ESIMRequestTypeMaxNumOfRequests, iSIMReqHandles ); +#endif // REQHANDLE_TIMER + + // By default VIAG parameters are not requested. This means that + // when "SIM ready" indication is received, TSY will not check + // if it needs to read VIAG parameters or not. + iViagParamsReadRequested = EFalse; + + // Initialize pointer to NULL. + iCurrentlyRetrievedCache = NULL; + + // create the o2 HomeZone dynamic cache + // IGNORE if this fails due to Out-of-Memory problem + TInt leaveCode; + TRAP( leaveCode, iViagDynamicCache = new ( ELeave ) + CArrayFixFlat( + ( KPhEngMaxViagHomeZones * KPhEngMaxCacheId ) ); ); + if ( leaveCode ) + { +TFLOGSTRING2("TSY: CMmSIMTsy::ConstructL: Could not construct o2 HomeZone dynamic cache, error=%d", leaveCode); + iViagDynamicCache = NULL; + } + else + { + // initialise + RMmCustomAPI::TViagCacheRecordContent zero; + zero.iLac = 0xFFFF; + zero.iCellId = 0xFFFF; + iViagDynamicCache->AppendL( zero, ( KPhEngMaxViagHomeZones * + KPhEngMaxCacheId ) ); + iViagHomeZoneCacheReady = EFalse; +TFLOGSTRING("TSY: CMmSIMTsy::ConstructL: o2 HomeZone dynamic cache array created."); + } + } + +CMmSIMTsy* CMmSIMTsy::NewL( + CMmCustomTsy* aMmCustomTsy ) + { +TFLOGSTRING("TSY: CMmSIMTsy::NewL"); + CMmSIMTsy* self = new (ELeave) CMmSIMTsy(); + + CleanupStack::PushL( self ); + self->ConstructL( aMmCustomTsy ); + CleanupStack::Pop( self ); + + return self; + } + +CMmSIMTsy::~CMmSIMTsy() + { +TFLOGSTRING("TSY: CMmSIMTsy::~CMmSIMTsy()"); + // delete all CB ID related + ResetAndDestroySimCbTopics(); + + delete iTsyReqHandleStore; + delete iViagDynamicCache; + delete iCurrentlyRetrievedCache; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::Init +// Initialisation method that is called from ETel Server. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmSIMTsy::Init() + { + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::SupportingIPC +// Tells whether the object supports given IPC. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CMmSIMTsy::SupportingIPC( + TInt aIpc ) + { + TInt ret( EFalse ); + + switch ( aIpc ) + { + case EReadViagHomeZoneParamsIPC: + case EReadViagHomeZoneCacheIPC: + case EWriteViagHomeZoneCacheIPC: + case EWriteViagHomeZoneUHZIUESettingsIPC: + case ECustomStartSimCbTopicBrowsingIPC: + case ECustomGetNextSimCbTopicIPC: + case ECustomDeleteSimCbTopicIPC: + ret = ETrue; + break; + default: + ret = EFalse; + break; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::DoExtFuncL +// Dispatches extension function requests. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::DoExtFuncL( + const TTsyReqHandle aTsyReqHandle, + const TInt aIpc, + const TDataPackage& aPackage ) + { +TFLOGSTRING3("TSY: CMmSIMTsy::DoExtFuncL - IPC:%d Handle:%d", aIpc, aTsyReqHandle); + TInt ret( KErrGeneral ); + + // reset last tsy request type + iReqHandleType = ESIMTsyReqHandleUnknown; + + switch ( aIpc ) + { + case EReadViagHomeZoneParamsIPC: + ret = ReadViagHomeZoneParamsL( + REINTERPRET_CAST( RMmCustomAPI::TViagParams*, aPackage.Ptr1() + ), REINTERPRET_CAST( RMmCustomAPI::TViagElement*, + aPackage.Ptr2() ) ); + break; + case EReadViagHomeZoneCacheIPC: + ret = ReadDynamicViagHomeZoneCacheL( aTsyReqHandle, + REINTERPRET_CAST( RMmCustomAPI::TViagCacheRecordId*, + aPackage.Ptr1() ), REINTERPRET_CAST( + RMmCustomAPI::TViagCacheRecordContent*, aPackage.Ptr2() ) ); + break; + case EWriteViagHomeZoneCacheIPC: + ret = WriteViagHomeZoneCacheL( + REINTERPRET_CAST( RMmCustomAPI::TViagCacheRecordId*, + aPackage.Ptr1() ), REINTERPRET_CAST( + RMmCustomAPI::TViagCacheRecordContent*, aPackage.Ptr2() ) + ); + break; + case ECustomStartSimCbTopicBrowsingIPC: + ret = StartSimCbTopicBrowsingL( aTsyReqHandle ); + break; + case ECustomGetNextSimCbTopicIPC: + ret = GetNextSimCbTopic( aTsyReqHandle, REINTERPRET_CAST( + RMmCustomAPI::TSimCbTopic*, aPackage.Ptr1()) ); + break; + case ECustomDeleteSimCbTopicIPC: + ret = DeleteSimCbTopicL( aTsyReqHandle, REINTERPRET_CAST(TUint*, + aPackage.Ptr1() ) ); + break; + case EWriteViagHomeZoneUHZIUESettingsIPC: + ret = WriteViagHomeZoneUHZIUESettingsL( REINTERPRET_CAST( + RMmCustomAPI::TViagUHZIUESettings*, aPackage.Ptr1() ) ); + break; + default: + ret = KErrNotSupported; + break; + } + + // save request handle + if ( ESIMTsyReqHandleUnknown != iReqHandleType ) + { +#ifdef REQHANDLE_TIMER + SetTypeOfResponse( iReqHandleType, aTsyReqHandle ); +#else + iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, aTsyReqHandle ); +#endif // REQHANDLE_TIMER + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::ReqModeL +// Returns request mode for given IPC. Leaves with error code KErrNotSupported +// if the IPC number does not belong to some of the SIM API functions. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +CTelObject::TReqMode CMmSIMTsy::ReqModeL( + const TInt aIpc ) + { + CTelObject::TReqMode ret = 0; + + switch ( aIpc ) + { + case EReadViagHomeZoneParamsIPC: + case EReadViagHomeZoneCacheIPC: + case EWriteViagHomeZoneCacheIPC: + case EWriteViagHomeZoneUHZIUESettingsIPC: + case ECustomStartSimCbTopicBrowsingIPC: + case ECustomGetNextSimCbTopicIPC: + case ECustomDeleteSimCbTopicIPC: + ret = 0; // flow control in tsy + break; + default: + User::Leave( KErrNotSupported ); + break; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::NumberOfSlotsL +// Returns number of slots to be used for given IPC. Leaves with error code +// KErrNotSupported if the IPC number does not belong to some of the SIM +// API functions. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::NumberOfSlotsL( + const TInt aIpc ) + { + TInt numberOfSlots( KMmCustomDefaultSlots ); + + switch ( aIpc ) + { + case EReadViagHomeZoneParamsIPC: + case EReadViagHomeZoneCacheIPC: + case EWriteViagHomeZoneCacheIPC: + case EWriteViagHomeZoneUHZIUESettingsIPC: + case ECustomStartSimCbTopicBrowsingIPC: + case ECustomGetNextSimCbTopicIPC: + case ECustomDeleteSimCbTopicIPC: + numberOfSlots = KMmCustomDefaultSlots; + break; + default: + // Unknown or invalid IPC + User::Leave( KErrNotSupported ); + break; + } + + return numberOfSlots; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::CancelService +// When the clients close their sub-sessions (eg. by calling RPhone::Close), +// they may not have cancelled all their outstanding asynchronous requests +// before closing. It is up to the ETel server to clean up in this situation, +// so the server will find the list of outstanding requests related to that +// sub-session object and pass these outstanding IPC request numbers, one at +// a time, to the CancelService function in the TSY. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::CancelService( + const TInt aIpc, + const TTsyReqHandle aTsyReqHandle) + { + TInt ret( KErrGeneral ); + + switch ( aIpc ) + { + case EReadViagHomeZoneParamsIPC: + ret = ReadViagHomeZoneParamsCancel(); + break; + case EReadViagHomeZoneCacheIPC: + ret = ReadViagHomeZoneCacheCancel( aTsyReqHandle ); + break; + case EWriteViagHomeZoneCacheIPC: + ret = WriteViagHomeZoneCacheCancel(); + break; + case EWriteViagHomeZoneUHZIUESettingsIPC: + ret = WriteViagHomeZoneUHZIUESettingsCancel(); + break; + case ECustomGetNextSimCbTopicIPC: + case ECustomDeleteSimCbTopicIPC: + // operation cannot be cancelled on DOS side + ret = KErrNone; + break; + default: + ret = KErrGeneral; + break; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::RegisterNotification +// Called when the server recognises this notification being posted for +// the first time on this sub-session object. It enables the TSY to "turn on" +// any regular notification messages that it may receive from DOS. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::RegisterNotification( + const TInt ) + { + // No supported notifications in CMmSimTsy + return KErrNotSupported; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::DeregisterNotification +// Called when the server recognises that this notification will not be posted +// again because the last client to have a handle on this sub-session object +// has just closed the handle. It enables the TSY to "turn off" any regular +// notification messages that it may receive from DOS. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::DeregisterNotification( + const TInt ) + { + // No supported notifications in CMmSimTsy + return KErrNotSupported; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::ReadViagHomeZoneParamsL +// Reads VIAG Home Zone Parameters. +// If it has been requested before SIM is ready, the request is saved and will +// be done later. See methods CheckViagHomezoneParams and +// CMmPhoneTsy::CompleteNotifySimStatusReady. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::ReadViagHomeZoneParamsL( + RMmCustomAPI::TViagParams* aViagParameters, + RMmCustomAPI::TViagElement* aViagElements ) + { +TFLOGSTRING("TSY: CMmSIMTsy::ReadViagHomeZoneParamsL"); + TInt ret( KErrNone); + + if ( ESIMTsyReqHandleUnknown != iTsyReqHandleStore->GetTsyReqHandle( + ESIMRequestTypeReadParams ) ) + { + return KErrServerBusy; + } + + // Count is already checked in CustomAPI + iViagParams = aViagParameters; + iViagElems = aViagElements; + + // If SIM is ready, then request VIAG homezone parameters. + // If not ready, store pointers and send request when the + // "SIM ready" indication is received. + if ( iMmCustomTsy->Phone()->NosBootState()->iSIMReady ) + { + // send request to DOS (no parameters) + ret = iMmCustomTsy->Phone()->MessageManager()->HandleRequestL( + EReadViagHomeZoneParamsIPC ); + } + else + { + // SIM is not yet ready. TSY should send read request when SIM has + // indicated that it is ready. See CheckViagHomezoneParams and + // CMmPhoneTsy::CompleteNotifySimStatusReady. + iViagParamsReadRequested = ETrue; + } + + // If message is sent or we are waiting for adaptation indication SIM + // being ready. Then store handle. + if ( KErrNone == ret ) + { + iReqHandleType = ESIMRequestTypeReadParams; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::CheckViagHomezoneParamsL +// Reads VIAG Home Zone Parameters when it has been requested before +// SIM is ready. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmSIMTsy::CheckViagHomezoneParamsL() + { +TFLOGSTRING("TSY: CMmSIMTsy::CheckViagHomezoneParamsL"); + // Check if the request is pending + if ( ESIMTsyReqHandleUnknown != iTsyReqHandleStore->GetTsyReqHandle( + ESIMRequestTypeReadParams ) && iViagParamsReadRequested ) + { + // Ensure that we wont flood SIM with mupltiple VIAG params + // read requests, set flag to EFalse. + iViagParamsReadRequested = EFalse; + +TFLOGSTRING("TSY: CMmSIMTsy::CheckViagHomezoneParamsL - Sending request" ); + // send request to DOS (no parameters) + // Void return value, there is nothing to be done if request fails. + (void) iMmCustomTsy->Phone()->MessageManager()->HandleRequestL( + EReadViagHomeZoneParamsIPC ); + } + else + { +TFLOGSTRING("TSY: CMmSIMTsy::CheckViagHomezoneParamsL - VIAG homezone params not requested"); + } + + StartDynamicCachingL(); + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::CompleteReadViagHomeZoneParamsResp +// Completes a ReadViagHomeZoneParams request (which was issued either by +// ReadViagHomeZoneParams or by CheckViagHomezoneParams). +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmSIMTsy::CompleteReadViagHomeZoneParamsResp( + RMmCustomAPI::TViagParams* aParams, + RMmCustomAPI::TViagElements* aElems, + TInt aError ) + { +TFLOGSTRING2("TSY: CMmSIMTsy::CompleteReadViagHomeZoneParamsResp - aError: %d", aError ); + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ESIMRequestTypeReadParams ); + if ( ESIMTsyReqHandleUnknown != reqHandle ) + { + if ( aError == KErrNone && iViagParams && iViagElems ) + { + *iViagParams = *aParams; +TFLOGSTRING2("TSY: CMmSIMTsy::CompleteReadViagHomeZoneParamsResp - iSmsC: %S", &iViagParams->iSmsC ); +TFLOGSTRING2("TSY: CMmSIMTsy::CompleteReadViagHomeZoneParamsResp - iScp: %S", &iViagParams->iScp ); +TFLOGSTRING2("TSY: CMmSIMTsy::CompleteReadViagHomeZoneParamsResp - iSubscribedZoneAndVersion: %d", iViagParams->iSubscribedZoneAndVersion ); + + for ( TUint8 i = 0; i < RMmCustomAPI::KViagElementCount; i++ ) + { + iViagElems[ i ].iCoordinates.iX = aElems->At(i).iCoordinates.iX; +TFLOGSTRING3("TSY: CMmSIMTsy::CompleteReadViagHomeZoneParamsResp - Element: %d, iX: %d", i, aElems->At(i).iCoordinates.iX ); + + iViagElems[ i ].iCoordinates.iY = aElems->At(i).iCoordinates.iY; +TFLOGSTRING3("TSY: CMmSIMTsy::CompleteReadViagHomeZoneParamsResp - Element: %d, iY: %d", i, aElems->At(i).iCoordinates.iY ); + + iViagElems[ i ].iCoordinates.iR2 = aElems-> + At(i).iCoordinates.iR2; +TFLOGSTRING3("TSY: CMmSIMTsy::CompleteReadViagHomeZoneParamsResp - Element: %d, iR2: %d", i, aElems->At(i).iCoordinates.iR2 ); + + iViagElems[ i ].iCoordinates.iZoneId = aElems-> + At(i).iCoordinates.iZoneId; +TFLOGSTRING3("TSY: CMmSIMTsy::CompleteReadViagHomeZoneParamsResp - Element: %d, iZoneId: %d", i, aElems->At(i).iCoordinates.iZoneId ); + + iViagElems[ i ].iName.Copy( aElems->At(i).iName ); + iViagElems[ i ].iActiveFlag = aElems->At(i).iActiveFlag; +TFLOGSTRING3("TSY: CMmSIMTsy::CompleteReadViagHomeZoneParamsResp - Element: %d, iActiveFlag: %d", i, aElems->At(i).iActiveFlag ); + } + } + iMmCustomTsy->ReqCompleted( reqHandle, aError ); + } + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::ReadViagHomeZoneParamsCancel +// Cancels reading VIAG Home Zone parameters. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::ReadViagHomeZoneParamsCancel() + { +TFLOGSTRING("TSY: CMmSIMTsy::ReadViagHomeZoneParamsCancel"); + // reset the pointer to client space + iViagParams = NULL; + iViagElems = NULL; + + // reset the req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ESIMRequestTypeReadParams ); + + if ( ESIMTsyReqHandleUnknown != reqHandle ) + { + // complete with cancel + iMmCustomTsy->ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::ReadViagHomeZoneCacheL +// Reads VIAG Home Zone Cache. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::ReadViagHomeZoneCacheL( + RMmCustomAPI::TViagCacheRecordId* aViagRecordId, + RMmCustomAPI::TViagCacheRecordContent* aViagRecordContent ) + { +TFLOGSTRING("TSY: CMmSIMTsy::ReadViagHomeZoneCacheL"); + TInt ret( KErrGeneral ); + + if ( ESIMTsyReqHandleUnknown != iTsyReqHandleStore->GetTsyReqHandle( + ESIMRequestTypeReadCache ) ) + { + return KErrServerBusy; + } + + iViagReadCacheRecord = aViagRecordContent; + + // send request to DOS + // packed parameter: RMmCustomAPI::TViagCacheRecordId + CMmDataPackage dataPackage; + dataPackage.PackData( aViagRecordId ); + ret = iMmCustomTsy->Phone()->MessageManager()->HandleRequestL( + EReadViagHomeZoneCacheIPC, &dataPackage ); + + if ( KErrNone == ret ) + { + // Store the request handle + iReqHandleType = ESIMRequestTypeReadCache; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::CompleteReadViagHomeZoneCacheRespL +// Completes reading VIAG Home Zone Cache. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmSIMTsy::CompleteReadViagHomeZoneCacheRespL( + RMmCustomAPI::TViagCacheRecordContent* aViagRecord, + TInt aError ) + { +TFLOGSTRING("TSY: CMmSIMTsy::CompleteReadViagHomeZoneCacheRespL"); + if (iCurrentlyRetrievedCache == NULL) + { + // Got an unexpected update... ignore! + return; + } + if ( KErrNone == aError ) + { + // response OK + if ( iViagDynamicCache ) + { + // save in dynamic cache + // some arithmetics: + // cache ids range 1..4 + // record ids range 0..20 + // array indexes range 0..83 + // ==> A[c][r] = A[((c-1)*rMax)+r] + TInt arrayIndex = + ( ( iCurrentlyRetrievedCache->iCacheId - 1 ) * 21 ) + + iCurrentlyRetrievedCache->iRecordId; + iViagDynamicCache->At( arrayIndex ) = *aViagRecord; +TFLOGSTRING3("TSY: CMmSIMTsy::CompleteReadViagHomeZoneCacheRespL:Entry at cacheId=%d, recordId=%d read.", iCurrentlyRetrievedCache->iCacheId,iCurrentlyRetrievedCache->iRecordId); + + TRAP_IGNORE( + // loop. loop four caches times 21 entries! + if ( 20 > iCurrentlyRetrievedCache->iRecordId ) + { + iCurrentlyRetrievedCache->iRecordId++; + // send request to DOS + // packed parameter: RMmCustomAPI::TViagCacheRecordId + CMmDataPackage dataPackage; + dataPackage.PackData( iCurrentlyRetrievedCache ); + iMmCustomTsy->Phone()->MessageManager()->HandleRequestL( + EReadViagHomeZoneCacheIPC, &dataPackage ); + } + else if ( 4 > iCurrentlyRetrievedCache->iCacheId ) + { + // next cache + iCurrentlyRetrievedCache->iCacheId++; + iCurrentlyRetrievedCache->iRecordId = 0; + // send request to DOS + // packed parameter: RMmCustomAPI::TViagCacheRecordId + CMmDataPackage dataPackage; + dataPackage.PackData( iCurrentlyRetrievedCache ); + iMmCustomTsy->Phone()->MessageManager()->HandleRequestL( + EReadViagHomeZoneCacheIPC, &dataPackage ); + } + else + { + // caching done + delete iCurrentlyRetrievedCache; + iCurrentlyRetrievedCache = NULL; + iViagHomeZoneCacheReady = ETrue; +TFLOGSTRING("TSY: CMmSIMTsy::CompleteReadViagHomeZoneCacheRespL:Caching completed successfully!"); + + if( 0 < iReadViagHomeZoneCacheRequests.Count() ) + { + + for ( TInt i=0; i A[c][r] = A[((c-1)*rMax)+r] + TInt arrayIndex = ( ( req->iViagRecordId->iCacheId - 1 ) * 21 ) + + req->iViagRecordId->iRecordId;//iCacheId; + + //set value in client side + *(req->iViagRecordContent) =iViagDynamicCache->At( arrayIndex ); + //reset the return pointer + iMmCustomTsy->ReqCompleted( req->iReqHandle, KErrNone ); + } + iReadViagHomeZoneCacheRequests.ResetAndDestroy(); + + } + } + ); + } + } + else + { + // caching aborted + delete iCurrentlyRetrievedCache; + iCurrentlyRetrievedCache = NULL; +TFLOGSTRING2("TSY: CMmSIMTsy::CompleteReadViagHomeZoneCacheRespL:There was a problem reading cache values from SIM, error=%d", aError); + } + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::ReadViagHomeZoneCacheCancel +// Cancels reading VIAG Home Zone cache. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::ReadViagHomeZoneCacheCancel( + const TTsyReqHandle aTsyReqHandle ) + { +TFLOGSTRING("TSY: CMmSIMTsy::ReadViagHomeZoneCacheCancel"); +TFLOGSTRING2("TSY: CMmSIMTsy::ReadViagHomeZoneCacheCancel - Handle:%d",aTsyReqHandle); + // Reset the pointer to client space + iViagReadCacheRecord = NULL; + + // Check if request handle already exists + TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle( + ESIMRequestTypeReadCache ); + + if (aTsyReqHandle == reqHandle ) + { + // Reset the request handle. Returns the deleted req handle + reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ESIMRequestTypeReadCache ); + if ( ESIMTsyReqHandleUnknown != reqHandle ) + { +TFLOGSTRING2("TSY: CMmSIMTsy::ReadViagHomeZoneCacheCancel - Completed with Cancel Handle:%d",reqHandle); + // Complete request with cancel + iMmCustomTsy->ReqCompleted( reqHandle, KErrCancel ); + } + } + else + { + if( 0 < iReadViagHomeZoneCacheRequests.Count() ) + { + // Search the request handle in the array + for ( TInt i=0; i < iReadViagHomeZoneCacheRequests.Count(); i++ ) + { + TReadViagHomeZoneCacheRequest* req = + iReadViagHomeZoneCacheRequests[ i ]; + + if (aTsyReqHandle == req->iReqHandle) + { + // Complete the request if the request handle is found +TFLOGSTRING3("TSY: CMmSIMTsy::ReadViagHomeZoneCacheCancel - Complete with Cancel from array Handle:%d Id=%d ", req->iReqHandle,i); + iMmCustomTsy->ReqCompleted( req->iReqHandle, KErrCancel ); + delete iReadViagHomeZoneCacheRequests[ i ]; + iReadViagHomeZoneCacheRequests.Remove(i); + break; + } + } + } + } + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::ReadDynamicViagHomeZoneCacheL +// Reads Dynamic VIAG Home Zone cache. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::ReadDynamicViagHomeZoneCacheL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TViagCacheRecordId* aViagRecordId, + RMmCustomAPI::TViagCacheRecordContent* aViagRecordContent ) + { +TFLOGSTRING2("TSY: CMmSIMTsy::ReadDynamicViagHomeZoneCache:Is ViagHomeZoneCache Ready =%d", iViagHomeZoneCacheReady); +TFLOGSTRING3("TSY: CMmSIMTsy::ReadDynamicViagHomeZoneCache iCacheId %d iRecordId %d",aViagRecordId->iCacheId,aViagRecordId->iRecordId ); + TInt err = KErrNone; + // KPhEngMaxViagHomeZones(4) * KPhEngMaxCacheId(21) + if ( 1 > aViagRecordId->iCacheId || 4 < aViagRecordId->iCacheId || + 0 > aViagRecordId->iRecordId || 20 < aViagRecordId->iRecordId ) + { + err = KErrArgument; + } + else if ( iViagDynamicCache && iViagHomeZoneCacheReady ) + { +TFLOGSTRING("TSY: CMmSIMTsy::ReadDynamicViagHomeZoneCache: else if : Cache is ready, Reading cache possible"); + // copy data from dynamic cache to client + // some arithmetics: + // cache ids range 1..4 + // record ids range 0..20 + // array indexes range 0..83 + // ==> A[c][r] = A[((c-1)*rMax)+r] + TInt arrayIndex = ( ( aViagRecordId->iCacheId - 1 ) * 21 ) + + aViagRecordId->iRecordId; + *aViagRecordContent = iViagDynamicCache->At( arrayIndex ); + } + else if ( !iViagHomeZoneCacheReady ) + { + TFLOGSTRING("TSY: CMmSIMTsy::ReadDynamicViagHomeZoneCache: else if : Cache is NOT ready, Reading cache NOT possible"); + //The request is already in processing because of previous request + //Complete request with status value informing the client about + TReadViagHomeZoneCacheRequest* req = + new (ELeave) TReadViagHomeZoneCacheRequest(); + req->iReqHandle = aTsyReqHandle; + req->iViagRecordId = aViagRecordId; + req->iViagRecordContent = aViagRecordContent; + iReadViagHomeZoneCacheRequests.AppendL( req ); + } + + // complete to client + if ( iViagHomeZoneCacheReady ) + { + iMmCustomTsy->ReqCompleted( aTsyReqHandle, err ); + return KErrNone; + } + return err; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::WriteViagHomeZoneCacheL +// Writes VIAG Home Zone Cache. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::WriteViagHomeZoneCacheL( + RMmCustomAPI::TViagCacheRecordId* aViagRecordId, + RMmCustomAPI::TViagCacheRecordContent* aViagRecordContent ) + { +TFLOGSTRING3("TSY: CCMmSIMTsy::WriteViagHomeZoneCacheL iCacheId %d iRecordId %d",aViagRecordId->iCacheId,aViagRecordId->iRecordId ); + TInt ret( KErrGeneral ); + + if ( ESIMTsyReqHandleUnknown != iTsyReqHandleStore->GetTsyReqHandle( + ESIMRequestTypeWriteCache ) ) + { + return KErrServerBusy; + } + if ( 1 > aViagRecordId->iCacheId || 4 < aViagRecordId->iCacheId || + 0 > aViagRecordId->iRecordId || 20 < aViagRecordId->iRecordId ) + { + return KErrArgument; + } + else if ( iViagDynamicCache ) + { + // copy data from client to dynamic cache + // some arithmetics: + // cache ids range 1..4 + // record ids range 0..20 + // array indexes range 0..83 + // ==> A[c][r] = A[((c-1)*rMax)+r] + TInt arrayIndex = ( ( aViagRecordId->iCacheId - 1 ) * 21 ) + + aViagRecordId->iRecordId; + iViagDynamicCache->At( arrayIndex ) = *aViagRecordContent; + } + + // send request to DOS + // packed parameters: RMmCustomAPI::TViagCacheRecordId and + // RMmCustomAPI::TViagCacheRecordContent + CMmDataPackage dataPackage; + dataPackage.PackData( aViagRecordId, aViagRecordContent ); + ret = iMmCustomTsy->Phone()->MessageManager()->HandleRequestL( + EWriteViagHomeZoneCacheIPC, &dataPackage ); + + if( KErrNone == ret ) + { + // Store the request handle + iReqHandleType = ESIMRequestTypeWriteCache; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::CompleteWriteViagHomeZoneCacheResp +// Completes writing VIAG Home Zone Cache. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmSIMTsy::CompleteWriteViagHomeZoneCacheResp( + TInt aError ) + { +TFLOGSTRING("TSY: CMmSIMTsy::CompleteWriteViagHomeZoneCacheResp"); + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ESIMRequestTypeWriteCache ); + + if ( ESIMTsyReqHandleUnknown != reqHandle ) + { + iMmCustomTsy->ReqCompleted( reqHandle, aError ); + } + + return; + } + +// ---------------------------------------------------------------------------- +// CMmSIMTsy::CompleteWriteViagHomeZoneUHZIUESettingsResp +// This method copletes the VIAG Home Zone UHZIUE settings write request. +// (other items were commented in a header). +// ---------------------------------------------------------------------------- +// +void CMmSIMTsy::CompleteWriteViagHomeZoneUHZIUESettingsResp( + TInt aError ) + { +TFLOGSTRING2("TSY: CMmSIMTsy::CompleteWriteViagHomeZoneUHZIUESettingsResp error = %d",aError); + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ESIMRequestTypeWriteSettings ); + + if ( ESIMTsyReqHandleUnknown != reqHandle ) + { + iMmCustomTsy->ReqCompleted( reqHandle, aError ); + } + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::WriteViagHomeZoneCacheCancel +// Cancels writing VIAG Home Zone cache. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::WriteViagHomeZoneCacheCancel() + { + // reset the req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ESIMRequestTypeWriteCache ); + + if ( ESIMTsyReqHandleUnknown != reqHandle ) + { + // complete with cancel + iMmCustomTsy->ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::StartDynamicCachingL +// Start dynamic caching +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmSIMTsy::StartDynamicCachingL() + { +TFLOGSTRING("TSY: CMmSIMTsy::StartDynamicCachingL"); + + // Make sure there are no ongoing dynamic caching requests.. + if( iCurrentlyRetrievedCache ) + { +TFLOGSTRING("TSY: CMmSIMTsy::StartDynamicCachingL - iCurrentlyRetrievedCache already exists - no new request done"); + return; + } + + TInt trapError; + TRAP( trapError, iCurrentlyRetrievedCache = new (ELeave) + RMmCustomAPI::TViagCacheRecordId(); ); + if ( trapError ) + { +TFLOGSTRING2("TSY: CMmSIMTsy::StartDynamicCachingL:Could not start caching, error=%d", trapError); + return; + } +TFLOGSTRING("TSY: CMmSIMTsy::StartDynamicCachingL:Starting caching now."); + iCurrentlyRetrievedCache->iCacheId = 1; // caches range from 1 to 4 + iCurrentlyRetrievedCache->iRecordId = 0; // records range from 0 to 20 + // send request to DOS + // packed parameter: RMmCustomAPI::TViagCacheRecordId + CMmDataPackage dataPackage; + dataPackage.PackData( iCurrentlyRetrievedCache ); + iMmCustomTsy->Phone()->MessageManager()->HandleRequestL( + EReadViagHomeZoneCacheIPC, &dataPackage ); + + } + +// ---------------------------------------------------------------------------- +// CMmSIMTsy::ReadViagHomeZoneUHZIUESettingsL +// This method writes specified VIAG Home Zone UHZIUE settings to SIM. +// (other items were commented in a header). +// ---------------------------------------------------------------------------- +// +TInt CMmSIMTsy::WriteViagHomeZoneUHZIUESettingsL( + RMmCustomAPI::TViagUHZIUESettings* aSettings ) + { +TFLOGSTRING("TSY: CMmSIMTsy::WriteViagHomeZoneUHZIUESettingsL"); + TInt ret( KErrGeneral ); + + if ( ESIMTsyReqHandleUnknown != iTsyReqHandleStore->GetTsyReqHandle( + ESIMRequestTypeWriteSettings ) ) + { + return KErrServerBusy; + } + + CMmDataPackage dataPackage; + dataPackage.PackData( aSettings ); + ret = iMmCustomTsy->Phone()->MessageManager()->HandleRequestL( + EWriteViagHomeZoneUHZIUESettingsIPC, &dataPackage ); + + if( KErrNone == ret ) + { + // Store the request handle + iReqHandleType = ESIMRequestTypeWriteSettings; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::WriteViagHomeZoneUHZIUESettingsCancel +// Cancels writing request of VIAG Home Zone UHZIUE settings. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::WriteViagHomeZoneUHZIUESettingsCancel() + { +TFLOGSTRING("TSY: CMmSIMTsy::WriteViagHomeZoneUHZIUESettingsCancel"); + // check if handle is not in use. + TTsyReqHandle scFileHandle = + iTsyReqHandleStore->GetTsyReqHandle( ESIMRequestTypeWriteSettings ); + + if( ESIMTsyReqHandleUnknown != scFileHandle ) + { + // reset the req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ESIMRequestTypeWriteSettings ); + + if ( ESIMTsyReqHandleUnknown != reqHandle ) + { + // complete with cancel + iMmCustomTsy->ReqCompleted( reqHandle, KErrCancel ); + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::StartSimCbTopicBrowsingL +// This method reads Cell Broadcast messages from SIM, and caches them in +// iSimCbTopics. No data will be copied to client, this is done via +// GetNextSimCbTopic. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::StartSimCbTopicBrowsingL( + const TTsyReqHandle /*aTsyReqHandle */) + { +TFLOGSTRING("TSY: CMmSIMTsy::StartSimCbTopicBrowsingL"); + // reset variables + ResetAndDestroySimCbTopics(); + iGetNextSimCbTopicIndex = KNoCbIds; + TInt ret( KErrNone ); + + if ( ESIMTsyReqHandleUnknown != iTsyReqHandleStore->GetTsyReqHandle( + ESIMRequestTypeStartSimCbTopicBrowsing ) || + ESIMTsyReqHandleUnknown != iTsyReqHandleStore->GetTsyReqHandle( + ESIMRequestTypeDeleteSimCbTopic ) ) + { + // this request cannot be processed if either reading or deleting + // CB topics is currently pending + ret = KErrServerBusy; + } + else + { + // send request to DOS (no packed parameters). + ret = iMmCustomTsy->Phone()->MessageManager()->HandleRequestL( + ECustomStartSimCbTopicBrowsingIPC ); + if ( KErrNone == ret ) + { + // store the request handle + iReqHandleType = ESIMRequestTypeStartSimCbTopicBrowsing; + } + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::CompleteStartSimCbTopicBrowsing +// This method completes the StartSimCbTopicBrowsing request. No data will be +// copied to client, this is done via GetNextSimCbTopic. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmSIMTsy::CompleteStartSimCbTopicBrowsing( + CArrayFixFlat* aTopics, + TInt aError ) + { +TFLOGSTRING("TSY: CMmSIMTsy::CompleteStartSimCbTopicBrowsing"); + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ESIMRequestTypeStartSimCbTopicBrowsing ); + + if ( ESIMTsyReqHandleUnknown != reqHandle ) + { + if ( KErrNone == aError && aTopics ) + { + // Request succeeded. Replace old CB topic array by the new one. + ResetAndDestroySimCbTopics(); + iGetNextSimCbTopicIndex = 0; + TRAP_IGNORE( iSimCbTopics = new ( ELeave ) + CArrayFixFlat( aTopics->Count() ); + // copy entries + for ( int i = 0; i < aTopics->Count(); i++ ) + { + iSimCbTopics->AppendL( aTopics->At( i ) ); + } + ); + } + else + { + // Request failed. Destroy CB topics array + ResetAndDestroySimCbTopics(); + iGetNextSimCbTopicIndex = KNoCbIds; + } + + // complete request + iMmCustomTsy->ReqCompleted( reqHandle, aError ); + } + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::GetNextSimCbTopic +// This method get's the next id from local array and put's it to aSimCbTopic +// which is a pointer to client side structure. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::GetNextSimCbTopic( + TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TSimCbTopic *aSimCbTopic ) + { +TFLOGSTRING("TSY: CMmSIMTsy::GetNextSimCbTopic"); + // initialize ret with KErrNotFound + TInt ret ( KErrNotFound ); + + if( ( iGetNextSimCbTopicIndex >= 0 ) && iSimCbTopics ) + { + if( iSimCbTopics->Count() > iGetNextSimCbTopicIndex ) + { + // read the next id and put it to client side pointer + *aSimCbTopic = ( iSimCbTopics->At( iGetNextSimCbTopicIndex ) ); + iGetNextSimCbTopicIndex++; + ret = KErrNone; + } + else + { + // set index to -1 + iGetNextSimCbTopicIndex = KNoCbIds; + } + } + + // complete request + iMmCustomTsy->ReqCompleted( aTsyReqHandle, ret ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::DeleteSimCbTopicL +// Delete a CB topic stored on SIM. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmSIMTsy::DeleteSimCbTopicL( + const TTsyReqHandle /*aTsyReqHandle */, + TUint* aSimCbTopicNumber ) + { +TFLOGSTRING("TSY: CMmSIMTsy::DeleteSimCbTopicL"); + TInt ret( KErrNone ); + TBool topicInSimMemoryDelete ( EFalse ); + + // Check that neither browsing nor deleting request is pending + if ( ESIMTsyReqHandleUnknown != iTsyReqHandleStore->GetTsyReqHandle( + ESIMRequestTypeDeleteSimCbTopic ) || + ESIMTsyReqHandleUnknown != iTsyReqHandleStore->GetTsyReqHandle( + ESIMRequestTypeStartSimCbTopicBrowsing ) ) + { + ret = KErrServerBusy; + } + + // Find the topic id in cached list + if ( ( KErrNone == ret ) && iSimCbTopics ) + { + iSimCbTopicIndexToBeDeleted = KErrNotFound; + for ( int i = 0; i < iSimCbTopics->Count(); i++ ) + { + if ( iSimCbTopics->At( i ).iNumber == *aSimCbTopicNumber ) + { + // Store index of entry to be deleted + iSimCbTopicIndexToBeDeleted = i; + ret = KErrNone; + topicInSimMemoryDelete = ETrue; + break; + } + } + } + + // Send delete request to DOS + if ( KErrNone == ret ) + { + // Send delete request to DOS + // Packed parameter: TUint with topic id + CMmDataPackage dataPackage; + dataPackage.PackData( aSimCbTopicNumber, &topicInSimMemoryDelete ); + ret = iMmCustomTsy->Phone()->MessageManager()->HandleRequestL( + ECustomDeleteSimCbTopicIPC, &dataPackage ); + } + + if ( KErrNone == ret ) + { + // Store the request handle + iReqHandleType = ESIMRequestTypeDeleteSimCbTopic; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::CompleteDeleteSimCbTopic +// Completes DeleteSimCbTopic request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmSIMTsy::CompleteDeleteSimCbTopic( + TInt aError ) + { +TFLOGSTRING2("TSY: CMmSIMTsy::CompleteDeleteSimCbTopic- aError: %d", aError); + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ESIMRequestTypeDeleteSimCbTopic ); + + if ( ESIMTsyReqHandleUnknown != reqHandle ) + { + + // if delete was successful, the cached array has to be updated + if ( KErrNone == aError ) + { + // Delete entry from array + if ( iSimCbTopics && ( iSimCbTopicIndexToBeDeleted != KErrNotFound ) ) + { + iSimCbTopics->Delete( iSimCbTopicIndexToBeDeleted ); + iSimCbTopics->Compress(); + } + + // Reset index, it could go crazy otherwise + iGetNextSimCbTopicIndex = 0; + + // Reset index of topic to be deleted + iSimCbTopicIndexToBeDeleted = KErrNotFound; + } + + iMmCustomTsy->ReqCompleted( reqHandle, aError ); + } + } + + +// --------------------------------------------------------------------------- +// CMmSIMTsy::ResetAndDestroySimCbTopics +// Destroys the CB message id array +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmSIMTsy::ResetAndDestroySimCbTopics() + { + if( iSimCbTopics ) + { + iSimCbTopics->Reset(); + delete iSimCbTopics; + iSimCbTopics = NULL; + } + } + +#ifdef REQHANDLE_TIMER +// --------------------------------------------------------------------------- +// CMmSIMTsy::SetTypeOfResponse +// Sets the type of response for a given handle. Automatic mode includes an +// automatic response in case of non response from the DOS in a specified time. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmSIMTsy::SetTypeOfResponse( + const TInt aReqHandleType, + const TTsyReqHandle aTsyReqHandle ) + { + TInt timeOut( 0 ); + TInt ipc( 0 ); + + switch ( aReqHandleType ) + { + case ESIMRequestTypeReadParams: + timeOut = KMmViagHomeZoneReadParamsTimeOut; + ipc = EReadViagHomeZoneParamsIPC; + break; + case ESIMRequestTypeReadCache: + timeOut = KMmViagHomeZoneReadCacheTimeOut; + ipc = EReadViagHomeZoneCacheIPC; + break; + case ESIMRequestTypeWriteCache: + timeOut = KMmViagHomeZoneWriteCacheTimeOut; + ipc = EWriteViagHomeZoneCacheIPC; + break; + case ESIMRequestTypeWriteSettings: + timeOut = KMmViagHomeZoneWriteSettingsTimeOut; + ipc = EWriteViagHomeZoneUHZIUESettingsIPC; + break; + case ESIMRequestTypeStartSimCbTopicBrowsing: + timeOut = KMmStartSimCbTopicBrowsingTimeOut; + ipc = ECustomStartSimCbTopicBrowsingIPC; + break; + case ESIMRequestTypeDeleteSimCbTopic: + timeOut = KMmDeleteSimCbTopicTimeOut; + ipc = ECustomDeleteSimCbTopicIPC; + break; + default: + // Does not use timer + iTsyReqHandleStore->SetTsyReqHandle( + aReqHandleType, aTsyReqHandle ); + break; + } + + if ( 0 < timeOut ) + { + // The timeout parameter is given in seconds. + iTsyReqHandleStore->SetTsyReqHandle( aReqHandleType, aTsyReqHandle, + timeOut, ipc ); + } + } + +// --------------------------------------------------------------------------- +// CMmSIMTsy::Complete +// Completes the request due the timer expiration. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +void CMmSIMTsy::Complete( + TInt aReqHandleType, + TInt aError ) + { +TFLOGSTRING3( "CustomTSY: CMmSIMTsy::Complete.\n\t ReqHandleType:%d \n\t Error:%d\n", aReqHandleType, aError ); + + // All possible TSY req handle types are listed in the + // switch case below. + switch ( aReqHandleType ) + { + case ESIMRequestTypeReadParams: + CompleteReadViagHomeZoneParamsResp( NULL, NULL, aError ); + break; + case ESIMRequestTypeReadCache: + TRAP_IGNORE( + CompleteReadViagHomeZoneCacheRespL( NULL, aError );); + break; + case ESIMRequestTypeWriteCache: + CompleteWriteViagHomeZoneCacheResp( aError ); + break; + case ESIMRequestTypeWriteSettings: + CompleteWriteViagHomeZoneUHZIUESettingsResp( aError ); + break; + case ESIMRequestTypeStartSimCbTopicBrowsing: + CompleteStartSimCbTopicBrowsing( NULL, aError ); + break; + default: + iMmCustomTsy->ReqCompleted( iTsyReqHandleStore->ResetTsyReqHandle( + aReqHandleType ), aError ); + break; + } + } +#endif // REQHANDLE_TIMER + +// End of File