Re: [Ring] GSoC Houmin

[Stepan Salenikovich]

Hi,
So, we just discussed some details about your project.

The main goal of the project is to have a sort of Ring client which
can run on various systems and is able to send and receive commands
which it then executes.

Some possible use cases:

 - A rpi with multiple cameras connected to it. The client receives
   commands via Ring to start a video call with some peer and then
   receives commands to switch from one camera to another.
 - An embedded system connected to various sensors. The client receives
   commands via Ring to start a program which monitors and logs those
   sensors and then possibly sends the data to some peer.

With these goals in mind, what we envision is not a C++ plugin in the
ring-daemon, but a separate client (like ring-client-gnome, for example)
which uses ring-daemon API (dring.h) to communicate with the daemon and
receive the commands via Ring text messages. Since we want something which
can potentially run on as many systems as possible, we want something as
lightweight as possible and with the fewest (maybe none at all) dependencies.
Thus it would not be like dringctrl python client which uses DBus, because
DBus is generally only available on GNU/Linux distros, and even then its very
possible to have a lightweight GNU/Linux system which was not built with dbus
support. Instead a C++ client would probably be the best choice, since C++ is
a portable language and it can call the dring.h interface directly. In general,
any system which can compile and run the ring-daemon should be able to compile
and run this client without any additional dependencies.

To do this, I think here is the list of high-level tasks, in order of priority:

 1. create simple client with a main loop (basically just a while loop) which
    can receive and send Ring text messages
    - should be as simple as possible; the Ring account can be created using
      another client and everything can be hardcoded
    - the only daemon events which need to handled are receiving a message
 2. decide on the protocol/format of the messages
    - something like JSON might be a good idea as we need to be able to easily
      expand the type of commands this client will accept
 3. build a simple way to send commands with this client
    - this could be a command line interface, or just maybe just a file with
      a list of commands which the client reads and sends and another instance
      of this client receives
    - the idea is to be able to simply test and demo this client
 4. build proof of concept command execution
    - ie: when a client receives one of these commands, the idea is that it
      executes it
    - this should be something simple but cool, something like placing a call
    - eg: client A sends client B a 'place call to X command', client B places
      a call to X

If we have the above working, it would already be something functional and cool
which can be then extended to be more robust and support more commands.

Depending on the pace of development, these could be some "stretch goals"

 - generalize and stabilize command execution architecture
   * what happens if we get an invalid command
   * what type of commands can we handle
   * what happens if its a complex ring-daemon command which is actually several
     commands which require waiting for a response
   * what happens if there is an error?
 - support a client configuration file
   * we probably don't want clients to accepts any command from anyone, we could
     have a list of RingIDs which the client will automatically trust
 - support account creation
   * when the client starts and no Ring account exists, it should create one

This is still up for discussion, so: comments, questions, suggestions?

-stepan

----- On May 10, 2017, at 11:45 AM, Houmin address@hidden wrote:

> Hi all,
> I am Houmin from Peking University of China (You can found me on IRC with
> the name Houmin)
> Thanks Ring community to accept my proposal of GSoC 2017. I am honored to
> be part of you.
> I will work for GNU on Ring this summer in Beijing, which is in UTC+8 h
> timezone.
> 
> Ring is not only a communication tool but also a building block for IoT
> project.
> 
> My job is to Create a C++ plugin for Ring to realize remote control by
> messaging.
> 
> I will accomplish the job by 2 parts
> - read the coming message and try to parse it
> - detect keyword and use Ring API to realize remote control
> 
> You can find my proposal here
> <https://docs.google.com/document/d/1h6LDPXjk6qsy9rvExVqjMoBGWhbn9CObpC-XFRWf_Kc/edit>
> for more information.
> 
> I am looking forward to this summer and feel great to work with you.
> 
> Houmin