/*
* Copyright (c) 2004-2007 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:  
:                
*
*/




// INCLUDES
#include <e32std.h>
#include "s_CVPbkContactStoreList.h"
#include "CVPbkStoreContactStub.h"
#include "s_CVPbkContactView.h"

CVPbkContactStoreStub gLocalStore;
CVPbkContactStoreStub gXSPStore;

// FORWARD DECLARATIONS

/**
 * Returns fixed properties of this contact store.
 *
 * Fixed properties do not change when the store is open. 
 * The store must be opened before retrieving the properties.
 *
 * @return Store properties.
 */
const MVPbkContactStoreProperties& CVPbkContactStoreStub::StoreProperties() const 
{ 
MVPbkContactStoreProperties* ret = NULL;
return *ret;
}

/**
 * Opens this contact store asynchronously.
 *
 * Calls back the observer when the opening completes. Notice
 * that the same store instance can be opened by several observers.
 *
 * @param aObserver An observer for the store.
 * @exception KErrInUse If another asynchronous operation
 *            is already in progress.
 */
void CVPbkContactStoreStub::OpenL(
        MVPbkContactStoreObserver& /*aObserver*/ ) { }

/**
 * Replaces an existing store and opens it asynchronously. 
 * 
 * E.g. If the database is a file then this replaces the database if
 * it's not locked by other clients. If the store 
 * implementation can not implment replacing then this behaves 
 * like OpenL.
 *
 * If the store does not exist, it is created if possible.
 * Calls back the observer when the opening completes.
 *
 * @param aObserver An observer for the store.
 */
void CVPbkContactStoreStub::ReplaceL(
        MVPbkContactStoreObserver& /*aObserver*/ ) { }

/**
 * Closes this contact store from a single observer. 
 * 
 * This can be always called safely even if OpenL or ReplaceL
 * hasn't been called. 
 * If the client calls OpenL it must also call this after usage,
 * The observer will no longer receive events from this store.
 * If there are other observers for the store then the store
 * will remain open for them.
 *
 * @param aObserver An observer that was given in OpenL or ReplaceL.
 */
void CVPbkContactStoreStub::Close(
        MVPbkContactStoreObserver& /*aObserver*/ ) { }

/**
 * Creates a new contact associated to this store.
 * 
 * The contact can be edited and then it must be committed by
 * calling MVPbkStoreContact::CommitL for actually saving
 * it to the store.
 *
 * @return A new contact associated to this store. Caller takes
 *         ownership of the returned contact.
 * @see MVPbkStoreContact
 * @see MVPbkStoreContact::CommitL
 */
MVPbkStoreContact* CVPbkContactStoreStub::CreateNewContactLC() 
{ 
return new (ELeave) CVPbkStoreContactStub;
}

/**
 * Creates a new contact group associated to this store. 
 * 
 * MVPbkContactStoreProperties::SupportsContactGroups must be
 * true if this is used.
 * The contact group might be saved to the store immeadiately
 * depending on the store implementation. 
 * It is left open for editing. Use CommitL to commit 
 * the creation of the group and its content.
 *
 * @return A new contact group associated to this store. Caller takes
 *         the ownership of the returned contact group.
 * @exception KErrNotSupported if the store doesn't support groups.
 *              Client should check store properties before
 *              calling this.
 * @see MVPbkContactStoreProperties
 * @see MVPbkContactGroup
 * @see MVPbkStoreContact
 * @see MVPbkStoreContact::CommitL
 */
MVPbkContactGroup* CVPbkContactStoreStub::CreateNewContactGroupLC() { return NULL; }

/**
 * Creates a new contact view from the store asynchronously.
 *
 * Client gets the ownership of the view. The content of
 * the view depends on the CVPbkContactViewDefinition. The
 * client must wait the observer event before using the view.
 *
 * @param aViewDefinition Defines the properties of the new view.
 * @param aObserver An observer for the view events.
 * @param aSortOrder Field types that are used in the view contact
 *                   in the same order as in this list. Notice that
 *                   stores may not support all possible field types
 *                   in a view contact. The implementation
 *                   of the view contact must have as many fields as
 *                   the sort order. If the store doesn't support the
 *                   field type in a view contact then it sets empty
 *                   data to the field.
 * @return  A new contact view object. Caller takes ownership of the
 *          returned contact.
 * @see MVPbkContactView
 * @see CVPbkContactViewDefinition
 */
