1 /*

     2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  PIM manager singleton native side, a starting point to PIM API.

    15  *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "cpimmanager.h"

    21 #include <e32std.h>

    22 #include <badesca.h>

    23 #include "pimcommon.h"

    24 #include "mpimcontactadaptermanager.h"

    25 #include "mpimeventadaptermanager.h"

    26 #include "mpimtodoadaptermanager.h"

    27 #include "mpimcontactlistadapter.h"

    28 #include "mpimeventlistadapter.h"

    29 #include "mpimtodolistadapter.h"

    30 #include "cpimversit.h"

    31 #include "mpimlocalizationmanager.h"

    32 #include "mpimlocalizationdata.h"

    33 #include "cpimcontactlist.h"

    34 #include "cpimeventlist.h"

    35 #include "cpimtodolist.h"

    36 #include "cpimcontactvalidator.h"

    37 #include "cpimeventvalidator.h"

    38 #include "cpimtodovalidator.h"

    39 #include "mpimadapteraccess.h"

    40 #include "cpimcmadapteraccess.h"

    41 #include "cpimeventadapteraccess.h"

    42 #include "cpimtodoadapteraccess.h"

    43 #include "pimpanics.h"

    44 #include "pimjnitools.h"

    45 #include "pimutils.h"

    46 #include "jstringutils.h"

    47 #include "logger.h"

    48 #include "cpimlocalizationmanager.h"

    49 

    50 // CONSTANTS

    51 

    52 /**

    53  * Array granularity for arrays of managers, cached list names and

    54  * localization objects. Number of such objects in an array is quite

    55  * low, at the time of writing 1 to 4.

    56  */

    57 const TInt KManagerArrayGranularity = 2;

    58 

    59 

    60 CPIMManager::CPIMManager() :

    61         java::util::FunctionServer("CPIMManager"), iAdapterAccesses()

    62 {

    63     JELOG2(EPim);

    64 }

    65 

    66 void CPIMManager::ConstructL()

    67 {

    68     JELOG2(EPim);

    69     iContactValidator = CPIMContactValidator::NewL();

    70     iEventValidator = CPIMEventValidator::NewL();

    71     iToDoValidator = CPIMToDoValidator::NewL();

    72 

    73     iLocalizationManager

    74     = (MPIMLocalizationManager*)(CPIMLocalizationManager::NewL());

    75 

    76     createServerToNewThread();

    77 }

    78 

    79 pimbasemanager* pimbasemanager::getInstance()

    80 {

    81     JELOG2(EPim);

    82     // Create CPIMManager

    83 

    84     CPIMManager* self = NULL;

    85     TInt error = KErrNone;

    86     TRAP(error, self = CPIMManager::NewL());

    87     if (error != KErrNone)

    88         throw error;

    89     return self;

    90 }

    91 

    92 CPIMManager* CPIMManager::NewL()

    93 {

    94     JELOG2(EPim);

    95     CPIMManager* self = new(ELeave) CPIMManager;

    96 

    97     CleanupStack::PushL(self);

    98     self->ConstructL();

    99 

   100     MPIMLocalizationManager* localizationManager = self->iLocalizationManager;

   101 

   102     // Create Adapter Access objects

   103 

   104     MPIMAdapterAccess* contactAdapterAccess = CPIMCMAdapterAccess::NewL(

   105                 localizationManager, self);

   106     CleanupDeletePushL(contactAdapterAccess);

   107     self->AddAdapterAccessL(contactAdapterAccess);

   108     CleanupStack::Pop(contactAdapterAccess);

   109 

   110     MPIMAdapterAccess* eventAdapterAccess = CPIMEventAdapterAccess::NewL(

   111                                                 localizationManager, self);

   112     CleanupDeletePushL(eventAdapterAccess);

   113     self->AddAdapterAccessL(eventAdapterAccess);

   114     CleanupStack::Pop(eventAdapterAccess);

   115 

   116     MPIMAdapterAccess* toDoAdapterAccess = CPIMToDoAdapterAccess::NewL(

   117                                                localizationManager, self);

   118     CleanupDeletePushL(toDoAdapterAccess);

   119     self->AddAdapterAccessL(toDoAdapterAccess);

   120     CleanupStack::Pop(toDoAdapterAccess);

   121 

   122     CleanupStack::Pop(self);

   123 

   124     return self;

   125 }

   126 

   127 CPIMManager::~CPIMManager()

   128 {

   129     JELOG2(EPim);

   130     delete iLocalizationManager;

   131     iLocalizationManager = NULL;

   132     iAdapterAccesses.ResetAndDestroy();

   133     delete iContactValidator;

   134     iContactValidator = NULL;

   135     delete iEventValidator;

   136     iEventValidator = NULL;

   137     delete iToDoValidator;

   138     iToDoValidator = NULL;

   139     stopServer();

   140 }

   141 

   142 void CPIMManager::dispose()

   143 {

   144     JELOG2(EPim);

   145     delete iContactValidator;

   146     iContactValidator = NULL;

   147     delete iEventValidator;

   148     iEventValidator = NULL;

   149     delete iToDoValidator;

   150     iToDoValidator = NULL;

   151 }

   152 

   153 MPIMLocalizationManager* CPIMManager::localizationManager() const

   154 {

   155     JELOG2(EPim);

   156     return iLocalizationManager;

   157 }

   158 

   159 void CPIMManager::AddAdapterAccessL(MPIMAdapterAccess* aAdapterAccess)

   160 {

   161     JELOG2(EPim);

   162     User::LeaveIfError(iAdapterAccesses.Append(aAdapterAccess));

   163 }

   164 

   165 pimbaselist* CPIMManager::openPimList(const TPIMListType& aPimListType,

   166                                       jstring aPimListName, JNIEnv* aJniEnv)

   167 {

   168     JELOG2(EPim);

   169     const JStringUtils listName(*aJniEnv, aPimListName);

   170     const TDesC* listNameArg = (aPimListName ? &listName : NULL);

   171     pimbaselist* list = NULL;

   172     TInt error = KErrNone;

   173     TRAP(error, list = DoOpenPimListL(aPimListType, listNameArg));

   174     if (error != KErrNone)

   175         throw error;

   176     return list;

   177 }

   178 

   179 pimbaselist* CPIMManager::DoOpenPimListL(const TPIMListType& aPimListType,

   180         const TDesC* aPimListName)

   181 {

   182     JELOG2(EPim);

   183     pimbaselist* list = NULL;

   184 

   185     if (aPimListType == EPIMContactList)

   186     {

   187         list = DoOpenContactListL(aPimListName);

   188     }

   189     else if (aPimListType == EPIMEventList)

   190     {

   191         list = DoOpenEventListL(aPimListName);

   192     }

   193     else if (aPimListType == EPIMToDoList)

   194     {

   195         list = DoOpenToDoListL(aPimListName);

   196     }

   197     else

   198     {

   199         // invalid list type

   200         User::Leave(KErrArgument);

   201     }

   202 

   203     // Check results

   204 

   205     if (!list)

   206     {

   207         if (aPimListName)

   208         {

   209             // list name was given but no such list exists

   210             User::Leave(KErrNotFound);

   211         }

   212         else

   213         {

   214             // default list was not found

   215             User::Leave(KErrNotSupported);

   216         }

   217     }

   218 

   219     return list;

   220 }

   221 

   222 CDesCArray* CPIMManager::DoListPimListsL(const TPIMListType& aPimListType)

   223 {

   224     JELOG2(EPim);

   225     CDesCArray* retVal = new(ELeave) CDesCArrayFlat(KManagerArrayGranularity);

   226     CleanupStack::PushL(retVal);

   227 

   228     // Loop through the Adapter Accesses

   229 

   230     const TInt numAccesses = iAdapterAccesses.Count();

   231     for (TInt accessIndex = 0; accessIndex < numAccesses; accessIndex++)

   232     {

   233         // Loop through the lists provided by an Adapter Access

   234 

   235         const CDesCArray& lists = iAdapterAccesses[accessIndex]->ListNamesL(

   236                                       aPimListType);

   237 

   238         const TInt numLists = lists.Count();

   239         for (TInt listIndex = 0; listIndex < numLists; listIndex++)

   240         {

   241             retVal->AppendL(lists[listIndex]);

   242         }

   243     }

   244 

   245     // Done

   246 

   247     CleanupStack::Pop(retVal);

   248     return retVal;

   249 

   250 }

   251 

   252 jobjectArray CPIMManager::listPimLists(const TPIMListType& aPimListType,

   253                                        jintArray aError, JNIEnv* aJniEnv)

   254 {

   255     JELOG2(EPim);

   256     jobjectArray javaStringArray = NULL;

   257     CDesCArray* lists = NULL;

   258     TInt error = KErrNone;

   259     TRAP(error, lists = DoListPimListsL(aPimListType));

   260     if (error == KErrNone)

   261     {

   262         javaStringArray = CreateJavaStringArray(aJniEnv, *lists, EFalse); // (do not handle KPIMNullArrayElement elements specially)

   263 

   264         if (!javaStringArray)

   265         {

   266             SetJavaErrorCode(aJniEnv, aError, KErrNoMemory);

   267         }

   268 

   269         delete lists;

   270     }

   271     else

   272     {

   273         // list array was not created

   274         SetJavaErrorCode(aJniEnv, aError, error);

   275     }

   276     return javaStringArray;

   277 }

   278 

   279 const CPIMContactValidator& CPIMManager::ContactValidator()

   280 {

   281     JELOG2(EPim);

   282     return *iContactValidator;

   283 }

   284 

   285 const CPIMEventValidator& CPIMManager::EventValidator()

   286 {

   287     JELOG2(EPim);

   288     return *iEventValidator;

   289 }

   290 

   291 const CPIMToDoValidator& CPIMManager::ToDoValidator()

   292 {

   293     JELOG2(EPim);

   294     return *iToDoValidator;

   295 }

   296 

   297 CPIMContactList* CPIMManager::DoOpenContactListL(const TDesC* aListName)

   298 {

   299     JELOG2(EPim);

   300     CPIMContactList* contactList = NULL;

   301 

   302     MPIMContactAdapterManager* contactAdapterManager = NULL;

   303     MPIMContactListAdapter* contactListAdapter = NULL;

   304     MPIMLocalizationData* localizationData = NULL;

   305 

   306     const TInt n = iAdapterAccesses.Count();

   307     for (TInt i = 0; i < n; i++)

   308     {

   309         if (iAdapterAccesses[i]->OpenContactListL(aListName,

   310                 &contactAdapterManager, &contactListAdapter, &localizationData))

   311         {

   312             // got one

   313             CleanupDeletePushL(contactAdapterManager);

   314             CleanupDeletePushL(contactListAdapter);

   315 

   316             contactList = CPIMContactList::NewL(contactAdapterManager,

   317                                                 contactListAdapter, localizationData, *iContactValidator);

   318 

   319             CleanupStack::Pop(contactListAdapter);

   320             CleanupStack::Pop(contactAdapterManager);

   321 

   322             break;

   323         }

   324 

   325         // else try next Adapter Access

   326     }

   327 

   328     return contactList;

   329 }

   330 

   331 CPIMEventList* CPIMManager::DoOpenEventListL(const TDesC* aListName)

   332 {

   333     JELOG2(EPim);

   334     CPIMEventList* eventList = NULL;

   335 

   336     MPIMEventAdapterManager* eventAdapterManager = NULL;

   337     MPIMEventListAdapter* eventListAdapter = NULL;

   338     MPIMLocalizationData* localizationData = NULL;

   339 

   340     const TInt n = iAdapterAccesses.Count();

   341     for (TInt i = 0; i < n; i++)

   342     {

   343         if (iAdapterAccesses[i]->OpenEventListL(aListName,

   344                                                 &eventAdapterManager, &eventListAdapter, &localizationData))

   345         {

   346             // got one

   347             CleanupDeletePushL(eventAdapterManager);

   348             CleanupDeletePushL(eventListAdapter);

   349 

   350             eventList = CPIMEventList::NewL(eventAdapterManager,

   351                                             eventListAdapter, localizationData, *iEventValidator);

   352 

   353             CleanupStack::Pop(eventListAdapter);

   354             CleanupStack::Pop(eventAdapterManager);

   355 

   356             break;

   357         }

   358 

   359         // else try next Adapter Access

   360     }

   361 

   362     return eventList;

   363 }

   364 

   365 CPIMToDoList* CPIMManager::DoOpenToDoListL(const TDesC* aListName)

   366 {

   367     JELOG2(EPim);

   368     CPIMToDoList* toDoList = NULL;

   369 

   370     MPIMToDoAdapterManager* toDoAdapterManager = NULL;

   371     MPIMToDoListAdapter* toDoListAdapter = NULL;

   372     MPIMLocalizationData* localizationData = NULL;

   373 

   374     const TInt n = iAdapterAccesses.Count();

   375     for (TInt i = 0; i < n; i++)

   376     {

   377         if (iAdapterAccesses[i]->OpenToDoListL(aListName, &toDoAdapterManager,

   378                                                &toDoListAdapter, &localizationData))

   379         {

   380             // got one

   381             CleanupDeletePushL(toDoAdapterManager);

   382             CleanupDeletePushL(toDoListAdapter);

   383 

   384             toDoList = CPIMToDoList::NewL(toDoAdapterManager, toDoListAdapter,

   385                                           localizationData, *iToDoValidator);

   386 

   387             CleanupStack::Pop(toDoListAdapter);

   388             CleanupStack::Pop(toDoAdapterManager);

   389 

   390             break;

   391         }

   392 

   393         // else try next Adapter Access

   394     }

   395 

   396     return toDoList;

   397 }

   398 

   399 //  End of File