/*

* 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 <e32std.h>

#include <badesca.h>

#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;

    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;

    const TInt n = iAdapterAccesses.Count();

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

    {

                                                &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;

    const TInt n = iAdapterAccesses.Count();

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

    {

                                               &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