public void Conversation_Send_Text_Message()
        {
            AVClient.Initialize("JXyR8vfpeSr8cfaYnob2zYl0-9Nh9j0Va", "Fgq2YlPdnP1KJEoWyF5tk2az");
            var client = new AVIMClient("Tom");

            AVIMConversation conversation = AVIMConversation.CreateWithoutData("573df12679df540060417452", client);

            client.ConnectAsync().ContinueWith(_ =>
            {
                client.RegisterMessage <AVIMTextMessage>((message) =>
                {
                    var textMessage = message as AVIMTextMessage;
                    Trace.WriteLine(textMessage.TextContent);
                });

                client.RegisterMessage <AVIMAudioMessage>((audio) =>
                {
                });

                var text = new AVIMTextMessage("Hi,Jerry");
                conversation.SendMessageAsync(text).ContinueWith(t =>
                {
                    Trace.WriteLine(text.Id);
                }).Wait();
            }).Wait();
        }
Example #2
0
        public async void CreateClient(string clientId)
        {
            Console.WriteLine(clientId + " connecting...");
            client = await realtime.CreateClientAsync(clientId);

            Console.WriteLine(clientId + " connected.");
        }
Example #3
0
        public static async Task Main(string[] args)
        {
            string appId    = "uay57kigwe0b6f5n0e1d4z4xhydsml3dor24bzwvzr57wdap";
            string appKey   = "kfgz7jjfsk55r5a8a3y4ttd3je1ko11bkibcikonk32oozww";
            string clientId = "wujun";

            AVClient.Initialize(appId, appKey);
            AVRealtime realtime = new AVRealtime(appId, appKey);

            AVRealtime.WebSocketLog(Console.WriteLine);


            AVIMClient tom = await realtime.CreateClientAsync(clientId, tag : "Mobile", deviceId : "xxxbbbxxx");

            tom.OnSessionClosed += Tom_OnSessionClosed;
            var conversation = await tom.GetConversationAsync("5b83a01a5b90c830ff80aea4");

            var messages = await conversation.QueryMessageAsync(limit : 10);

            var afterMessages = await conversation.QueryMessageAfterAsync(messages.First());

            var earliestMessages = await conversation.QueryMessageFromOldToNewAsync();

            var nextPageMessages = await conversation.QueryMessageAfterAsync(earliestMessages.Last());

            var earliestMessage = await conversation.QueryMessageFromOldToNewAsync(limit : 1);

            var latestMessage = await conversation.QueryMessageAsync(limit : 1);

            var messagesInInterval = await conversation.QueryMessageInIntervalAsync(earliestMessage.FirstOrDefault(), latestMessage.FirstOrDefault());

            Console.ReadKey();
        }
        public void AVIMClient_Connect()
        {
            AVClient.Initialize("uay57kigwe0b6f5n0e1d4z4xhydsml3dor24bzwvzr57wdap", "kfgz7jjfsk55r5a8a3y4ttd3je1ko11bkibcikonk32oozww");
            var client = new AVIMClient("Tom");

            client.ConnectAsync().Wait();
        }
Example #5
0
 private async void btn_logIn_Click(object sender, EventArgs e)
 {
     client = await realtime.CreateClientAsync(clientId: txb_clientId.Text.Trim());
     client.OnMessageReceived += Client_OnMessageReceived;
     client.OnMessageRecalled += Client_OnMessageRecalled;
     client.OnMessageModified += Client_OnMessageModified;
 }
