FolderChangesManifest ISourceFolder.EnumerateChanges(EnumerateContentChangesFlags flags, int maxChanges)
{
if (!base.Folder.IsContentAvailable)
{
return(new FolderChangesManifest(base.FolderId));
}
SyncContentsManifestState syncState = ((MapiSourceMailbox)base.Mailbox).SyncState[base.FolderId];
bool flag = maxChanges != 0;
if (!flag || flags.HasFlag(EnumerateContentChangesFlags.FirstPage))
{
MapiStore mapiStore = base.Mailbox.MapiStore;
int[] array = new int[4];
array[0] = 8;
if (mapiStore.IsVersionGreaterOrEqualThan(array))
{
this.contentChangesFetcher = new ManifestContentChangesFetcher(this, base.Folder, base.Mailbox, flag);
}
else
{
this.contentChangesFetcher = new TitaniumContentChangesFetcher(this, base.Folder, base.Mailbox);
}
}
return(this.contentChangesFetcher.EnumerateContentChanges(syncState, flags, maxChanges));
}
FolderChangesManifest ISourceFolder.EnumerateChanges(EnumerateContentChangesFlags flags, int maxChanges)
{
FolderChangesManifest folderChangesManifest = new FolderChangesManifest(base.FolderId);
folderChangesManifest.ChangedMessages = new List <MessageRec>();
folderChangesManifest.ReadMessages = new List <byte[]>();
folderChangesManifest.UnreadMessages = new List <byte[]>();
SyncContentsManifestState syncContentsManifestState = base.Mailbox.SyncState[base.FolderId];
PopFolderState lastSyncedState;
if (syncContentsManifestState.Data != null)
{
lastSyncedState = PopFolderState.Deserialize(syncContentsManifestState.Data);
}
else
{
lastSyncedState = PopFolderState.CreateNew();
}
List <MessageRec> messages = base.EnumerateMessagesOnPopConnection(maxChanges);
PopFolderState popFolderState = PopFolderState.Create(messages);
this.EnumerateIncrementalChanges(popFolderState, lastSyncedState, folderChangesManifest, messages);
syncContentsManifestState.Data = popFolderState.Serialize();
return(folderChangesManifest);
}
internal static void ValidateEnumeration(IFolder sourceFolder, EnumerateContentChangesFlags flags, IContentChangesFetcher contentChangesFetcher, bool hasMoreChangesPrevPage, bool isPagedEnumeration)
{
flags.HasFlag(EnumerateContentChangesFlags.FirstPage);
flags.HasFlag(EnumerateContentChangesFlags.Catchup);
if (!isPagedEnumeration || flags.HasFlag(EnumerateContentChangesFlags.FirstPage) || flags.HasFlag(EnumerateContentChangesFlags.Catchup))
{
return;
}
}
FolderChangesManifest ISourceFolder.EnumerateChanges(EnumerateContentChangesFlags flags, int maxChanges)
{
FolderChangesManifest result = null;
base.CreateContext("ISourceFolder.EnumerateChanges", new DataContext[]
{
new SimpleValueDataContext("flags", flags),
new SimpleValueDataContext("maxChanges", maxChanges)
}).Execute(delegate
{
result = ((ISourceFolder)this.WrappedObject).EnumerateChanges(flags, maxChanges);
}, true);
return(result);
}
FolderChangesManifest ISourceFolder.EnumerateChanges(EnumerateContentChangesFlags flags, int maxChanges)
{
MrsTracer.Provider.Function("StorageSourceFolder.EnumerateChanges({0}, 0x{1:x}, {2})", new object[]
{
base.DisplayNameForTracing,
(int)flags,
maxChanges
});
SyncContentsManifestState syncState = ((StorageSourceMailbox)base.Mailbox).SyncState[base.FolderId];
bool flag = maxChanges != 0;
if (!flag || flags.HasFlag(EnumerateContentChangesFlags.FirstPage))
{
this.contentChangesFetcher = new ManifestContentChangesFetcher(this, this.MapiFolder, base.Mailbox, flag);
}
return(this.contentChangesFetcher.EnumerateContentChanges(syncState, flags, maxChanges));
}
FolderChangesManifest ISourceFolder.EnumerateChanges(EnumerateContentChangesFlags flags, int maxChanges)
{
MrsTracer.ProxyClient.Function("ISourceFolder.EnumerateChanges({0}, {1}): {2}", new object[]
{
flags,
maxChanges,
base.FolderName
});
if (((IMailbox)this.Mailbox).IsMailboxCapabilitySupported(MailboxCapabilities.PagedEnumerateChanges))
{
return(base.MrsProxy.ISourceFolder_EnumerateChanges2(base.Handle, (int)flags, maxChanges));
}
if (maxChanges != 0)
{
throw new UnsupportedRemoteServerVersionWithOperationPermanentException(base.MrsProxyClient.ServerName, base.ServerVersion.ToString(), "ISourceFolder_EnumerateChanges2");
}
return(base.MrsProxy.ISourceFolder_EnumerateChanges(base.Handle, flags.HasFlag(EnumerateContentChangesFlags.Catchup)));
}
FolderChangesManifest ISourceFolder.EnumerateChanges(EnumerateContentChangesFlags flags, int maxChanges)
{
FolderChangesManifest folderChangesManifest = base.CreateInitializedChangesManifest();
SyncContentsManifestState syncContentsManifestState = base.Mailbox.SyncState[base.EntryId];
EasFolderSyncState persistedSyncState = base.Mailbox.GetPersistedSyncState(syncContentsManifestState);
string syncKey = persistedSyncState.SyncKey;
EasSyncOptions options = new EasSyncOptions
{
SyncKey = syncKey,
RecentOnly = true,
MaxNumberOfMessage = 512
};
EasSyncResult easSyncResult = base.SyncMessages(base.Mailbox.EasConnectionWrapper, options);
List <MessageRec> messageRecs = easSyncResult.MessageRecs;
this.EnumerateIncrementalChanges(folderChangesManifest, messageRecs);
this.MergePendingDeletes(folderChangesManifest, persistedSyncState.CrawlerDeletions);
persistedSyncState.SyncKey = easSyncResult.NewSyncKey;
persistedSyncState.ChangesSynced = new DateTime?(DateTime.UtcNow);
persistedSyncState.CrawlerDeletions.Clear();
syncContentsManifestState.Data = persistedSyncState.Serialize();
return(folderChangesManifest);
}
FolderChangesManifest ISourceFolder.EnumerateChanges(EnumerateContentChangesFlags flags, int maxChanges)
{
FolderChangesManifest folderChangesManifest = new FolderChangesManifest(base.FolderId);
folderChangesManifest.ChangedMessages = new List <MessageRec>();
folderChangesManifest.ReadMessages = new List <byte[]>();
folderChangesManifest.UnreadMessages = new List <byte[]>();
if (!base.Folder.IsSelectable)
{
return(folderChangesManifest);
}
SyncContentsManifestState syncContentsManifestState = base.Mailbox.SyncState[base.FolderId];
ImapFolderState imapFolderState;
if (syncContentsManifestState.Data != null)
{
imapFolderState = ImapFolderState.Deserialize(syncContentsManifestState.Data);
if (imapFolderState.UidValidity != base.Folder.UidValidity)
{
syncContentsManifestState.Data = ImapFolderState.CreateNew(base.Folder).Serialize();
this.nextSeqNumCrawl = null;
folderChangesManifest.FolderRecoverySync = true;
return(folderChangesManifest);
}
}
else
{
imapFolderState = ImapFolderState.CreateNew(base.Folder);
}
List <MessageRec> messages = base.EnumerateMessages(FetchMessagesFlags.None, null, null);
ImapFolderState imapFolderState2 = ImapFolderState.Create(messages, imapFolderState.SeqNumCrawl, base.Folder.UidNext, base.Folder.UidValidity);
this.EnumerateIncrementalChanges(imapFolderState2, imapFolderState, folderChangesManifest, messages);
syncContentsManifestState.Data = imapFolderState2.Serialize();
return(folderChangesManifest);
}
private void ConfigureMapiManifest(SyncContentsManifestState syncState, FolderChangesManifest changes, EnumerateContentChangesFlags flags, int maxChanges)
{
if (this.isPagedEnumeration && !flags.HasFlag(EnumerateContentChangesFlags.FirstPage))
{
this.callback.InitializeNextPage(changes, maxChanges);
return;
}
this.callback = new ManifestContentsCallback(this.folder.GetFolderId(), this.isPagedEnumeration);
this.callback.InitializeNextPage(changes, maxChanges);
ManifestConfigFlags manifestConfigFlags = ManifestConfigFlags.Associated | ManifestConfigFlags.Normal | ManifestConfigFlags.OrderByDeliveryTime;
if (flags.HasFlag(EnumerateContentChangesFlags.Catchup))
{
manifestConfigFlags |= ManifestConfigFlags.Catchup;
}
Restriction restriction = ((this.mailbox.Options & MailboxOptions.IgnoreExtendedRuleFAIs) != MailboxOptions.None) ? ContentChangesFetcherUtils.ExcludeAllRulesRestriction : ContentChangesFetcherUtils.ExcludeV40RulesRestriction;
using (this.mailbox.RHTracker.Start())
{
this.mapiManifest = this.mapiFolder.CreateExportManifest();
}
using (MemoryStream memoryStream = (syncState.Data != null) ? new MemoryStream(syncState.Data) : null)
{
using (this.mailbox.RHTracker.Start())
{
this.mapiManifest.Configure(manifestConfigFlags, restriction, memoryStream, this.callback, new PropTag[0]);
}
}
}
private FolderChangesManifest EnumerateChanges(SyncContentsManifestState syncState, EnumerateContentChangesFlags flags, int maxChanges)
{
FolderChangesManifest folderChangesManifest = new FolderChangesManifest(this.folder.GetFolderId());
if (this.folder.GetFolderRec(null, GetFolderRecFlags.None).FolderType == FolderType.Search)
{
return(folderChangesManifest);
}
this.ConfigureMapiManifest(syncState, folderChangesManifest, flags, maxChanges);
ManifestStatus manifestStatus;
do
{
manifestStatus = this.mapiManifest.Synchronize();
}while (manifestStatus != ManifestStatus.Done && manifestStatus != ManifestStatus.Yielded);
using (MemoryStream memoryStream = new MemoryStream())
{
this.mapiManifest.GetState(memoryStream);
syncState.Data = memoryStream.ToArray();
}
return(folderChangesManifest);
}
FolderChangesManifest IContentChangesFetcher.EnumerateContentChanges(SyncContentsManifestState syncState, EnumerateContentChangesFlags flags, int maxChanges)
{
FolderChangesManifest folderChangesManifest = this.EnumerateChanges(syncState, flags, maxChanges);
if (MrsTracer.Provider.IsEnabled(TraceType.DebugTrace))
{
int num;
int num2;
int num3;
folderChangesManifest.GetMessageCounts(out num, out num2, out num3);
MrsTracer.Provider.Debug("Discovered {0} new, {1} changed, {2} deleted, {3} read, {4} unread.", new object[]
{
num,
num2,
num3,
folderChangesManifest.ReadMessages.Count,
folderChangesManifest.UnreadMessages.Count
});
}
return(folderChangesManifest);
}
FolderChangesManifest IContentChangesFetcher.EnumerateContentChanges(SyncContentsManifestState syncState, EnumerateContentChangesFlags enumerateFlags, int maxChanges)
{
FolderChangesManifest folderChangesManifest = new FolderChangesManifest(this.folder.GetFolderId());
bool flag = enumerateFlags.HasFlag(EnumerateContentChangesFlags.Catchup);
ManifestContentsCallback manifestContentsCallback = new ManifestContentsCallback(this.folder.GetFolderId(), false);
manifestContentsCallback.InitializeNextPage(folderChangesManifest, maxChanges);
SyncConfigFlags syncConfigFlags = SyncConfigFlags.ReadState | SyncConfigFlags.Associated | SyncConfigFlags.Normal | SyncConfigFlags.OnlySpecifiedProps;
if (flag)
{
syncConfigFlags |= SyncConfigFlags.Catchup;
}
PropTag[] propsInclude = new PropTag[]
{
PropTag.EntryId,
PropTag.MessageSize
};
MapiSynchronizer mapiSynchronizer;
using (this.mailbox.RHTracker.Start())
{
mapiSynchronizer = this.mapiFolder.CreateContentsSynchronizer();
}
using (MapiManifestCollector mapiManifestCollector = new MapiManifestCollector(this.mapiFolder, manifestContentsCallback))
{
using (mapiSynchronizer)
{
using (MemoryStream memoryStream = new MemoryStream())
{
if (syncState.Data != null)
{
memoryStream.Write(syncState.Data, 0, syncState.Data.Length);
memoryStream.Position = 0L;
}
Restriction restriction = ((this.mailbox.Options & MailboxOptions.IgnoreExtendedRuleFAIs) != MailboxOptions.None) ? ContentChangesFetcherUtils.ExcludeAllRulesRestriction : ContentChangesFetcherUtils.ExcludeV40RulesRestriction;
using (this.mailbox.RHTracker.Start())
{
mapiSynchronizer.Config(memoryStream, syncConfigFlags, mapiManifestCollector, restriction, propsInclude, null);
while (mapiSynchronizer.Synchronize() != 0)
{
}
}
syncState.Data = memoryStream.ToArray();
}
}
}
if (!flag && MrsTracer.Provider.IsEnabled(TraceType.DebugTrace))
{
int num;
int num2;
int num3;
folderChangesManifest.GetMessageCounts(out num, out num2, out num3);
MrsTracer.Provider.Debug("Discovered {0} new, {1} changed, {2} deleted, {3} read, {4} unread.", new object[]
{
num,
num2,
num3,
folderChangesManifest.ReadMessages.Count,
folderChangesManifest.UnreadMessages.Count
});
}
return(folderChangesManifest);
}
FolderChangesManifest ISourceFolder.EnumerateChanges(EnumerateContentChangesFlags flags, int maxChanges)
{
return(base.CreateInitializedChangesManifest());
}
FolderChangesManifest ISourceFolder.EnumerateChanges(EnumerateContentChangesFlags flags, int maxChanges)
{
throw new NotImplementedException();
}