MVPbkContactView* CVPbkContactStoreStub::CreateViewLC(
        const CVPbkContactViewDefinition& /*aViewDefinition*/,
        MVPbkContactViewObserver& /*aObserver*/,
        const MVPbkFieldTypeList& /*aSortOrder*/ ) 
        { 
        CVPbkContactViewStub* some = new (ELeave) CVPbkContactViewStub;
        CleanupStack::PushL(some);
        return some;
        }
    
/**
 * Returns contact groups contained in this store.
 *
 * MVPbkContactStoreProperties::SupportsContactGroups must be
 * true if this is used. Implementation should return an empty
 * link array and not NULL.
 *
 * @return Contact group identifiers contained in this store.
 */
MVPbkContactLinkArray* CVPbkContactStoreStub::ContactGroupsLC() const { return NULL; }

/**
 * Returns a contact store information. Information can vary
 * runtime.
 *
 * @return Contact store information.
 */
const MVPbkContactStoreInfo& CVPbkContactStoreStub::StoreInfo() const 
{ 
MVPbkContactStoreInfo* ret = NULL;
return *ret;
}

/**
 * This is part of Virtual Phonebook internal framefork and not
 * usable for clients. Clients use CVPbkContactManager 
 * for creating links from a stream.
 *
 * Creates a link array from a stream. Stream contains the internals
 * of the contact link. Internals are the contact store implementation
 * specific part of the package format.
 *
 * NOTE: this must work wheter the OpenL has been called or not. This
 *       means that a link can not contain any data that would need
 *       an open store before internalizing.
 *
 * @param aStream A stream containing the link internals.
 * @return A new contact link.
 * @internal
 */
MVPbkContactLink* CVPbkContactStoreStub::CreateLinkFromInternalsLC(
        RReadStream& /*aStream*/ ) const { return NULL; }

/**
* Returns own contact link asynchronously.
* 
* @params aObserver Operation observer
* @return operation handle
* @Asynchronous
*/
MVPbkContactOperationBase* CVPbkContactStoreStub::OwnContactLinkL(
	   MVPbkSingleContactLinkOperationObserver& /*aObserver*/) const { return NULL; }
    

/**
 * Returns the parent object of this object. For the root of the 
 * hierarchy returns self.
 * @return The parent object.
 */
MVPbkObjectHierarchy& CVPbkContactStoreStub::ParentObject() const 
{ 
MVPbkObjectHierarchy* ret=NULL;
return *ret;
}


/**
 * Creates an operation for contact retrieval.
 *
 * @param aLink A link to the contact
 * @param aObserver An observer for the operation.
 * @return A handle to the operation or NULL if the factory
 *         doesn't have reference to the store of the link.
 */
MVPbkContactOperation* CVPbkContactStoreStub::CreateContactRetrieverL(
        const MVPbkContactLink& /*aLink*/,
        MVPbkSingleContactOperationObserver& /*aObserver*/) { return NULL; }

/**
 * Creates an operation for deleting multiple contacts.
 *
 * @param aContactLinks An array of contact links that specify 
 *                      the contacts.
 * @param aObserver An observer for the operation.
 * @return A handle to the operation or NULL
 */
MVPbkContactOperation* CVPbkContactStoreStub::CreateDeleteContactsOperationL(
        const MVPbkContactLinkArray& /*aContactLinks*/, 
        MVPbkBatchOperationObserver& /*aObserver*/ ) { return NULL; }

/**
 * Creates an operation for committing multiple contacts.
 *
 * @param aContacts An array of contact links that specify
 *                  the contacts
 * @param aObserver An observer for the operation.
 * @return A handle to the operation or NULL
 */
MVPbkContactOperation* CVPbkContactStoreStub::CreateCommitContactsOperationL(
        const TArray<MVPbkStoreContact*>& /*aContacts*/,
        MVPbkBatchOperationObserver& /*aObserver*/) { return NULL; }

/**
 * Creates an operation for asynchronous phone number matching.
 * 
 * @param aPhoneNumber  A phone number to search for.
 * @param aMaxMatchDigits   Maximum number of digits to match from 
 *                          the end of the number.
 * @param aObserver Observer for the find process.
 * @return A handle to the operation or NULL
 */
