1 /*

     2 * Copyright (c) 2009 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 the License "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:  

    15 *

    16 */

    17 

    18  

    19 

    20 #include <e32base.h>

    21 ////#include <senduiconsts.h>

    22 #include "messagingservice.h"

    23 #include <BADESCA.H>

    24 #include "getheader.h"

    25 #include <f32file.h>

    26 //#include "messageheader.h"

    27 #ifdef MAIN

    28 #define getheadermmsasync_test3 main

    29 #endif

    30 

    31 class CTestAsync;

    32 /**

    33  * Callback class for asynchronous SAPI message header

    34 */  

    35 class CMsgCallbackHeader : public CMsgCallbackBase

    36     {

    37     public:

    38         

    39         static CMsgCallbackHeader* NewL(CActiveSchedulerWait* aWaitSchedular, CMessagingService*s);

    40         

    41         virtual ~CMsgCallbackHeader(){}

    42         

    43         virtual void HandleGetlistL (TInt aErrCode, CMsvEntrySelection* aEntrySelection, CFilterParamInfo* aFilter);

    44         

    45         virtual void NotifyResultL(TInt aErrCode, TAny* aResult);

    46         

    47        

    48         

    49     private:

    50     

    51         CMsgCallbackHeader(CActiveSchedulerWait* aWaitSchedular, CMessagingService*s):iWaitSchedular(aWaitSchedular), iservice(s){ }

    52         CTestAsync *testasync;

    53         CActiveSchedulerWait*   iWaitSchedular;

    54         CMessagingService*  iservice;

    55        

    56     };

    57 

    58 class CTestAsync : public CActive

    59 {

    60 public:

    61     static CTestAsync* NewL();

    62     ~CTestAsync();

    63     void Start();

    64     TInt Result();

    65     void setCallbackresult(TInt res);

    66 

    67     

    68 private:

    69     void ConstructL();

    70     CTestAsync();

    71     

    72     virtual void DoCancel();

    73     virtual void RunL();

    74     

    75     

    76     void TestFunc();

    77 

    78     

    79     

    80 private:    

    81     CActiveSchedulerWait*   iWaitSchedular;

    82     CMessagingService*      iMessagingService;

    83     CMsgCallbackHeader*     iCallBack;

    84     TInt                    iResult; 

    85     TInt                iCallbackresult;

    86    

    87 };

    88 

    89 

    90 void CMsgCallbackHeader::NotifyResultL( TInt aErrCode, TAny* aResult )

    91     {

    92     

    93     }

    94 

    95 void CMsgCallbackHeader::HandleGetlistL( TInt aErrCode, CMsvEntrySelection* aEntrySelection, CFilterParamInfo* aFilter )

    96     {

    97     

    98     testasync = CTestAsync::NewL();

    99     CFilterParamInfo* filterParams = aFilter;

   100     CMsvEntrySelection* en=aEntrySelection;

   101     TInt iter=0;

   102     TInt val=0;

   103     TInt index = 0;

   104     TTime startdate=filterParams->StartDate();

   105     TTime enddate = filterParams->EndDate();

   106     for(;;)

   107         {

   108             CMessageHeader* header = NULL;

   109             iservice->GetNextHeaderL(filterParams, en, index, NULL, header);

   110             if(header)

   111                 {

   112                  iter++;

   113                  TTime temp =header->Time();

   114                  

   115                   if((header->Mtm().FindF(_L("MMS")) != KErrNotFound ) && (startdate <= temp && temp <= enddate ) )   

   116                      val++;

   117                  

   118                   

   119                 delete header;

   120                 }

   121             else

   122                 break;  

   123             

   124         }

   125    delete filterParams;

   126    

   127    delete en;

   128    

   129    if(iter==val)

   130        testasync->setCallbackresult(KErrNone);

   131    else

   132        testasync->setCallbackresult(KErrGeneral);

   133    delete testasync;

   134 

   135    iWaitSchedular->AsyncStop();

   136    }

   137 

   138 CMsgCallbackHeader* CMsgCallbackHeader::NewL(CActiveSchedulerWait* aWaitSchedular, CMessagingService* s)

   139     {

   140     CMsgCallbackHeader* self = new (ELeave) CMsgCallbackHeader(aWaitSchedular, s);

   141     return self;

   142     }

   143 

   144 CTestAsync* CTestAsync::NewL()

   145     {

   146     CTestAsync* self = new(ELeave) CTestAsync();

   147     self->ConstructL();

   148     return self;

   149     }

   150 

   151 CTestAsync::~CTestAsync()

   152     {

   153     Cancel();

   154     

   155     if(iWaitSchedular->IsStarted() )

   156         iWaitSchedular->AsyncStop();

   157     

   158     if(iMessagingService )

   159         delete iMessagingService;

   160     

   161     if(iWaitSchedular )

   162         delete iWaitSchedular;

   163     }

   164 

   165 void CTestAsync::ConstructL()

   166     {

   167     CActiveScheduler::Add(this);

   168     iMessagingService = CMessagingService::NewL();

   169     iWaitSchedular = new(ELeave) CActiveSchedulerWait();

   170     }

   171 

   172 CTestAsync::CTestAsync() :

   173 CActive(EPriorityStandard)

   174     {

   175     }

   176 

   177 void CTestAsync::DoCancel()

   178     {

   179         

   180     }

   181 

   182 void CTestAsync::RunL()

   183     {

   184     TestFunc();

   185     }

   186 

   187 void CTestAsync::Start()

   188     {

   189     iCallBack = CMsgCallbackHeader::NewL(iWaitSchedular, iMessagingService);

   190     SetActive();

   191     TRequestStatus* temp = &iStatus;

   192     User::RequestComplete(temp, KErrNone);

   193     iWaitSchedular->Start();    

   194     }

   195 

   196 void CTestAsync::setCallbackresult(TInt res)

   197     {

   198     if(res==KErrNone)

   199         iCallbackresult=KErrNone;

   200     else

   201         iCallbackresult=KErrGeneral;

   202     }

   203 TInt CTestAsync::Result()

   204     {

   205    

   206     if(iCallbackresult==KErrNone && iResult==KErrNone)

   207        return KErrNone;

   208     else

   209        return KErrGeneral; 

   210     }

   211 

   212 

   213 void CTestAsync::TestFunc()

   214     {

   215     CFilterParamInfo* filterParams = CFilterParamInfo::NewL();

   216         CleanupStack::PushL(filterParams);

   217 

   218         filterParams->SetSortType(EMsvSortByDate);

   219           

   220             filterParams->AddMtmL(_L("MMS"));

   221              

   222            TDateTime start(2008,EMarch,22,0,0,0,0);

   223            TInt startyear = start.Year();

   224            TInt startmonth = start.Month();

   225            TInt startday = start.Day();

   226            

   227            TTime startdate(start);

   228            

   229            filterParams->SetStartDateFilter(startdate);

   230 

   231            TDateTime end(2010,EJune,23,0,0,0,0);

   232            TInt endyear = end.Year();

   233            TInt endmonth = end.Month();

   234            TInt endday = end.Day();

   235 

   236 

   237            TTime enddate(end) ;       

   238 

   239            filterParams->SetEndDate(enddate);

   240 

   241         

   242         CMsvEntrySelection* entryselection = NULL ;  

   243     TRAPD(err, iMessagingService->GetIdListL(filterParams,0,iCallBack,entryselection));

   244     if(err==KErrNone )

   245         iResult=KErrNone;

   246     else

   247         iResult=KErrGeneral;

   248     CleanupStack::PopAndDestroy(filterParams);

   249     

   250     }

   251 

   252 

   253 int getheadermmsasync_test3(int, char**)

   254     {

   255     TInt result;

   256     __UHEAP_MARK;

   257     CTestAsync* test = CTestAsync::NewL();

   258     test->Start();

   259     result=test->Result();

   260     delete test;

   261     __UHEAP_MARKEND;

   262     if(result==KErrNone)

   263        return KErrNone;

   264     else

   265        return KErrGeneral;

   266 

   267     

   268     }