examples/Messaging/SearchSortExample/searchsortexample.cpp

/*
Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
� list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
� this list of conditions and the following disclaimer in the documentation
� and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
� may be used to endorse or promote products derived from this software
� without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description:� 
*/


#include "searchsortexample.h"
#include "mAsyncWaiter.h"
#include <msvsearchsortoperation.h>

void CSearchsortExample::HandleSessionEventL(TMsvSessionEvent aEvent, TAny*, TAny*, TAny*)
        {

        switch (aEvent)
                {
                case MMsvSessionObserver::EMsvServerReady:
                        break;
                case MMsvSessionObserver::EMsvEntriesCreated:
                        break;
                default:
                        break;
                }
        }

 CSearchsortExample* CSearchsortExample::NewL()
        {
        CSearchsortExample* self=new(ELeave)CSearchsortExample;
        CleanupStack::PushL(self);
        self->ConstructL();
        CleanupStack::Pop();
        return self;
        }
CSearchsortExample::CSearchsortExample()
        {
        }

void CSearchsortExample::ConstructL()
        {
        }

 CSearchsortExample::~ CSearchsortExample()
        {
        if(iMtm)
                {
                delete iMtm;
                iMtm = NULL;
                }
        if(iClientRegistry)
                {
                delete iClientRegistry;
                iClientRegistry  = NULL;
                }
        if(iSearch)
                {
                delete iSearch;
                iSearch = NULL;
                }
        if(iSession)
                {
                delete iSession;
                iSession = NULL;
                }

        iQueryIdTable.Close();
        iTResultSummary.Close();

        }


void  CSearchsortExample::CreateClientRegistryL()
        {
        //Creates a session with message server.
        iSession = CMsvSession::OpenAsyncL(*this);
        CleanupStack::PushL(iSession);

        iSearch = CMsvSearchSortOperation::NewL(*iSession);
        CleanupStack::PushL(iSearch);

        // Create a client-side MTM registry.
        iClientRegistry = CClientMtmRegistry::NewL(*iSession,KMsvDefaultTimeoutMicroSeconds32);
        if (iClientRegistry != NULL && iClientRegistry->IsPresent(KUidMsgTypePOP3))
                {
                CleanupStack::PushL(iClientRegistry);
                }
        // Create a Client-side MTM object for the specified MTM UID.
        iMtm = (CPop3ClientMtm*)iClientRegistry->NewMtmL(KUidMsgTypePOP3);

        CleanupStack::Pop(3,iSession); //iClientRegistry,iSession,iSearch.
    }

void  CSearchsortExample::CreatePopAndSmtpAccountL()
        {
        CEmailAccounts* emailAccounts = CEmailAccounts::NewLC();
        CImPop3Settings* settings = new(ELeave) CImPop3Settings();
        CleanupStack::PushL(settings);

        CImIAPPreferences* popIAP = CImIAPPreferences::NewLC();

        // Set the server address to system address.
        settings->SetServerAddressL(KPopServer);
        settings->SetLoginNameL(KPopLoginName);
        settings->SetPasswordL(KPopPassword);
        settings->SetPort(KPortValue);

        // Create a Pop account.
        iPopAccount = emailAccounts->CreatePopAccountL(KTxtAccountName, *settings,*popIAP,EFalse);

        CImSmtpSettings *smtpSettings = new (ELeave) CImSmtpSettings();
        CleanupStack::PushL(smtpSettings);

        emailAccounts->PopulateDefaultSmtpSettingsL(*smtpSettings, *popIAP);

        // Create an Smtp acoount.
        iSmtpAccount = emailAccounts->CreateSmtpAccountL(iPopAccount, *smtpSettings, *popIAP, EFalse);

        emailAccounts->SetDefaultSmtpAccountL(iSmtpAccount);

        smtpSettings->SetServerAddressL(KSmtpServerAddress);
        smtpSettings->SetEmailAliasL(KEmailAlias);
        smtpSettings->SetEmailAddressL(KSmtpEmailAddress);
        smtpSettings->SetReplyToAddressL(KSmtpEmailAddress);
        smtpSettings->SetReceiptAddressL(KSmtpEmailAddress);
        smtpSettings->SetPort(KSmtpPortValue);

        // Add IAP to the IAP preferences.
        CImIAPPreferences* prefs = CImIAPPreferences::NewLC();
        TImIAPChoice iap;
        TInt iapID = 0;
        CMDBSession* dbSession = CMDBSession::NewL(KCDVersion1_1);
        CleanupStack::PushL(dbSession);
        CCDConnectionPrefsRecord *connPrefRecord = static_cast<CCDConnectionPrefsRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord));
        CleanupStack::PushL(connPrefRecord);

        // Set the direction of connection.
        connPrefRecord->iDirection = ECommDbConnectionDirectionOutgoing;
        connPrefRecord->iRanking = 1;
        if(!connPrefRecord->FindL(*dbSession))
                {
                User::Leave(KErrNotFound);
                }
        iapID = connPrefRecord->iDefaultIAP;
        iap.iIAP = iapID;
        iap.iDialogPref = ECommDbDialogPrefDoNotPrompt;
        prefs->AddIAPL(iap);

        emailAccounts->GetSmtpAccountL(iSmtpAccount.iSmtpService, iSmtpAccount);
        emailAccounts->SaveSmtpSettingsL(iSmtpAccount,*smtpSettings);
        emailAccounts->SaveSmtpIapSettingsL(iSmtpAccount, *prefs);

        //Deleting the message entries if they exist for resetting.
        DeleteSmtpMessageL();
        //connPrefRecord, dbSession, prefs, smtpSettings, popIAP, settings, emailAccounts.
        CleanupStack::PopAndDestroy(7,emailAccounts);
        }

