diff -r f5050f1da672 -r 04becd199f91 javaextensions/pim/framework/src.s60/cpimmanager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javaextensions/pim/framework/src.s60/cpimmanager.cpp Tue Apr 27 16:30:29 2010 +0300 @@ -0,0 +1,399 @@ +/* +* Copyright (c) 2008 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: PIM manager singleton native side, a starting point to PIM API. + * +*/ + + +// INCLUDE FILES +#include "cpimmanager.h" +#include +#include +#include "pimcommon.h" +#include "mpimcontactadaptermanager.h" +#include "mpimeventadaptermanager.h" +#include "mpimtodoadaptermanager.h" +#include "mpimcontactlistadapter.h" +#include "mpimeventlistadapter.h" +#include "mpimtodolistadapter.h" +#include "cpimversit.h" +#include "mpimlocalizationmanager.h" +#include "mpimlocalizationdata.h" +#include "cpimcontactlist.h" +#include "cpimeventlist.h" +#include "cpimtodolist.h" +#include "cpimcontactvalidator.h" +#include "cpimeventvalidator.h" +#include "cpimtodovalidator.h" +#include "mpimadapteraccess.h" +#include "cpimcmadapteraccess.h" +#include "cpimeventadapteraccess.h" +#include "cpimtodoadapteraccess.h" +#include "pimpanics.h" +#include "pimjnitools.h" +#include "pimutils.h" +#include "jstringutils.h" +#include "logger.h" +#include "cpimlocalizationmanager.h" + +// CONSTANTS + +/** + * Array granularity for arrays of managers, cached list names and + * localization objects. Number of such objects in an array is quite + * low, at the time of writing 1 to 4. + */ +const TInt KManagerArrayGranularity = 2; + + +CPIMManager::CPIMManager() : + java::util::FunctionServer("CPIMManager"), iAdapterAccesses() +{ + JELOG2(EPim); +} + +void CPIMManager::ConstructL() +{ + JELOG2(EPim); + iContactValidator = CPIMContactValidator::NewL(); + iEventValidator = CPIMEventValidator::NewL(); + iToDoValidator = CPIMToDoValidator::NewL(); + + iLocalizationManager + = (MPIMLocalizationManager*)(CPIMLocalizationManager::NewL()); + + createServerToNewThread(); +} + +pimbasemanager* pimbasemanager::getInstance() +{ + JELOG2(EPim); + // Create CPIMManager + + CPIMManager* self = NULL; + TInt error = KErrNone; + TRAP(error, self = CPIMManager::NewL()); + if (error != KErrNone) + throw error; + return self; +} + +CPIMManager* CPIMManager::NewL() +{ + JELOG2(EPim); + CPIMManager* self = new(ELeave) CPIMManager; + + CleanupStack::PushL(self); + self->ConstructL(); + + MPIMLocalizationManager* localizationManager = self->iLocalizationManager; + + // Create Adapter Access objects + + MPIMAdapterAccess* contactAdapterAccess = CPIMCMAdapterAccess::NewL( + localizationManager, self); + CleanupDeletePushL(contactAdapterAccess); + self->AddAdapterAccessL(contactAdapterAccess); + CleanupStack::Pop(contactAdapterAccess); + + MPIMAdapterAccess* eventAdapterAccess = CPIMEventAdapterAccess::NewL( + localizationManager, self); + CleanupDeletePushL(eventAdapterAccess); + self->AddAdapterAccessL(eventAdapterAccess); + CleanupStack::Pop(eventAdapterAccess); + + MPIMAdapterAccess* toDoAdapterAccess = CPIMToDoAdapterAccess::NewL( + localizationManager, self); + CleanupDeletePushL(toDoAdapterAccess); + self->AddAdapterAccessL(toDoAdapterAccess); + CleanupStack::Pop(toDoAdapterAccess); + + CleanupStack::Pop(self); + + return self; +} + +CPIMManager::~CPIMManager() +{ + JELOG2(EPim); + delete iLocalizationManager; + iLocalizationManager = NULL; + iAdapterAccesses.ResetAndDestroy(); + delete iContactValidator; + iContactValidator = NULL; + delete iEventValidator; + iEventValidator = NULL; + delete iToDoValidator; + iToDoValidator = NULL; + stopServer(); +} + +void CPIMManager::dispose() +{ + JELOG2(EPim); + delete iContactValidator; + iContactValidator = NULL; + delete iEventValidator; + iEventValidator = NULL; + delete iToDoValidator; + iToDoValidator = NULL; +} + +MPIMLocalizationManager* CPIMManager::localizationManager() const +{ + JELOG2(EPim); + return iLocalizationManager; +} + +void CPIMManager::AddAdapterAccessL(MPIMAdapterAccess* aAdapterAccess) +{ + JELOG2(EPim); + User::LeaveIfError(iAdapterAccesses.Append(aAdapterAccess)); +} + +pimbaselist* CPIMManager::openPimList(const TPIMListType& aPimListType, + jstring aPimListName, JNIEnv* aJniEnv) +{ + JELOG2(EPim); + const JStringUtils listName(*aJniEnv, aPimListName); + const TDesC* listNameArg = (aPimListName ? &listName : NULL); + pimbaselist* list = NULL; + TInt error = KErrNone; + TRAP(error, list = DoOpenPimListL(aPimListType, listNameArg)); + if (error != KErrNone) + throw error; + return list; +} + +pimbaselist* CPIMManager::DoOpenPimListL(const TPIMListType& aPimListType, + const TDesC* aPimListName) +{ + JELOG2(EPim); + pimbaselist* list = NULL; + + if (aPimListType == EPIMContactList) + { + list = DoOpenContactListL(aPimListName); + } + else if (aPimListType == EPIMEventList) + { + list = DoOpenEventListL(aPimListName); + } + else if (aPimListType == EPIMToDoList) + { + list = DoOpenToDoListL(aPimListName); + } + else + { + // invalid list type + User::Leave(KErrArgument); + } + + // Check results + + if (!list) + { + if (aPimListName) + { + // list name was given but no such list exists + User::Leave(KErrNotFound); + } + else + { + // default list was not found + User::Leave(KErrNotSupported); + } + } + + return list; +} + +CDesCArray* CPIMManager::DoListPimListsL(const TPIMListType& aPimListType) +{ + JELOG2(EPim); + CDesCArray* retVal = new(ELeave) CDesCArrayFlat(KManagerArrayGranularity); + CleanupStack::PushL(retVal); + + // Loop through the Adapter Accesses + + const TInt numAccesses = iAdapterAccesses.Count(); + for (TInt accessIndex = 0; accessIndex < numAccesses; accessIndex++) + { + // Loop through the lists provided by an Adapter Access + + const CDesCArray& lists = iAdapterAccesses[accessIndex]->ListNamesL( + aPimListType); + + const TInt numLists = lists.Count(); + for (TInt listIndex = 0; listIndex < numLists; listIndex++) + { + retVal->AppendL(lists[listIndex]); + } + } + + // Done + + CleanupStack::Pop(retVal); + return retVal; + +} + +jobjectArray CPIMManager::listPimLists(const TPIMListType& aPimListType, + jintArray aError, JNIEnv* aJniEnv) +{ + JELOG2(EPim); + jobjectArray javaStringArray = NULL; + CDesCArray* lists = NULL; + TInt error = KErrNone; + TRAP(error, lists = DoListPimListsL(aPimListType)); + if (error == KErrNone) + { + javaStringArray = CreateJavaStringArray(aJniEnv, *lists, EFalse); // (do not handle KPIMNullArrayElement elements specially) + + if (!javaStringArray) + { + SetJavaErrorCode(aJniEnv, aError, KErrNoMemory); + } + + delete lists; + } + else + { + // list array was not created + SetJavaErrorCode(aJniEnv, aError, error); + } + return javaStringArray; +} + +const CPIMContactValidator& CPIMManager::ContactValidator() +{ + JELOG2(EPim); + return *iContactValidator; +} + +const CPIMEventValidator& CPIMManager::EventValidator() +{ + JELOG2(EPim); + return *iEventValidator; +} + +const CPIMToDoValidator& CPIMManager::ToDoValidator() +{ + JELOG2(EPim); + return *iToDoValidator; +} + +CPIMContactList* CPIMManager::DoOpenContactListL(const TDesC* aListName) +{ + JELOG2(EPim); + CPIMContactList* contactList = NULL; + + MPIMContactAdapterManager* contactAdapterManager = NULL; + MPIMContactListAdapter* contactListAdapter = NULL; + MPIMLocalizationData* localizationData = NULL; + + const TInt n = iAdapterAccesses.Count(); + for (TInt i = 0; i < n; i++) + { + if (iAdapterAccesses[i]->OpenContactListL(aListName, + &contactAdapterManager, &contactListAdapter, &localizationData)) + { + // got one + CleanupDeletePushL(contactAdapterManager); + CleanupDeletePushL(contactListAdapter); + + contactList = CPIMContactList::NewL(contactAdapterManager, + contactListAdapter, localizationData, *iContactValidator); + + CleanupStack::Pop(contactListAdapter); + CleanupStack::Pop(contactAdapterManager); + + break; + } + + // else try next Adapter Access + } + + return contactList; +} + +CPIMEventList* CPIMManager::DoOpenEventListL(const TDesC* aListName) +{ + JELOG2(EPim); + CPIMEventList* eventList = NULL; + + MPIMEventAdapterManager* eventAdapterManager = NULL; + MPIMEventListAdapter* eventListAdapter = NULL; + MPIMLocalizationData* localizationData = NULL; + + const TInt n = iAdapterAccesses.Count(); + for (TInt i = 0; i < n; i++) + { + if (iAdapterAccesses[i]->OpenEventListL(aListName, + &eventAdapterManager, &eventListAdapter, &localizationData)) + { + // got one + CleanupDeletePushL(eventAdapterManager); + CleanupDeletePushL(eventListAdapter); + + eventList = CPIMEventList::NewL(eventAdapterManager, + eventListAdapter, localizationData, *iEventValidator); + + CleanupStack::Pop(eventListAdapter); + CleanupStack::Pop(eventAdapterManager); + + break; + } + + // else try next Adapter Access + } + + return eventList; +} + +CPIMToDoList* CPIMManager::DoOpenToDoListL(const TDesC* aListName) +{ + JELOG2(EPim); + CPIMToDoList* toDoList = NULL; + + MPIMToDoAdapterManager* toDoAdapterManager = NULL; + MPIMToDoListAdapter* toDoListAdapter = NULL; + MPIMLocalizationData* localizationData = NULL; + + const TInt n = iAdapterAccesses.Count(); + for (TInt i = 0; i < n; i++) + { + if (iAdapterAccesses[i]->OpenToDoListL(aListName, &toDoAdapterManager, + &toDoListAdapter, &localizationData)) + { + // got one + CleanupDeletePushL(toDoAdapterManager); + CleanupDeletePushL(toDoListAdapter); + + toDoList = CPIMToDoList::NewL(toDoAdapterManager, toDoListAdapter, + localizationData, *iToDoValidator); + + CleanupStack::Pop(toDoListAdapter); + CleanupStack::Pop(toDoAdapterManager); + + break; + } + + // else try next Adapter Access + } + + return toDoList; +} + +// End of File