Example #6
0
        private async void Window_Loaded(object sender, RoutedEventArgs e)
        {
            //初始化登录用户信息
            usernameheader.Text = AVUser.CurrentUser.Username[0].ToString();
            username.Text       = AVUser.CurrentUser.Username;
            useremail.Text      = AVUser.CurrentUser.Email;
            //初始化即时通讯服务
            try
            {
                Websockets.Net.WebsocketConnection.Link();
                Realtime = new AVRealtime(new AVRealtime.Configuration
                {
                    ApplicationId  = "EthsHELtLfXL9XBqcFfzMrPO-gzGzoHsz",
                    ApplicationKey = "xODJ808fAD8hpLHlblQhk0t1",
                    //可以有
                    RTMRouter = new Uri("https://ethshelt.lc-cn-n1-shared.com"),
                    OfflineMessageStrategy = AVRealtime.OfflineMessageStrategy.Default
                });
                //注册自定义消息
                Realtime.RegisterMessageType <NoticeMessage>();
                //注册离线消息监听
                Realtime.OnOfflineMessageReceived += OnOfflineMessageReceived;
                //登录Client
                User = await Realtime.CreateClientAsync(AVUser.CurrentUser);

                if (AVUser.CurrentUser.Get <string>("Friends") == "null")
                {
                    //如果是第一次登录给用户添加Friends的ConversationId
                    AVIMConversation Myfriends = await User.CreateConversationAsync(member : null, name : AVUser.CurrentUser.Username + "的小伙伴们", isUnique : false);

                    AVUser.CurrentUser["Friends"] = Myfriends.ConversationId;
                    await AVUser.CurrentUser.SaveAsync();
                }
                //获取FriendsConversation
                FriendsConversation = await User.GetConversationAsync(AVUser.CurrentUser.Get <string>("Friends"));

                //上线后给所有的好友发送“我上线了”的notice
                NoticeMessage notice = new NoticeMessage
                {
                    Notice = "我上线啦"
                };
                await FriendsConversation.SendMessageAsync(notice);

                //绑定listbox数据
                BindingFriendListSrouce();
                //添加好友事件监听(好友邀请事件:同意,拒绝,好友邀请反馈事件:同意)
                User.OnInvited += OnInvited;
                //被删除事件监听
                User.OnKicked += OnKicked;
                //好友操作事件监听(删除好友,好友邀请反馈事件:拒绝)==》TODO:未完成
                //User.OnMembersLeft += OnMembersLeft;
                //User.OnMembersJoined += OnMembersJoined;
                User.OnMessageReceived += OnMessageReceived;
            }
            catch (Exception err)
            {
                MessageBox.Show(err.ToString());
            }
        }
        private async void btn_Connect_Click(object sender, EventArgs e)
        {
            selfClient = new AVIMClient(txb_clientId.Text.Trim());
            await selfClient.ConnectAsync();

            LoadData();
            BindEventHandler();
            Log(txb_clientId.Text.Trim() + " 登陆成功!");
        }
        public void AVIMClient_SyncRouter()
        {
            AVClient.Initialize("uay57kigwe0b6f5n0e1d4z4xhydsml3dor24bzwvzr57wdap", "kfgz7jjfsk55r5a8a3y4ttd3je1ko11bkibcikonk32oozww");
            var client = new AVIMClient("Tom");

            AVIMClient.RouterController.GetAsync(CancellationToken.None).ContinueWith(t =>
            {
                Trace.WriteLine(t.Result.server);
            }).Wait();
        }
        public void Conversation_Send_Image_Message()
        {
            AVClient.Initialize("uay57kigwe0b6f5n0e1d4z4xhydsml3dor24bzwvzr57wdap", "kfgz7jjfsk55r5a8a3y4ttd3je1ko11bkibcikonk32oozww");
            var client = new AVIMClient("Tom");

            client.ConnectAsync().ContinueWith(_ =>
            {
                AVIMImageMessage message = AVIMImageMessage.FromUrl("http://ww3.sinaimg.cn/bmiddle/596b0666gw1ed70eavm5tg20bq06m7wi.gif");
            }).Wait();
        }