void  CSearchsortExample::CreateSmtpMessageL(TInt aindex,TDes& aFrominfo,TDes& aToinfo,TDes& aSubjectinfo)
        {

        TMsvId inboxId = KMsvGlobalInBoxIndexEntryId;

        // Set the context to the folder in which message has to be created.
        CMsvEntry*      entry = CMsvEntry::NewL(*iSession,inboxId,TMsvSelectionOrdering());
        CleanupStack::PushL(entry);
        entry->SetEntryL(inboxId);

        CMessAsyncWaiter* waiter = CMessAsyncWaiter::NewL();
        CleanupStack::PushL(waiter);

        TMsvEmailTypeList msvEmailTypeList = 0;
        TMsvPartList partList = (KMsvMessagePartBody | KMsvMessagePartAttachments|KMsvMessagePartTo|KMsvMessagePartFrom|KMsvMessagePartSubject);

        CImEmailOperation* emailOperation = CImEmailOperation::CreateNewL(waiter->iStatus, *iSession,KMsvGlobalInBoxIndexEntryId, partList, msvEmailTypeList, KUidMsgTypeSMTP);
        CleanupStack::PushL(emailOperation);
        waiter->StartAndWait();

        TMsvId temp;
        TPckgC<TMsvId> paramPack(temp);
        const TDesC8& progBuf = emailOperation->ProgressL();

        paramPack.Set(progBuf);
        TMsvId newMessageId;
        newMessageId = paramPack();


        entry->SetEntryL(newMessageId);

        CMsvStore* store = entry->EditStoreL();
        CleanupStack::PushL(store);

        //Setting the Header for message entry.
        CImHeader* emailEntry = CImHeader::NewLC();
        emailEntry->RestoreL(*store);

        //Setting the Header according to the message entry count.
        switch(aindex)
                {
                case 0:
                        {
                        emailEntry->SetFromL((TDesC8&)KFrom1);
                        emailEntry->SetSubjectL((TDesC&)KSubject1);
                        emailEntry->ToRecipients().AppendL((TDesC&)KTo1);
                        aToinfo.Copy(KTo1);
                        }
                        break;
                case 1:
                        {
                        emailEntry->SetFromL((TDesC8&)KFrom2);
                        emailEntry->SetSubjectL((TDesC&)KSubject2);
                        emailEntry->ToRecipients().AppendL((TDesC&)KTo2);
                        aToinfo.Copy(KTo2);
                        }
                        break;
                case 2:
                        {
                        emailEntry->SetFromL((TDesC8&)KFrom3);
                        emailEntry->SetSubjectL((TDesC&)KSubject3);
                        emailEntry->ToRecipients().AppendL((TDesC&)KTo3);
                        aToinfo.Copy(KTo3);
                        }
                        break;
                case 3:
                        {
                        emailEntry->SetFromL((TDesC8&)KFrom4);
                        emailEntry->SetSubjectL((TDesC&)KSubject4);
                        emailEntry->ToRecipients().AppendL((TDesC&)KTo4);
                        aToinfo.Copy(KTo4);
                        }
                        break;
                case 4:
                        {
                        emailEntry->SetFromL((TDesC8&)KFrom5);
                        emailEntry->SetSubjectL((TDesC&)KSubject5);
                        emailEntry->ToRecipients().AppendL((TDesC&)KTo5);
                        aToinfo.Copy(KTo5);
                        }
                        break;
                default:
                        break;
                }

        aFrominfo.Copy(emailEntry->From());
        aSubjectinfo.Copy(emailEntry->Subject());

        // Paragraph format layer for the rich text object.
        CParaFormatLayer* paraFormatLayer = CParaFormatLayer::NewL();
        CleanupStack::PushL(paraFormatLayer);
        // Character format layer for the rich text object.
        CCharFormatLayer* charFormatLayer = CCharFormatLayer::NewL();
        CleanupStack::PushL(charFormatLayer);

        CRichText* bodyText = CRichText::NewL(paraFormatLayer, charFormatLayer, CEditableText::EFlatStorage, 256);
        CleanupStack::PushL(bodyText);

        // Inserts the contents of a buffer into the document at specified position.
        bodyText->InsertL(0, KBodyContents);
        store->StoreBodyTextL(*bodyText);
        emailEntry->StoreL(*store);
        // Store the changes permanently.
        store->CommitL();

        // bodyText, charFormatLayer, paraFormatLayer, emailEntry, store, emailOperation, waiter, entry.
        CleanupStack::PopAndDestroy(8,entry);
        }


