[sharenote] add shared note app

Author: okay

src/rmkit/fb/fb.cpy

@@ -628,7 +628,7 @@ namespace framebuffer:
     int perform_redraw(bool):
       #ifndef PERF_BUILD
       msync(self.fbmem, self.byte_size, MS_SYNC)
-      self.draw_circle_filled(last_mouse_ev.x, last_mouse_ev.y, 4, 2, BLACK)
+      // self.draw_circle_filled(last_mouse_ev.x, last_mouse_ev.y, 4, 2, BLACK)
       self.save_png()
       #endif
       return 0

src/rmkit/ui/layouts.cpy

@@ -28,6 +28,10 @@ namespace ui:
         w->show()
       self.visible = true
 
+    void refresh():
+      for auto ch : children:
+        ch->dirty = 1
+
     // Layouts generally don't receive events
     bool ignore_event(input::SynMotionEvent &ev):
       return true

src/rmkit/ui/main_loop.cpy

@@ -235,7 +235,7 @@ namespace ui:
       if ev.x == -1 || ev.y == -1:
         return false
 
-      mouse_down := ev.left || ev.right || ev.middle
+      mouse_down := ev.left > 0 || ev.right > 0 || ev.middle > 0
 
       widgets := display_scene->widgets;
       for auto it = widgets.rbegin(); it != widgets.rend(); it++:

src/sharenote/Makefile

@@ -0,0 +1,4 @@
+include ../actions.make
+
+EXE=sharenote
+FILES=main.cpy

src/sharenote/main.cpy

