Get updates for unread channel messages without polling (so flood exception might be prevented)

[paulbir]

How do I get updates for new channel messages without bumping flood limits?
First I tried this:

            while (true)
            {
                Task.Delay(500).Wait();
                TLState state = client.SendRequestAsync<TLState>(new TLRequestGetState()).Result;
                //if (state.UnreadCount <= 0) continue;

                TLRequestGetDifference req = new TLRequestGetDifference { Date = state.Date, Pts = state.Pts, Qts = state.Qts, Sequence = state.Seq + 1 };
                TLDifference diff = client.SendRequestAsync<TLAbsDifference>(req).Result as TLDifference;

                if (diff != null)
                {
                    foreach (TLUpdateNewChannelMessage upd in diff.OtherUpdates.OfType<TLUpdateNewChannelMessage>())
                        Console.WriteLine(((TLMessage)upd.Message).Message);

                    foreach (TLChannel ch in diff.Chats.OfType<TLChannel>().Where(x => !x.Left))
                    {
                        TLInputChannel ich = new TLInputChannel { ChannelId = ch.Id, AccessHash = ch.AccessHash ?? 0 };
                        TLRequestReadHistory readed = new TLRequestReadHistory { Channel = ich, MaxId = -1 };
                        client.SendRequestAsync<bool>(readed).Wait();
                    }
                }
            }

But state.UnreadCount > 0 only for unread messages from PeerUsers. And even if state.UnreadCount > 0, client.SendRequestAsync<TLAbsDifference> always returns TLDifferenceEmpty.

Also I tried:

            while (true)
            {
                Task.Delay(2000).Wait();
                var dialogs = client.GetUserDialogsAsync().Result as TLDialogs;
                if (dialogs == null) continue;

                foreach (TLDialog dialog in dialogs.Dialogs.Where(lambdaDialog => lambdaDialog.Peer is TLPeerChannel && lambdaDialog.UnreadCount > 0))
                {
                    TLPeerChannel peer = (TLPeerChannel)dialog.Peer;
                    TLChannel channel = dialogs.Chats.OfType<TLChannel>().First(lambdaChannel => lambdaChannel.Id == peer.ChannelId);
                    TLInputPeerChannel target = new TLInputPeerChannel { ChannelId = channel.Id, AccessHash = channel.AccessHash ?? 0 };

                    TLChannelMessages hist = (TLChannelMessages)client.GetHistoryAsync(target, 0, -1, dialog.UnreadCount).Result;

                    var users = hist.Users.OfType<TLUser>().ToList();
                    foreach (TLMessage message in hist.Messages.OfType<TLMessage>())
                    {
                        TLUser sentUser = users.Single(lambdaUser => lambdaUser.Id == message.FromId);
                        Console.WriteLine($"{sentUser.FirstName} {sentUser.LastName} {sentUser.Username}: {message.Message}");
                    }

                    TLInputChannel channelToMarkRead = new TLInputChannel { ChannelId = target.ChannelId, AccessHash = target.AccessHash };
                    int firstUnreadMessageId = ((TLMessage)hist.Messages.First()).Id;
                    TLRequestReadHistory markHistoryAsReadRequest = new TLRequestReadHistory
                    {
                        Channel = channelToMarkRead,
                        MaxId = -1,
                        ConfirmReceived = true,
                        Dirty = true,
                        MessageId = firstUnreadMessageId,
                        Sequence = dialog.UnreadCount
                    };

                    bool isMarked = client.SendRequestAsync<bool>(markHistoryAsReadRequest).Result;
                }
            }

It shows me unread messages, but has two problems.

1. It causes Flood prevention exception after several iterations if there are no new messages.
2. It causes InvalidCastException on second iteration if there are new messages.
   Here what happens:

• I call client.SendRequestAsync<bool>(markHistoryAsReadRequest) to mark messages as read.
• It always returns False, despite messages have been marked as read.
• On the next iteration I call var dialogs = client.GetUserDialogsAsync().Result as TLDialogs; again.
• It causes InvalidCastException because SendRequestAsync<TLAbsDialogs> is called inside GetUserDialogsAsync. But it receives TLBoolTrue as a result. And tries to cast it to TLAbsDialogs which fails.