void CSearchsortExample::SearchSortRequestWithoutIteratorL(TDes& aSearchtext,TBool aCaseSensitivity,TBool aWholeWordSearch,TBool aCombinedSearch,TInt& aResultCount)
        {

        //CMessAsyncWaiter for async request.
        CMessAsyncWaiter* waiter = CMessAsyncWaiter::NewL();
        CleanupStack::PushL(waiter);

        //Create instance of CMsvSearchSortQuery to create a search-sort query.
        CMsvSearchSortQuery* searchQuery = CMsvSearchSortQuery::NewL();
        CleanupStack::PushL(searchQuery);

        //Search-sort operation is performed on a specified folder. (e.g, on INBOX, SENT ITEMS,
        //DRAFT, OUTBOX or any user created folder). Needs to sets the value of the folder entry.
        searchQuery->SetParentId(KMsvGlobalInBoxIndexEntryIdValue);
        //Sets the type of result expected out of the search-sort operation.
        searchQuery->SetResultType(EMsvResultAsTMsvEntry);
        searchQuery->SetWholeWord(aWholeWordSearch);
        searchQuery->SetCaseSensitiveOption(aCaseSensitivity);
        searchQuery->SetWildCardSearch(EFalse);

        //Adding search option.
        searchQuery->AddSearchOptionL(EMsvTo,aSearchtext, EMsvEqual);

        //Combined search-sort we can add some more AddSearchOptionL function.
        if(aCombinedSearch)
                {
                TInt size = KSize;
                //Adding search option.
                searchQuery->AddSearchOptionL(EMsvSize, size, EMsvLessThanOrEqual);
                searchQuery->AddSearchOptionL(EMsvSubject, KSubjectSearch, EMsvEqual);

                }

        //Adding sort option.
        searchQuery->AddSortOptionL(EMsvDate, EMsvSortAscending);

        //Poping the searchQuery object from cleanupstack as here after.
        //the control transfers to CMsvSearchSortOperation by making a call to RequestL.
        CleanupStack::Pop(searchQuery);

        //Search-sort Request.
        iSearch->RequestL(searchQuery, ETrue, waiter->iStatus);
        waiter->StartAndWait();

        //To hold Search-sort results.
        RArray<TMsvEntry> resultArray;

        //After the completion RequestL(), GetResultsL function provides a list of
        //index entry Id objects (TMsvEntry).
        TRAPD(ret, iSearch->GetResultsL(resultArray));

        iTResultSummary.Reset();

        TMsvId inboxId=KMsvGlobalInBoxIndexEntryId;
        CMsvEntry*      entry = CMsvEntry::NewL(*iSession,inboxId,TMsvSelectionOrdering());
        CleanupStack::PushL(entry);

        if(ret == KErrNone)
                {
                //for getting and the entry details.
                for(TInt index=0;index<resultArray.Count();index++)
                        {
                        TResultSummary tempdata;
                        TMsvEntry tempentry;
                        TTime date;

                        tempentry=resultArray[index];
                        entry->SetEntryL(tempentry.Id());

                        //For obtaining header info.
                        CMsvStore* store = entry->ReadStoreL();
                        CleanupStack::PushL(store);
                        CImHeader* emailEntry = CImHeader::NewLC();
                        emailEntry->RestoreL(*store);

                        tempdata.iSubjectText.Copy(emailEntry->Subject());
                        tempdata.iToText.Copy((emailEntry->ToRecipients())[0]);
                        tempdata.iSize=tempentry.iSize;
                        date=tempentry.iDate;
                        date.FormatL(tempdata.iDatestring,KFormat1);
                        date.FormatL(tempdata.iTimestring,KFormat2);
                        iTResultSummary.Append(tempdata);

                        CleanupStack::PopAndDestroy(2,store); //emailEntry, store.
                        }
                aResultCount=iSearch->GetResultCountL();
                }
        //After the completion of RequestL(), GetQueryIdL function provides the query Id.
        //corresponding to a search-sort query.
        iQueryId = iSearch->GetQueryIdL();

        iExampleTQueryTable.iQueryId=iQueryId;
        iExampleTQueryTable.iResultType=EMsvResultAsTMsvEntry;
        iQueryIdTable.Append(iExampleTQueryTable);

        resultArray.Close();
        CleanupStack::PopAndDestroy(2,waiter); //entry, waiter.
        }