Example #10
0
        static void TestRealtime()
        {
            Websockets.Net.WebsocketConnection.Link();

            //var appId = "Eohx7L4EMfe4xmairXeT7q1w-gzGzoHsz";
            //var appKey = "GSBSGpYH9FsRdCss8TGQed0F";

            AVRealtime.LogPrinter = Console.WriteLine;

            var client = AVIMClient.GetInstance("xxxxxxx");

            client.OnReceivedMessage += (message) => {
                Console.WriteLine("☎️  {0} received message", client.ClientId);
                if (message is AVIMTextMessage)
                {
                    Console.WriteLine("☎️  {0} received: {1}", client.ClientId, (message as AVIMTextMessage).Text);
                }
            };
            client.OnDisconnected += () => {
                Console.WriteLine("☎️  {0} is disconnected", client.ClientId);
            };
            client.OnReconnected += () => {
                Console.WriteLine("☎️  {0} is reconnected", client.ClientId);
            };

            //client.Open().ContinueWith(t => {
            //    Console.WriteLine("☎️  {0}", "client open done");
            //    var memberIds = new List<string> { "x", "y" };
            //    return client.CreateConversationAsync(memberIds);
            //}).Unwrap().ContinueWith(t => {
            //    Console.WriteLine("☎️  {0}", "conversation create done");
            //    Console.WriteLine(t.Result.rawData);
            //});

            client.Open().ContinueWith(t => {
                Console.WriteLine("☎️  {0}", "client open done");
                var memberIds = new List <string> {
                    "x", "y"
                };
                return(client.CreateConversationAsync(memberIds));
            }).Unwrap().ContinueWith(t => {
                Console.WriteLine("☎️  {0}", "conversation create done");
                Console.WriteLine(t.Result.rawData);
                var conv = t.Result;
                var msg  = new AVIMTextMessage {
                    Text = "hello, world",
                };
                return(conv.SendMessageAsync(msg));
            }).Unwrap().ContinueWith(t => {
                Console.WriteLine("☎️  {0}", "send message done");
            });
        }
        public void Conversation_Join()
        {
            AVClient.Initialize("uay57kigwe0b6f5n0e1d4z4xhydsml3dor24bzwvzr57wdap", "kfgz7jjfsk55r5a8a3y4ttd3je1ko11bkibcikonk32oozww");
            var client = new AVIMClient("John");

            client.UseLeanEngineSignatureFactory();

            client.ConnectAsync().ContinueWith(_ =>
            {
                AVIMConversation consersation = AVIMConversation.CreateWithoutData("575e88521532bc0060995d32", client);
                consersation.JoinAsync().Wait();
            }).Wait();
        }
Example #12
0
        public async Task OnExecuteAsync(CommandLineApplication app, IConsole console)
        {
            AVClient.Initialize(AppId, AppKey);
            AVRealtime.WebSocketLog((str) =>
            {
                console.WriteLine(str);
            });
            AVRealtime realtime = new AVRealtime(AppId, AppKey);

            AVIMClient client = await realtime.CreateClientAsync(ClientId);

            client.OnMessageReceived += Client_OnMessageReceived;
            new RealtimeCommand().OnExecute(app, console);
        }
        private void Client_OnSessionClosed(object sender, AVIMSessionClosedEventArgs e)
        {
            if (e.Code == 4111)
            {
                var logInVM = ServiceLocator.Current.GetInstance <LogInViewModel>();
                logInVM.Reset();
                this.CurrentClient = null;
                Application.Current.Dispatcher.Invoke((Action) delegate
                {
                    this.CenterContent = new LogIn();
                    this.LeftContent   = null;
                    this.BottomContent = null;
                });

                MessageBox.Show("您的 client Id 在别处登录,当前登录失效,连接已断开", "单点登录冲突");
            }
        }
    void CreateLobby()
    {
        if (!Application.isPlaying)
        {
            Debug.LogError("Run this only in play mode");
            return;
        }
        AVIMClient zhouyu = null;

        _avRealtime.CreateClientAsync("9999").ContinueWith(t => { zhouyu = t.Result; }).ContinueWith(s =>
        {
            // 关键参数是 isTransient: true
            zhouyu.CreateConversationAsync(
                name: "游戏大厅",
                isTransient: true).ContinueWith(t => { Debug.Log(t.Result.ConversationId); });
        });
    }
        public void Create_Conversation()
        {
            AVClient.Initialize("uay57kigwe0b6f5n0e1d4z4xhydsml3dor24bzwvzr57wdap", "kfgz7jjfsk55r5a8a3y4ttd3je1ko11bkibcikonk32oozww");
            var client = new AVIMClient("Tom");

            client.UseLeanEngineSignatureFactory();
            AVIMConversation convseation = new AVIMConversation()
            {
                Name        = "xman",
                IsTransient = false,
            };

            convseation.MemberIds = new List <string>();
            convseation.MemberIds.Add("Jerry");

            client.ConnectAsync().ContinueWith(_ =>
            {
                client.CreateConversationAsync(convseation, true).Wait();
            }).Wait();
        }
    public void JoinLobby()
    {
        _avRealtime.CreateClientAsync(UserInfo.User).ContinueWith(t => _client = t.Result).ContinueWith(s =>
        {
            _client.OnMessageReceived += OnMessageReceived;
            Debug.Log("Joining");
            // 构建对话的时候需要指定一个 AVIMClient 实例做关联
            _lobbyConversation = AVIMConversation.CreateWithoutData(ConversationId, _client);
            _client.JoinAsync(_lobbyConversation).ContinueWith(a =>
            {
                if (a.IsFaulted)
                {
                    _lobbyConversation = null;
                    Debug.Log("Join failed");

                    return;
                }
                Debug.Log("Joined and sending message");
            });
        });
    }
        public async Task OnExecuteAsync(CommandLineApplication app, IConsole console)
        {
            AVClient.Initialize(AppId, AppKey);
            AVRealtime.WebSocketLog((str) =>
            {
                console.WriteLine(str);
            });

            AVRealtime realtime = new AVRealtime(AppId, AppKey);

            AVIMClient client = await realtime.CreateClientAsync(ClientId);

            var conversation = await client.GetConversationAsync("5b83a01a5b90c830ff80aea4");

            await conversation.SendImageAsync("http://ww3.sinaimg.cn/bmiddle/596b0666gw1ed70eavm5tg20bq06m7wi.gif", "Satomi_Ishihara", "萌妹子一枚", new Dictionary <string, object>
            {
                { "actress", "石原里美" }
            });

            new RealtimeCommand().OnExecute(app, console);
        }
