xan/skipstone
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Split skipstone_message_service into src/service.c

Browse source 
Split skipstone_message_service into src/service.c as skipstone_service
This commit is contained in:
XANTRONIX Development 2020-09-21 15:55:48 -05:00
parent 7120e736f6
commit 1cbde40e1f
10 changed files with 245 additions and 207 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
examples/test.c
View file

@ -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) {
perror("skipstone_message_service_new()");
goto error_message_service_new;
if ((service = skipstone_service_new(link)) == NULL) {
perror("skipstone_service_new()");
goto error_service_new;
}
context.link = link;
skipstone_message_service_register(service, 17, answer_phone_version_message, &context);
skipstone_message_service_register(service, 32, answer_music_message, &context);
skipstone_message_service_register(service, 33, answer_phone_message, &context);
skipstone_service_responder_add(service, answer_phone_version_message, 17, &context);
skipstone_service_responder_add(service, answer_music_message, 32, &context);
skipstone_service_responder_add(service, answer_phone_message, 33, &context);
while (1) {
if (skipstone_message_service_event_handle(service) < 0) {
perror("skipstone_message_service_event_handle()");
if (skipstone_service_event_handle(service) < 0) {
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:

35
include/skipstone/message.h
View file

@ -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 */

6
include/skipstone/music.h
View file

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

48
include/skipstone/service.h Normal file
View file

@ -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 */

5
include/skipstone/system.h
View file

@ -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,
uint32_t flags);
int skipstone_system_send_client_version(skipstone_link *link, uint32_t flags);
#endif /* _SKIPSTONE_SYSTEM_H */

6
src/Makefile
View file

@ -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

145
src/message.c
View file

@ -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;
}

6
src/music.c
View file

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

164
src/service.c Normal file
View file

@ -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;
}

4
src/system.c
View file

@ -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;