On this web site you would probably find every functionality that was put into this
application. I realize that. Hence I'm not going to post the source code just yet.
However, I've put it up here to see how much interest this application
would attract, specifically if there is any interest in the techniques
that I've used to implement it. I'm going to enumerate some of the
techniques in this short article. Let me know if there is anything of
interest to you and I will probably write up a separate article for whatever is requested.
This is a peer-to-peer communicator that allows you to chat
with a single person at a time and exchange files simultaneously.
Sockets, ..., sockets, ... Zzzzzap! (::) (Connection established)
A socket library built upon Berkley sockets was designed and implemented.
I've taken a well known approach of having an object package itself
into a stream on the sender's side and do the opposite on the receiver side.
Using the library above, a hierarchy of classes is introduced to accommodate the file transfer.
A set of classes encapsulate the threading/synchronization Windows API.
Each thread is responsible for handling logically separated functional
areas of the software. That is, I've introduced:
- A UI thread.
This thread is the MFC's main thread that handles all UI components.
This thread is a subscriber for event notifications from the rest of the threads.
- A couple of Listener threads.
One of which is to listen for incoming requests for the first connection with the remote party to be established.
Once the connection is up, another Listener is brought alive to await for any possible requests to send a file.
- A Sender thread.
This thread handles the file sending functionality.
- A Receiver thread.
This thread handles the file receiving functionality.
The Sender and Receiver threads notify the UI thread about the progress of the work
by adding notification events into the shared memory queue. The UI thread polls
the queue for the notifications every few milliseconds. This approach is good
enough for such a simple application, but if I was to have a lot of worker
(Hello Microsoft! :)) threads, I should have probably created a dedicated worker thread
which all it would do is to sit locked on the queue's mutex, until an event is added
and then do
UI_Thread::PostThreadMessage(), so that UI would have
much faster response to the application events.
I hope by now you're not yelling at the monitor, hoping that I might hear it
"Where is the Source Code?!". Well, honestly I don't believe that one can learn
a lot from a load of not very well documented source code. So if there are people
who want to know, let me know what part of this software would be of most interest to you and I'll come up with an article.
Well, after getting several emails with the source request, I figured I should probably give
it to the community :) Unfortunately I don't have time to explain all of the concepts of the NetLib that is included here, but
basically this library allows you in a limited form to marshal an arbitrary C++ object(s) across a network.
Some threading and synch classes are included and provider/consumer design pattern is applied for communicating
with the UI thread. As soon as I get a brake from work, I'll come up with a better article. Actually let me know
if there is a need for it.
Well happy coding to you, I hope this will be of some help.