Example #18
0
        public async Task InitChatSDK()
        {
            string userid = string.Empty;
            string roomid = string.Empty;

            try
            {
                userid = VenueRtcCLI.VenueRTC.Instance.getUserId();
                roomid = VenueRtcCLI.VenueRTC.Instance.getRoomId();
            }
            catch (Exception ex)
            {
                App.LogError(ex);
            }
            AVClient.Initialize("Q2BQPmQMCARUy2LY6pqc8Tk3-gzGzoHsz", "5jl51fyVTMUhHt6ddghrXNTa");
            AVRealtime realtime = new AVRealtime("Q2BQPmQMCARUy2LY6pqc8Tk3-gzGzoHsz", "5jl51fyVTMUhHt6ddghrXNTa");

            Websockets.Net.WebsocketConnection.Link();
            vIMClient = await realtime.CreateClientAsync(userid);

            AVIMConversationQuery   query         = vIMClient.GetChatRoomQuery().WhereEqualTo("name", roomid);
            List <AVIMConversation> conversations = (List <AVIMConversation>)(await query.FindAsync());

            if (conversations == null || conversations.Count == 0)
            {
                conversation = await vIMClient.CreateChatRoomAsync(roomid);
            }
            else
            {
                conversation = conversations[0];
            }

            await vIMClient.JoinAsync(conversation);

            await getHistoryMessage();

            vIMClient.OnMessageReceived += VIMClient_OnMessageReceived;
        }
Example #19
0
 public Addfriend(AVIMClient user, AVIMConversation conversation) : this()
 {
     User         = user;
     Conversation = conversation;
 }
Example #20
0
 public Task<AVIMClient> CreateClient(string clientId, ISignatureFactory signatureFactory = null, string tag = null)
 {
     CurrentConfiguration = new Configuration()
     {
         ApplicationId = CurrentConfiguration.ApplicationId,
         ApplicationKey = CurrentConfiguration.ApplicationKey,
         SignatureFactory = signatureFactory
     };
     var client = new AVIMClient(clientId, tag)
     {
         SignatureFactory = signatureFactory
     };
     return client.ConnectAsync().ContinueWith(t =>
     {
         return Task.FromResult(client);
     }).Unwrap();
     //return Task.FromResult(new AVIMClient(clientId, tag)
     //{
     //    SignatureFactory = signatureFactory
     //});
 }
 private async void btn_Connect_Click(object sender, EventArgs e)
 {
     selfClient = new AVIMClient(txb_clientId.Text.Trim());
     await selfClient.ConnectAsync();
     LoadData();
     BindEventHandler();
     Log(txb_clientId.Text.Trim() + " 登陆成功!");
 }
Example #22
0
 public Main(UserList invitefriend, AVRealtime realtime, AVIMClient user) : this()
 {
     InviteFriend = invitefriend;
     Realtime     = realtime;
     User         = user;
 }
