精华内容
下载资源
问答
  • 客户端应用程序 - 是需要安装在用户电脑上才可以使用程序特点:不需要联网也可以打开使用部分功能但是现在情况是许多功能依然需要互联网的支持 代码部分在用户电脑上执行 WinForm常用窗体属性: 布局: ...

    客户端应用程序 - 是需要安装在用户电脑上才可以使用的程序
    特点:
    不需要联网也可以打开使用部分功能
    但是现在的情况是许多功能依然需要互联网的支持

    代码部分在用户电脑上执行

    WinForm常用窗体属性:

    布局:

    AutoScroll:当控件内容超出可见区域是否显示滚动条;

    Autosize:当控件内容有超出时是否自动调整窗口;

    Location:控件左上角相对于其容器的坐标;

    StartPosition:窗口运行的位置,居中之类的,CenterScreen--居中,Manual--屏幕左上角;

    Maximumsize:窗体可调整到的最大大小;

    Minimumsize:窗体可调整到的最小大小;

    padding :控件的内部边距;
    Size :窗口大小 ;
    WindowState :运行的状态,运行起来最大最小化;
    ---------------------------------------------------------------------------------------------------------------------------
    窗口样式:
    ControlBox :窗体左上角或右上角的最大最小关闭按钮;
    Icon :设置窗体左上角的图标,只能是ico文件;

    MaximizeBox :控制最大化按钮是否可用;
    MinimizeBox :控制最小化按钮是否可用;
    HelpButton:帮助窗口(仅当没有最大化按钮和最小化按钮时显示);
    Opacity:透明度;
    ShowIcon:是否显示左上角图标;
    ShowInTaskbar :是否在windows任务栏里显示窗体;
    TopMost :最顶层窗口,始终在最上面
    TransparencyKey:要透明显示的颜色是哪个颜色,一般用来做透明窗体
    ----------------------------------------------------------------------------------------------------------
    设计:
    Name:窗体类的类名;
    ----------------------------------------------------------------------------------------------------------
    数据:
    Tag - 与对象关联的用户定义数据;
    ----------------------------------------------------------------------------------------------------------
    外观:
    BackgroundImage :背景图片;
    BackgroundImagelayout : 背景图片布局;
    BackColor:背景颜色;
    Cursor :鼠标样式;
    FormBorderStyle :边框样式;可锁定边框不能拖拽。。
    Text:标题栏文字;
    ------------------------------------------------------------------------------------------------------------------
    杂项:
    AcceptButton :“接受按钮”,用户每次按enter键都相当于单击此按钮;
    CancelButton :“取消按钮”,用户每次按enter键都相当于单击此按钮;

    常用的几个控件:

    窗体中显示文字 - Label
    用户输入内容 - TextBox 
    按钮 - Button
    复选框 - CheckBox
    单选框 - RadioButton

    下拉菜单-ComboBox

    转载于:https://www.cnblogs.com/baimangguo/p/6132616.html

    展开全文
  • 我们在常用的安防监控、互联网视频直播等系统服务中,常常主要的就那么几个环节: 视频获取:RTSP源、SDK源、GB28181源; 视频输出:RTMP推流、SDK推流、GB28181 PS over RTP输出; 视频转换:Demux、Mux、Codec...

    我们在常用的安防监控、互联网视频直播等系统服务中,常常最主要的就那么几个环节:

    • 视频获取:RTSP源、SDK源、GB28181源;
    • 视频输出:RTMP推流、SDK推流、GB28181 PS over RTP输出;
    • 视频转换:Demux、Mux、Codec、Snap、Info等等;

    今天,我们着重讲解的是视频输出中的RTMP推流功能,这也是我们EasyNVR功能组件中,最为重要的一个组成部分!
    EasyRTMP是一套封装了基础的RTMP推流协议,并提供了一套非常简单易用调用接口的功能组件,在Github上有多个基于EasyRTMP SDK的Demo。Github地址:https://github.com/EasyDSS/EasyRTMP, Demo中EasyRTMP_RTSP项目是将RTSP流获取到本地进行RTMP推送,可进行RTMP直播。

    RTSP视频源进行RTMP直播:EasyRTMP_RTSP

    目前市面上的安防设备,现有的以及未来的,基本都是RTSP协议输出格式,且为被动拉流才能从设备获取到音视频流,更不用说直接推流到RTMP流媒体服务器或者CDN了。

    在:https://github.com/EasyDSS/EasyRTMP EasyRTMP_RTSP Demo中通过libEasyRTSPClient库将RTSP数据流获取回调,再将获取来的音视频数据送给libEasyRTMP进行RTMP推送。如果获取来的数据不是AAC格式,而是G711、G726、PCM等格式,使用EasyDarwin团队提供的开源的EasyAACEncoder将音频数据转换成AAC格式再推送。这样可以实现将RTSP视频源实时的进行RTMP协议直播。

    /* EasyRTSPClient获取数据后回调给上层 */
    int Easy_APICALL __RTSPSourceCallBack( int _chid, void *_chPtr, int _mediatype, char *pbuf, RTSP_FRAME_INFO *frameinfo)
    {
    	if (NULL != frameinfo)
    	{
    		if (frameinfo->height==1088)		frameinfo->height=1080;
    		else if (frameinfo->height==544)	frameinfo->height=540;
    	}
    	Easy_Bool bRet = 0;
    	int iRet = 0;
    
    	//目前只处理视频
    	if (_mediatype == EASY_SDK_VIDEO_FRAME_FLAG)
    	{
    		if(frameinfo && frameinfo->length)
    		{
    			if( frameinfo->type == EASY_SDK_VIDEO_FRAME_I)
    			{
    				if(g_rtmpPusher.rtmpHandle == 0)
    				{
    					g_rtmpPusher.rtmpHandle = EasyRTMP_Create();
    
    					bRet = EasyRTMP_Connect(g_rtmpPusher.rtmpHandle, SRTMP);
    					if (!bRet)
    					{
    						printf("Fail to EasyRTMP_Connect ...\n");
    					}
    
    					EASY_MEDIA_INFO_T mediaInfo;
    					memset(&mediaInfo, 0, sizeof(EASY_MEDIA_INFO_T));
    					mediaInfo.u32VideoFps = 25;
    					mediaInfo.u32AudioSamplerate = 8000;
    					iRet = EasyRTMP_InitMetadata(g_rtmpPusher.rtmpHandle, &mediaInfo, 1024);
    					if (iRet < 0)
    					{
    						printf("Fail to InitMetadata ...\n");
    					}
    				}
    
    				EASY_AV_Frame avFrame;
    				memset(&avFrame, 0, sizeof(EASY_AV_Frame));
    				avFrame.u32AVFrameFlag = EASY_SDK_VIDEO_FRAME_FLAG;
    				avFrame.u32AVFrameLen = frameinfo->length;
    				avFrame.pBuffer = (unsigned char*)pbuf;
    				avFrame.u32VFrameType = EASY_SDK_VIDEO_FRAME_I;
    				avFrame.u32TimestampSec = frameinfo->timestamp_sec;
    				avFrame.u32TimestampUsec = frameinfo->timestamp_usec;
    				
    				iRet = EasyRTMP_SendPacket(g_rtmpPusher.rtmpHandle, &avFrame);
    				if (iRet < 0)
    				{
    					printf("Fail to EasyRTMP_SendH264Packet(I-frame) ...\n");
    				}
    				else
    				{
    					printf("I");
    				}
    			}
    			else
    			{
    				if(g_rtmpPusher.rtmpHandle)
    				{
    					EASY_AV_Frame avFrame;
    					memset(&avFrame, 0, sizeof(EASY_AV_Frame));
    					avFrame.u32AVFrameFlag = EASY_SDK_VIDEO_FRAME_FLAG;
    					avFrame.u32AVFrameLen = frameinfo->length-4;
    					avFrame.pBuffer = (unsigned char*)pbuf+4;
    					avFrame.u32VFrameType = EASY_SDK_VIDEO_FRAME_P;
    					avFrame.u32TimestampSec = frameinfo->timestamp_sec;
    					avFrame.u32TimestampUsec = frameinfo->timestamp_usec;
    					iRet = EasyRTMP_SendPacket(g_rtmpPusher.rtmpHandle, &avFrame);
    					if (iRet < 0)
    					{
    						printf("Fail to EasyRTMP_SendH264Packet(P-frame) ...\n");
    					}
    					else
    					{
    						printf("P");
    					}
    				}
    			}				
    		}	
    	}
    	else if (_mediatype == EASY_SDK_AUDIO_FRAME_FLAG)
    	{
    		EASY_AV_Frame	avFrame;
    		memset(&avFrame, 0x00, sizeof(EASY_AV_Frame));
    		avFrame.u32AVFrameFlag = EASY_SDK_AUDIO_FRAME_FLAG;
    		avFrame.u32TimestampSec = frameinfo->timestamp_sec;
    		avFrame.u32TimestampUsec = frameinfo->timestamp_usec;
    
    		if(frameinfo->codec == EASY_SDK_AUDIO_CODEC_AAC)
    		{
    			avFrame.pBuffer = (Easy_U8*)(pbuf);
    			avFrame.u32AVFrameLen  = frameinfo->length;	
    			printf("*");
    			iRet = EasyRTMP_SendPacket(g_rtmpPusher.rtmpHandle, &avFrame);
    		}
    		else if ((frameinfo->codec == EASY_SDK_AUDIO_CODEC_G711A) || (frameinfo->codec == EASY_SDK_AUDIO_CODEC_G711U) || (frameinfo->codec == EASY_SDK_AUDIO_CODEC_G726))
    		{
    			if(EasyInitAACEncoder(frameinfo) == 0)
    			{
    				memset(g_rtmpPusher.m_pAACEncBufer, 0, 64*1024);
    				unsigned int iAACBufferLen = 0;
    
    				if(Easy_AACEncoder_Encode(g_rtmpPusher.m_pAACEncoderHandle, (unsigned char*)pbuf,  frameinfo->length, g_rtmpPusher.m_pAACEncBufer, &iAACBufferLen) > 0)
    				{
    					printf("*");
    					avFrame.pBuffer = (Easy_U8*)(g_rtmpPusher.m_pAACEncBufer);
    					avFrame.u32AVFrameLen  = iAACBufferLen;	
    					iRet = EasyRTMP_SendPacket(g_rtmpPusher.rtmpHandle, &avFrame);
    				}
    			}
    		}
    	}
    
    	return 0;
    }
    
    

    接收RTMP推流并进行RTMP/FLV/HLS/RTSP同步输出:EasyDSS

    通常情况下,EasyRTMP推流到标准的RTMP流媒体服务器就能实现基础的RTMP、HLS(m3u8)直播功能,但,如果需要得到一个更好的直播输出效果,我们通常选择的是EasyDSS流媒体服务器,EasyDSS流媒体服务器解决方案是一套集流媒体点播、转码与管理、直播、录像、检索、时移回看于一体的一套完整的商用流媒体服务器解决方案,EasyDSS高性能RTMP流媒体服务器支持RTMP推流,同步输出HTTP、RTMP、HLS、HTTP-FLV、RTSP,支持推流分发/拉流分发,支持秒开、GOP缓冲、录像、检索、回放、录像下载、网页管理等多种功能,是目前市面上最合理的一款流媒体服务器!
    EasyNVR摄像机无插件直播

    获取更多信息

    邮件:support@easynvr.com

    WEB:www.EasyNVR.com

    Copyright © EasyNVR.com 2016-2019

    展开全文
  • 如今QQ成为中国网民喜欢通讯软件了,当年只有很简单的功能,经过发展升级变成了今天超级强大的功能了,当然还有类似国内通讯软件,如新浪UC软件等。90年代后期,互联网刚刚在中国开始普及时候,国外...

    Internet信使

     

    【摘要】 时下腾讯QQ即时通讯软件的应用如火如荼,只要上网的人都知道QQ,几乎得上网的人都拥有自己的QQ号甚至是多个,然而腾讯的前身是QICQ,走到今天算是一个不平凡的历史,当年她就是模仿外国的ICQ来的,由于版权原因最终才改为腾讯QQ的。如今QQ成为中国网民最喜欢的通讯软件了,当年只有很简单的功能,经过几年的发展升级变成了今天超级强大的功能了,当然还有类似的国内通讯软件,如新浪的UC软件等。

    90年代后期,互联网刚刚在中国开始普及的时候,国外的ICQ软件可算是全球的聊天软件的老大,比腾讯QQ要早,ICQ是英文“I seek you”的简称,中文意思是我找你。ICQ最大的功能就是即时信息交流,只要记得对方的号码,上网时可以呼他,无论他在哪里,只要他上网打开ICQ,人们就可以随时交流。ICQ源于以色列特拉维夫的Mirabils公司。改公司成立于19967月,也就是这个时候,互联网最出名,下载使用人数最多的免费软件ICQ诞生了。

    但是这些公司都只是提供软件的客户端程序免费下载,而不提供其服务器程序,因此对于与互联网连接的私有网络或局域网,这些软件就用不上了。下面的软件是基于C++语言设计的聊天程序,功能只有和腾讯QQ早期最初的功能类似。

     

     

     

    【关键词】 ICQ,腾讯QQ,通信软件,即时信息

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    目录

    问题描述及设计思路 3

    1.1问题描述 3

    1.2实现功能 3

    1.2.1服务器端功能 3

    1.2.2客户端功能 3

    1.3设计思路 4

    1.3.1总体架构思路 4

    1.3.2服务器端 4

    1.3.3客户端 4

    详细设计过程 4

    2.1程序总体架构图 4

    2.2通信协议设计 5

    2.2.1消息类型: 5

    2.2.2消息结构体设计 7

    2.2.3群留言信息结构设计 7

    2.3通信模块软件设计 7

    2.3.1注册模块 7

    2.3.2登录模块 7

    2.3.3下线模块 7

    2.3.4添加好友模块 7

    2.3.5好友聊天模块 7

    2.3.6删除好友模块 7

    2.3.7加入群模块 7

    2.3.8创建群模块 7

    2.3.9退出群模块 7

    2.3.10群聊模块 8

    2.3.11资源共享模块 8

    2.3.12资源下载模块 8

    2.4服务器界面模块设计 8

    2.4.1运行信息显示模块 8

    2.4.2群信息以及群成员显示模块 8

    2.4.3用户信息显示模块 8

    2.4.4其他功能模块 8

    2.5客服端界面模块设计 8

    2.5.1注册模块 8

    2.5.2登录模块 8

    2.5.3添加好友模块 8

    2.5.4单聊模块 8

    2.5.5群聊模块 8

    2.5.6加入群模块 8

    2.5.7创建群模块 8

    2.5.8资源共享模块 8

    2.5.9资源下载模块 8

    结论及体会 8

    3.1程序运行主界面 8

    3.1.1服务器 8

    3.1.2客服端 9

    3.2功能测试 9

    3.2.1登录测试 9

    3.2.2注册测试 9

    3.2.3添加好友测试 10

    3.2.4与好友聊天测试 10

    3.2.5加入群测试 10

    3.2.6创建群测试 10

    3.2.7文件传输测试 11

    3.2.8群聊测试 11

    3.2.9资源共享测试 11

    3.2.10文件收索及下载测试 11

    3.2.11服务器测试 12

    3.3体会 12

    3.3.1程序设计 12

    3.3.2文档编写 13

    附录 13

    附录A:服务器处理通信协议的源代码 13

    1.处理客户端连接消息 13

    2. 处理接收到的各种消息: 14

    附录B客户端处理通信程序: 32

    1. 作为本地服务器 33

    2.接受服务器端信息并处理程序: 33

    1. 带颜色的ListBox 47

    2. 客服端通信封装的类(关键代码) 50

    3. 客服端作为本地服务器封装的类(关键代码) 51

    参考文献 53

     

     

     

     

     

     

     

     

     

     

     

     

    一.问题描述及设计思路

    1.1问题描述

    模拟QQ即时聊天工具设计一套网络聊天应用程序按照C/S结构分别设计服务端程序和客户端程序。现在腾讯QQ的功能超级强大,要完全现实它的功能不是一两个人一两天能够完成的任务,基于时间和开发人员只有本人的情况下,所以选择一部分最常用的功能实现。设计的程序界面友好简单易用。

     

    1.2实现功能

    1.2.1服务器端功能

    服务器端主要功能就是通过图形界面来维护服务器的信息,包括服务器运行信息的即时显示;手动启动和停止服务器的运行;查看现有群以及每个群有的成员;查看所有注册用户以及是否在线;清除服务器信息;服务器后台运行;保存和加载服务器信息等。

    1.2.2客户端功能

    客服端主要实现的功能有:用户注册;用户登陆;用户下线;程序运行的动态信息显示;添加好友;和好友聊天;删除好友;加入群;创建群;退出群;群聊;资源共享;下载共享资源;文件传输;实时监听好友是否传输文件等。

    1.3设计思路

    1.3.1总体架构思路

    此程序要求设计客户端和服务器端,主要解决的问题就是客户端和服务器端的通信以及客户端和客户端的通信。因为涉及到通信的内容很多,例如登陆信息,注册信息,聊天信息等等。怎样识别不同的信息需要自己设计通信协议,及根据每次收到的信息的不同做相应的处理。所以自己定义了许多通信消息的类型,以便准确完成通信。

    1.3.2服务器端

    服务器运行开始等待客户端的登陆以及注册信息,当有客户端要求通信时,便对客户端信息做保存并更新服务器信息。对于每一个客服端都建立一个相应的通信套接字并实时异步监听客服端是否有动作。服务器端的主要作用就是维护客服端的信息以及中转必要的通信信息,例如对于客户添加好友,服务器端就需要转发客服端的求情信息到另外一个客户端。另外一点设计思路就是通过图形界面来操作服务器。

    1.3.3客户端

    客户端主要根据用户的使用信息即时相应消息,然后根据不同的信息发送不同的信息到服务器端,开始和服务器端通信。客户端在登录成功以后便建立自己的本地服务器,方便自己共享资源以及可以直接和好友聊天儿不必每次发送信息都需要通过服务器中转,一般情况下首次发送的信息由服务器中转,之后都是直接通信了。这样可以减少服务器端的负载,让服务器运行更稳定,以及支持更多的客服端数量。客服端需要实时监听好友是否上线的信息,如果好友上线了应该即时得到通知。同样客服端也实时显示程序运行的信息,这对于开发人员尤其关键和重要,因为可以根据这个来了解程序是否运行正常。

     

     

     

     

    二.详细设计过程

    2.1程序总体架构图

    2.2通信协议设计

    2.2.1消息类型:

    //消息类型

    enum MSGType

    enroll,check_name,login,add_friend,single_chat,group_chat,invalid_name,

    invalid_password,already_login,success,fail,establish_group,join_group,

    secede_group,single_chat_server,single_chat_client,single_chat_transfer,

    offline,client_list,group_list,member_list,server_address,full,leave_word,

    addfriend_exist,addfriend_error,offline_error, friend_data, group_data,

    addfriend_success, addfriend_fail, joingroup_success, joingroup_fail,

    secedegroup_success, secedegroup_fail, establishgroup_success,

    establishgroup_fail,delete_friend,search_file,search_return,search_null,

    down_file,declare_file,declare_success

    };

    每种消息具体说明如下:

    enroll: 用户注册

    check_name: 检查用户名是否可用

    login: 用户登陆

    add_friend 添加好友

    single_chat 单聊

    group_chat 群聊

    invalid_name 无效用户名

    invalid_password 无效的密码

    already_login 已近登陆

    success 成功

    fail 失败

    establish_group 建立群

    join_group 加入群

    secede_group 退出群

    single_chat_server 接收私聊时对方发送过来的信息

    single_chat_client 从服务器接收到好友的addr

    single_chat_transfer 从服务器接收到中转的信息

    offline 下线

    client_list 请求客户好友信息

    group_list 请求客户群信息

    member_list 请求群成员信息

    server_address 服务器地址

    leave_word 留言

    addfriend_exist 好友已经存在

    addfriend_error 添加好友出错

    offline_error 下线出错

    friend_data 好友数据

    group_data 群数据

    addfriend_success, 添加好友成功

    addfriend_fail 添加好友失败

    joingroup_success 加入群成功

    joingroup_fail 加入群失败

    secedegroup_success 退出群成功

    secedegroup_fail 退出群失败

    establishgroup_success:建立群成功

    establishgroup_fail 建立群失败

    delete_friend 删除好友

    search_file 收索文件

    search_return 收索返回

    search_null, 收索为空

    down_file 下载文件

    declare_file 共享文件

    declare_success 共享成功

    服务器和客户端就是通过这些信息类型来通信的。

    2.2.2消息结构体设计

    struct message

    {

    MSGType type; //消息类型

    char name[MaxNameContent + 1];//消息名称

    char msg[MaxMsgContent + 1]; //消息具体内容

    //重载复制操作符

    void operator =( const message& b)

    {

    type  =  b.type;

    strcpy(name, b.name);

    strcpy(msg, b.msg);

    }

    };

    每次客服端和服务器的通信都是发送这样的结构体数据信息。

    2.2.3群留言信息结构设计

    //群的留言1.群名,2.发言人名,3.发言内容,

    struct word

    {

    char groupName[MaxNameContent + 1];

    char clientName[MaxNameContent + 1];

    char leaveWord [MaxMsgContent + 1];

    //重载复制操作符

    void operator = (const word& b)

    {

    strcpy(groupName, b.groupName);

    strcpy(clientName, b.clientName);

    strcpy(leaveWord , b.leaveWord);

    }

    };

    2.3通信模块软件设计

    2.3.1注册模块

    客服端在填写好完整的注册信息以后就发送注册用户类型的消息到服务器端,服务器端接收到注册信息以后做相应的处理,如果成功就保存客户信息。如下图所示:

    2.3.2登录模块

    客服端发送登录信息到服务器端,服务器端根据用户名和密码检查是否成功登录,如果登录成功的话,就需要将客户的信息发送给客户端,具体有好友信息,用户加入的群信息等。如果登录成功客户端接收服务器发送给客服端的好友和群等信息并在界面中显示出来。如下图:

    2.3.3下线模块

    客服端发送下线请求的信息到服务器端,服务器端接到此信息以后把此用户状态改为离线。服务器端返回下线操作是否成功。如下图所示:

    2.3.4添加好友模块

    客户端可以请求服务器所用的用户信息并显示出来,客户端可以选择某一个用户向服务器端发送添加此用户为好友的信息。服务器接收到添加好友的信息以后查找被添加的用户,如果找到就发送一条有用户添加他为好友的信息,如果对方不在线服务器就直接返回一条此用户不在线的信息给添加好友的用户。如果被添加的用户在线并且接受请求,那么服务端就更新用户信息,将他们互相添加为好友信息。如下图:

    2.3.5好友聊天模块

    客服端选择一个好友向服务器发送聊天请求,服务器在他们没有互相建立以前中转他们的发送聊天信息。一旦他们建立连接以后服务器就不作用了。如果对方不存在就把信息存放起来,等到对方上线以后再转发给改用户就可以了。如下图:

    2.3.6删除好友模块

    客户端选择一个需要删除的好友,然后向服务器发送删除好友的信息,服务器接受到信息以后向对方发送删除好友的信息已通知对方,后然更新服务器信息,解除次二人的好友关系。通知双方好友关系已解除。

     

    2.3.7加入群模块

    此模块的设计同添加好友模块类似。

    2.3.8创建群模块

    这个模块的功能和用户注册模块类似,不详细叙述了。

    2.3.9退出群模块

    此模块的设计同删除好友模块类似。

    2.3.10群聊模块

    此模块的设计同聊天模块类似,只不过是以群为单位开始聊天,同样没有在线的用户就以后登录接收到此聊天信息。

    2.3.11资源共享模块

    客服端作为本地服务器可以共享资源,共享的资源在服务器端由记录。当其他好友收索到共享的资源以后就可以下载了。

    2.3.12资源下载模块

    每个用户可以登录以后可以收索有哪些共享资源,并且可以下载到本地。

    2.4服务器界面模块设计

    2.4.1运行信息显示模块

    此功能在程序中的各个模块中都有涉及到,每次服务器的操作信息动态的显示到界面中来就可以了。此功能模块有助于程序员了解服务器程序是否运行正常。

    2.4.2群信息以及群成员显示模块

    将所有的群都显示到列表框中,在单击每一个群的时候在另一个列表框中显示此群有哪些成员用户。

    2.4.3用户信息显示模块

    根据用户是都在线分别显示所有用户的情况,在线的用户显示到在线的列表框,离线的显示在离线对话框。

    2.4.4其他功能模块

    其他的很多按钮功能,点击某一个按钮实现相应的功能。主要有启动和停止运行服务器;保存服务器现在的信息到数据文件,从数据文件加载服务器信息;以及清空服务器信息等。

    2.5客服端界面模块设计

    2.5.1注册模块

    需要填写用户名和密码,可以发送注册信息。

    2.5.2登录模块

    根据填写的用户名和密码发送登录信息,可以调用注册模块注册。

    2.5.3添加好友模块

    从服务器端获取所有用户并显示用户信息到列表框中,选中某一用户发送请求。

    2.5.4单聊模块

    能够发送聊天信息并且查看聊天记录信息,还可以传输文件信息。

    2.5.5群聊模块

    此模块功能同单聊模块,界面上对一个参与聊天的用户列表,没有文件传送功能。

    2.5.6加入群模块

    同添加好友模块。

    2.5.7创建群模块

    同用户注册模块。

    2.5.8资源共享模块

    能够将本地文件共享并显示文件相关信息到列表框中。

    2.5.9资源下载模块

    能够收索已经共享的文件并且显示出每一个文件的相关信息。

    三.结论及体会

    3.1程序运行主界面

    3.1.1服务器

    3.1.2客服端

    3.2功能测试

    3.2.1登录测试

    登录界面如下:

    登录成功界面如下:

    3.2.2注册测试

    3.2.3添加好友测试

    3.2.4与好友聊天测试

    3.2.5加入群测试

    3.2.6创建群测试

    3.2.7文件传输测试

    3.2.8群聊测试

    3.2.9资源共享测试

    3.2.10文件收索及下载测试

    3.2.11服务器测试

    通过上面那么多的测试,服务器端都记录了他们的信息,如下截图可知:

    3.3体会

    3.3.1程序设计

    通过本软件的设计与开发使自己体会很多,现简单的总结如下:

    首先在开始编写程序以前需要思考很多,比如考虑需要实现哪些功能,考虑使用哪一种IO模型。这些对于后面程序的设计以及开发都是相当重要的,如果很多需求前期没有做好,后面返工的可能性很大,而且更加麻烦。所以前期的分析暂用了很多时间,但是这些都是很必要的。

    在实际程序的编写过程中遇到的问题更多,因为通信程序设计涉及到客服端和服务器端,不论从开发的模式和调试的难度都比一般的程序更具挑战度。因为你编程的时候不仅仅只需要考虑能不能正常运行,还必须考虑服务器和客服端是否能够真正的通信,而且保证是正确的。可能调试通信用的时间比本身写程序用的时间更多。因为有时间很难找到不能正确通信的原因。比如说,明明发送方正确发送了信息,客户端就是没有收到,或者是明明发送了4次信息,但是对方却只收到一条或2条信息,这个时候就必须认真考虑出现这种情况的可能信息,就是在连续发送的时候,对方是不是收到一条信息以后就处理信息去了,后面的信息就没有接受到。当再次接收的时候已经发送完毕了,所以接收信息不完整。这样的情况很多,遇到一次问题就是锻炼自己的一次机会,所以我就在遇到问题的时候静下心来慢慢分析,把解决问题当成不仅仅是锻炼自己的机会,更把这个当做自己最快乐的事情来对待。这是为什么了?那是因为解决问题以后的那种激动心情和成就感。每个人做自己已经会的事大家都觉得很平常,但是当你做一件你本来就不会的事,但是你却做成功了,这说明学到了东西并且完成了任务。所以困难是一定能够战胜的。

    随着功能的慢慢实现,对程序的感觉越来越好,后面的功能就更快的实现了。这说明做什么事情都需要投入,只有万分的投入才能真正的找到感觉。

    3.3.2文档编写

    虽然很久以前自己就开始有写文档的意识,但是以前写的都是注重技术性问题的解决的文档,像本次这么完成的文档还是很少自己写到。其实很多人都认识到写设计文档的重要性,但是很少有人去真正做到。特别是对于我们还是在校生,因为这些任务都不是必须的。很多人做一个项目只注重项目功能的显示,至于具体怎么实现可能很多人都没有开始前仔细去想过。反正根据需要完成的功能去一步步做就是了。前期的设计根本无从谈起,但是基本上项目最后的功能都能够实现。这是因为在校生做的项目都是比较小,而且经不起检验和扩展的。作为大型的项目这样做基本上就是等于失败,在前一段时间我带领我的团队(都是在校大学生,我也是)一个相对大型一些的一个项目,由于缺乏前期数据库的设计和整体功能的软件架构设计。几乎做到还不到三分之一大家都做不下去了,因为大家都在不停的改动数据库。网络通信功能根本还没有谈起,当然这个项目最终就这样不了了之了。因为后面大家时间都很忙,就放弃这个项目了。从这一点可以看出,锻炼每一个人的分析分析和前期软件设计的能力是多么的重要,更重要的是体现单把具体的设计文档化吗,这样便于大家讨论后修改,这也是后期真正软件开发的基石和根据。以上就是对于此次写文档的体会吧。

    四.附录

    附录A:服务器处理通信协议的源代码

    1.处理客户端连接消息

    LRESULT CQQServerDlg::OnAccept(WPARAM wParam, LPARAM lParam)

    {

    if (WSAGETSELECTEVENT(lParam) == FD_ACCEPT)

    {

    int len = sizeof(sockaddr_in);

    m_acceptedSocket = accept(m_localSocket, (sockaddr*)&m_tempAddr, &len);

    if (m_acceptedSocket == INVALID_SOCKET)

    {

    MessageBox("接受套接字时出错", "错误");

    return -1L;

    }

    WSAAsyncSelect(m_acceptedSocket, m_hWnd, WM_READ, FD_READ|FD_CLOSE);

    }

    return 0L;

    }

    2.处理接收到的各种消息:

    LRESULT CQQServerDlg::OnRead(WPARAM wParam, LPARAM lParam)

    {

    int i, j, k; //辅助计数变量

    CEdit* pEdit;

    BOOL bExist = FALSE;

    SOCKET sClient = (SOCKET)wParam;

    int iTempNum;

    switch (WSAGETSELECTEVENT(lParam))

    {

    case FD_READ:

    if(recv(sClient, (char*)&m_recvData, sizeof(message), 0) == SOCKET_ERROR)

    {

    MessageBox("读取用户信息时出错", "错误");

    return -1L;

    }

    switch (m_recvData.type)

    {

    case enroll: //用户注册

    if (m_iClientNum < MaxClient) //数目尚未超过可以供注册的数目

    {

    bExist = FALSE;

    for (i=0 ; i<m_iClientNum; i++) //搜索是否存在同名

    {

    if(strcmp(m_cArrClient[i], m_recvData.name) == 0 )

    {

    bExist = TRUE;

    break;

    }

    }

    if (!bExist) //没有同名时……

    {

    strcpy(m_cArrClient[m_iClientNum], m_recvData.name);

    strncpy(m_cArrPassword[m_iClientNum], m_recvData.msg, sizeof(m_cArrPassword[m_iClientNum]));

    m_sendData.type = success;

    //将注册成功消息发给新注册的用户

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0); m_sendData.type = enroll;

    strcpy(m_sendData.name, m_recvData.name);

    for (k=0; m_bArrOnline[k] && k<m_iClientNum; k++) //将新用户注册的信息发给每一个用户

    {

    send(m_arrClientSocket[k], (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    m_iClientNum++; //客户数目加1

     

    //服务器信息更新

    m_strInfo += "新注册了一个用户!/r/n";

    m_strInfo += "该新用户名字是";

    m_strInfo += m_recvData.name;

    m_strInfo += "/r/n";

    UpdateData(FALSE);

    pEdit = (CEdit *)GetDlgItem(IDC_INFO);

    pEdit->LineScroll(pEdit->GetLineCount());

    update(); //更新一下资料

    }

    else

    {

    //当有同名时返回错误信息

    m_sendData.type = invalid_name;

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    }

    else

    {

    //数目超过可供注册的数目

    m_sendData.type = fail;

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    closesocket(sClient);

    break;

    case check_name:

    bExist = FALSE;

    for (i=0 ; i<m_iClientNum; i++ )  //搜索是否存在同名

    {

    if (strcmp(m_cArrClient[i], m_recvData.name) == 0)

    {

    bExist = TRUE;

    break;

    }

    }

    if (!bExist) //没有同名时……

    {

    m_sendData.type = check_name;

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0); //将注册成功消息发给新注册的用户

    }

    else

    {

    //当有同名时返回错误信息

    m_sendData.type = invalid_name;

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    break;

    case login:

    //搜索该账号是否存在

    for (j=0; strcmp(m_cArrClient[j], m_recvData.name)!=0 && j<m_iClientNum; j++)

    {

    ;

    //没有该账号

    if (j == m_iClientNum )

    {

    m_sendData.type = invalid_name;

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    closesocket(sClient);

    break;

    }

    //密码错误

    if (strcmp(m_cArrPassword[j], m_recvData.msg) != 0)

    {

    m_sendData.type = invalid_password;

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    closesocket(sClient);

    break;

    }

    //已经登录

    if (m_bArrOnline[j])

    {

    m_sendData.type = already_login;

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    closesocket(sClient);

    break;

    }

    //将登录成功信息发送回给该请求客户端

    m_sendData.type = success;

    itoa(m_iArrHFriend[j][0], m_sendData.name, 10);//name里包含有好友数

    itoa(m_iArrHGroup[j][0], m_sendData.msg, 10);//msg里包含有群数

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    /*   编写将当前好友资料,拥有的群资料和留言发给该用户的代码   */

    //一个好友一条发送消息地发给客户端,客户端关掉wsaasyncselect功能后

    //用一个循环接收处理就行了

    Sleep(1000);

    for (k=1; k<=m_iArrHFriend[j][0]; k++)

    {

    m_sendData.type = friend_data;

    strcpy(m_sendData.name, m_cArrClient[m_iArrHFriend[j][k]]);

    //m_bArrOnline数组资料就合在msg里了

    itoa(m_bArrOnline[m_iArrHFriend[j][k]], m_sendData.msg, 10);

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    Sleep(10);

    }

    //这是将一个群名一条消息地发给客户端,同上理

    for(k=1; k<=m_iArrHGroup[j][0]; k++)

    {

    m_sendData.type = group_data;

    strcpy(m_sendData.name, m_cArrGroup[m_iArrHGroup[j][k]]);

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    Sleep(10);

    }

    //接下来是留言操作……

    m_sendData.type = leave_word;

    while (!m_arrClientWord[j].empty())

    {

    m_sendData = m_arrClientWord[j].front();

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    Sleep(10);

    m_arrClientWord[j].pop_front();

    }

    while (!m_arrGroupWord[j].empty())

    {

    m_sendData = m_arrGroupWord[j].front();

    send(sClient, (char*)&m_sendData,sizeof(m_sendData), 0);

    Sleep(10);

    m_arrGroupWord[j].pop_front();

    }

    m_bArrOnline[j] = TRUE;

    m_arrClientSocket[j] = sClient;

    //发送新用户登录信息给所有在线的该用户的好友

    m_sendData.type = login;

    strcpy(m_sendData.name, m_recvData.name);

    for (k=1 ; k<=m_iArrHFriend[j][0]; k++)

    {

    if(m_bArrOnline[m_iArrHFriend[j][k]])

    {

    send(m_arrClientSocket[m_iArrHFriend[j][k]], (char*)&m_sendData, sizeof(m_sendData), 0);

    Sleep(10);

    }

    }

     

    m_strInfo += "用户";

    m_strInfo += m_recvData.name;

    m_strInfo +="登录成功/r/n";

    update(); //更新一下资料

    UpdateData(FALSE);

    pEdit = (CEdit *)GetDlgItem(IDC_INFO);

    pEdit->LineScroll(pEdit->GetLineCount());

    break;

    case add_friend:

    bExist = FALSE;

    //根据用户名搜索对方序号

    for (i=0; strcmp(m_recvData.name, m_cArrClient[i])!=0 && i<m_iClientNum; i++)

    {

    ;

    }

    //根据socket来搜索主动方

    for (j= 0; sClient!=m_arrClientSocket[j] && j<m_iClientNum; j++)

    {

    }

    for(k=0; k<m_iArrHFriend[j][0]; k++) 

    {

    //判断是否已经存在于对方的好友列表中

    if (m_iArrHFriend[j][k] == i)

    {

    bExist = TRUE;

    }

    }

    //如果已经存在或者就是申请者本身或者对方不在线无法答复,返回相应失败信息

    if (bExist)

    {

    m_sendData.type = addfriend_exist;

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    break;

    }

    if (i == j || i == m_iClientNum)

    {

    m_sendData.type = addfriend_error;

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    break;

    }

    if (!m_bArrOnline[i])

    {

    m_sendData.type = offline_error;

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    break;

    }

    //若上面情况没有发生,发送加好友请求给对方

    m_sendData.type = add_friend;

    strcpy(m_sendData.name, m_cArrClient[j]);

    strcpy(m_sendData.msg, m_recvData.msg);

    send(m_arrClientSocket[i], (char*)&m_sendData, sizeof(m_sendData), 0);

    //等待对方答复,若成功则返回success,否则为fail

    //注意,客户端在返回该类信息时,name应该为自己的名字

    //msg为对方(请求加自己为好友的一方)的名字

    break;

    case addfriend_success:

    //答应,记录好友信息,返回成功信息

    //根据socket来搜索主动方

    for (i=0; sClient!=m_arrClientSocket[i] && i<m_iClientNum; i++)

    {

    }

    //根据用户名搜索请求方序号

    for (j=0; strcmp(m_recvData.name, m_cArrClient[j])!=0 && j<m_iClientNum; j++) 

    {

    ;

    }

    //加好友操作

    iTempNum = 0;

    iTempNum = m_iArrHFriend[j][0];

    iTempNum++;

    m_iArrHFriend[j][0] = iTempNum;

    m_iArrHFriend[j][iTempNum] = i;

    iTempNum = 0;

    iTempNum = m_iArrHFriend[i][0];

    iTempNum++;

    m_iArrHFriend[i][0] = iTempNum;

    m_iArrHFriend[i][iTempNum] = j;

    if (m_bArrOnline[j]) //若请求方还在线的话

    {

    m_sendData.type = addfriend_success;

    strcpy(m_sendData.name, m_cArrClient[i]);

    send(m_arrClientSocket[j], (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    break;

    case addfriend_fail:

    //被拒绝,什么不做地返回失败信息给对方

    //根据socket来搜索主动方

    for (i=0; sClient!=m_arrClientSocket[i] && i<m_iClientNum; i ++)

    {

    }

    //根据用户名搜索请求方序号

    for (j=0; strcmp(m_recvData.name, m_cArrClient[j])!=0 && j<m_iClientNum; j++) 

    {

    ;

    }

    if (m_bArrOnline[j]) //若请求方还在线的话

    {

    m_sendData.type = addfriend_fail;

    strcpy(m_sendData.name, m_cArrClient[i]);

    send(m_arrClientSocket[j], (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    break;

    case delete_friend://删除好友操作

    //根据Socket来搜索申请人名称

    for (i =0; sClient!=m_arrClientSocket[i] && i<m_iClientNum; i++)

    {

    ;

    }

    for (j=0; strcmp(m_recvData.name, m_cArrClient[j])!=0 && j<m_iClientNum; j++)

    {

    ;

    }

    //i中的好友j删除

    for (k=1; k<=m_iArrHFriend[i][0]; k++)

    {

    if (m_iArrHFriend[i][k] == j)

    {

    break;

    }

    }

    for(; k<m_iArrHFriend[i][0]; k++)

    {

    m_iArrHFriend[i][k] = m_iArrHFriend[i][k+1];

    }

    m_iArrHFriend[i][0]--;

    // 将删除好友的信息返回给用户

    m_sendData.type = delete_friend;

    strcpy(m_sendData.name, m_cArrClient[j]);

    send(m_arrClientSocket[i], (char*)&m_sendData,sizeof(m_sendData), 0);

    //如果j在线则通知j将好友i删除

    if (m_bArrOnline[j])

    {

    m_sendData.type = delete_friend;

    strcpy(m_sendData.name, m_cArrClient[i]);

    send(m_arrClientSocket[j], (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    //j中的好友i删除

    for (k=1; k<=m_iArrHFriend[j][0]; k++)

    {

    if(m_iArrHFriend[j][k] == i)

    {

    break;

    }

    }

    for (; k<m_iArrHFriend[j][0]; k++)

    {

    m_iArrHFriend[j][k] = m_iArrHFriend[j][k+1];

    }

    m_iArrHFriend[j][0]--;

    break;

    case server_address://客户端发送过来他作为服务器的sockaddr_in结构

    //根据用户名搜索对方序号

    for( i = 0; strcmp(m_recvData.name, m_cArrClient[i])!=0 && i<m_iClientNum; i++)

    {

    ;

    }

    memcpy(&m_arrClientAddr[i], m_recvData.msg, sizeof(sockaddr_in));

    break;

     

    case single_chat:

    //搜索被叫用户的序号

    for (j=0; strcmp(m_cArrClient[j], m_recvData.name)!=0 && j<m_iClientNum; j++)

    {

    ;

    }

    //搜索主叫用户的序号

    for (k=0; m_arrClientSocket[k]!=sClient; k++)

    {

    ;

    }

    if (m_bArrOnline[j])

    {

    //被叫用户在线操作

    //主动方操作

    m_sendData.type = single_chat_client;

    strcpy(m_sendData.name, m_recvData.name); // 被叫用户的名字

    memcpy(m_sendData.msg, &m_arrClientAddr[j], sizeof(sockaddr_in));// 被叫用户的addr

    send(sClient,(char*)&m_sendData, sizeof(m_sendData), 0);

     

    //被动方操作

    m_sendData.type = single_chat_client;

    strcpy(m_sendData.name, m_cArrClient[k]);// 主叫用户的名字

    memcpy(m_sendData.msg, &m_arrClientAddr[k], sizeof(sockaddr_in)); // 主叫用户的addr

    send(m_arrClientSocket[j], (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    else

    {

    //被叫用户离线操作

    m_sendData.type = single_chat_transfer;

    strcpy(m_sendData.name, m_recvData.name);

    strcpy(m_sendData.msg, "对方不在线,信息将通过服务器中转!/r/n/r/n");

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    break;

     

    case single_chat_transfer:

    //搜索被叫用户的序号

    for (j=0; strcmp(m_cArrClient[j], m_recvData.name)!=0 && j<m_iClientNum; j++)

    {

    ;

    }

    //搜索主叫用户的序号

    for (k=0; m_arrClientSocket[k]!=sClient; k++)

    {

    ;

    }

    strcpy(m_recvData.name, m_cArrClient[k]);

    m_arrClientWord[j].push_back(m_recvData);//保存被叫用户的信息,名字就是主叫用户

    break;

    case group_chat:

    //搜索发言人

    for (i=0; m_arrClientSocket[i]!=sClient && i<m_iClientNum; i++)

    {

    ;

    }

    //搜索群序号

    for (j=0; strcmp(m_cArrGroup[j], m_recvData.name)!=0 && j<m_iClientNum; j++)

    {

    ;

    }

    //对每个用户发信息

    for (k=1; k<=m_iArrMember[j][0]; k++ )

    {

    //如果用户在线

    if(m_bArrOnline[m_iArrMember[j][k]])

    {

    if (m_arrClientSocket[m_iArrMember[j][k]] != sClient)

    {

    send(m_arrClientSocket[m_iArrMember[j][k]], (char*)&m_recvData,sizeof(m_recvData), 0);

    }

    }

    else

    {

    //否则,用户离线,需要将该信息保存起来

    m_arrGroupWord[m_iArrMember[j][k]].push_back(m_recvData);

    }

    }

    break;

    case client_list://来自客户端的用户列表请求

     

    //首先发送client_list消息过去,让客户端确认人数

    m_sendData.type = client_list;

    for (i=0; i<m_iClientNum; i++)

    {

    strcpy(m_sendData.name, m_cArrClient[i]);

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0 );

    Sleep(10);

    }

    break;

    case group_list://来自客户端的群列表请求

    //首先发送group_list过去,让客户端确认人数,人数包含在name

    m_sendData.type = group_list;

    //然后发送group的名字过去

    for (i=0; i<m_iGroupNum; i++)

    {

    strcpy(m_sendData.name, m_cArrGroup[i]);

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    Sleep(10);

    }

    break;

    case member_list://来自客户端的群内成员列表请求

    //搜索该群序号

    for (i=0; strcmp(m_recvData.name, m_cArrGroup[i])!=0 && i<m_iGroupNum; i++)

    {

    }

    m_sendData.type = member_list;

    for (j=1; j<=m_iArrMember[i][0]; j++)

    {

    //一个成员一条消息地发给客户端

    strcpy(m_sendData.name, m_recvData.name);

    strcpy(m_sendData.msg, m_cArrClient[m_iArrMember[i][j]]);

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    Sleep(10);

    }

    break;

    case establish_group:

    if (m_iGroupNum < MaxGroup )

    {

    //判断是否存在同名群

    bExist = FALSE;

    for (i=0; i<m_iGroupNum; i++)

    {

    if (strcmp(m_cArrGroup[i], m_recvData.name) == 0)

    {

    bExist = TRUE;

    m_sendData.type = establishgroup_fail;

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    break;

    }

    }

    if (!bExist)

    {

    //若没有同名群,刚成功

    //搜索申请人

    for (i=0; m_arrClientSocket[i]!=sClient && i<m_iClientNum; i++)

    {

    ;

    }

    strcpy(m_cArrGroup[m_iGroupNum], m_recvData.name);

    m_iArrMember[m_iGroupNum][0] = 1;

    m_iArrMember[m_iGroupNum][1] = i; //新群内已有1人,就是该申请人

    //该申请人参加的群增加1个,群号是m_iGroupNum

    m_iArrHGroup[i][++m_iArrHGroup[i][0]] = m_iGroupNum;

    m_sendData.type = establishgroup_success;

    strcpy(m_sendData.name, m_recvData.name);

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

     

    //服务器信息更新

    m_strInfo += "用户";

    m_strInfo += m_cArrClient[i];

    m_strInfo += "建立了一个新群";

    m_strInfo += m_cArrGroup[m_iGroupNum];

    m_strInfo += "/r/n";

    m_iGroupNum++;

    UpdateData(FALSE);

    pEdit = (CEdit *)GetDlgItem(IDC_INFO);

    pEdit->LineScroll(pEdit->GetLineCount());

    }

    }

    update();//更新一下资料

    break;

    case join_group:

    //搜索该群序号

    for (i=0; strcmp(m_cArrGroup[i], m_recvData.name)!=0 && i<m_iGroupNum; i++)

    {

    ;

    }

    if (i < m_iGroupNum)

    {

    if (m_iArrMember[i][0] < MaxMember )

    {

    //群内人数未满

    bExist = FALSE;

    //搜索申请人

    for (j=0; m_arrClientSocket[j]!=wParam && j<m_iClientNum; j++)

    {

    ;

    }

    for (k=1; k<=m_iArrHGroup[j][0]; k++)

    {

    if (m_iArrHGroup[j][k] == i)

    {

    bExist = TRUE;

    break;

    }

    }

    if (!bExist)

    {

    //用户尚未加入该群

    //群更新资料发送到每位群内在线用户

    m_sendData.type = join_group;

    strcpy(m_sendData.name, m_cArrGroup[i]);

    strncpy(m_sendData.msg, m_cArrClient[j], sizeof(m_cArrClient[j]));

    for (k=1; k<=m_iArrMember[i][0]; k++)

    {

    if (m_bArrOnline[m_iArrMember[i][k]] && m_iArrMember[i][k] != j)

    {

    send(m_arrClientSocket[m_iArrMember[i][k]], (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    }

    m_iArrMember[i][0]++;

    m_iArrMember[i][m_iArrMember[i][0]] = j;

    m_iArrHGroup[j][++m_iArrHGroup[j][0]] = i;

    //服务器信息更新

    m_strInfo += "用户";

    m_strInfo += m_cArrClient[j];

    m_strInfo += "加入了群";

    m_strInfo += m_cArrGroup[i];

    m_strInfo += "/r/n";

    UpdateData(FALSE);

    pEdit = (CEdit *)GetDlgItem(IDC_INFO);

    pEdit->LineScroll(pEdit->GetLineCount());

    m_sendData.type = joingroup_success;

    strcpy(m_sendData.name, m_recvData.name);

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    else

    {

    //用户已经加入该群

    m_sendData.type = joingroup_fail;

    strcpy(m_sendData.name, m_recvData.name);

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    }

    else

    {

    //人数满了

    m_sendData.type = joingroup_fail;

    strcpy(m_sendData.name, m_recvData.name);

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    update();//更新一下资料

    }

    else

    {

    m_sendData.type = joingroup_fail;

    strcpy(m_sendData.name, m_recvData.name);

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    break;

     

    case secede_group:

    //搜索该群序号

    for (i=0; strcmp(m_cArrGroup[i], m_recvData.name)!=0 && i<m_iGroupNum; i++)

    {

    ;

    }

    //搜索申请人

    for (j=0; m_arrClientSocket[j]!=sClient && j<m_iClientNum; j++)

    {

    ;

    }

    //搜索申请人拥有的群中该群所在位置

    for (k=1; i!=m_iArrHGroup[j][k] && k<=m_iArrHGroup[j][0]; k++)

    {

    ;

    }

    // 该群组不存在或用户不属于该群组

    if (i==m_iGroupNum || i!= m_iArrHGroup[j][k])

    {

    m_sendData.type = secedegroup_fail;

    strcpy(m_sendData.name, m_recvData.name);

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    }

    else

    {

    for(; k<m_iArrHGroup[j][0]; k ++ )

    {

    m_iArrHGroup[j][k] = m_iArrHGroup[j][k+1];

    }

    m_iArrHGroup[j][0]--;

     

    //搜索该申请人在群内的序号

    for (k=1; k<=m_iArrMember[i][0] && m_iArrMember[i][k]!=j; k++)

    {

    ;

    }

    m_iArrMember[i][0]--;

     

    //服务器信息更新

    m_strInfo += "用户";

    m_strInfo += m_cArrClient[j];

    m_strInfo += "退出了群";

    m_strInfo += m_cArrGroup[i];

    m_strInfo += "/r/n";

    //当群还有用户存在的时候

    if (m_iArrMember[i] != 0)

    {

    for(; k<=m_iArrMember[i][0]; k++) 

    {

    m_iArrMember[i][k] = m_iArrMember[i][k+1];

    }

    //将用户退群信息发给所有该群的用户

    m_sendData.type = secede_group;

    strcpy(m_sendData.name, m_cArrGroup[i]);

    strcpy(m_sendData.msg, m_cArrClient[j]);

    for(k=1; k<=m_iArrMember[i][0]; k++)

    {

    send(m_arrClientSocket[m_iArrMember[i][k]],(char*)&m_sendData, sizeof(m_sendData), 0);

    }

    }

    else

    {

    //没有用户则删除该群

    m_iGroupNum--;

    for (k=i; k<m_iGroupNum; k++)

    {

    strcpy(m_cArrGroup[k], m_cArrGroup[ k+1]);

    }

    int temp[MaxGroup][MaxMember+1];//暂存成员数据

    memcpy(temp, m_iArrMember, sizeof(int)*(MaxGroup-k-1) * MaxMember);

    memcpy(&m_iArrMember[k][0] ,temp, sizeof(int)*(MaxGroup-k-1) * MaxMember);

     

    //服务器信息更新

    m_strInfo += "";

    m_strInfo += m_cArrGroup[i];

    m_strInfo += "由于没有用户存在而被取消了!/r/n";

    }

     

    将退群成功信息发送给该用户

    m_sendData.type = secedegroup_success;

    strcpy(m_sendData.name, m_recvData.name);

    send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    //ps:这里貌似也不需要了……

     

    UpdateData(FALSE);

    pEdit = (CEdit *)GetDlgItem(IDC_INFO);

    pEdit->LineScroll(pEdit->GetLineCount());

    update();//更新一下资料

    }

    break;

    case search_file:

    {

     int count = 0;

     //搜索文件

                 for (i=0; i<m_iClientNum; i++)

     {

     CString strFile(m_cArrFileShare[i]);

     CString strSearch(m_recvData.name);

     int nPos = strFile.Find(strSearch);

     if (nPos != -1)

     {

     m_sendData.type = search_return;

         strcpy(m_sendData.name, m_cArrClient[i]); // 拥有资源的客户端

     

     //CString s=L"offline";

     //memcpy(state,s,s.GetLength()*2);

     //memset(sendData.msg,0,sizeof(sendData.msg));//复制其名字

     if(m_bArrOnline[i])  //如果在线则发送IP地址过去,否则发送"offline"

     {

              memcpy(m_sendData.msg, &m_arrClientAddr[i], sizeof(sockaddr_in));// 

     }

     else

     {

     strcpy(m_sendData.msg, "offline");

     }

     

     

         send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

     count++;

     }

     }

     if (count == 0)

     {

     m_sendData.type = search_null;

                     send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

     }

    }

     break;

    case declare_file:

    //根据Socket来搜索声明人

    for( i = 0; wParam != m_arrClientSocket[i] && i<m_iClientNum; i++)

    {

    ;

    }

    strcpy(m_cArrFileShare[i], m_recvData.msg);

    m_sendData.type = declare_success;

                send(sClient, (char*)&m_sendData, sizeof(m_sendData), 0);

    break;

    default: 

    break;

    }

    break;

     

    //客户端下线操作

    case FD_CLOSE:

    //搜索下线用户的序号

    for (i=0; sClient!=m_arrClientSocket[i] && i<m_iClientNum; i++)

    {

    }

    if (i < m_iClientNum)

    {

    m_bArrOnline[i] = FALSE;

    closesocket(m_arrClientSocket[i]);

     

    m_sendData.type = offline;

    strcpy(m_sendData.name, m_cArrClient[i]);

    for (j=1; j<=m_iArrHFriend[i][0]; j++)

    {

    if(m_bArrOnline[m_iArrHFriend[i][j]])

    {

    if (send(m_arrClientSocket[m_iArrHFriend[i][j]], 

    (char*)&m_sendData, sizeof(m_sendData), 0) == SOCKET_ERROR)

    {

    AfxMessageBox("发送离线信息失败!");

    }

    }

    }

    m_strInfo += "用户";

    m_strInfo += m_cArrClient[i];

    m_strInfo += "下线了!/r/n";

    update();

    UpdateData(FALSE);

    pEdit = (CEdit *)GetDlgItem(IDC_INFO);

    pEdit->LineScroll(pEdit->GetLineCount());

    break;

    }

    }

    return 0L;

    }

     

    附录B客户端处理通信程序:

    1.作为本地服务器

    LRESULT CQQClientDlg::OnServerMessage(WPARAM wParam, LPARAM lParam)

    {

    // 此函数用于接收私聊时对方发送过来的信息

    SOCKET socket = (SOCKET)wParam;

    CEdit *output = NULL;

    int len;

    switch(lParam)

    {

    case FD_ACCEPT:

    socket = accept(m_server.m_hSocket, NULL, NULL);

    return 0;

    case FD_READ:

    len = recv(socket, (char*)&m_recvData, sizeof(m_recvData), 0);

    switch(m_recvData.type)

    {

    case single_chat_server:

    CString strname;

    strname = m_recvData.name ;

    m_singlechat_client = TRUE;

    m_singlechat_server = TRUE;

    m_singlechat_transfer = FALSE;

    m_singlechat_update = TRUE;

    // 判断是否弹出对话框

    OnFriendDlg(strname);

    }

    return 0;

     

    case FD_WRITE:

    return 0;

     

    case FD_CLOSE:

    return 0;

     

    default:

    return 0;

    }

    }

    2.接受服务器端信息并处理程序:

    LRESULT CQQClientDlg::OnClientMessage(WPARAM wParam, LPARAM lParam)

    {

    // 此函数用于接收从服务器发送过来的消息

    CEdit *pEdit = NULL;

    int len;

    CString strName;

    switch(lParam)

    {

    case FD_CONNECT:

    len = GetLastError();

    if(len != 0)

    {

    AfxMessageBox("Error in Connecting");

    }

    else

    {

    m_bInit = TRUE;

    m_bClient = TRUE;

    m_strShowText += "已连接到好友的服务器!/r/n";

    }

    return 0;

    case FD_READ:

    len = recv(m_client.m_hSocket, (char*)&m_recvData, MaxBuf, 0);

    // 获取发送方的名称

    strName = m_recvData.name ;

    switch(m_recvData.type)

    {

    // 从服务其接收到新用户注册的消息

    case enroll:

    {

    CString str = m_recvData.name;

    m_strShowText += "/r/n";

    m_strShowText += str;

    m_strShowText+="-注册了!/r/n";

    // 随时跟踪滚动条位置

    pEdit = (CEdit *)GetDlgItem(IDC_SHOWTEXT);

    pEdit->SetWindowText(m_strShowText);

    pEdit->LineScroll(pEdit->GetLineCount());

    }

    return 0;

    // 从服务器接收到好友上线的消息

    case login:

    {

    // 在客户端状态编辑框里显示

    m_strShowText += strName;

    m_strShowText += "-上线了!/r/n";

    // 随时跟踪滚动条位置

    pEdit = (CEdit *)GetDlgItem(IDC_SHOWTEXT);

    pEdit->SetWindowText(m_strShowText);

    pEdit->LineScroll(pEdit->GetLineCount());

     

    // listbox中修改好友状态

    int index = m_friendList.FindString(0, strName);

    m_friendList.DeleteString(index);

    m_friendList.AddString(strName, RGB(255, 0, 0));

    map<CString, BOOL>::iterator it = m_friendMap.find(strName);

    if (it != m_friendMap.end())

    {

    it->second = TRUE;

    }

    // 当正在和好友聊天(通过服务中转)修改状态

    // pFriendDlgMap中查找私聊的窗口是否打开

    map<CString, CFriendDlg*>::iterator itdlg = m_pFriendDlgMap.find(strName);

    if (itdlg != m_pFriendDlgMap.end())

    { // 私聊模式转换成非中转模式

    itdlg->second->m_bClient = FALSE;

    itdlg->second->m_bTransfer = FALSE;

     

    // 修改标题

    CString str;

    str = "与  聊天中";

    str.Insert(2, strName);

    str += " (在线)";

    itdlg->second->SetWindowText(str);

    // 提示好友上线了

    itdlg->second->m_strFriendrecv += "对方上线了自动建立连接!/r/n/r/n";

    itdlg->second->GetDlgItem(IDC_FRIENDRECV)->SetWindowText(itdlg->second->m_strFriendrecv);

    pEdit = (CEdit *)itdlg->second->GetDlgItem(IDC_FRIENDRECV);

    // 随时跟踪滚动条的位置

    pEdit->LineScroll(pEdit->GetLineCount());

     

    // 向服务器发送私聊的请求(即与对方建立连接)

    m_sendData.type = single_chat;

    strcpy(m_sendData.name, strName.GetBuffer(strName.GetLength()));

    strName.ReleaseBuffer();

    send(m_client.m_hSocket, (char*)&m_sendData, sizeof(m_sendData), 0);

    } // end if

    }

    return 0;

    // 从服务器接收到好友的数据

    case friend_data:

    {

    // 若好友在线则字体颜色为红色

    BOOL bOnline;

    bOnline = atoi(m_recvData.msg);

    if(bOnline)

    {

    m_friendList.AddString(strName, RGB(255, 0, 0));

    }

    else

    {

    m_friendList.AddString(strName);

    }

    // 将好友的资料添加到FriendMap

    m_friendMap.insert(make_pair(strName, bOnline));

    }

    return 0;

    // 从服务器接收到好友的数据

    case group_data:

    {

    CString strData;

    strData = "默认";

    m_groupMap.insert(make_pair(strName, strData));

    m_groupList.AddString(strName);

    }

    return 0;

    // 从服务器接收到添加好友后的返回值

    case addfriend_exist:

    {

    AfxMessageBox("该好友已存在!");

    }

    return 0;

    case addfriend_error:

    {

    AfxMessageBox("你加自己为好友了?或者无此用户");

    }

    return 0;

    case offline_error:

    {

    AfxMessageBox("该用户不在线");

    }

    return 0;

    // 从服务器接收到被要求添加好友的信息(被请求方)

    case add_friend:

    {

    CAddFriendAnwserDlg dlg;

    dlg.m_strAddFriendprName = strName;

    dlg.m_client = m_client;

    dlg.m_strAddFriendprContent = m_recvData.msg;

    dlg.DoModal();

    if (dlg.m_bAccept)

    {

    m_friendList.AddString(strName, RGB(255, 0, 0));

    m_friendMap.insert(make_pair<CString,BOOL>(strName, TRUE)); // 添加好友时,假定好友在线

    }

    }

    return 0;

    // 从服务器接收到添加好友成功的信息(请求方)

    case addfriend_success:

    {

    CString str;

    str = strName;

    str += " 接受了你的请求!";

    m_friendList.AddString(strName, RGB(255, 0, 0));

    // 加入到好友map

    m_friendMap.insert(make_pair<CString,BOOL>(strName, TRUE));

    AfxMessageBox(str);

    }

    return 0;

    // 从服务器接收到对方拒绝添加好友的信息

    case addfriend_fail:

    {

    CString str;

    str = strName;

    str += " 拒绝添加你为好友!";

    AfxMessageBox(str);

    }

    return 0;

    // 从服务器接收到删除好友的信息

    case delete_friend:

    {

    CString str;

    str = strName;

    str += "- 好友删除(你执行了该操作或对方执行了)!";

    AfxMessageBox(str);

    m_friendMap.erase(strName);

    int index;

    index = m_friendList.FindString(0, strName);

        m_friendList.DeleteString(index);

    }

    return 0;

    // 从服务器接收到新用户加入群组

    case join_group:

    {

    CString str;

    str = m_recvData.msg;

    str += " 加入了群 - ";

    str += strName;

    str += "/r/n";

    CString strMemberName;

    strMemberName = m_recvData.msg;

    // 寻找对应的群并在打开的对话框中显示新用户加入的信息

    CGroupDlg *pGroupDlg = NULL;

    map<CString, CGroupDlg*>::iterator it_dlg = m_pGroupDlgMap.find(strName);

    if (it_dlg != m_pGroupDlgMap.end())

    {

    pGroupDlg = it_dlg->second;

    }

    if (pGroupDlg != NULL)

    {

        pGroupDlg->m_strGroupRecv += str;

    pGroupDlg->GetDlgItem(IDC_GROUPRECV)->SetWindowText(pGroupDlg->m_strGroupRecv);

    pEdit = (CEdit *)pGroupDlg->GetDlgItem(IDC_GROUPRECV);

    // 随时跟踪滚动条的位置

    pEdit->LineScroll(pEdit->GetLineCount());

    pGroupDlg->m_groupMemberList.AddString(strMemberName);

    }

    }

    return 0;

    //从服务器接收到加入群组请求后的返回信息

    case joingroup_success:

    {

    CString str;

    str = "群 - ";

    str += strName;

    str += " 加入成功!";

    m_groupList.AddString(strName);

    // GroupMap中加入

    m_groupMap.insert(make_pair(strName, CString("默认")));

    AfxMessageBox(str);

    }

    return 0;

    case joingroup_fail:

    {

    CString str;

    str = "群 - ";

    str += strName;

    str += " 加入失败!";

    str += m_recvData.msg;

    AfxMessageBox(str);

    }

    return 0;

    // 从服务器接收到新建群组后的返回信息

    case establishgroup_success:

    {

    CString str;

    str = "群 - ";

    str += strName;

    str += " 创建成功!";

    m_groupList.AddString(strName);

    // GroupMap中加入

    m_groupMap.insert(make_pair(strName, CString("默认")));

    AfxMessageBox(str);

    }

    return 0;

    case establishgroup_fail:

    {

    CString str;

    str = "群 - ";

    str += strName;

    str += " 创建失败! ";

    str += m_recvData.msg;

    AfxMessageBox(str);

    }

    return 0;

    // 从服务器接收到某用户退出群组

    case secede_group:

    {

    CString str;

    str = m_recvData.msg;

    str += " 退出了群 - ";

    str += strName;

    str += "/r/n";

    CString strMemberName;

    strMemberName = m_recvData.msg;

     

    // 寻找对应的群并在打开的对话框中显示用户退出的信息

    CGroupDlg *pGroupDlg = NULL;

    map<CString, CGroupDlg*>::iterator it_dlg = m_pGroupDlgMap.find(strName);

    if (it_dlg != m_pGroupDlgMap.end())

    {

    pGroupDlg = it_dlg->second;

    }

     

    if (pGroupDlg != NULL)

    {

        pGroupDlg->m_strGroupRecv += str;

    pGroupDlg->GetDlgItem(IDC_GROUPRECV)->SetWindowText(pGroupDlg->m_strGroupRecv);

    pEdit = (CEdit *)pGroupDlg->GetDlgItem(IDC_GROUPRECV);

    // 随时跟踪滚动条的位置

    pEdit->LineScroll(pEdit->GetLineCount());

     

    int index = pGroupDlg->m_groupMemberList.FindString(0, strMemberName);

    pGroupDlg->m_groupMemberList.DeleteString(index);

    }

    }

    return 0;

    // 从服务器接收到退出群组后的返回信息

    case secedegroup_success:

    {

    CString str;

    str = "群 - ";

    str += strName;

    str += " 退出成功!";

    // listbox中删除相应的字符串

    int index;

    index = m_groupList.FindString(0, strName);

        m_groupList.DeleteString(index);

    // 寻找对应的群关闭窗口

    CGroupDlg *pGroupDlg = NULL;

    map<CString, CGroupDlg*>::iterator it_dlg = m_pGroupDlgMap.find(strName);

    if (it_dlg != m_pGroupDlgMap.end())

    {

    pGroupDlg = it_dlg->second;

    }

    if (pGroupDlg != NULL)

    {

    pGroupDlg->PostMessage(WM_CLOSE, 0, 0);

    }

     

    // GroupMap中删除

    m_groupMap.erase(strName);

    AfxMessageBox(str);

    }

    return 0;

     

    case secedegroup_fail:

    {

    CString str;

    str = "群 - ";

    str += strName;

    str += " 退出失败!";

    AfxMessageBox(str);

    }

    return 0;

    // 从服务器接收到群的成员资料

    case member_list:

    {

    // 在存储对话框搜索是否存在strname对应的对话框即判断对话框是否已经创建

    CGroupDlg* pGroupDlg = NULL;

    CString strMemberName;

    strMemberName = m_recvData.msg;

    map<CString, CGroupDlg*>::iterator it_dlg = m_pGroupDlgMap.find(strName);

    if (it_dlg != m_pGroupDlgMap.end())

    {

    pGroupDlg = it_dlg->second;

    }

     

    if (pGroupDlg != NULL)

    {

    pGroupDlg->m_groupMemberList.AddString(strMemberName);

    }

    }

    return 0;

    // 从服务器接收到成员列表

    case client_list:

    {

    m_pAddFriendDlg->m_clientList.AddString(strName);

    }

    return 0;

    // 从服务器接收到群组列表

    case group_list:

    {

    m_pJoinGroupDlg->m_groupList.AddString(strName);

    }

    return 0;

    // 从服务器接收到好友的addr

    case single_chat_client:

    {

    m_singlechat_client = TRUE;

    m_singlechat_server = FALSE;

    m_singlechat_transfer = FALSE;

    m_singlechat_update = FALSE;

     

    // 获取好友服务器的addr

    sockaddr_in addr;

    memcpy(&addr, m_recvData.msg, sizeof(sockaddr_in));

     

    // 将好友的addr添加到FriendAddrMap

    map<CString, sockaddr_in>::iterator it = m_friendAddrMap.find(strName);

    if (it == m_friendAddrMap.end())

    {

    m_friendAddrMap.insert(make_pair(strName, addr));

    }

    else

    {

    it->second = addr;

    }

    OnFriendDlg(strName);

    }

    return 0;

    // 从服务器接收到中转的信息

    case single_chat_transfer:

    {

    m_singlechat_client = FALSE;

    m_singlechat_server = FALSE;

    // 判断好友是否在线

    map<CString, BOOL>::iterator it = m_friendMap.find(strName);

    if (it != m_friendMap.end())

    {

    if (it->second) // 好友在线

    {

    m_singlechat_transfer = FALSE;

    }

    else 

    {

    m_singlechat_transfer = TRUE;

    }

    m_singlechat_update = TRUE;

    OnFriendDlg(strName);

    }

    }

    return 0;

    // 从私聊对方接收到私聊的信息

    case single_chat:

    m_singlechat_update = TRUE;

    OnFriendDlg(strName);

    return 0;

    // 接收到的为群聊的信息

    case group_chat:

    {

    m_groupchat_update = TRUE;

    OnGroupDlg(strName);

    }

    return 0;

    //搜索返回

    case  search_return:

    {

    //AfxMessageBox(L"Yeah~I have");

    CString strMsg = m_recvData.msg;//msg里存IP

    if (strcmp(m_recvData.msg, "offline") == 0)

    {

    m_pFileSearchDlg->m_fileList.AddString(strName);

    m_pFileSearchDlg->push(m_recvData.msg);

    }

    else

    {

    // AfxMessageBox(L"OnLine!");

     sockaddr_in Saddr;

     memcpy(&Saddr, m_recvData.msg, sizeof(sockaddr_in));

    //m_MyFriends.AddString(strname, RGB(255, 0, 0));

    m_pFileSearchDlg->m_fileList.AddString(strName,RGB(255, 0, 0));

     

    CString strIP = inet_ntoa(Saddr.sin_addr);

    //AfxMessageBox(strIP);

                    

    char wchIP[15];

    memset(wchIP, 0, sizeof(wchIP));

    memcpy(wchIP, strIP, strIP.GetLength());

    m_pFileSearchDlg->push(wchIP);

    }

    //m_FileSearchDlg

    }

    return 0;

    case  search_null:

    {

    AfxMessageBox("Oh~~No such file");

    }

    return 0;

    // 从服务器接收到好友的addr

    case declare_success:

    AfxMessageBox("声明成功!");

    return 0;

    // 从服务器接收到好友下线的信息

    case offline:

    {

    // 在主窗口的控件中显示相应信息

    CString str = m_recvData.name;

    m_strShowText += str;

    m_strShowText += "-下线了!/r/n";

    // 随时跟踪滚动条位置

    pEdit = (CEdit *)GetDlgItem(IDC_SHOWTEXT);

    pEdit->SetWindowText(m_strShowText);

    pEdit->LineScroll(pEdit->GetLineCount());

     

    // listbox中修改好友状态为离线

    int index = m_friendList.FindString(0, strName);

    m_friendList.DeleteString(index);

    m_friendList.AddString(strName);

     

    // FriendMap中修改好友状态

    map<CString, BOOL>::iterator itdata = m_friendMap.find(strName);

    if (itdata != m_friendMap.end())

    {

    itdata->second = FALSE;

    }

     

    // pFriendDlgMap中查找私聊的窗口是否打开

    map<CString, CFriendDlg*>::iterator it = m_pFriendDlgMap.find(strName);

    if (it != m_pFriendDlgMap.end())

    // 私聊模式转换成服务器中转模式

    it->second->m_bClient = FALSE;

    it->second->m_bTransfer = TRUE;

    it->second->m_client = m_client;

     

    // 修改标题

    CString strCaption;

    strCaption = "与  聊天中";

    strCaption.Insert(2, strName);

    strCaption += " (离线)";

    it->second->SetWindowText(str);

     

    // 修改窗口的ipport

    CString strIP("IP: ");

    strIP += m_strServerIP;

    strIP += "  Port: ";

    CString strPort;

    strPort.Format("%d", m_uPort);

    strIP += strPort;

    it->second->GetDlgItem(IDC_SHOWIP)->SetWindowText(strIP);

     

    // 显示下线信息

    it->second->m_strFriendrecv += "对方下线了信息通过服务器中转!/r/n/r/n";

    it->second->GetDlgItem(IDC_FRIENDRECV)->SetWindowText(it->second->m_strFriendrecv);

    pEdit = (CEdit *)it->second->GetDlgItem(IDC_FRIENDRECV);

    // 随时跟踪滚动条的位置

    pEdit->LineScroll(pEdit->GetLineCount());

     

    } // end if

     

    // FriendAddrMap中查找对方的addr

    map<CString, sockaddr_in>::iterator iter = m_friendAddrMap.find(strName);

    if (iter != m_friendAddrMap.end()) // 删除保存好友的addr

    {

    m_friendAddrMap.erase(strName);

    }

    } // end case

    return 0;

     

    } // end switch

    return 0;

    case FD_WRITE:

    return 0;

    case FD_CLOSE:

    if (wParam == m_client.m_hSocket) // 服务器下线

    {

    OnOffline();

    m_strShowText += "服务器关闭了!/r/n";

    // 随时跟踪滚动条位置

    pEdit = (CEdit *)GetDlgItem(IDC_SHOWTEXT);

    pEdit->SetWindowText(m_strShowText);

    pEdit->LineScroll(pEdit->GetLineCount());

    AfxMessageBox("服务器关闭了!");

    }

    return 0;

    default:

    if (wParam == m_client.m_hSocket) // 服务器下线

    {

    OnOffline();

    m_strShowText+="服务器关闭了!/r/n";

    // 随时跟踪滚动条位置

    pEdit = (CEdit *)GetDlgItem(IDC_SHOWTEXT);

    pEdit->SetWindowText(m_strShowText);

    pEdit->LineScroll(pEdit->GetLineCount());

    AfxMessageBox("服务器关闭了!");

    }

    pEdit = (CEdit *)GetDlgItem(IDC_SHOWTEXT);

    pEdit->SetWindowText("An network error has occured, the connection is dropped!/r/n");

    m_bInit = FALSE;

    return 0;

    }

    }

    附录C其他辅助类代码

    1.带颜色的ListBox

    void CColorListBox::DrawItem(LPDRAWITEMSTRUCT lpdis) 

    {

    if (GetCount() <= 0)

    {

    return;

    }

    if (lpdis->itemID < 0)

    {

    return; 

    }

    COLORREF cvText;

    COLORREF cvBack;

    CString itemString; 

    if ((lpdis->itemState & ODS_SELECTED) && // if item has been selected

    (lpdis->itemAction & (ODA_SELECT | ODA_DRAWENTIRE)))

    DrawFocusRect(lpdis->hDC, &lpdis->rcItem); 

    if (!(lpdis->itemState & ODS_SELECTED) && // if item has been deselected

    (lpdis->itemAction & ODA_SELECT))

    DrawFocusRect(lpdis->hDC, &lpdis->rcItem); 

    // get and display item text

    GetText(lpdis->itemID, itemString );

    if(lpdis->itemData) // if color information is present

    {

    cvText = SetTextColor(lpdis->hDC, lpdis->itemData);

    itemString += " (在线)";

    }

    else // if no color information, use default system colors

    {

    cvText = SetTextColor(lpdis->hDC, GetSysColor((lpdis->itemState & ODS_SELECTED)

    ? COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT)); 

    itemString += " (离线)";

    }

    // always use system colors for background

    cvBack = SetBkColor(lpdis->hDC, GetSysColor((lpdis->itemState & ODS_SELECTED)

    ? COLOR_HIGHLIGHT : COLOR_WINDOW)); 

     

    DrawText(lpdis->hDC, itemString, -1, &lpdis->rcItem, DT_LEFT | DT_SINGLELINE); 

     

    // restore DC colors

    SetTextColor(lpdis->hDC, cvText); 

    SetBkColor(lpdis->hDC, cvBack); 

    int CColorListBox::AddString( /*LPCTSTR*/CString lpszItem)

    {

    return ((CListBox*)this)->AddString(lpszItem);

    int CColorListBox::AddString(CString lpszItem,COLORREF rgb )

    {

    int item = AddString(lpszItem);

    if(item >=0)

    {

    SetItemData(item,rgb);

    }

    return item;

    int CColorListBox::InsertString( int nIndex, /*LPCTSTR*/CString lpszItem, COLORREF rgb)

    {

    int item = ((CListBox*)this)->InsertString(nIndex,lpszItem);

    if(item >=0)

    {

    SetItemData(item,rgb);

    }

    return item; 

     

    }

    2.客服端通信封装的类(关键代码)

    #define SER_MESSAGE WM_USER + 100

    #define CLI_MESSAGE WM_USER + 101

    BOOL CClient::InitAndConnect(HWND hwnd, UINT port, CString strserver)

    {

    m_hWnd = hwnd;

    m_uPort = port;

    m_strServer = strserver;

    if (m_hSocket != NULL)

    {

    // 如果原来打开这个套接字则先将其关闭

    //closesocket(m_hSocket);

    m_hSocket = NULL;

    }

    if (m_hSocket == NULL)

    {

    // 创建新的流套接字

    m_hSocket = socket(AF_INET, SOCK_STREAM, 0);

    ASSERT(m_hSocket != NULL);

    //ClientInit();

    if(WSAAsyncSelect(m_hSocket, hwnd, CLI_MESSAGE, FD_READ| FD_WRITE| FD_CLOSE| FD_CONNECT)>0)

    {

    AfxMessageBox("Error in select");

    }

    }

    // 准备服务器的信息这里需要指定服务器的地址

    in_addr.sin_family = AF_INET;

        char *pAnsi = m_strServer.GetBuffer(m_strServer.GetLength());

    m_strServer.ReleaseBuffer();

    in_addr.sin_addr.S_un.S_addr = inet_addr(pAnsi);

    in_addr.sin_port = htons(m_uPort); // 改变端口号的数据格式

     

    // 这里主动连接服务器

    int ret = 0;

    int error = 0;

    ret = connect(m_hSocket, (LPSOCKADDR)&in_addr, sizeof(in_addr));

    if(ret == SOCKET_ERROR)

    {

    // 连接失败

    if(GetLastError()!=WSAEWOULDBLOCK)

    {

    AfxMessageBox("请确认服务器已经打开并工作在同一端口!");

    return FALSE;

    }

    }

    return TRUE;

    }

    void CClient::SendString(CString a)

    {

    char *pAnsi = m_strServer.GetBuffer(m_strServer.GetLength());

    m_strServer.ReleaseBuffer();

    if(send(m_hSocket, pAnsi, strlen(pAnsi), 0) == SOCKET_ERROR)

    {

    AfxMessageBox("Client send data error");

    }

    }

     

    void CClient::GetString(CString &str)

    {

    char *pAnsi = new char[1024] ;

    recv(m_hSocket, pAnsi, 1024, MSG_DONTROUTE);

    str = pAnsi;

    delete []pAnsi;

    }

     

    void CClient::ClientInit()

    {

    if(WSAAsyncSelect(m_hSocket, m_hWnd, CLI_MESSAGE, FD_READ| FD_WRITE| FD_CLOSE| FD_CONNECT)>0)

    {

    AfxMessageBox("Error in select");

    }

    }

    3.客服端作为本地服务器封装的类(关键代码)

    #define SER_MESSAGE WM_USER + 100

    #define CLI_MESSAGE WM_USER + 101

    CServer::~CServer(void)

    {

    WSAAsyncSelect(m_hSocket, m_hWnd, 0, 0);

    }

    BOOL CServer::InitAndListen(HWND hwnd, UINT &port)

    {

    m_hWnd = hwnd;

    if (m_hSocket != NULL)

    {

    // 如果已经创建了套接字则先关闭原来的

    closesocket(m_hSocket);

    m_hSocket = NULL;

    }

    if (m_hSocket == NULL)

    {

    // 创建新的套接字这里创建的是流类型的套接字

    m_hSocket = socket(AF_INET, SOCK_STREAM, 0);

    ASSERT(m_hSocket != NULL);

    WSAAsyncSelect(m_hSocket, hwnd, SER_MESSAGE, FD_ACCEPT| FD_READ| FD_WRITE| FD_CLOSE);

    }

    int ret = SOCKET_ERROR;

    int error = 0;

     

    //  为新建的服务器寻找一个端口

    while(ret == SOCKET_ERROR)

    {

    in_addr.sin_family = AF_INET;

    in_addr.sin_addr.S_un.S_addr = INADDR_ANY;

    in_addr.sin_port = htons(port);

     

    // 绑定一个套接字到本机的地址

    ret = bind(m_hSocket, (LPSOCKADDR)&in_addr, sizeof(in_addr));

     

    if (ret != SOCKET_ERROR)

    {

    break;

    }

    port++;

    }

    if (ret == SOCKET_ERROR)

    {

    // 绑定错误

    AfxMessageBox("Binding Error");

    return FALSE;

    }

    // 开始监听等待客户连接

    ret = listen(m_hSocket, 100); // 第二个参数表示最多支持的客户连接数

    if (ret == SOCKET_ERROR)

    {

    // 监听失败

    AfxMessageBox("Listen Error");

    return FALSE;

    }

     

    return TRUE;

    }

    void CServer::ServerInit()

    {

    if(WSAAsyncSelect(m_hSocket, m_hWnd, SER_MESSAGE, FD_ACCEPT| FD_READ| FD_WRITE| FD_CLOSE) > 0)

    {

    AfxMessageBox("Select Error");

    }

    }

    五.参考文献

     

    展开全文
  • 我们在常用的安防监控、互联网视频直播等系统服务中,常常主要的就那么几个环节:视频获取:RTSP源、SDK源、GB28181源;视频输出:RTMP推流、SDK推流、GB28181 PS over RTP输出;视频转换:Demux、Mux、Codec、...

    我们在常用的安防监控、互联网视频直播等系统服务中,常常最主要的就那么几个环节:

    视频获取:RTSP源、SDK源、GB28181源;

    视频输出:RTMP推流、SDK推流、GB28181 PS over RTP输出;

    视频转换:Demux、Mux、Codec、Snap、Info等等;

    今天,我们着重讲解的是视频输出中的RTMP推流功能,这也是我们EasyNVR功能组件中,最为重要的一个组成部分!

    EasyRTMP是一套封装了基础的RTMP推流协议,并提供了一套非常简单易用调用接口的功能组件,在Github上有多个基于EasyRTMP SDK的Demo。Github地址:https://github.com/EasyDSS/EasyRTMP, Demo中EasyRTMP_RTSP项目是将RTSP流获取到本地进行RTMP推送,可进行RTMP直播。

    RTSP视频源进行RTMP直播:EasyRTMP_RTSP

    目前市面上的安防设备,现有的以及未来的,基本都是RTSP协议输出格式,且为被动拉流才能从设备获取到音视频流,更不用说直接推流到RTMP流媒体服务器或者CDN了。

    在:https://github.com/EasyDSS/EasyRTMP EasyRTMP_RTSP Demo中通过libEasyRTSPClient库将RTSP数据流获取回调,再将获取来的音视频数据送给libEasyRTMP进行RTMP推送。如果获取来的数据不是AAC格式,而是G711、G726、PCM等格式,使用EasyDarwin团队提供的开源的EasyAACEncoder将音频数据转换成AAC格式再推送。这样可以实现将RTSP视频源实时的进行RTMP协议直播。

    /* EasyRTSPClient获取数据后回调给上层 */

    int Easy_APICALL __RTSPSourceCallBack( int _chid, void *_chPtr, int _mediatype, char *pbuf, RTSP_FRAME_INFO *frameinfo)

    {

    if (NULL != frameinfo)

    {

    if (frameinfo->height==1088)frameinfo->height=1080;

    else if (frameinfo->height==544)frameinfo->height=540;

    }

    Easy_Bool bRet = 0;

    int iRet = 0;

    //目前只处理视频

    if (_mediatype == EASY_SDK_VIDEO_FRAME_FLAG)

    {

    if(frameinfo && frameinfo->length)

    {

    if( frameinfo->type == EASY_SDK_VIDEO_FRAME_I)

    {

    if(g_rtmpPusher.rtmpHandle == 0)

    {

    g_rtmpPusher.rtmpHandle = EasyRTMP_Create();

    bRet = EasyRTMP_Connect(g_rtmpPusher.rtmpHandle, SRTMP);

    if (!bRet)

    {

    printf("Fail to EasyRTMP_Connect ...n");

    }

    EASY_MEDIA_INFO_T mediaInfo;

    memset(&mediaInfo, 0, sizeof(EASY_MEDIA_INFO_T));

    mediaInfo.u32VideoFps = 25;

    mediaInfo.u32AudioSamplerate = 8000;

    iRet = EasyRTMP_InitMetadata(g_rtmpPusher.rtmpHandle, &mediaInfo, 1024);

    if (iRet < 0)

    {

    printf("Fail to InitMetadata ...n");

    }

    }

    EASY_AV_Frame avFrame;

    memset(&avFrame, 0, sizeof(EASY_AV_Frame));

    avFrame.u32AVFrameFlag = EASY_SDK_VIDEO_FRAME_FLAG;

    avFrame.u32AVFrameLen = frameinfo->length;

    avFrame.pBuffer = (unsigned char*)pbuf;

    avFrame.u32VFrameType = EASY_SDK_VIDEO_FRAME_I;

    avFrame.u32TimestampSec = frameinfo->timestamp_sec;

    avFrame.u32TimestampUsec = frameinfo->timestamp_usec;

    iRet = EasyRTMP_SendPacket(g_rtmpPusher.rtmpHandle, &avFrame);

    if (iRet < 0)

    {

    printf("Fail to EasyRTMP_SendH264Packet(I-frame) ...n");

    }

    else

    {

    printf("I");

    }

    }

    else

    {

    if(g_rtmpPusher.rtmpHandle)

    {

    EASY_AV_Frame avFrame;

    memset(&avFrame, 0, sizeof(EASY_AV_Frame));

    avFrame.u32AVFrameFlag = EASY_SDK_VIDEO_FRAME_FLAG;

    avFrame.u32AVFrameLen = frameinfo->length-4;

    avFrame.pBuffer = (unsigned char*)pbuf+4;

    avFrame.u32VFrameType = EASY_SDK_VIDEO_FRAME_P;

    avFrame.u32TimestampSec = frameinfo->timestamp_sec;

    avFrame.u32TimestampUsec = frameinfo->timestamp_usec;

    iRet = EasyRTMP_SendPacket(g_rtmpPusher.rtmpHandle, &avFrame);

    if (iRet < 0)

    {

    printf("Fail to EasyRTMP_SendH264Packet(P-frame) ...n");

    }

    else

    {

    printf("P");

    }

    }

    }

    }

    }

    else if (_mediatype == EASY_SDK_AUDIO_FRAME_FLAG)

    {

    EASY_AV_FrameavFrame;

    memset(&avFrame, 0x00, sizeof(EASY_AV_Frame));

    avFrame.u32AVFrameFlag = EASY_SDK_AUDIO_FRAME_FLAG;

    avFrame.u32TimestampSec = frameinfo->timestamp_sec;

    avFrame.u32TimestampUsec = frameinfo->timestamp_usec;

    if(frameinfo->codec == EASY_SDK_AUDIO_CODEC_AAC)

    {

    avFrame.pBuffer = (Easy_U8*)(pbuf);

    avFrame.u32AVFrameLen = frameinfo->length;

    printf("*");

    iRet = EasyRTMP_SendPacket(g_rtmpPusher.rtmpHandle, &avFrame);

    }

    else if ((frameinfo->codec == EASY_SDK_AUDIO_CODEC_G711A) || (frameinfo->codec == EASY_SDK_AUDIO_CODEC_G711U) || (frameinfo->codec == EASY_SDK_AUDIO_CODEC_G726))

    {

    if(EasyInitAACEncoder(frameinfo) == 0)

    {

    memset(g_rtmpPusher.m_pAACEncBufer, 0, 64*1024);

    unsigned int iAACBufferLen = 0;

    if(Easy_AACEncoder_Encode(g_rtmpPusher.m_pAACEncoderHandle, (unsigned char*)pbuf, frameinfo->length, g_rtmpPusher.m_pAACEncBufer, &iAACBufferLen) > 0)

    {

    printf("*");

    avFrame.pBuffer = (Easy_U8*)(g_rtmpPusher.m_pAACEncBufer);

    avFrame.u32AVFrameLen = iAACBufferLen;

    iRet = EasyRTMP_SendPacket(g_rtmpPusher.rtmpHandle, &avFrame);

    }

    }

    }

    }

    return 0;

    }

    接收RTMP推流并进行RTMP/FLV/HLS/RTSP同步输出:EasyDSS

    通常情况下,EasyRTMP推流到标准的RTMP流媒体服务器就能实现基础的RTMP、HLS(m3u8)直播功能,但,如果需要得到一个更好的直播输出效果,我们通常选择的是EasyDSS流媒体服务器,EasyDSS流媒体服务器解决方案是一套集流媒体点播、转码与管理、直播、录像、检索、时移回看于一体的一套完整的商用流媒体服务器解决方案,EasyDSS高性能RTMP流媒体服务器支持RTMP推流,同步输出HTTP、RTMP、HLS、HTTP-FLV、RTSP,支持推流分发/拉流分发,支持秒开、GOP缓冲、录像、检索、回放、录像下载、网页管理等多种功能,是目前市面上最合理的一款流媒体服务器!

    ca7abc7915b8c1e8538e0dba1ba3f251.png

    获取更多信息

    Copyright © EasyNVR.com 2016-2019

    展开全文
  • 入门学习Linux常用必会60命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    建议在/mnt里建几个/mnt/cdrom、/mnt/floppy、/mnt/mo等目录,当作目录专用挂载点。举例而言,如要挂载下列5个设备,其执行指令可能如下 (假设都是Linuxext2系统,如果是Windows XX请将ext2改成vfat): 软盘 ==...
  • 关系型数据库在互联网项目中应用极为广泛,今天小编就和大家分享几个数据库优化的几种方案: 建立索引 数据库优化第一步就是建立合理的索引,这也是初级的优化,也是DBA常用的优化方案!MySql索引类型有:普通索引...
  • HTML5大前端分享常用开发工具大集合 HTML5作为当前最为流行编程语言,广为适用。...随着每一新版本发布,HTML通过更好的功能和技术渐渐占据了制高点。接下来,就与大家着重分享种HTML5常见开发工具,...
  • 之前弄过一个门户系统,其最初每天只有百个用户会访问使用,后来在公司业务各种推广后,这个门户系统在高峰...例如一个对常用业务进行分析,很多时候,我们开发这个功能的时候,并没有考虑到其性能,尤其是在...
  • 随着每一新版本发布,HTML通过更好的功能和技术渐渐占据了制高点。接下来,好程序员就与大家着重分享种HTML5常见开发工具,供大家学习和参考。 第一种是Initializr——Initializr是制作HTML5网...
  • ABTest是所有互联网公司最常用,也是最有效对产品功能或策略效果进行测试方法。前天,算法工程师在1004分桶上,上了一rerank策略,现在想要分析一下这策略效果。通常情况下,我们报表平台,能够...
  • 随着每一新版本发布,HTML通过更好的功能和技术渐渐占据了制高点。接下来,好程序员就与大家着重分享种HTML5常见开发工具,供大家学习和参考。 第一种是Initializr——Initializr是制作HTML5网站入门...
  • 随着每一新版本发布,HTML通过更好的功能和技术渐渐占据了制高点。接下来,好程序员就与大家着重分享种HTML5常见开发工具,供大家学习和参考。 第一种是Initializr——Initializr是制作HTML5网站入门...
  • 微软推出Windows Phone平台是微软在移动互联网时代重量级产品,微软对于WindowsPhone7推广力度非常大,因此很多公司也开始进行Windows Phone7产品研发,2011年下半年Windows Phone7开发人员需求将会...
  • Elasticsearch作为这流行搜索引擎,越来越多的互联网企业都在采用它;作为java开发者来说,如果想进一步提高自己能力,同时也为了能够在实际工作中遇到搜索、存储问题多一解决方案,学习ES绝对大家工作、...
  • ASP只是一一般的引擎,具有支持多种语言的能力,不过默认的并且是最常用的还是VBScript。 mod_perl与Perl一样强大,只是更快一些。 二、PHP入门 PHP站点的在线教程已经很棒了。在那里还有一些其他教程的链接。...
  • 当在窗口中激活这个功能时“任何发生在这个窗口中事情都不会进入你计算机。”  多进程(Multiprocessing)  能容许多个程序同时执行而互不影响,每个网页标签将位于程序窗口外沿单独存在,当资源过高或崩溃...
  • 随着互联网的普及,搜索成为人们最常用的基本功能之一,但这背后的秘密是什么呢?近日,微软公司介绍了他们是其如何应对用户搜索习惯的改变,并开源了支撑 Bing 搜索背后的算法。 作者 |Charlie Waldburger 译者...
  • 【导读】随着互联网的普及,搜索成为人们最常用的基本功能之一,但这背后的秘密是什么呢?近日,微软公司介绍了他们是其如何应对用户搜索习惯的改变,并开源了支撑 Bing 搜索背后的算法。 作者 |Charlie ...
  • 迄今为止,微信月活跃用户接近6亿,称得是每智能手机用户最常用的应用,人人都说,微信是伟大的产品。现在微信作为一平台型的产品,集成了众多丰富的,能给用户带来不同功能和体验的模块和工具,已经成为了...
  • Elasticsearch作为这流行搜索引擎,越来越多的互联网企业都在采用它;作为java开发者来说,如果想进一步提高自己能力,同时也为了能够在实际工作中遇到搜索、存储问题多一解决方案,学习ES绝对大家工作、...
  • 媒体查询 CSS媒体查询允许开发者基于浏览网站的设备的特性来应用不同的样式申明,最常用的特性是视口宽度。 GCF 谷歌内嵌浏览器框架, 使用此插件,用户可以通过Internet Explorer的用户界面,以Chrome内核的渲染方式...
  • PGP是一基于RSA公钥加密体系加密软件,是开源且免费,后经互联网志愿者发展完善并广泛应用,具有如下特点:(1)选择可用加密算法作为系统构造模块,所用算法已被广泛检验过,相当安全;并将这些算法...
  • 腾讯早在几个月前就开发了 WebQQ ,这是一款十分优秀在线应用程序(Web App),将 Windows 版 QQ 中的常用功能搬到了互联网上,让你无须安装任何客户端只需要浏览器就能享受到不错聊天体验。而如果再配合最新版 ...
  • MySQL所使用 SQL 语言是用于访问数据库的最常用标准化语言。由于其体积小、速度快、总体拥有成本低,尤其是开放源码这一特点,一般中小型网站开发都选择 MySQL 作为网站数据库。 Python具有丰富和强大库。它常...
  • MySQL是一种开放源代码的关系型数据库管理系统(RDBMS),MySQL数据库系统使用最常用的数据库管理语言--结构化查询语言(SQL)进行数据库管理。 由于MySQL是开放源代码的,因此任何人都可以在General Public License...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 131
精华内容 52
关键字:

互联网最常用的几个功能