[knocte]

IMO the problem here is that you're using polling to get new messages.

I haven't investigated this yet but there should be a way for the server to send events to the client once connected.

[paulbir]

In some similar issue I saw an advice to try to use TLRequestRegisterDevice request, but I didn't understand how to use it. Where should I get device token and how do I get push messages? And can I even use it with windows desktop?

[paulbir]

In my second approach with GetUserDialogsAsync I could try to play around with random delays between requests. But as I mentioned it crashes on second iteration. Can I use some workaround to skip this TLBoolTrue result?

[knocte]

Where should I get device token and how do I get push messages? And can I even use it with windows desktop?

I don't know how to answer this sorry. Maybe the best way to figure this out is look at how TelegramDesktop's official app is built, see what's their even reception approach there, and "translate" it to C#.

But as I mentioned it crashes on second iteration.

If you're referring to InvalidCastException, those are definitely TLSharp bugs. Please contribute a PullRequest to fix the InvalidCastException.

Thanks

[paulbir]

So finally it seems to work so far. I'll post my workarounds here just in case. I'm not going to pullrequest because my changes to TLSharp source are dirty hacks and workarounds just for my case.
In TLRequestGetDialogs change
Response = (Messages.TLAbsDialogs)ObjectUtils.DeserializeObject(br);
to
Response = ObjectUtils.DeserializeObject(br) as Messages.TLAbsDialogs;

In TLRequestGetHistory change
Response = (Messages.TLAbsMessages)ObjectUtils.DeserializeObject(br);
to
Response = ObjectUtils.DeserializeObject(br) as Messages.TLAbsMessages;

So no exception will be thrown in case of casting to wrong type.

And my code:

            var rnd = new Random();

            while (true)
            {
                Task.Delay(rnd.Next(3000, 6000)).Wait();
                var dialogs = client.GetUserDialogsAsync().Result as TLDialogs;

                if (dialogs == null)
                {
                    Task.Delay(rnd.Next(3000, 6000)).Wait();
                    continue;
                }

                foreach (TLDialog dialog in dialogs.Dialogs.Where(lambdaDialog => lambdaDialog.Peer is TLPeerChannel && lambdaDialog.UnreadCount > 0))
                {
                    TLPeerChannel peer = (TLPeerChannel)dialog.Peer;
                    TLChannel channel = dialogs.Chats.OfType<TLChannel>().First(lambdaChannel => lambdaChannel.Id == peer.ChannelId);
                    TLInputPeerChannel target = new TLInputPeerChannel { ChannelId = channel.Id, AccessHash = channel.AccessHash ?? 0 };

                    Task.Delay(rnd.Next(3000, 6000)).Wait();
                    TLChannelMessages hist = (TLChannelMessages)client.GetHistoryAsync(target, 0, -1, dialog.UnreadCount).Result;
                    if (hist == null) continue;

                    var users = hist.Users.OfType<TLUser>().ToList();
                    var messages = hist.Messages.OfType<TLMessage>().ToList();

                    foreach (TLMessage message in messages)
                    {
                        TLUser sentUser = users.Single(lambdaUser => lambdaUser.Id == message.FromId);
                        Console.WriteLine($"{channel.Title} {sentUser.FirstName} {sentUser.LastName} {sentUser.Username}: {message.Message}");
                    }

                    TLInputChannel channelToMarkRead = new TLInputChannel { ChannelId = target.ChannelId, AccessHash = target.AccessHash };
                    var firstAbsMessage = hist.Messages[0];
                    int firstUnreadMessageId;
                    if (firstAbsMessage is TLMessage) firstUnreadMessageId = ((TLMessage) firstAbsMessage).Id;
                    else if (firstAbsMessage is TLMessageService) firstUnreadMessageId = ((TLMessageService)firstAbsMessage).Id;
                    else continue;

                    TLRequestReadHistory markHistoryAsReadRequest = new TLRequestReadHistory
                    {
                        Channel = channelToMarkRead,
                        MaxId = -1,
                        ConfirmReceived = true,
                        Dirty = true,
                        MessageId = firstUnreadMessageId,
                        Sequence = dialog.UnreadCount
                    };

                    Task.Delay(rnd.Next(3000, 6000)).Wait();
                    client.SendRequestAsync<bool>(markHistoryAsReadRequest).Wait();

                    Console.WriteLine("Mark messages as read");
                }
            }

