Split skipstone_message_service into src/service.c

Split skipstone_message_service into src/service.c as skipstone_service

examples/test.c

@@ -5,6 +5,7 @@
 
 #include <skipstone/link.h>
 #include <skipstone/message.h>
+#include <skipstone/service.h>
 #include <skipstone/system.h>
 
 #include "../src/util.h"
@@ -18,19 +19,21 @@ static void usage(int argc, char **argv) {
     exit(1);
 }
 
-static int answer_phone_version_message(skipstone_message_service *service,
+static int answer_phone_version_message(skipstone_service *service,
                                         void *buf,
                                         uint16_t size,
                                         uint16_t id,
-                                        void *context) {
+                                        void *ctx) {
     const uint32_t flags = SKIPSTONE_SYSTEM_CLIENT_TELEPHONY
                          | SKIPSTONE_SYSTEM_CLIENT_SMS
                          | SKIPSTONE_SYSTEM_CLIENT_ANDROID;
 
-    return skipstone_system_send_client_version(service, flags);
+    struct context *context = ctx;
+
+    return skipstone_system_send_client_version(context->link, flags);
 }
 
-static int answer_music_message(skipstone_message_service *service,
+static int answer_music_message(skipstone_service *service,
                                 void *buf,
                                 uint16_t size,
                                 uint16_t id,
@@ -95,7 +98,7 @@ error_message_pack:
     return -1;
 }
 
-static int answer_phone_message(skipstone_message_service *service,
+static int answer_phone_message(skipstone_service *service,
                                 void *buf,
                                 uint16_t size,
                                 uint16_t id,
@@ -107,7 +110,7 @@ static int answer_phone_message(skipstone_message_service *service,
 
 int main(int argc, char **argv) {
     skipstone_link *link;
-    skipstone_message_service *service;
+    skipstone_service *service;
 
     struct context context;
 
@@ -120,20 +123,20 @@ int main(int argc, char **argv) {
         goto error_link_open;
     }
 
-    if ((service = skipstone_message_service_new(link)) == NULL) {
+    if ((service = skipstone_service_new(link)) == NULL) {
-        perror("skipstone_message_service_new()");
+        perror("skipstone_service_new()");
-        goto error_message_service_new;
+        goto error_service_new;
     }
 
     context.link = link;
 
-    skipstone_message_service_register(service, 17, answer_phone_version_message, &context);
+    skipstone_service_responder_add(service, answer_phone_version_message, 17, &context);
-    skipstone_message_service_register(service, 32, answer_music_message,         &context);
+    skipstone_service_responder_add(service, answer_music_message,         32, &context);
-    skipstone_message_service_register(service, 33, answer_phone_message,         &context);
+    skipstone_service_responder_add(service, answer_phone_message,         33, &context);
 
     while (1) {
-        if (skipstone_message_service_event_handle(service) < 0) {
+        if (skipstone_service_event_handle(service) < 0) {
-            perror("skipstone_message_service_event_handle()");
+            perror("skipstone_service_event_handle()");
 
             goto error_io;
         }
@@ -144,7 +147,7 @@ int main(int argc, char **argv) {
     return 0;
 
 error_io:
-error_message_service_new:
+error_service_new:
     skipstone_link_close(link);
 
 error_link_open:

include/skipstone/message.h

@@ -9,48 +9,13 @@
 
 #define SKIPSTONE_MESSAGE_MAX_PAYLOAD 4096
 
-enum {
-    SKIPSTONE_MESSAGE_ENDPOINT_NONE           =  0,
-    SKIPSTONE_MESSAGE_ENDPOINT_FIRMWARE       =  1,
-    SKIPSTONE_MESSAGE_ENDPOINT_TIME           = 11,
-    SKIPSTONE_MESSAGE_ENDPOINT_VERSIONS       = 16,
-    SKIPSTONE_MESSAGE_ENDPOINT_PHONE_VERSION  = 17,
-    SKIPSTONE_MESSAGE_ENDPOINT_SYSTEM_MESSAGE = 18,
-    SKIPSTONE_MESSAGE_ENDPOINT_MUSIC_CONTROL  = 32,
-    SKIPSTONE_MESSAGE_ENDPOINT_PHONE_CONTROL  = 33
-};
-
 typedef struct _skipstone_message_header {
     uint16_t size,
              id;
 } skipstone_message_header;
 
-typedef struct _skipstone_message_service skipstone_message_service;
-
-typedef int (skipstone_message_handler)(skipstone_message_service *service,
-                                        void *buf,
-                                        uint16_t size,
-                                        uint16_t id,
-                                        void *context);
-
 ssize_t skipstone_message_pack(void *message,
                                size_t len,
                                const char *template, ...);
 
-skipstone_message_service *skipstone_message_service_new(skipstone_link *link);
-
-void skipstone_message_service_destroy(skipstone_message_service *service);
-
-skipstone_link *skipstone_message_service_link(skipstone_message_service *service);
-
-int skipstone_message_service_register(skipstone_message_service *service,
-                                       uint16_t id,
-                                       skipstone_message_handler *handler,
-                                       void *context);
-
-int skipstone_message_service_deregister(skipstone_message_service *service,
-                                         uint16_t id);
-
-int skipstone_message_service_event_handle(skipstone_message_service *service);
-
 #endif /* _SKIPSTONE_MESSAGE_H */

include/skipstone/music.h

@@ -11,7 +11,9 @@ enum {
     SKIPSTONE_MUSIC_EVENT_VOLUME_DOWN = 0x07
 };
 
-int skipstone_music_send_current_track(skipstone_message_service *service,
+int skipstone_music_send_current_track(skipstone_link *link,
-        char *artist, char *album, char *song);
+                                       char *artist,
+                                       char *album,
+                                       char *song);
 
 #endif /* _SKIPSTONE_MUSIC_H */

include/skipstone/service.h

@@ -0,0 +1,48 @@
+#ifndef _SKIPSTONE_SERVICE_H
+#define _SKIPSTONE_SERVICE_H
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include <skipstone/link.h>
+
+enum {
+    SKIPSTONE_SERVICE_ENDPOINT_NONE           =  0,
+    SKIPSTONE_SERVICE_ENDPOINT_FIRMWARE       =  1,
+    SKIPSTONE_SERVICE_ENDPOINT_TIME           = 11,
+    SKIPSTONE_SERVICE_ENDPOINT_VERSIONS       = 16,
+    SKIPSTONE_SERVICE_ENDPOINT_PHONE_VERSION  = 17,
+    SKIPSTONE_SERVICE_ENDPOINT_SYSTEM_SERVICE = 18,
+    SKIPSTONE_SERVICE_ENDPOINT_MUSIC_CONTROL  = 32,
+    SKIPSTONE_SERVICE_ENDPOINT_PHONE_CONTROL  = 33
+};
+
+typedef struct _skipstone_service skipstone_service;
+
+typedef int (skipstone_service_responder)(skipstone_service *service,
+                                          void *buf,
+                                          uint16_t size,
+                                          uint16_t id,
+                                          void *context);
+
+ssize_t skipstone_message_pack(void *message,
+                               size_t len,
+                               const char *template, ...);
+
+skipstone_service *skipstone_service_new(skipstone_link *link);
+
+void skipstone_service_destroy(skipstone_service *service);
+
+skipstone_link *skipstone_service_link(skipstone_service *service);
+
+int skipstone_service_responder_add(skipstone_service *service,
+                                    skipstone_service_responder *responder,
+                                    uint16_t id,
+                                    void *ctx);
+
+void skipstone_service_responder_remove(skipstone_service *service,
+                                        uint16_t id);
+
+int skipstone_service_event_handle(skipstone_service *service);
+
+#endif /* _SKIPSTONE_SERVICE_H */

include/skipstone/system.h

@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 
-#include <skipstone/message.h>
+#include <skipstone/link.h>
 
 #define SKIPSTONE_SYSTEM_ENDPOINT_PHONE_VERSION 0x11
 
@@ -37,7 +37,6 @@ enum {
     SKIPSTONE_SYSTEM_VERSION_RESPONSE = 1
 };
 
-int skipstone_system_send_client_version(skipstone_message_service *service,
+int skipstone_system_send_client_version(skipstone_link *link, uint32_t flags);
-        uint32_t flags);
 
 #endif /* _SKIPSTONE_SYSTEM_H */

src/Makefile

@@ -7,9 +7,11 @@ CC		= $(CROSS)cc
 CFLAGS		+= -fPIC -I$(INCLUDE_PATH)
 LDFLAGS		=
 
-HEADERS		= watch.h link.h map.h message.h music.h queue.h system.h
+HEADERS		= watch.h link.h map.h message.h service.h music.h queue.h \
+		  system.h
 
-OBJS		= watch.o link.o map.o message.o music.o queue.o system.o
+OBJS		= watch.o link.o map.o message.o service.o music.o queue.o \
+		  system.o
 
 VERSION_MAJOR	= 0
 VERSION_MINOR	= 0.1

src/message.c

@@ -9,21 +9,6 @@
 #include <skipstone/queue.h>
 #include <skipstone/message.h>
 
-struct endpoint {
-    skipstone_message_handler *handler;
-    void *context;
-    uint16_t id;
-};
-
-struct _skipstone_message_service {
-    skipstone_link *link;
-    skipstone_map *endpoints;
-    skipstone_queue *pending;
-
-    size_t bufsz;
-    void *buf;
-};
-
 #define case_type(t, type_t) \
     case t: { \
         type_t v = va_arg(args, type_t); \
@@ -99,133 +84,3 @@ done:
 error_invalid_template:
     return -1;
 }
-
-skipstone_message_service *skipstone_message_service_new(skipstone_link *link) {
-    skipstone_message_service *service;
-
-    if ((service = malloc(sizeof(*service))) == NULL) {
-        goto error_malloc_service;
-    }
-
-    if ((service->buf = malloc(SKIPSTONE_MESSAGE_MAX_PAYLOAD)) == NULL) {
-        goto error_malloc_buf;
-    }
-
-    if ((service->endpoints = skipstone_map_new()) == NULL) {
-        goto error_map_new_endpoints;
-    }
-
-    if ((service->pending = skipstone_queue_new()) == NULL) {
-        goto error_queue_new_pending;
-    }
-
-    service->link  = link;
-    service->bufsz = SKIPSTONE_MESSAGE_MAX_PAYLOAD;
-
-    return service;
-
-error_queue_new_pending:
-    skipstone_map_destroy(service->endpoints, free);
-
-error_map_new_endpoints:
-    free(service->buf);
-
-error_malloc_buf:
-    free(service);
-
-error_malloc_service:
-    return NULL;
-}
-
-void skipstone_message_service_destroy(skipstone_message_service *service) {
-    skipstone_map_destroy(service->endpoints, free);
-
-    skipstone_queue_destroy(service->pending);
-
-    free(service->buf);
-
-    free(service);
-
-    return;
-}
-
-skipstone_link *skipstone_message_service_link(skipstone_message_service *service) {
-    return service->link;
-}
-
-int skipstone_message_service_register(skipstone_message_service *service,
-        uint16_t id, skipstone_message_handler *handler, void *context) {
-    struct endpoint *endpoint;
-
-    if ((endpoint = malloc(sizeof(*endpoint))) == NULL) {
-        goto error_malloc_endpoint;
-    }
-
-    endpoint->id      = id;
-    endpoint->handler = handler;
-    endpoint->context = context;
-
-    return skipstone_map_set(service->endpoints, id, endpoint);
-
-error_malloc_endpoint:
-    return -1;
-}
-
-int skipstone_message_service_deregister(skipstone_message_service *service,
-                                         uint16_t id) {
-    return skipstone_map_set((skipstone_map *)service, id, NULL);
-}
-
-int skipstone_message_service_event_handle(skipstone_message_service *service) {
-    struct endpoint *endpoint;
-
-    fd_set fds;
-
-    struct timeval timeout = {
-        .tv_sec  = 0,
-        .tv_usec = 50000
-    };
-
-    int fd = skipstone_link_fd(service->link),
-        ready;
-
-    ssize_t len;
-    uint16_t id;
-
-    memset(&fds, '\0', sizeof(fds));
-
-    FD_SET(fd, &fds);
-
-    if ((ready = select(fd + 1,
-                        &fds,
-                        NULL,
-                        NULL,
-                        &timeout)) < 0) {
-        goto error_io;
-    } else if (ready == 0 || !FD_ISSET(fd, &fds)) {
-        goto done;
-    } 
-
-    if ((len = skipstone_link_recv(service->link,
-                                   service->buf,
-                                   &id,
-                                   service->bufsz)) < 0) {
-        goto error_io;
-    }
-
-    if ((endpoint = skipstone_map_get(service->endpoints, id)) != NULL) {
-        if (endpoint->handler(service,
-                              service->buf,
-                              len,
-                              id,
-                              endpoint->context) < 0) {
-            goto error_io;
-        }
-    }
-
-done:
-    return 0;
-
-error_io:
-    return -1;
-}

src/music.c

@@ -1,6 +1,8 @@
 #include <skipstone/music.h>
 
-int skipstone_music_send_current_track(skipstone_message_service *service,
+int skipstone_music_send_current_track(skipstone_link *link,
-        char *artist, char *album, char *song) {
+                                       char *artist,
+                                       char *album,
+                                       char *song) {
     return 0;
 }

src/service.c

@@ -0,0 +1,164 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+
+#include <skipstone/link.h>
+#include <skipstone/map.h>
+#include <skipstone/queue.h>
+#include <skipstone/message.h>
+#include <skipstone/service.h>
+
+struct _skipstone_service {
+    skipstone_link *link;
+    skipstone_map *endpoints;
+    skipstone_queue *pending;
+
+    size_t bufsz;
+    void *buf;
+};
+
+skipstone_service *skipstone_service_new(skipstone_link *link) {
+    skipstone_service *service;
+
+    if ((service = malloc(sizeof(*service))) == NULL) {
+        goto error_malloc_service;
+    }
+
+    if ((service->buf = malloc(SKIPSTONE_MESSAGE_MAX_PAYLOAD)) == NULL) {
+        goto error_malloc_buf;
+    }
+
+    if ((service->endpoints = skipstone_map_new()) == NULL) {
+        goto error_map_new_endpoints;
+    }
+
+    if ((service->pending = skipstone_queue_new()) == NULL) {
+        goto error_queue_new_pending;
+    }
+
+    service->link  = link;
+    service->bufsz = SKIPSTONE_MESSAGE_MAX_PAYLOAD;
+
+    return service;
+
+error_queue_new_pending:
+    skipstone_map_destroy(service->endpoints, free);
+
+error_map_new_endpoints:
+    free(service->buf);
+
+error_malloc_buf:
+    free(service);
+
+error_malloc_service:
+    return NULL;
+}
+
+void skipstone_service_destroy(skipstone_service *service) {
+    skipstone_map_destroy(service->endpoints, free);
+
+    skipstone_queue_destroy(service->pending);
+
+    free(service->buf);
+
+    free(service);
+
+    return;
+}
+
+skipstone_link *skipstone_service_link(skipstone_service *service) {
+    return service->link;
+}
+
+struct endpoint {
+    uint16_t id;
+    skipstone_service_responder *responder;
+    void *context;
+};
+
+int skipstone_service_responder_add(skipstone_service *service,
+                                    skipstone_service_responder *responder,
+                                    uint16_t id,
+                                    void *ctx) {
+    struct endpoint *endpoint;
+
+    if ((endpoint = malloc(sizeof(*endpoint))) == NULL) {
+        goto error_malloc_endpoint;
+    }
+
+    endpoint->id        = id;
+    endpoint->responder = responder;
+    endpoint->context   = ctx;
+
+    return skipstone_map_set(service->endpoints, id, endpoint);
+
+error_malloc_endpoint:
+    return -1;
+}
+
+void skipstone_service_responder_remove(skipstone_service *service,
+                                        uint16_t id) {
+    struct endpoint *endpoint;
+
+    if ((endpoint = skipstone_map_get(service->endpoints, id)) != NULL) {
+        free(endpoint);
+    }
+
+    (void)skipstone_map_set((skipstone_map *)service, id, NULL);
+}
+
+int skipstone_service_event_handle(skipstone_service *service) {
+    struct endpoint *endpoint;
+
+    fd_set fds;
+
+    struct timeval timeout = {
+        .tv_sec  = 0,
+        .tv_usec = 50000
+    };
+
+    int fd = skipstone_link_fd(service->link),
+        ready;
+
+    ssize_t len;
+    uint16_t id;
+
+    memset(&fds, '\0', sizeof(fds));
+
+    FD_SET(fd, &fds);
+
+    if ((ready = select(fd + 1,
+                        &fds,
+                        NULL,
+                        NULL,
+                        &timeout)) < 0) {
+        goto error_io;
+    } else if (ready == 0 || !FD_ISSET(fd, &fds)) {
+        goto done;
+    } 
+
+    if ((len = skipstone_link_recv(service->link,
+                                   service->buf,
+                                   &id,
+                                   service->bufsz)) < 0) {
+        goto error_io;
+    }
+
+    if ((endpoint = skipstone_map_get(service->endpoints, id)) != NULL) {
+        if (endpoint->responder(service,
+                                service->buf,
+                                len,
+                                id,
+                                endpoint->context) < 0) {
+            goto error_io;
+        }
+    }
+
+done:
+    return 0;
+
+error_io:
+    return -1;
+}

src/system.c

@@ -5,10 +5,8 @@
 
 #include "util.h"
 
-int skipstone_system_send_client_version(skipstone_message_service *service,
+int skipstone_system_send_client_version(skipstone_link *link,
                                          uint32_t flags) {
-    skipstone_link *link = skipstone_message_service_link(service);
-
     uint8_t message[25];
     ssize_t len;