@@ -0,0 +1,330 @@
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <iostream>
+#include "../build/rmkit.h"
+#include "../vendor/json/json.hpp"
+#include "../shared/string.h"
+
+#define BUF_SIZE 1024
+
+// TODO:
+// * implement TINIT
+// * implement latency calculation (while drawing?)
+// * implement room counter
+// * implement shared clear
+// * implement undrawing when server doesn't respond within time limit
+
+// message types
+#define TINIT "init"
+#define TJOIN "join"
+#define TDRAW "draw"
+#define TCLEAR "clear"
+
+using json = nlohmann::json
+
+HOST := getenv("HOST") ? getenv("HOST") : "rmkit.dev"
+PORT := getenv("PORT") ? getenv("PORT") : "65432"
+
+using PLS::Observable
+class AppState:
+  public:
+  Observable<bool> erase
+  Observable<string> room
+AppState STATE
+
+class JSONSocket:
+  public:
+  int sockfd
+  struct addrinfo hints;
+  struct addrinfo *result, *rp;
+  char buf[BUF_SIZE]
+  string leftover
+  deque<json> out_queue
+  std::mutex lock
+  deque<json> in_queue
+  const char* host
+  const char* port
+  bool _connected = false
+
+  JSONSocket(const char* host, port):
+    sockfd = socket(AF_INET, SOCK_STREAM, 0)
+    memset(&hints, 0, sizeof(struct addrinfo));
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_DGRAM;
+    hints.ai_flags = 0;
+    hints.ai_protocol = 0;
+    self.host = host
+    self.port = port
+    self.leftover = ""
+
+    new thread([=]() {
+      s := getaddrinfo(host, port, &hints, &result)
+      if s != 0:
+        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(s));
+        exit(EXIT_FAILURE);
+
+      self.listen()
+    })
+
+    new thread([=]() {
+      self.write_loop();
+    })
+
+  void write_loop():
+    while true:
+      if self.sockfd < 3:
+        debug "CANT WRITE TO SOCKET"
+        sleep(1)
+        continue
+
+      self.lock.lock()
+      if !self._connected:
+        // wait for listen() to reconnect
+        self.lock.unlock()
+        sleep(1)
+        continue
+
+      for (i:=0;i<self.in_queue.size();i++):
+        json_dump := self.in_queue[i].dump()
+        msg_c_str := json_dump.c_str()
+        ::send(self.sockfd, msg_c_str, strlen(msg_c_str), MSG_DONTWAIT)
+        ::send(self.sockfd, "\n", 1, MSG_DONTWAIT)
+      self.in_queue.clear()
+      self.lock.unlock()
+
+  void write(json &j):
+    self.lock.lock()
+    self.in_queue.push_back(j);
+    self.lock.unlock()
+
+  void listen():
+    bytes_read := -1
+    while true:
+      while bytes_read <= 0:
+        err := connect(self.sockfd, self.result->ai_addr, self.result->ai_addrlen)
+        if err == 0 || errno == EISCONN:
+            debug "(re)connected"
+            self.lock.lock()
+            self._connected = true
+            self.lock.unlock()
+            break
+        debug "(re)connecting...", err, errno
+        self.lock.lock()
+        close(self.sockfd)
+        self._connected = false
+        self.lock.unlock()
+        sleep(1)
+
+      bytes_read = read(sockfd, buf, BUF_SIZE-1)
+      if bytes_read <= 0:
+        if bytes_read == -1 and errno == EAGAIN:
+            continue
+
+          close(self.sockfd)
+          self.sockfd = socket(AF_INET, SOCK_STREAM, 0)
+          sleep(1)
+          continue
+      buf[bytes_read] = 0
+      sbuf := string(buf)
+      memset(buf, 0, BUF_SIZE)
+
+      msgs := str_utils::split(sbuf, '\n')
+      if leftover != "" && msgs.size() > 0:
+        msgs[0] = leftover + msgs[0]
+        leftover = ""
+      if sbuf[sbuf.length()-1] != '\n':
+        leftover = msgs.back()
+        msgs.pop_back()
+      for (i:=0; i!=msgs.size(); ++i):
+        try:
+            msg_json := json::parse(msgs[i].begin(), msgs[i].end())
+            lock.lock()
+            out_queue.push_back(msg_json)
+            lock.unlock()
+        catch(...):
+            debug "COULDNT PARSE", msgs[i]
+
+      ui::TaskQueue::wakeup()
+
+
+class Note: public ui::Widget:
+  public:
+  int prevx = -1, prevy = -1
+  framebuffer::VirtualFB *vfb
+  bool full_redraw
+  JSONSocket *socket
+
+  Note(int x, y, w, h, JSONSocket* s): Widget(x, y, w, h):
+    vfb = new framebuffer::VirtualFB(self.fb->width, self.fb->height)
+    vfb->clear_screen()
+    self.full_redraw = true
+    self.socket = s
+    self.mouse_down = false
+
+  void on_mouse_up(input::SynMotionEvent &ev):
+    prevx = prevy = -1
+
+  bool ignore_event(input::SynMotionEvent &ev):
+    return input::is_touch_event(ev) != NULL
+
+  void on_mouse_move(input::SynMotionEvent &ev):
+    width := STATE.erase ? 20 : 5
+    if prevx != -1:
+      vfb->draw_line(prevx, prevy, ev.x, ev.y, width, GRAY)
+      self.dirty = 1
+
+      json j
+      j["type"] = TDRAW
+      j["prevx"] = prevx
+      j["prevy"] = prevy
+      j["x"] = ev.x
+      j["y"] = ev.y
+      j["width"] = width
+      j["color"] = STATE.erase ? WHITE : BLACK
+
+      self.socket->write(j)
+
+    prevx = ev.x
+    prevy = ev.y
+
+  void render():
+    if self.full_redraw:
+      self.full_redraw = false
+      memcpy(self.fb->fbmem, vfb->fbmem, vfb->byte_size)
+      return
+
+    dirty_rect := self.vfb->dirty_area
+    for int i = dirty_rect.y0; i < dirty_rect.y1; i++:
+      memcpy(&fb->fbmem[i*fb->width + dirty_rect.x0], &vfb->fbmem[i*fb->width + dirty_rect.x0],
+        (dirty_rect.x1 - dirty_rect.x0) * sizeof(remarkable_color))
+    self.fb->dirty_area = vfb->dirty_area
+    self.fb->dirty = 1
+    framebuffer::reset_dirty(vfb->dirty_area)
+
+
+class EraseButton: public ui::Button:
+  public:
+  EraseButton(int x, y, w, h): Button(x, y, w, h, "erase"):
+    pass
+
+  void on_mouse_down(input::SynMotionEvent &ev):
+    STATE.erase = !STATE.erase
+    debug "SETTING ERASER TO", STATE.erase
+    self.dirty = 1
+    if STATE.erase:
+      self.text = "pen"
+    else:
+      self.text = "eraser"
+
+class RoomInput: public ui::TextInput:
+  public:
+
+  RoomInput(int x, y, w, h, JSONSocket *sock): TextInput(x, y, w, h, "default"):
+    self->events.done += PLS_LAMBDA(string &s):
+      self.join(s)
+    ;
+
+  void join(string room):
+    debug "SETTING ROOM TO", room
+    STATE.room = room
+
+
+class App:
+  public:
+  Note *note
+  JSONSocket *socket
+  ui::HorizontalLayout *button_bar
+
+  App():
+    demo_scene := ui::make_scene()
+    ui::MainLoop::set_scene(demo_scene)
+
+    fb := framebuffer::get()
+    fb->clear_screen()
+    fb->redraw_screen()
+    w, h = fb->get_display_size()
+
+    socket = new JSONSocket(HOST, PORT)
+    note = new Note(0, 0, w, h-50, socket)
+    demo_scene->add(note)
+
+    button_bar = new ui::HorizontalLayout(0, 0, w, 50, demo_scene)
+    hbar := new ui::VerticalLayout(0, 0, w, h, demo_scene)
+    hbar->pack_end(button_bar)
+
+    erase_button := new EraseButton(0, 0, 200, 50)
+    room_label := new ui::Text(0, 0, 200, 50, "room: ")
+    room_label->justify = ui::Text::JUSTIFY::RIGHT
+    room_button := new RoomInput(0, 0, 200, 50, socket)
+
+    button_bar->pack_start(erase_button)
+    button_bar->pack_end(room_button)
+    button_bar->pack_end(room_label)
+
+    STATE.room(PLS_DELEGATE(self.join_room))
+    room_button->join("default")
+
+
+  void join_room(string room):
+    // we are not connected to socket just yet
+    json j
+    j["type"] = TJOIN
+    j["room"] = room
+    socket->write(j)
+    // hit URL for downloading room image
+    url := "http://rmkit.dev:65431/room/" + room
+    room_file := "/tmp/room_" + room
+    curl_cmd := "curl " + url  + " > " + room_file
+    ret := system(curl_cmd.c_str())
+
+    if ret != 0:
+        debug "ERROR WITH CURL?"
+    else:
+        debug "DISPLAYING IMAGE"
+        self.note->vfb->load_from_png(room_file)
+        ui::MainLoop::full_refresh()
+
+  def handle_key_event(input::SynKeyEvent ev):
+    // pressing any button will clear the screen
+    if ev.key == KEY_LEFT:
+      debug "CLEARING SCREEN"
+      note->vfb->clear_screen()
+      ui::MainLoop::fb->clear_screen()
+      button_bar->refresh()
+
+  def handle_server_response():
+    socket->lock.lock()
+    for (i:=0; i < socket->out_queue.size(); i++):
+      j := socket->out_queue[i]
+      try:
+        if j["type"] == TDRAW:
+          note->vfb->draw_line(j["prevx"], j["prevy"], j["x"], j["y"], j["width"], j["color"])
+          note->dirty = 1
+          button_bar->refresh()
+        else if j["type"] == TCLEAR:
+          // TODO
+          pass
+        else:
+          debug "unknown message type"
+      catch(...):
+        debug "COULDN'T PARSE RESPONSE FROM SERVER", j
+    socket->out_queue.clear()
+    socket->lock.unlock()
+
+  def run():
+    ui::MainLoop::key_event += PLS_DELEGATE(self.handle_key_event)
+
+    while true:
+      self.handle_server_response()
+      ui::MainLoop::main()
+      ui::MainLoop::redraw()
+      ui::MainLoop::read_input()
+
+app := App()
+int main():
+  app.run()

