diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/multimodetsy/Multimode/Mphbook.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/multimodetsy/Multimode/Mphbook.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,410 @@ +// Copyright (c) 1997-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: +// \file MPHBOOK.CPP +// Mulimode TSY Phone book access Implementation file. +// This file contains the implementation of the CMobilePhonebookStore +// class which is used for GSM phone book access. +// +// + +#include "mSLOGGER.H" +#include "mPHBOOK.H" +#include "Mphbkcom.h" +#include "ATINIT.H" +#include "NOTIFY.H" +#include + +// +// CPhoneBook definitions +// + +CMobilePhonebookStore* CMobilePhonebookStore::NewL(CATIO* aATIO,CATInit* aInit,CPhoneGlobals* aPhoneGlobals,const TDesC8& aStorageType) +/** + * Standard 2 phase constructor. + */ + { + CMobilePhonebookStore* subsession=new(ELeave) CMobilePhonebookStore(aATIO,aInit,aPhoneGlobals,aStorageType); + CleanupStack::PushL(subsession); + subsession->ConstructL(); + CleanupStack::Pop(); + return subsession; + } + +CMobilePhonebookStore::CMobilePhonebookStore(CATIO* aATIO,CATInit* aInit,CPhoneGlobals* aMmGlobals,const TDesC8& aStorageType) + : iIo(aATIO), iInit(aInit), iPhoneGlobals(aMmGlobals), iStorageType(aStorageType) + { + } + +void CMobilePhonebookStore::ConstructL() +/** + * ConstructL() function. Creates CATPhoneBookInit, CATPhoneBookWrite, CATPhoneBookDelete + * objects. + */ + { + iInfo=CATPhoneBookInfo::NewL(iIo,this,iInit,iPhoneGlobals); + iRead=CATPhoneBookRead::NewL(iIo,this,iInit,iPhoneGlobals,iInfo); + iWrite=CATPhoneBookWrite::NewL(iIo,this,iInit,iPhoneGlobals); + iDelete=CATPhoneBookDelete::NewL(iIo,this,iInit,iPhoneGlobals); + + // Assume that all phone books have at least read access + iReadWriteAccess|=RMobilePhoneStore::KCapsReadAccess; + + // Check if phone book should have write access + if (CPhoneGlobals::IsWriteAccess(iStorageType)) + iReadWriteAccess |= RMobilePhoneStore::KCapsWriteAccess | RMobilePhoneStore::KCapsReadAccess; + } + +CMobilePhonebookStore::~CMobilePhonebookStore() +/** + * Destructor. + */ + { + if (iPhoneGlobals != NULL) + iPhoneGlobals->iNotificationStore->RemoveClientFromLastEvents(this); //Joe + delete iRead; + delete iWrite; + delete iDelete; + delete iInfo; + } + +CTelObject::TReqMode CMobilePhonebookStore::ReqModeL(const TInt aIpc) +/** + * This function is basically a switch statement which describes the flow control + * capabilities for each request dealt with by the CPhoneBook sub-session extension. + */ + { + CTelObject::TReqMode ret(0); + + switch (aIpc) + { + case EMobilePhoneStoreGetInfo: + ret=KReqModeFlowControlObeyed|KReqModeMultipleCompletionEnabled; + break; + + case EMobilePhoneBookStoreWrite: + case EMobilePhoneBookStoreRead: + case EMobilePhoneStoreDelete: + ret=KReqModeFlowControlObeyed; + break; + + default: + User::Leave(KErrNotSupported); + } + + // Check if the data port is currently loaned. If it is and the requested IPC + // is flow controlled then block Etel calling the IPC by leaving with KErrInUse + if((ret&KReqModeFlowControlObeyed) && iPhoneGlobals->iPhoneStatus.iDataPortLoaned) + { + LOGTEXT2(_L8("ReqModeL Leaving with KErrInUse as data port is loaned (aIpc=%d)"),aIpc); + User::Leave(KErrInUse); + } + + return ret; + } + +TInt CMobilePhonebookStore::NumberOfSlotsL(const TInt /*aIpc*/) +/** + * This function returns the number of slots (buffered in server) for any + * KReqRepostImmediately Ipc calls in the ReqModeL() function. + */ + { + return 1; + } + +TInt CMobilePhonebookStore::RegisterNotification(const TInt /*aIpc*/) +/** + * This function is not supported. + */ + { + return KErrNone; + } + +TInt CMobilePhonebookStore::DeregisterNotification(const TInt /*aIpc*/) +/** + * This function is not supported. + */ + { + return KErrNone; + } + +void CMobilePhonebookStore::Init() + { + LOGTEXT(_L8("CMobilePhonebookStore::Init() called")); + } + +TInt CMobilePhonebookStore::CancelService(const TInt aIpcToCancel,const TTsyReqHandle aTsyReqHandle) +/** + * This function is called when an asynchronous request has passed to the TSY module + * but is yet to be completed. It's used to cancel a client's service request. + */ + { + switch (aIpcToCancel) + { + case EMobilePhoneBookStoreWrite: + iWrite->CancelCommand(aTsyReqHandle); + break; + case EMobilePhoneBookStoreRead: + iRead->CancelCommand(aTsyReqHandle); + break; + case EMobilePhoneStoreDelete: + iDelete->CancelCommand(aTsyReqHandle); + break; + case EMobilePhoneStoreGetInfo: + iInfo->CancelCommand(aTsyReqHandle); + break; + default: // & synchronous functions, nothing to cancel + break; + } + return KErrNone; + } + +CTelObject* CMobilePhonebookStore::OpenNewObjectByNameL(const TDesC& /*aName*/) +/** + * This function is not supported. + */ + { + User::Leave(KErrNotSupported); + return NULL; + } + +CTelObject* CMobilePhonebookStore::OpenNewObjectL(TDes& /*aName*/) +/** + * This function is not supported. + */ + { + User::Leave(KErrNotSupported); + return NULL; + } + + +TInt CMobilePhonebookStore::ExtFunc(const TTsyReqHandle aTsyReqHandle, const TInt aIpc,const TDataPackage& aPackage) +/** + * This function is responsible for dealing with IPC requests the server doesn't support. + */ + { + // Can't initialise if the port is tied up... + if((iPhoneGlobals->iPhoneStatus.iPortAccess==EPortAccessDenied) || (iPhoneGlobals->iPhoneStatus.iMode == RPhone::EModeOnlineData)) + { + LOGTEXT2(_L8("CMobilePhonebookStore::ExtFunc (aIpc=%d)"),aIpc); + LOGTEXT(_L8("CMobilePhonebookStore::ExtFunc\tPort Access Denied/Mode Online flag detected, returning KErrAccessDenied error")); + + return KErrAccessDenied; + } + + // we can handle the request now + return HandleExtFunc(aTsyReqHandle,aIpc,aPackage); + } + +TInt CMobilePhonebookStore::HandleExtFunc(TTsyReqHandle aTsyReqHandle,TInt aIpc,const TDataPackage& aPackage) +/** + * Handle the requested function. The phone book data is now fully live. + */ + { + // We're in a state to execute commands... + TAny* dataPtr1=aPackage.Ptr1(); + TAny* dataPtr2=aPackage.Ptr2(); + + switch (aIpc) + { + case EMobilePhoneStoreGetInfo: + return GetInfo(aTsyReqHandle, aPackage.Des1n()); + + case EMobilePhoneBookStoreRead: + return Read(aTsyReqHandle, reinterpret_cast(dataPtr1), aPackage.Des2n()); + + case EMobilePhoneBookStoreWrite: + return Write(aTsyReqHandle, aPackage.Des1n(), reinterpret_cast(dataPtr2)); + + case EMobilePhoneStoreDelete: + return Delete(aTsyReqHandle,reinterpret_cast(dataPtr1)); + + default: + return KErrNotSupported; + } + } + +TInt CMobilePhonebookStore::GetInfo(TTsyReqHandle aTsyReqHandle, TDes8* aInfoPckg) +/** Get Phone Book Storage Information + * + * This function queries the phone for storage information on the current phone book + * store. + * It returns the related storage information only if supported by the phone. + * @param aTsyReqHandle Handle to the request ID . + * @param aInfoPckg Pointer to the struct that contains information about the phone book. + * @return error code. + */ + { + LOGTEXT(_L8("CMobilePhonebookStore::GetInfo called")); + + // Have to send AT+CPBR=? to get the phonebook information + // This command is sent every time to ensure we have up-to-date knowledge + // of used number of entries + iInfo->SetStorageType(iStorageType); + iInfo->ExecuteCommand(aTsyReqHandle, aInfoPckg); + + return KErrNone; + } + +TInt CMobilePhonebookStore::Read(TTsyReqHandle aTsyReqHandle, RMobilePhoneBookStore::TPBIndexAndNumEntries* aIndexAndEntries, TDes8* aPBData) +/** Read one or a number of Phone Book Enties + * + * This function reads the phone book entries from the current + * phone book store. + * @param aTsyReqHandle Handle to the request ID. + * @param aIndexAndEntries is a pointer to an index and a number of entries. + * @param aPBData is a pointer to a packet. + * @return error code. + */ + { + LOGTEXT(_L8("CMobilePhonebookStore::Read called")); + + if (!(iReadWriteAccess&RMobilePhoneStore::KCapsReadAccess)) + { + LOGTEXT(_L8("CMobilePhonebookStore::Read Completing with KErrAccessDenied as read access is not allowed")); + ReqCompleted(aTsyReqHandle,KErrAccessDenied); + return KErrNone; + } + + iRead->SetPBData(aPBData); + + // Store index & number of entries so we can modify/truncate it if required + iIndexAndEntries=*aIndexAndEntries; + + // If we already have information about this phonebook + // Check client has supplied valid locations - otherwise send command anyway + if (iInfo->Completed()) + { + // Allow CATPhoneBookInfo to map our clients index value (1..x) + // the this specific phone store index values (1+y..x+y) + // For the Motorola T260 SM phone book store y will be 100 + LOGTEXT(_L8("CMobilePhonebookStore::Read Mapping clients index to phone index")); + iInfo->MapClientIndexToPhoneIndex(iIndexAndEntries.iIndex); + + if (iInfo->IsValidPhoneIndex(iIndexAndEntries.iIndex)) + { + if (!iInfo->IsValidPhoneIndex(iIndexAndEntries.iIndex+iIndexAndEntries.iNumSlots-1)) + { + // Invalid finishing index - truncate to last valid one + iIndexAndEntries.iNumSlots = iInfo->TotalEntries()-iIndexAndEntries.iIndex+1 ; + } + } + else + { + // Invalid starting index - complete request with error + LOGTEXT(_L8("CMobilePhonebookStore::Read\t Index out of range")); + ReqCompleted(aTsyReqHandle,KErrArgument); // The Index is out of range. + return KErrNone; + } + } + + // We either have valid index or entries - or are trying anyway + iRead->ExecuteCommand(aTsyReqHandle, &iIndexAndEntries); + return KErrNone; + } + + +TInt CMobilePhonebookStore::Write(TTsyReqHandle aTsyReqHandle, TDes8* aPBData, TInt* aIndex) +/** Write a Phone Book Entry + * + * This function checks to see if the current phone book has Write Access; if it + * does, an entry is written to the phone book store. + * The function first creates the entry, then ensures there is space in the data + * object, before writing the entry. + * @param aTsyReqHandle Handle to the request ID. + * @param aPBData is a pointer to a packet. + * @param aIndex is a pointer to an entry in the phone book. + * @return error code. + */ + { + LOGTEXT(_L8("CMobilePhonebookStore::Write called")); + + if(!(iReadWriteAccess&RMobilePhoneStore::KCapsWriteAccess)) + { + ReqCompleted(aTsyReqHandle,KErrAccessDenied); + return KErrNone; + } + + // Take copy of clients data, as we do not want changes that we make here + // to be reflected in the clients space. + iIndex=*aIndex; + + iWrite->SetPBData(aPBData); + + // If we already have information about this phonebook + // Check client has supplied valid location - otherwise send command anyway + if (iInfo->Completed()) + { + // Allow CATPhoneBookInfo to map our clients index value (1..x) + // the this specific phone store index values (1+y..x+y) + // For the Motorola T260 SM phone book store y will be 100 + LOGTEXT(_L8("CMobilePhonebookStore::Write Mapping clients index to phone index")); + iInfo->MapClientIndexToPhoneIndex(iIndex); + + if(!iInfo->IsValidPhoneIndex(iIndex)) + { + LOGTEXT(_L8("CMobilePhonebookStore::Write\t Index out of range")); + ReqCompleted(aTsyReqHandle,KErrArgument); // The Index is out of range. + return KErrNone; + } + } + + iWrite->ExecuteCommand(aTsyReqHandle, &iIndex); + return KErrNone; + } + + +TInt CMobilePhonebookStore::Delete(TTsyReqHandle aTsyReqHandle,TInt* aIndex) +/** Delete a Phonebook Entry + * + * This function deletes a phonebook entry. + * The data object is only updated when the AT command completes successfully. + * @param aTsyReqHandle Handle to the request ID. + * @param aIndex is a pointer to an entry in the phone book. + * @return error code. + */ + { + LOGTEXT(_L8("CMobilePhonebookStore::Delete called")); + if(!(iReadWriteAccess & RMobilePhoneStore::KCapsWriteAccess)) + { + ReqCompleted(aTsyReqHandle,KErrAccessDenied); + return KErrNone; + } + + // Take copy of clients data, as we do not want changes that we make here + // to be relected in the clients space. + iIndex=*aIndex; + + // If we already have information about this phonebook + // Check client has supplied valid location - otherwise send command anyway + if (iInfo->Completed()) + { + // Allow CATPhoneBookInfo to map our clients index value (1..x) + // the this specific phone store index values (1+y..x+y) + // For the Motorola T260 SM phone book store y will be 100 + LOGTEXT(_L8("CMobilePhonebookStore::Delete Mapping clients index to phone index")); + iInfo->MapClientIndexToPhoneIndex(iIndex); + + if(!iInfo->IsValidPhoneIndex(iIndex)) + { + LOGTEXT(_L8("CMobilePhonebookStore::Delete\t Index out of range")); + ReqCompleted(aTsyReqHandle,KErrArgument); // The Index is out of range. + return KErrNone; + } + } + + iDelete->ExecuteCommand(aTsyReqHandle,&iIndex); + return KErrNone; + } + +