You can see that I just skip execution if request result is null. Also I added random delay before each request. So far so good.

[TgWindoz]

private static Task<TLState> offset;
private static async Task<TLState> GetOffset() => await client.SendRequestAsync<TLState>(new TLRequestGetState());

static void Worker()
{
    if (client.IsUserAuthorized())
    {
        offset = Task.Run(GetOffset);
        while (true)
        {
            Thread.Sleep(500);
            Task getUpdates = GetUpdates(offset.Result.Date, offset.Result.Pts, offset.Result.Qts);
            getUpdates.Wait();
        }
    }
}

private static async Task GetUpdates(int date, int pts, int qts)
{
    var req = new TLRequestGetDifference() { Date = date, Pts = pts, Qts = qts};
    if (await client.SendRequestAsync<TLAbsDifference>(req) is TLDifference diff)
    {
        foreach (var upd in diff.NewMessages)
        {
            offset.Result.Pts++;
            var msg = upd as TLMessage;
            Console.WriteLine(msg.Message);
        }
    }
    await client.SendPingAsync();
}

[paulbir]

As you can see in my first post TLRequestGetDifference always returns TLDifferenceEmpty

[TgWindoz]

@paulbir

TLState state = client.SendRequestAsync<TLState>(new TLRequestGetState()).Result;

you do not have to get TLState every time, but you have to get it only once before the while loop and then increase by 1 pts to every message received

[paulbir]

My mistake with copy paste. It was my late attempt with state. I tried without setting state each time.

[TgWindoz]

send current source @paulbir

[pp4x]

Is it possible to receive updates without polling?

[knocte]

@ppanhoto78 it should be possible because the official TelegramDesktop client does it. You could check their source code and publish the approach here.

[paulbir]

@TgWindoz, Here is the source I tried last time:

TLState state = await client.SendRequestAsync<TLState>(new TLRequestGetState());

while (!token.IsCancellationRequested)
{
    await Task.Delay(500, token);

    //if (state.UnreadCount <= 0) continue;

    var req = new TLRequestGetDifference {Date = state.Date, Pts = state.Pts, Qts = state.Qts};
    TLAbsDifference tmpdiff = await client.SendRequestAsync<TLAbsDifference>(req);

    if (!(tmpdiff is TLDifference)) continue;
    TLDifference diff = tmpdiff as TLDifference;

    foreach (var upd in diff.NewMessages)
    {
        state.Pts++;
        var msg = upd as TLMessage;
        if (msg == null) continue;
        Console.WriteLine(msg.Message);
    }

    foreach (TLUpdateNewChannelMessage upd in diff.OtherUpdates.OfType<TLUpdateNewChannelMessage>())
        Console.WriteLine(((TLMessage)upd.Message).Message);

    foreach (TLChannel ch in diff.Chats.OfType<TLChannel>().Where(x => !x.Left))
    {
        var inputChannel = new TLInputChannel {ChannelId = ch.Id, AccessHash = ch.AccessHash ?? 0};
        var markHistoryAsReadRequest = new TLRequestReadHistory {Channel = inputChannel, MaxId = -1};
        await client.SendRequestAsync<bool>(markHistoryAsReadRequest);
    }
}

tmpdiff is used to watch the real type of TLAbsDifference return value while debugging. And it is always TLDifferenceEmpty even though I have unread messages at the moment.

[RiddlerKnight]

I try so many times and I found that
TLState state = await client.SendRequestAsync<TLState>(new TLRequestGetState());
This method alway return "unread = 0" for Channel but Chat and Group Chat is ok.

[pp4x]

I did my version of an event handling engine. I'm not happy with it, though. It can be checked out at
https://github.com/ppanhoto78/TLSharp/