src/sharenote/server/server.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+
+import io
+import os
+import json
+import socket
+import threading
+
+from flask import Flask, send_file
+from PIL import Image, ImageDraw
+
+HOST = "0.0.0.0"
+PORT = 65432  # Port to listen on (non-privileged ports are > 1023)
+
+WIDTH = 1404
+HEIGHT = 1872
+
+# TODO:
+# * room messages
+# * validate messages
+# * init message
+# * (MSG, DATA) proto
+
+class Room:
+    def __init__(self, name="default"):
+        self.clients = []
+        self.name = name
+        self.msgs_file = "/tmp/room_"+name+"_msgs"
+        self.write_handle = open(self.msgs_file, "wb")
+        self.image = Image.new("L", (WIDTH, HEIGHT), 255)
+        self.image_file = "/tmp/room_"+name+"_img"
+        self.imgdraw = ImageDraw.Draw(self.image)
+        self.lock = threading.Lock()
+
+        if os.path.exists(self.image_file):
+            self.image = Image.open(self.image_file)
+
+        if os.path.exists(self.msgs_file):
+            with open(self.msgs_file, "rb") as f:
+                for line in f.readlines():
+                    msg_obj = json.loads(line)
+                    x, y, px, py = (
+                        msg_obj["x"],
+                        msg_obj["y"],
+                        msg_obj["prevx"],
+                        msg_obj["prevy"]
+                    )
+                    self.imgdraw.line(
+                        [(px, py), (x, y)],
+                        fill=msg_obj["color"],
+                        width=msg_obj["width"]
+                    )
+
+
+    def __del__(self):
+        with self.lock:
+            self.write_handle.close()
+
+    def add(self, client):
+        with self.lock:
+            self.clients.append(client)
+            self.write_handle.flush()
+
+            with open(self.msgs_file, 'rb') as f:
+                client.conn.sendall(f.read())
+
+    def remove(self, client):
+        with self.lock:
+            print("Removing connection", client.conn.addr)
+            self.clients.remove(client)
+
+    def send(self, msg_str):
+        with self.lock:
+            for client in self.clients:
+                try:
+                    client.conn.sendall(msg_str + b'\n')
+                except:
+                    pass
+
+            # make thread safe?
+            self.write_handle.write(msg_str + b'\n')
+            self.write_handle.flush()
+
+    def clear(self):
+        with self.lock:
+            self.image = Image.new("L", (WIDTH, HEIGHT), 255)
+            self.clear_log()
+
+        self.send(b'{"type":"clear"}')
+
+    def clear_log(self):
+        self.write_handle.truncate()
+
+
+
+_rooms = { "default": Room(name="default")}
+room_lock = threading.Lock()
+
+
+class ClientThread(threading.Thread):
+    def __init__(self, addr, conn):
+        threading.Thread.__init__(self)
+        self.conn = conn
+        self.addr = addr
+        self.room = None
+
+    def __del__(self):
+        with room_lock:
+            if self.room in _rooms:
+                _rooms[self.room].remove(self)
+
+    def join(self, room):
+        print("New connection added: ", self.addr, "to room", room)
+        with room_lock:
+            if room not in _rooms:
+                _rooms[room] = Room(name=room)
+            _rooms[room].add(self)
+            self.room = room
+        # TODO send URL with image download
+
+    def handle_message(self, msg_obj):
+        if msg_obj["type"] == "join":
+            self.join(msg_obj["room"])
+
+        if self.room == None:
+            return
+
+        if msg_obj["type"] == "draw":
+            x, y, px, py = (
+                msg_obj["x"],
+                msg_obj["y"],
+                msg_obj["prevx"],
+                msg_obj["prevy"]
+            )
+            room = _rooms[self.room]
+            room.imgdraw.line(
+                [(px, py), (x, y)],
+                fill=msg_obj["color"],
+                width=msg_obj["width"]
+            )
+            msg_str = bytes(json.dumps(msg_obj), encoding='utf8')
+            with room_lock:
+                _rooms[self.room].send(msg_str)
+        elif msg_obj["type"] == "clear":
+            with room_lock:
+                _rooms[self.room].clear()
+
+    def run(self):
+        # self.csocket.send(bytes("Hi, This is from Server..",'utf-8'))
+        messages = []
+        message = b""
+        while True:
+            try:
+                data = self.conn.recv(1024)
+            except ConnectionResetError:
+                with room_lock:
+                    _rooms[self.room].remove(self)
+                return
+            if not data:
+                break
+            chunks = data.split(b"\n")
+            for chunk in chunks[:-1]:
+                message += chunk
+                messages.append(json.loads(message))
+                message = b""
+            message += chunks[-1]
+            if data[-1] == "\n":
+                messages.append(json.loads(message))
+                message = b""
+
+            for msg_obj in messages:
+                self.handle_message(msg_obj)
+
+            messages = []
+        self.conn.close()
+
+
+app = Flask(__name__)
+
+@app.route('/room/<room>')
+def get_room_image(room):
+    s = io.BytesIO()
+    with room_lock:
+        if room not in _rooms:
+            return "room not found"
+        room = _rooms[room]
+
+    with room.lock:
+        im = room.image
+        im.save(room.image_file, format="png")
+        im.save(s, format="png")
+        room.clear_log()
+    bytes = s.getvalue()
+    return bytes
+
+def listen_socket():
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        s.bind((HOST, PORT))
+        print("server started")
+
+        while True:
+            s.listen()
+            conn, addr = s.accept()
+            newthread = ClientThread(addr, conn)
+            newthread.start()
+
+def listen_http():
+    app.run(host="0.0.0.0", port=65431)
+
+def main():
+    thread_socket = threading.Thread(target=listen_socket)
+    thread_http = threading.Thread(target=listen_http)
+
+    thread_socket.start()
+    thread_http.start()
+
+    thread_socket.join()
+    thread_http.join()
+
+main()