Example #23
0
        static void Test()
        {
            //var appId = "nb4egfMaDOj6jzqRhBuWpk5m-gzGzoHsz";
            //var appKey = "zJ4aUsCraV6eBE6dGHWYE57z";

            var appId  = "Eohx7L4EMfe4xmairXeT7q1w-gzGzoHsz";
            var appKey = "GSBSGpYH9FsRdCss8TGQed0F";

            AVIMConversation conv = null;

            Console.WriteLine($"test at {Thread.CurrentThread.ManagedThreadId}");
            AVClient.Initialize(appId, appKey);
            AVRealtime realtime = new AVRealtime(new AVRealtime.Configuration {
                ApplicationId  = appId,
                ApplicationKey = appKey,
                //RealtimeServer = new Uri("wss://rtm51.leancloud.cn/"),
            });

            realtime.CreateClientAsync("lean").ContinueWith(t => {
                if (t.IsFaulted)
                {
                    Console.WriteLine($"create client failed at {Thread.CurrentThread.ManagedThreadId}");
                    throw t.Exception;
                }
                Console.WriteLine($"create client at {Thread.CurrentThread.ManagedThreadId}");
                AVIMClient client         = t.Result;
                client.OnMessageReceived += (sender, e) => {
                    Console.WriteLine($"{e.Message.Id} is received at {Thread.CurrentThread.ManagedThreadId}");
                };
                client.OnMessageRecalled += (sender, e) => {
                    Console.WriteLine($"{e.Message} is recall at {Thread.CurrentThread.ManagedThreadId}");
                };
                client.OnMessageUpdated += (sender, e) => {
                    Console.WriteLine($"{e.Message} is updated at {Thread.CurrentThread.ManagedThreadId}");
                };
                realtime.OnDisconnected += (sender, e) => {
                    Console.WriteLine($"{client.ClientId} is disconnected");
                    try {
                        conv.SendTextAsync("I am disconnected");
                    } catch (Exception err) {
                        Console.WriteLine($"send error: {err.Message}");
                    }
                };
                realtime.OnReconnecting += (sender, e) => {
                    Console.WriteLine($"{client.ClientId} is reconnecting");
                };
                realtime.OnReconnected += (sender, e) => {
                    Console.WriteLine($"{client.ClientId} is reconnected");
                    conv.SendTextAsync("I am reconnected");
                };
                //realtime.CreateClient("aaa").ContinueWith(xxx => {
                //    if (xxx.IsFaulted) {
                //        Console.WriteLine($"create xxx error: {xxx.Exception.Message} at {Thread.CurrentThread.ManagedThreadId}");
                //    } else {
                //        Console.WriteLine($"create xxx at {Thread.CurrentThread.ManagedThreadId}");
                //    }
                //});
                return(client.CreateConversationAsync(members: new string[] { "xxx", "zzz" }));
            }).Unwrap().ContinueWith(t => {
                if (t.IsFaulted)
                {
                    throw t.Exception;
                }
                Console.WriteLine($"create conversation at {Thread.CurrentThread.ManagedThreadId}");
                conv = t.Result;
                return(conv.SendTextAsync("无码种子"));
            }).Unwrap().ContinueWith(t => {
                if (t.IsFaulted)
                {
                    throw t.Exception;
                }
                Console.WriteLine($"send message at {Thread.CurrentThread.ManagedThreadId}");
                Console.WriteLine("send success");
            });


            //await client.CloseAsync();

            //client = await realtime.CreateClientAsync("leancloud");

            //await client.CloseAsync();

            //var newMsg = new AVIMTextMessage("大家好");

            //var timer = new Timer {
            //    Interval = 1000,
            //};
            //timer.Elapsed += async (sender, e) => {
            //    timer.Stop();

            //    try {
            //        var modifiedMsg = await conv.UpdateAsync(msg, newMsg);
            //        Console.WriteLine($"{modifiedMsg.Id} 修改成功");
            //    } catch (Exception exception) {
            //        Console.WriteLine(exception.Message);
            //    }

            //    //try {
            //    //    var recalledMsg = await conv.RecallAsync(msg);
            //    //    Console.WriteLine($"{recalledMsg.Id} is recalled");
            //    //} catch (Exception exception) {
            //    //    Console.WriteLine(exception.Message);
            //    //}
            //};
            //timer.Start();
        }