MVPbkContactOperation* CVPbkContactStoreStub::CreateMatchPhoneNumberOperationL(
        const TDesC& /*aPhoneNumber*/, 
        TInt /*aMaxMatchDigits*/,
        MVPbkContactFindObserver& /*aObserver*/) { return NULL; }

/**
 * Creates an operation for asynchronous contact finding.
 *
 * @param aSearchString String to search for.
 * @param aFieldTypes   List of field types that the search will include.
 * @param aObserver Observer for the find process.
 * @return A handle to the operation or NULL
 */
MVPbkContactOperation* CVPbkContactStoreStub::CreateFindOperationL(
        const TDesC& /*aSearchString*/,
        const MVPbkFieldTypeList& /*aFieldTypes*/,
        MVPbkContactFindObserver& /*aObserver*/) { return NULL; }

/**
 * Creates an operation for asynchronous contact finding.
 * Finds a string containing text that is stored in one or more fields.
 * Client can give multiple find words. All the words must match to separated
 * data. E.g if there are two find words: "Jo" and "Jo" then field data
 * "John Johnson" matches but "John Doe" doesn't if the word parser uses
 * white space as a word separator.
 *
 * NOTE: The accuracy of the results depends on the ability of the store
 *       implementation to implement the find. The performance can vary
 *       too depending on the store. 
 *
 * @param aSearchStrings    Words that are compared to field data.
 * @param aFieldTypes   Types of the fields that are used.
 * @param aObserver An observer for asynchronous operation.
 * @param aWordParserCallBack a client implementation of word parser 
 *                            function that separates the field data 
 *                            into words. Parameter to function is 
 *                            TVPbkWordParserParam.
 * @return A handle to the operation or NULL
 */
MVPbkContactOperation* CVPbkContactStoreStub::CreateFindOperationL(
        const MDesC16Array& /*aSearchStrings*/, 
        const MVPbkFieldTypeList& /*aFieldTypes*/, 
        MVPbkContactFindFromStoresObserver& /*aObserver*/, 
        const TCallBack& /*aWordParserCallBack*/ ) { return NULL ;}
    
/**
 * Creates an operation for compressing the store.
 *
 * @param aObserver An observer for the compress operation.
 * @return A handle to the operation or NULL
 */
MVPbkContactOperation* CVPbkContactStoreStub::CreateCompressStoresOperationL(
		MVPbkBatchOperationObserver& /*aObserver*/) { return NULL; }
 

/**
 * Returns the number of stores in the list.
 *
 * @return The number of stores in the list.
 */
TInt CVPbkContactStoreListStub::Count() const { return 0; }

/**
 * Returns the store in given index in the list.
 *
 * @param aIndex the index of the store in the list
 * @precond aIndex > && aIndex < Count()
 *              VPbkError::Panic(VPbkError::EInvalidStoreIndex)
 *              is raised if the precondition does not hold.
 * @return The store in the specified index.
 */
MVPbkContactStore& CVPbkContactStoreListStub::At(TInt /*aIndex*/) const 
{ 
MVPbkContactStore* ret =NULL;
return *ret;
}

/**
 * Finds the contact store corresponding to the aUri.
 *
 * @param aUri the store URI to search for.
 * @return The contact store corresponding to the aUri or NULL.
 */
MVPbkContactStore* CVPbkContactStoreListStub::Find(
    const TVPbkContactStoreUriPtr& /*aUri*/) const 
    { 
    return &gXSPStore;
    }

/**
 * Opens all stores in the list asynchronously.
 *
 * A client can not use stores before it has successfully opened
 * them. CloseAll must be always called by the same observer that has
 * opened stores.
 *
 * NOTE: There can be only one observer for one store list at a time.
 *
 * @param aObserver An observer for the stores.
 * @exception KErrInUse If one observer is currently opening this list.
 */
void CVPbkContactStoreListStub::OpenAllL(MVPbkContactStoreListObserver& /*aObserver*/) { }

/**
 * Closes all stores in the list.
 *
 * This is safe to call in all circumstances. Implementations
 * can not trust that OpenAllL has been called before.
 *
 * @param aObserver An observer for the close process.
 */
void CVPbkContactStoreListStub::CloseAll(MVPbkContactStoreListObserver& /*aObserver*/) { }



//End of file