emailservices/emailcommon/src/CFSMailRequestHandler.cpp
changeset 20 ecc8def7944a
parent 18 578830873419
child 30 759dc5235cdb
equal deleted inserted replaced
18:578830873419 20:ecc8def7944a
     1 /*
     1 /*
     2 * Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies). 
     2 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). 
     3 * All rights reserved.
     3 * All rights reserved.
     4 * This component and the accompanying materials are made available
     4 * This component and the accompanying materials are made available
     5 * under the terms of "Eclipse Public License v1.0"
     5 * under the terms of "Eclipse Public License v1.0"
     6 * which accompanies this distribution, and is available
     6 * which accompanies this distribution, and is available
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
    13 *
    13 *
    14 * Description:  plugin request handler
    14 * Description:  plugin request handler
    15 *
    15 *
    16 */
    16 */
    17 
    17 
    18 
    18 // <qmail>
       
    19 // Exports removed because entire class is exported from DLL
    19 #include <nmcommonheaders.h>
    20 #include <nmcommonheaders.h>
       
    21 // </qmail>
       
    22 
    20 #include "emailtrace.h"
    23 #include "emailtrace.h"
    21 #include "CFSMailRequestHandler.h"
    24 #include "CFSMailRequestHandler.h"
    22 #include "CFSMailRequestObserver.h"
    25 #include "CFSMailRequestObserver.h"
    23 
    26 
    24 
    27 
    25 // ================= MEMBER FUNCTIONS ==========================================  
    28 // ================= MEMBER FUNCTIONS ==========================================    
    26 // -----------------------------------------------------------------------------
    29 // -----------------------------------------------------------------------------
    27 // CFSMailRequestHandler::CFSMailRequestHandler
    30 // CFSMailRequestHandler::CFSMailRequestHandler
    28 // -----------------------------------------------------------------------------
    31 // -----------------------------------------------------------------------------
    29  CFSMailRequestHandler::CFSMailRequestHandler() : iRequestId(0)
    32  CFSMailRequestHandler::CFSMailRequestHandler() : iRequestId(0)
    30 {
    33 {
    34     TInt err = Dll::SetTls(static_cast<TAny*>(this));
    37     TInt err = Dll::SetTls(static_cast<TAny*>(this));
    35 
    38 
    36     // reset 
    39     // reset 
    37     iPendingRequests.Reset();
    40     iPendingRequests.Reset();
    38     iPluginList.Reset();
    41     iPluginList.Reset();
    39   
    42     
    40     iTempDirName =NULL;
    43     iTempDirName =NULL;
    41 }
    44 }
    42 
    45 
    43 // -----------------------------------------------------------------------------
    46 // -----------------------------------------------------------------------------
    44 // CFSMailRequestHandler::~CFSMailRequestHandler
    47 // CFSMailRequestHandler::~CFSMailRequestHandler
    45 // -----------------------------------------------------------------------------
    48 // -----------------------------------------------------------------------------
    46  CFSMailRequestHandler::~CFSMailRequestHandler()
    49  CFSMailRequestHandler::~CFSMailRequestHandler()
    47 {
    50     {
    48     FUNC_LOG;
    51     FUNC_LOG;
    49     TRAP_IGNORE( CancelAllRequestsL() );
    52     TRAP_IGNORE( CancelAllRequestsL() );
    50     RemoveAllRequests();
    53     RemoveAllRequests();
    51     iPendingRequests.Reset();
    54     iPendingRequests.Reset();
    52     iPluginList.ResetAndDestroy();
    55     iPluginList.ResetAndDestroy();
    55         {
    58         {
    56         delete iTempDirName;
    59         delete iTempDirName;
    57         // close file server connection
    60         // close file server connection
    58         iFs.Close();        
    61         iFs.Close();        
    59         }
    62         }
       
    63     
       
    64     // clear TLS
       
    65     Dll::FreeTls();
       
    66     }
       
    67 
       
    68 // -----------------------------------------------------------------------------
       
    69 // CFSMailRequestHandler::NewLC
       
    70 // -----------------------------------------------------------------------------
       
    71  CFSMailRequestHandler* CFSMailRequestHandler::NewLC( 
       
    72                                     RPointerArray<CImplementationInformation>& aPluginInfo,
       
    73                                     RPointerArray<CFSMailPlugin>& aPlugins )
       
    74 {
       
    75     FUNC_LOG;
       
    76   CFSMailRequestHandler* pluginHandler = new (ELeave) CFSMailRequestHandler();
       
    77   CleanupStack:: PushL(pluginHandler);
       
    78   pluginHandler->ConstructL( aPluginInfo, aPlugins );
       
    79   return pluginHandler;
       
    80 } 
       
    81 
       
    82 // -----------------------------------------------------------------------------
       
    83 // CFSMailRequestHandler::NewL
       
    84 // -----------------------------------------------------------------------------
       
    85  CFSMailRequestHandler* CFSMailRequestHandler::NewL( 
       
    86                                     RPointerArray<CImplementationInformation>& aPluginInfo,
       
    87                                     RPointerArray<CFSMailPlugin>& aPlugins )
       
    88 {
       
    89     FUNC_LOG;
       
    90   CFSMailRequestHandler* pluginHandler =  
       
    91                 CFSMailRequestHandler::NewLC( aPluginInfo, aPlugins );
       
    92   CleanupStack:: Pop(pluginHandler);
       
    93   return pluginHandler;
    60 }
    94 }
    61 
    95 
    62 // -----------------------------------------------------------------------------
    96 // -----------------------------------------------------------------------------
    63 // CFSMailRequestHandler::NewLC
    97 // CFSMailRequestHandler::ConstructL
    64 // -----------------------------------------------------------------------------
    98 // -----------------------------------------------------------------------------
    65  CFSMailRequestHandler* CFSMailRequestHandler::NewLC( 
    99 void CFSMailRequestHandler::ConstructL( 
    66                   RPointerArray<CImplementationInformation>& aPluginInfo,
   100                                 RPointerArray<CImplementationInformation> /*aPluginInfo*/,
    67                   RPointerArray<CFSMailPlugin>& aPlugins )
   101                                 RPointerArray<CFSMailPlugin> /*aPlugins*/ )
    68 {
   102 {
    69     FUNC_LOG;
   103     FUNC_LOG;
    70     CFSMailRequestHandler* pluginHandler = new (ELeave) CFSMailRequestHandler();
   104 
    71     CleanupStack:: PushL(pluginHandler);
   105 
    72     pluginHandler->ConstructL( aPluginInfo, aPlugins );
       
    73     return pluginHandler;
       
    74 } 
       
    75 
       
    76 // -----------------------------------------------------------------------------
       
    77 // CFSMailRequestHandler::NewL
       
    78 // -----------------------------------------------------------------------------
       
    79  CFSMailRequestHandler* CFSMailRequestHandler::NewL( 
       
    80                   RPointerArray<CImplementationInformation>& aPluginInfo,
       
    81                   RPointerArray<CFSMailPlugin>& aPlugins )
       
    82 {
       
    83     FUNC_LOG;
       
    84     CFSMailRequestHandler* pluginHandler =  
       
    85           CFSMailRequestHandler::NewLC( aPluginInfo, aPlugins );
       
    86     CleanupStack:: Pop(pluginHandler);
       
    87     return pluginHandler;
       
    88 }
   106 }
    89 
   107 
    90 // -----------------------------------------------------------------------------
   108 // -----------------------------------------------------------------------------
    91 // CFSMailRequestHandler::ConstructL
       
    92 // -----------------------------------------------------------------------------
       
    93 void CFSMailRequestHandler::ConstructL( 
       
    94                 RPointerArray<CImplementationInformation> /*aPluginInfo*/,
       
    95                 RPointerArray<CFSMailPlugin> /*aPlugins*/ )
       
    96 {
       
    97     FUNC_LOG;
       
    98 }
       
    99 
       
   100 // -----------------------------------------------------------------------------
       
   101 // CFSMailRequestHandler::GetPluginByUid
   109 // CFSMailRequestHandler::GetPluginByUid
   102 // -----------------------------------------------------------------------------
   110 // -----------------------------------------------------------------------------
   103  CFSMailPlugin* CFSMailRequestHandler::GetPluginByUid( TFSMailMsgId aObjectId )
   111  CFSMailPlugin* CFSMailRequestHandler::GetPluginByUid( TFSMailMsgId aObjectId )
   104 {
   112     {
   105     FUNC_LOG;
   113     FUNC_LOG;
   106 
   114 
   107     for(TInt i=0;i<iPluginList.Count();i++)
   115     for(TInt i=0;i<iPluginList.Count();i++)
   108         {
   116         {
   109         if(iPluginList[i]->iPluginId.iUid == aObjectId.PluginId().iUid)
   117         if(iPluginList[i]->iPluginId.iUid == aObjectId.PluginId().iUid)
   110             {
   118             {
   111             return iPluginList[i]->iPlugin;
   119             return iPluginList[i]->iPlugin;
   112             }
   120             }
   113         }
   121         }
       
   122 
       
   123 
   114     return NULL;
   124     return NULL;
   115 }
   125     }
   116   
   126     
   117 // -----------------------------------------------------------------------------
   127 // -----------------------------------------------------------------------------
   118 // CFSMailRequestHandler::InitAsyncRequestL
   128 // CFSMailRequestHandler::InitAsyncRequestL
   119 // -----------------------------------------------------------------------------
   129 // -----------------------------------------------------------------------------
   120  TFSPendingRequest CFSMailRequestHandler::InitAsyncRequestL( 
   130  TFSPendingRequest CFSMailRequestHandler::InitAsyncRequestL( 
   121                           TUid aPluginId,
   131                                                     TUid aPluginId,
   122                           MFSMailRequestObserver& aOperationObserver )
   132                                                     MFSMailRequestObserver& aOperationObserver)
   123 {
   133     {
   124     FUNC_LOG;
   134     FUNC_LOG;
   125     TFSPendingRequest newRequest;
   135         TFSPendingRequest newRequest;
   126     for(TInt i=0;i<iPendingRequests.Count();i++)
   136         for(TInt i=0;i<iPendingRequests.Count();i++)
   127         {
   137             {
   128         if(iPendingRequests[i].iRequestStatus != TFSPendingRequest::EFSRequestPending)
   138             if(iPendingRequests[i].iRequestStatus != TFSPendingRequest::EFSRequestPending)
   129             {
   139                 {
   130             iPendingRequests[i].iPluginId = aPluginId;
   140                 iPendingRequests[i].iPluginId = aPluginId;
   131             iPendingRequests[i].iRequestStatus = TFSPendingRequest::EFSRequestPending;
   141                 iPendingRequests[i].iRequestStatus = TFSPendingRequest::EFSRequestPending;
   132             iPendingRequests[i].iObserver->SetUserObserver(aOperationObserver);     
   142                 iPendingRequests[i].iObserver->SetUserObserver(aOperationObserver);         
   133             newRequest = iPendingRequests[i];
   143                 newRequest = iPendingRequests[i];
   134             return newRequest;
   144                 return newRequest;
   135             }
   145                 }
   136         }
   146             }
   137 
   147 
   138     newRequest.iRequestId = iPendingRequests.Count();
   148         newRequest.iRequestId = iPendingRequests.Count();
   139     newRequest.iPluginId = aPluginId;
   149         newRequest.iPluginId = aPluginId;
   140     newRequest.iRequestStatus = TFSPendingRequest::EFSRequestPending;     
   150         newRequest.iRequestStatus = TFSPendingRequest::EFSRequestPending;           
   141     CFSMailRequestObserver* observer = 
   151         CFSMailRequestObserver* observer = 
   142             CFSMailRequestObserver::NewL(*this, aOperationObserver);
   152             CFSMailRequestObserver::NewL(*this, aOperationObserver);
   143     newRequest.iObserver = observer;
   153         newRequest.iObserver = observer;
   144     iPendingRequests.Append(newRequest);
   154         iPendingRequests.Append(newRequest);
   145       
   155         
   146     return newRequest;
   156         return newRequest;
   147 }
   157     }
   148 
   158 
   149 // -----------------------------------------------------------------------------
   159 // -----------------------------------------------------------------------------
   150 // CFSMailRequestHandler::CompleteRequest
   160 // CFSMailRequestHandler::CompleteRequest
   151 // -----------------------------------------------------------------------------
   161 // -----------------------------------------------------------------------------
   152  void CFSMailRequestHandler::CompleteRequest( TInt aRequestId )
   162  void CFSMailRequestHandler::CompleteRequest( TInt aRequestId )
   153 {
   163     {
   154     FUNC_LOG;
   164     FUNC_LOG;
   155     for(TInt i=0;i<iPendingRequests.Count();i++)
   165         for(TInt i=0;i<iPendingRequests.Count();i++)
   156         {
   166         {
   157         if(iPendingRequests[i].iRequestId == aRequestId)
   167         if(iPendingRequests[i].iRequestId == aRequestId)
   158             {
   168             {
   159             iPendingRequests[i].iRequestStatus = TFSPendingRequest::EFSRequestComplete;
   169             iPendingRequests[i].iRequestStatus = TFSPendingRequest::EFSRequestComplete;
   160             break;
   170             break;
   161             }
   171             }
   162         }
   172         }
   163 }
   173 
   164   
   174     }
       
   175     
   165 // -----------------------------------------------------------------------------
   176 // -----------------------------------------------------------------------------
   166 // CFSMailRequestHandler::CancelRequestL
   177 // CFSMailRequestHandler::CancelRequestL
   167 // -----------------------------------------------------------------------------
   178 // -----------------------------------------------------------------------------
   168  void CFSMailRequestHandler::CancelRequestL( TInt aRequestId )
   179  void CFSMailRequestHandler::CancelRequestL( TInt aRequestId )
   169 {
   180     {
   170     FUNC_LOG;
   181     FUNC_LOG;
   171     for(TInt i=0;i<iPendingRequests.Count();i++)
   182         for(TInt i=0;i<iPendingRequests.Count();i++)
   172         {
   183         {
   173         if(iPendingRequests[i].iRequestId == aRequestId 
   184         if(iPendingRequests[i].iRequestId == aRequestId &&
   174             && iPendingRequests[i].iRequestStatus == TFSPendingRequest::EFSRequestPending)
   185             iPendingRequests[i].iRequestStatus == TFSPendingRequest::EFSRequestPending)
   175             {
   186             {
   176             TFSMailMsgId pluginId(iPendingRequests[i].iPluginId,0);
   187             TFSMailMsgId pluginId(iPendingRequests[i].iPluginId,0);
   177             CFSMailPlugin* plugin = GetPluginByUid(pluginId);
   188             if(CFSMailPlugin* plugin = GetPluginByUid(pluginId))
   178             plugin->CancelL(aRequestId);
   189                 {
       
   190                 plugin->CancelL(aRequestId);
       
   191                 }
   179             iPendingRequests[i].iRequestStatus = TFSPendingRequest::EFSRequestCancelled;
   192             iPendingRequests[i].iRequestStatus = TFSPendingRequest::EFSRequestCancelled;
   180             break;
   193             break;
   181             }
   194             }
   182         }
   195         }
   183 }
   196     }
   184 
   197 
   185 // -----------------------------------------------------------------------------
   198 // -----------------------------------------------------------------------------
   186 // CFSMailRequestHandler::CancelAllRequestsL
   199 // CFSMailRequestHandler::CancelAllRequestsL
   187 // -----------------------------------------------------------------------------
   200 // -----------------------------------------------------------------------------
   188  void CFSMailRequestHandler::CancelAllRequestsL( )
   201  void CFSMailRequestHandler::CancelAllRequestsL( )
   189 {
   202     {
   190     FUNC_LOG;
   203     FUNC_LOG;
   191     for(TInt i=0;i<iPendingRequests.Count();i++)
   204         for(TInt i=0;i<iPendingRequests.Count();i++)
   192         {
   205         {
   193         if(iPendingRequests[i].iRequestStatus == TFSPendingRequest::EFSRequestPending)
   206             if(iPendingRequests[i].iRequestStatus == TFSPendingRequest::EFSRequestPending)
   194             {
   207                 {
   195             TFSMailMsgId pluginId(iPendingRequests[i].iPluginId,0);
   208                 TFSMailMsgId pluginId(iPendingRequests[i].iPluginId,0);
   196             CFSMailPlugin* plugin = GetPluginByUid(pluginId);
   209                 if(CFSMailPlugin* plugin = GetPluginByUid(pluginId))
   197             plugin->CancelL(iPendingRequests[i].iRequestId);
   210                     {
   198             iPendingRequests[i].iRequestStatus = TFSPendingRequest::EFSRequestCancelled;
   211                     plugin->CancelL(iPendingRequests[i].iRequestId);
   199             }
   212                     }
   200         }
   213                 iPendingRequests[i].iRequestStatus = TFSPendingRequest::EFSRequestCancelled;
   201 }
   214                 }
       
   215         }
       
   216     }
   202 
   217 
   203 // -----------------------------------------------------------------------------
   218 // -----------------------------------------------------------------------------
   204 // CFSMailRequestHandler::AddPluginL
   219 // CFSMailRequestHandler::AddPluginL
   205 // -----------------------------------------------------------------------------
   220 // -----------------------------------------------------------------------------
   206  void CFSMailRequestHandler::AddPluginL( TUid aPluginId, CFSMailPlugin* aPlugin )
   221  void CFSMailRequestHandler::AddPluginL( TUid aPluginId, CFSMailPlugin* aPlugin )
   207 {
   222     {
   208     FUNC_LOG;
   223     FUNC_LOG;
   209 
   224 
   210     CFSMailPluginData* pluginData = new (ELeave) CFSMailPluginData;
   225     CFSMailPluginData* pluginData = new (ELeave) CFSMailPluginData;
   211     pluginData->iPluginId = aPluginId;
   226     pluginData->iPluginId = aPluginId;
   212     pluginData->iPlugin = aPlugin;
   227     pluginData->iPlugin = aPlugin;
   213     iPluginList.Append(pluginData);       
   228     iPluginList.Append(pluginData);             
   214 }
   229 
       
   230     }
   215 
   231 
   216 // -----------------------------------------------------------------------------
   232 // -----------------------------------------------------------------------------
   217 // CFSMailRequestHandler::RemoveAllRequests
   233 // CFSMailRequestHandler::RemoveAllRequests
   218 // -----------------------------------------------------------------------------
   234 // -----------------------------------------------------------------------------
   219 void CFSMailRequestHandler::RemoveAllRequests()
   235 void CFSMailRequestHandler::RemoveAllRequests()
   220 {
   236     {
   221     FUNC_LOG;
   237     FUNC_LOG;
   222     for(TInt i=0;i<iPendingRequests.Count();i++)
   238     for(TInt i=0;i<iPendingRequests.Count();i++)
   223         {
   239         {
   224         delete iPendingRequests[i].iObserver;
   240         delete iPendingRequests[i].iObserver;
   225         iPendingRequests[i].iObserver = NULL;
   241         iPendingRequests[i].iObserver = NULL;
   226         }
   242         }
   227 }
   243     }
   228 
   244 
   229 // -----------------------------------------------------------------------------
   245 // -----------------------------------------------------------------------------
   230 // CFSMailRequestHandler::GetTempFileL( )
   246 // CFSMailRequestHandler::GetTempFileL( )
   231 // -----------------------------------------------------------------------------
   247 // -----------------------------------------------------------------------------
   232 // <qmail>
       
   233  RFile CFSMailRequestHandler::GetTempFileL( TFSMailMsgId aContentId, TFileName aFileName )
   248  RFile CFSMailRequestHandler::GetTempFileL( TFSMailMsgId aContentId, TFileName aFileName )
   234 // </qmail>
       
   235 {
   249 {
   236     FUNC_LOG;
   250     FUNC_LOG;
   237     
   251     
   238     // get temp dir path
   252     // get temp dir path
   239     // <qmail>
   253     if(iTempDirName == NULL)
   240     if(!iTempDirName)
       
   241     // </qmail>
       
   242         {
   254         {
   243         // open file server connection
   255         // open file server connection
   244         User::LeaveIfError(iFs.Connect());
   256         User::LeaveIfError(iFs.Connect());
   245         iFs.CreatePrivatePath(EDriveC);
   257         iFs.CreatePrivatePath(EDriveC);
   246         iTempDirName = HBufC::NewL(20);
   258         iTempDirName = HBufC::NewL(20);
   253     aFileName.Append(iTempDirName->Des());
   265     aFileName.Append(iTempDirName->Des());
   254     aFileName.AppendNum(aContentId.PluginId().iUid);
   266     aFileName.AppendNum(aContentId.PluginId().iUid);
   255     aFileName.AppendNum(aContentId.Id());
   267     aFileName.AppendNum(aContentId.Id());
   256     file.Replace(iFs,aFileName,EFileWrite);
   268     file.Replace(iFs,aFileName,EFileWrite);
   257     return file;
   269     return file;
   258 }
   270     }
   259 
   271 
   260 // -----------------------------------------------------------------------------
   272 // -----------------------------------------------------------------------------
   261 // CFSMailRequestHandler::CleanTempDirL
   273 // CFSMailRequestHandler::CleanTempDirL
   262 // -----------------------------------------------------------------------------
   274 // -----------------------------------------------------------------------------
   263  void CFSMailRequestHandler::CleanTempDirL( )
   275  void CFSMailRequestHandler::CleanTempDirL( )
   264 {
   276     {
   265     FUNC_LOG;
   277     FUNC_LOG;
   266 }
   278     }
   267 
   279 
   268 // -----------------------------------------------------------------------------
   280 // -----------------------------------------------------------------------------
   269 // CFSMailRequestHandler::GetTempDirL
   281 // CFSMailRequestHandler::GetTempDirL
   270 // -----------------------------------------------------------------------------
   282 // -----------------------------------------------------------------------------
   271  TDesC& CFSMailRequestHandler::GetTempDirL( )
   283  TDesC& CFSMailRequestHandler::GetTempDirL( )
   272 {
   284     {
   273     FUNC_LOG;
   285     FUNC_LOG;
   274     return *iTempDirName;
   286     return *iTempDirName;
   275 }
   287     }
   276 
   288