void CSearchsortExample::SearchSortRequestWithIteratorL(TInt& aResultCount)
        {

        //CMessAsyncWaiter for async request.
        CMessAsyncWaiter* waiter = CMessAsyncWaiter::NewL();
        CleanupStack::PushL(waiter);

        //Create instance of CMsvSearchSortQuery to create a search-sort query.
        CMsvSearchSortQuery* searchQuery = CMsvSearchSortQuery::NewL();
        CleanupStack::PushL(searchQuery);

        //Search-sort operation is performed on a specified folder. (e.g, on INBOX, SENT ITEMS,
        //DRAFT, OUTBOX or any user created folder). Needs to sets the value of the folder entry.
        searchQuery->SetParentId(KMsvGlobalInBoxIndexEntryIdValue);
        //Sets the type of result expected out of the search-sort operation.
        searchQuery->SetResultType(EMsvResultAsTMsvId);
        searchQuery->SetWholeWord(ETrue);
        searchQuery->SetCaseSensitiveOption(EFalse);
        searchQuery->SetWildCardSearch(EFalse);


        TInt size = KSize;
        //Add search option.
        searchQuery->AddSearchOptionL(EMsvSize, size, EMsvLessThanOrEqual);

        //Add sort option.
        searchQuery->AddSortOptionL(EMsvDate, EMsvSortAscending);

        //to enable Iterator.
        TInt iterator = 1;

        //Poping the searchQuery object from cleanupstack as here after.
        //the control transfers to CMsvSearchSortOperation by making a call to RequestL.
        CleanupStack::Pop(searchQuery);
        //Search-sort Request.
        iSearch->RequestL(searchQuery, ETrue, waiter->iStatus,iterator);
        waiter->StartAndWait();

        //Array to copy Search-sort results.
        RArray<TMsvId> resultArray;
        TMsvId resultAsTMsvId;


        //Gets the TMsvId of a single index entry object at a time.
        //GetNextResultL function is used when getting the results using iterative mechanism
        //and it returns remaining search-sort results Count.
        while(iSearch->GetNextResultL(resultAsTMsvId))
                {
                resultArray.AppendL(resultAsTMsvId);
                }

        aResultCount=iSearch->GetResultCountL();

        resultArray.Close();
        CleanupStack::PopAndDestroy(waiter); //waiter.
        }

