ipsservices/ipssosplugin/src/ipsplgmsgmapper.cpp
branchRCL_3
changeset 80 726fba06891a
parent 73 c8382f7b54ef
equal deleted inserted replaced
73:c8382f7b54ef 80:726fba06891a
    84 // ---------------------------------------------------------------------------
    84 // ---------------------------------------------------------------------------
    85 //
    85 //
    86 CIpsPlgMsgMapper::~CIpsPlgMsgMapper()
    86 CIpsPlgMsgMapper::~CIpsPlgMsgMapper()
    87     {
    87     {
    88     FUNC_LOG;
    88     FUNC_LOG;
    89     if( iMsgMapperHelper )
       
    90         {
       
    91         delete iMsgMapperHelper;
       
    92         iMsgMapperHelper = NULL;
       
    93         }
       
    94     }
    89     }
    95 
    90 
    96 // ---------------------------------------------------------------------------
    91 // ---------------------------------------------------------------------------
    97 // CIpsPlgMsgMapper::CIpsPlgMsgMapper()
    92 // CIpsPlgMsgMapper::CIpsPlgMsgMapper()
    98 // ---------------------------------------------------------------------------
    93 // ---------------------------------------------------------------------------
   110 // ---------------------------------------------------------------------------
   105 // ---------------------------------------------------------------------------
   111 //
   106 //
   112 void CIpsPlgMsgMapper::ConstructL()
   107 void CIpsPlgMsgMapper::ConstructL()
   113     {
   108     {
   114     FUNC_LOG;
   109     FUNC_LOG;
   115 	
       
   116     iMsgMapperHelper = CIpsPlgMsgMapperHelper::NewL( iSession );
       
   117     }
   110     }
   118 
   111 
   119 // ---------------------------------------------------------------------------
   112 // ---------------------------------------------------------------------------
   120 // CIpsPlgMsgMapper::GetMailMessageL()
   113 // CIpsPlgMsgMapper::GetMailMessageL()
   121 // ---------------------------------------------------------------------------
   114 // ---------------------------------------------------------------------------
   364 
   357 
   365 
   358 
   366     // EFSMsgFlag_Answered: supported only with IMAP4 (see below)
   359     // EFSMsgFlag_Answered: supported only with IMAP4 (see below)
   367 
   360 
   368     // EFSMsgFlag_Forwarded: no counterpart in Symbian message in S60 3.1
   361     // EFSMsgFlag_Forwarded: no counterpart in Symbian message in S60 3.1
   369     if ( LogicalXor( aEmlEntry.Forwarded(), msgFlags & EFSMsgFlag_Forwarded ) )
       
   370         {
       
   371         aEmlEntry.SetForwarded( !aEmlEntry.Forwarded() );
       
   372         modified = ETrue;
       
   373         }
       
   374 
   362 
   375     // EFSMsgFlag_OnlyToMe: no counterpart in Symbian message
   363     // EFSMsgFlag_OnlyToMe: no counterpart in Symbian message
   376 
   364 
   377     // EFSMsgFlag_RemoteDeleted: no counterpart in Symbian message
   365     // EFSMsgFlag_RemoteDeleted: no counterpart in Symbian message
   378 
   366 
   759 
   747 
   760     // EFSMsgFlag_Answered: supported only with IMAP4 messages (see below)
   748     // EFSMsgFlag_Answered: supported only with IMAP4 messages (see below)
   761     aMsg.ResetFlag( EFSMsgFlag_Answered );
   749     aMsg.ResetFlag( EFSMsgFlag_Answered );
   762 
   750 
   763     // EFSMsgFlag_Forwarded: not supported in S60 3.1
   751     // EFSMsgFlag_Forwarded: not supported in S60 3.1
   764     if ( aEntry.Forwarded() )
   752     aMsg.ResetFlag( EFSMsgFlag_Forwarded );
   765         {
       
   766         aMsg.SetFlag( EFSMsgFlag_Forwarded );
       
   767         }
       
   768     else
       
   769         {
       
   770         aMsg.ResetFlag( EFSMsgFlag_Forwarded );
       
   771         }
       
   772 
   753 
   773     // EFSMsgFlag_OnlyToMe: like EFSMsgFlag_Multiple
   754     // EFSMsgFlag_OnlyToMe: like EFSMsgFlag_Multiple
   774 
   755 
   775     // EFSMsgFlag_RemoteDeleted: no reasonable use in IPS
   756     // EFSMsgFlag_RemoteDeleted: no reasonable use in IPS
   776 
   757 
  1512     else if ( ft == EFolderTypeMixed || ft == EFolderTypeRelated )
  1493     else if ( ft == EFolderTypeMixed || ft == EFolderTypeRelated )
  1513         {
  1494         {
  1514         aMsg.SetFlag( EFSMsgFlag_Attachments );
  1495         aMsg.SetFlag( EFSMsgFlag_Attachments );
  1515         if ( !aEntry.Attachment() )
  1496         if ( !aEntry.Attachment() )
  1516         	{
  1497         	{
  1517             TBool success = iMsgMapperHelper->AppendMsvIdToArrayL( aEntry.Id() );
  1498         	SetAttachmentFlagL( aEntry, ETrue );
  1518             if( success )
       
  1519                 {
       
  1520                 iMsgMapperHelper->StartSetAttchmentFlag();
       
  1521                 }
       
  1522         	}
  1499         	}
  1523         }
  1500         }
  1524 
  1501 
  1525     if ( !aMsg.IsFlagSet( EFSMsgFlag_Attachments ) && aEntry.Attachment() )
  1502     if ( !aMsg.IsFlagSet( EFSMsgFlag_Attachments ) && aEntry.Attachment() )
  1526     	{
  1503     	{
  1605         CleanupStack::PopAndDestroy( store );
  1582         CleanupStack::PopAndDestroy( store );
  1606         }
  1583         }
  1607     CleanupStack::PopAndDestroy( cEntry );
  1584     CleanupStack::PopAndDestroy( cEntry );
  1608     }
  1585     }
  1609 // </cmail>
  1586 // </cmail>
  1610 
       
  1611 
       
  1612 // ---------------------------------------------------------------------------
       
  1613 // CIpsPlgMsgMapperHelper::OpCompleted
       
  1614 // ---------------------------------------------------------------------------
       
  1615 //
       
  1616 void CIpsPlgMsgMapperHelper::OpCompleted(
       
  1617     CIpsPlgSingleOpWatcher& aOpWatcher,
       
  1618     TInt aCompletionCode )
       
  1619     {
       
  1620     FUNC_LOG;
       
  1621     
       
  1622     TInt opId = aOpWatcher.Operation().Id();
       
  1623     TMsvId completedMsvId = aOpWatcher.Operation().Service();
       
  1624     
       
  1625     if( iCurrentOperationWatcher )
       
  1626         {
       
  1627         CMsvOperation& oper = iCurrentOperationWatcher->Operation();
       
  1628         
       
  1629         //delete the iOngoingOperation when it has completed
       
  1630         if( oper.Id() == opId )
       
  1631             {
       
  1632             delete iCurrentOperationWatcher;
       
  1633             iCurrentOperationWatcher = NULL;
       
  1634             }
       
  1635         }
       
  1636     
       
  1637     //remove the completed MsvId from the iNeedSetAttachFlagArray
       
  1638     for( TInt j = 0; j < iNeedSetAttachFlagArray.Count(); ++j )
       
  1639         {
       
  1640         if( completedMsvId == iNeedSetAttachFlagArray[j] )
       
  1641             {
       
  1642             iNeedSetAttachFlagArray.Remove( j );
       
  1643             break;
       
  1644             }
       
  1645         }
       
  1646     //start next async process
       
  1647     iTimer.After( iStatus, 0 );
       
  1648     SetActive();
       
  1649     }
       
  1650 
       
  1651 
       
  1652 // ---------------------------------------------------------------------------
       
  1653 // CIpsPlgMsgMapperHelper::NewL
       
  1654 // ---------------------------------------------------------------------------
       
  1655 //
       
  1656 CIpsPlgMsgMapperHelper* CIpsPlgMsgMapperHelper::NewL( CMsvSession& aSession )
       
  1657     {
       
  1658     FUNC_LOG;
       
  1659     
       
  1660     CIpsPlgMsgMapperHelper* self = new (ELeave) CIpsPlgMsgMapperHelper( aSession );
       
  1661     CleanupStack::PushL(self);
       
  1662     self->ConstructL();
       
  1663     CleanupStack::Pop();
       
  1664     return self;
       
  1665     }
       
  1666 
       
  1667 // ---------------------------------------------------------------------------
       
  1668 // CIpsPlgMsgMapperHelper::~CIpsPlgMsgMapperHelper
       
  1669 // ---------------------------------------------------------------------------
       
  1670 //
       
  1671 CIpsPlgMsgMapperHelper::~CIpsPlgMsgMapperHelper()
       
  1672     {
       
  1673     FUNC_LOG;
       
  1674     
       
  1675     Cancel();
       
  1676     //should delete the iOngoingOperation if it not completed 
       
  1677     if( iCurrentOperationWatcher )
       
  1678         {
       
  1679         delete iCurrentOperationWatcher;
       
  1680         iCurrentOperationWatcher = NULL;
       
  1681         }
       
  1682     iNeedSetAttachFlagArray.Reset();
       
  1683     iNeedSetAttachFlagArray.Close();
       
  1684     
       
  1685     Deque();
       
  1686     iTimer.Close();
       
  1687     }
       
  1688 
       
  1689 // ---------------------------------------------------------------------------
       
  1690 // CIpsPlgMsgMapperHelper::CIpsPlgMsgMapperHelper
       
  1691 // ---------------------------------------------------------------------------
       
  1692 //
       
  1693 CIpsPlgMsgMapperHelper::CIpsPlgMsgMapperHelper( CMsvSession& aSession )
       
  1694 :CActive( EPriorityStandard ), iSession( aSession ), iPending( EFalse ),
       
  1695 iCurrentOperationWatcher( NULL )
       
  1696     {
       
  1697     FUNC_LOG;
       
  1698     }
       
  1699 
       
  1700 // ---------------------------------------------------------------------------
       
  1701 // CIpsPlgMsgMapperHelper::ConstructL
       
  1702 // ---------------------------------------------------------------------------
       
  1703 //
       
  1704 void CIpsPlgMsgMapperHelper::ConstructL()
       
  1705     {
       
  1706     FUNC_LOG;
       
  1707     
       
  1708     User::LeaveIfError( iTimer.CreateLocal() );
       
  1709     CActiveScheduler::Add(this);
       
  1710     }
       
  1711 
       
  1712 // inherited from CActive
       
  1713 // ---------------------------------------------------------------------------
       
  1714 // CIpsPlgMsgMapperHelper::RunL
       
  1715 // ---------------------------------------------------------------------------
       
  1716 //
       
  1717 void CIpsPlgMsgMapperHelper::RunL()
       
  1718     {
       
  1719     FUNC_LOG;
       
  1720 
       
  1721     User::LeaveIfError( iStatus.Int() );
       
  1722     // always start the async process from the index 0 of iNeedSetAttachFlagArray
       
  1723     TInt currentIndex = 0;
       
  1724     
       
  1725     if( iNeedSetAttachFlagArray.Count() > 0 )
       
  1726         {
       
  1727         TMsvId entry = iNeedSetAttachFlagArray[currentIndex];
       
  1728         TMsvId serviceId;
       
  1729         TMsvEmailEntry entryToBeChanged;
       
  1730         //get enty by msvid
       
  1731         TBool result = iSession.GetEntry( entry, serviceId, entryToBeChanged);
       
  1732         
       
  1733         if( entryToBeChanged.Attachment() )
       
  1734             {
       
  1735             // ignore this operation and delete when it has set the attach flag
       
  1736             iNeedSetAttachFlagArray.Remove( currentIndex );
       
  1737             iTimer.After( iStatus, 0 );
       
  1738             SetActive();
       
  1739             return;
       
  1740             }
       
  1741         
       
  1742         CIpsPlgSingleOpWatcher* opW = CIpsPlgSingleOpWatcher::NewLC( *this );
       
  1743         
       
  1744         CMsvEntry* cEntry = iSession.GetEntryL( entry );
       
  1745         CleanupStack::PushL( cEntry );
       
  1746         
       
  1747         entryToBeChanged.SetAttachment( ETrue );
       
  1748         CMsvOperation* ops = cEntry->ChangeL( entryToBeChanged, opW->iStatus );
       
  1749         CleanupStack::PopAndDestroy( cEntry );
       
  1750         
       
  1751         if( ops )
       
  1752             {
       
  1753             opW->SetOperation( ops );
       
  1754             if( iCurrentOperationWatcher )
       
  1755                 {
       
  1756                 delete iCurrentOperationWatcher;
       
  1757                 iCurrentOperationWatcher = NULL;
       
  1758                 }
       
  1759             iCurrentOperationWatcher = opW;
       
  1760             CleanupStack::Pop( opW );
       
  1761             }
       
  1762         else
       
  1763             {
       
  1764             CleanupStack::PopAndDestroy( opW ); 
       
  1765             }
       
  1766         }
       
  1767     else
       
  1768         {
       
  1769         //all these operation have processed
       
  1770         iPending = EFalse;
       
  1771         }
       
  1772     }
       
  1773 
       
  1774 // ---------------------------------------------------------------------------
       
  1775 // CIpsPlgMsgMapperHelper::RunError
       
  1776 // ---------------------------------------------------------------------------
       
  1777 //
       
  1778 TInt CIpsPlgMsgMapperHelper::RunError( TInt aError )
       
  1779     {
       
  1780     FUNC_LOG;
       
  1781 
       
  1782     if ( KErrNone != aError )
       
  1783         {
       
  1784         Cancel();
       
  1785         }
       
  1786     return KErrNone;
       
  1787     }
       
  1788 
       
  1789 void CIpsPlgMsgMapperHelper::DoCancel()
       
  1790     {
       
  1791     FUNC_LOG;
       
  1792     if( iCurrentOperationWatcher )
       
  1793         {
       
  1794         iCurrentOperationWatcher->Cancel();
       
  1795         delete iCurrentOperationWatcher;
       
  1796         iCurrentOperationWatcher = NULL;
       
  1797         }
       
  1798     iTimer.Cancel();
       
  1799     }
       
  1800 
       
  1801 // ---------------------------------------------------------------------------
       
  1802 // CIpsPlgMsgMapperHelper::StartSetAttchmentFlag
       
  1803 // ---------------------------------------------------------------------------
       
  1804 //
       
  1805 void CIpsPlgMsgMapperHelper::StartSetAttchmentFlag()
       
  1806     {    
       
  1807     FUNC_LOG;
       
  1808     //should start the ao when not in pending status
       
  1809     if( !IsActive() && !iPending )
       
  1810         {
       
  1811         iTimer.After( iStatus, 0 );
       
  1812         SetActive();
       
  1813         iPending = ETrue;
       
  1814         }
       
  1815     }
       
  1816 
       
  1817 // ---------------------------------------------------------------------------
       
  1818 // CIpsPlgMsgMapperHelper::AppendToArrayL
       
  1819 // ---------------------------------------------------------------------------
       
  1820 //
       
  1821 TBool CIpsPlgMsgMapperHelper::AppendMsvIdToArrayL( TMsvId aId )
       
  1822     {
       
  1823     FUNC_LOG;
       
  1824 
       
  1825     TInt count = iNeedSetAttachFlagArray.Count();
       
  1826     //check the MsvId if already exist in iNeedSetAttachFlagArray
       
  1827     for( TInt i = 0; i < count; ++i )
       
  1828         {
       
  1829         TMsvId id = iNeedSetAttachFlagArray[i];
       
  1830         if( id == aId )
       
  1831             {
       
  1832             return EFalse;
       
  1833             }
       
  1834         }
       
  1835     
       
  1836     iNeedSetAttachFlagArray.AppendL( aId );
       
  1837     return ETrue;
       
  1838     }
       
  1839 
       
  1840 
       
  1841