void CSearchsortExample::SearchSortRequestByQueryIdL(TInt& aResultCount)
        {


        //CMessAsyncWaiter for async request.
        CMessAsyncWaiter* waiter = CMessAsyncWaiter::NewL();
        CleanupStack::PushL(waiter);

        //Search-sort Request by QueryId.
        iSearch->RequestL(iQueryId, waiter->iStatus);
        waiter->StartAndWait();


        //To hold Search-sort results.
        TInt count=iQueryIdTable.Count();
        TQueryTable tempdata;

        TMsvId inboxId=KMsvGlobalInBoxIndexEntryId;
        CMsvEntry*      entry = CMsvEntry::NewL(*iSession,inboxId,TMsvSelectionOrdering());
        CleanupStack::PushL(entry);

        iTResultSummary.Reset();
        for(TInt index=0;index<count;index++)
                {
                tempdata=iQueryIdTable[index];
                if(tempdata.iQueryId==iQueryId)
                        {
                        if(tempdata.iResultType==EMsvResultAsTMsvId)
                                {
                                RArray<TMsvId> resultArray;
                                TRAPD(ret, iSearch->GetResultsL(resultArray));
                                if(ret == KErrNone)
                                        {
                                        TInt count = resultArray.Count();
                                        aResultCount=count;
                                        }
                                resultArray.Close();
                                }
                        else if(tempdata.iResultType==EMsvResultAsTMsvEntry)
                                {
                                RArray<TMsvEntry> resultArray;
                                TRAPD(ret, iSearch->GetResultsL(resultArray));
                                if(ret == KErrNone)
                                        {
                                        TInt count = resultArray.Count();
                                        aResultCount=count;

                                        //for getting the entry details.
                                        for(TInt index=0;index<count;index++)
                                                {
                                                TResultSummary tempdata;
                                                TMsvEntry tempentry;
                                                TTime date;


                                                tempentry=resultArray[index];
                                                entry->SetEntryL(tempentry.Id());

                                                //for getting header info.
                                                CMsvStore* store = entry->ReadStoreL();
                                                CleanupStack::PushL(store);
                                                CImHeader* emailEntry = CImHeader::NewLC();
                                                emailEntry->RestoreL(*store);


                                                tempdata.iSubjectText.Copy(emailEntry->Subject());
                                                tempdata.iToText.Copy((emailEntry->ToRecipients())[0]);
                                                tempdata.iSize=tempentry.iSize;
                                                date=tempentry.iDate;
                                                date.FormatL(tempdata.iDatestring,KFormat1);
                                                date.FormatL(tempdata.iTimestring,KFormat2);
                                                iTResultSummary.Append(tempdata);

                                                CleanupStack::PopAndDestroy(2,store);
                                                }
                                        }
                                        resultArray.Close();
                                }
                        }
                }
        CleanupStack::PopAndDestroy(2,waiter); // entry, waiter.
        }

void  CSearchsortExample::DeleteSmtpMessageL()
        {
        //CMessAsyncWaiter for async request.

        CMessAsyncWaiter* waiter = CMessAsyncWaiter::NewL();
        CleanupStack::PushL(waiter);

        TInt mycount;
        TMsvId inboxId = KMsvGlobalInBoxIndexEntryId;
        CMsvEntry*      messagingEntry = CMsvEntry::NewL(*iSession,inboxId,TMsvSelectionOrdering());
        CleanupStack::PushL(messagingEntry);
        messagingEntry->SetEntryL(inboxId);

        CMsvEntrySelection* filteredMessageIds =messagingEntry->ChildrenL();
        CleanupStack::PushL( filteredMessageIds);
         mycount=filteredMessageIds->Count();
        if(mycount)
                {
                CMsvOperation* operation = messagingEntry->DeleteL(*filteredMessageIds,waiter->iStatus);
                CleanupStack::PushL(operation);
                waiter->StartAndWait();
                CleanupStack::PopAndDestroy();
                }
        CleanupStack::PopAndDestroy(3,waiter); //filteredMessageIds, messagingEntry, waiter.
        }

void CSearchsortExample::DeleteAccountsL()
        {

        CEmailAccounts* accounts = CEmailAccounts::NewLC();

        RArray<TPopAccount>     pop3Accounts;
        CleanupClosePushL(pop3Accounts);
        accounts->GetPopAccountsL(pop3Accounts);
        TInt    count = pop3Accounts.Count();
        TInt    index=0;
        for( index = 0; index < count; index++ )
                {
                TPopAccount     id = pop3Accounts[index];

                TRAPD(err,accounts->DeletePopAccountL( id ));
                if(err!=KErrNone)
                        {
                        User::Panic(KUserPanic, err);
                        }
                }

        RArray<TImapAccount>    imap4Accounts;
        CleanupClosePushL(imap4Accounts);
        accounts->GetImapAccountsL(imap4Accounts);
        count = imap4Accounts.Count();
        for( TInt index = 0; index < count; index++ )
                {
                TImapAccount    id = imap4Accounts[index];
                TRAPD(err,accounts->DeleteImapAccountL( id ));
                if(err!=KErrNone)
                        {
                        User::Panic(KUserPanic, err);
                        }
                }

        RArray<TSmtpAccount>    smtpAccounts;
        CleanupClosePushL(smtpAccounts);
        accounts->GetSmtpAccountsL(smtpAccounts);

    count = smtpAccounts.Count();
    for( TInt index = 0; index < count; index++ )
                {
                TSmtpAccount    id = smtpAccounts[index];

                TRAPD(err,accounts->DeleteSmtpAccountL( id ));
                if(err!=KErrNone)
                        {
                        User::Panic(KUserPanic, err);
                        }
                }
        CleanupStack::PopAndDestroy(4, accounts);
        }

---