sol-mainloop.h

Go to the documentation of this file.

/*
 * This file is part of the Soletta (TM) Project
 *
 * Copyright (C) 2015 Intel Corporation. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include "sol-common-buildopts.h"

#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <time.h>

#ifdef __cplusplus
extern "C" {
#endif

int sol_init(void);

int sol_run(void);

void sol_quit(void);

void sol_quit_with_code(int return_code);

void sol_shutdown(void);

struct sol_timeout;
typedef struct sol_timeout sol_timeout;

struct sol_timeout *sol_timeout_add(uint32_t timeout_ms, bool (*cb)(void *data), const void *data);

bool sol_timeout_del(struct sol_timeout *handle);

struct sol_idle;
typedef struct sol_idle sol_idle;

struct sol_idle *sol_idle_add(bool (*cb)(void *data), const void *data);

bool sol_idle_del(struct sol_idle *handle);

#ifndef SOL_MAINLOOP_FD_ENABLED
/* keep doxygen happy */
#define SOL_MAINLOOP_FD_ENABLED
#undef SOL_MAINLOOP_FD_ENABLED
#endif

#ifdef SOL_MAINLOOP_FD_ENABLED

enum sol_fd_flags {
    SOL_FD_FLAGS_NONE = 0,
    SOL_FD_FLAGS_IN   = (1 << 0),
    SOL_FD_FLAGS_OUT  = (1 << 1),
    SOL_FD_FLAGS_PRI  = (1 << 2),
    SOL_FD_FLAGS_ERR  = (1 << 3),
    SOL_FD_FLAGS_HUP  = (1 << 4),
    SOL_FD_FLAGS_NVAL = (1 << 5)
};

struct sol_fd;
typedef struct sol_fd sol_fd;

struct sol_fd *sol_fd_add(int fd, uint32_t flags, bool (*cb)(void *data, int fd, uint32_t active_flags), const void *data);

bool sol_fd_del(struct sol_fd *handle);

bool sol_fd_set_flags(struct sol_fd *handle, uint32_t flags);

bool sol_fd_remove_flags(struct sol_fd *handle, uint32_t flags);

bool sol_fd_add_flags(struct sol_fd *handle, uint32_t flags);

uint32_t sol_fd_get_flags(const struct sol_fd *handle);
#endif


#ifndef SOL_MAINLOOP_FORK_WATCH_ENABLED
/* keep doxygen happy */
#define SOL_MAINLOOP_FORK_WATCH_ENABLED
#undef SOL_MAINLOOP_FORK_WATCH_ENABLED
#endif

#ifdef SOL_MAINLOOP_FORK_WATCH_ENABLED

struct sol_child_watch;
typedef struct sol_child_watch sol_child_watch;

struct sol_child_watch *sol_child_watch_add(uint64_t pid, void (*cb)(void *data, uint64_t pid, int status), const void *data);

bool sol_child_watch_del(struct sol_child_watch *handle);
#endif

#ifndef SOL_NO_API_VERSION
/* keep doxygen happy */
#define SOL_NO_API_VERSION
#undef SOL_NO_API_VERSION
#endif

#ifndef SOL_SET_API_VERSION
/* keep doxygen happy */
#define SOL_SET_API_VERSION(expression)
#undef SOL_SET_API_VERSION
#endif

typedef struct sol_mainloop_source_type {
#ifndef SOL_NO_API_VERSION
#define SOL_MAINLOOP_SOURCE_TYPE_API_VERSION (1)  
    uint16_t api_version;
#endif

    bool (*prepare)(void *data);

    bool (*get_next_timeout)(void *data, struct timespec *timeout);

    bool (*check)(void *data);

    void (*dispatch)(void *data);

    void (*dispose)(void *data);
} sol_mainloop_source_type;

struct sol_mainloop_source;
typedef struct sol_mainloop_source sol_mainloop_source;

struct sol_mainloop_source *sol_mainloop_add_source(const struct sol_mainloop_source_type *type, const void *data);

void sol_mainloop_del_source(struct sol_mainloop_source *handle);

void *sol_mainloop_source_get_data(const struct sol_mainloop_source *handle);

typedef struct sol_mainloop_implementation {
#ifndef SOL_NO_API_VERSION
#define SOL_MAINLOOP_IMPLEMENTATION_API_VERSION (1)  
    uint16_t api_version;
#endif

    int (*init)(void);

    void (*shutdown)(void);

    void (*run)(void);

    void (*quit)(void);

    void *(*timeout_add)(uint32_t timeout_ms, bool (*cb)(void *data), const void *data);

    bool (*timeout_del)(void *handle);

    void *(*idle_add)(bool (*cb)(void *data), const void *data);

    bool (*idle_del)(void *handle);

#ifdef SOL_MAINLOOP_FD_ENABLED

    void *(*fd_add)(int fd, uint32_t flags, bool (*cb)(void *data, int fd, uint32_t active_flags), const void *data);

    bool (*fd_del)(void *handle);

    bool (*fd_set_flags)(void *handle, uint32_t flags);

    uint32_t (*fd_get_flags)(const void *handle);
#endif

#ifdef SOL_MAINLOOP_FORK_WATCH_ENABLED

    void *(*child_watch_add)(uint64_t pid, void (*cb)(void *data, uint64_t pid, int status), const void *data);

    bool (*child_watch_del)(void *handle);
#endif

    void *(*source_add)(const struct sol_mainloop_source_type *type, const void *data);

    void (*source_del)(void *handle);

    void *(*source_get_data)(const void *handle);
} sol_mainloop_implementation;


extern const struct sol_mainloop_implementation *SOL_MAINLOOP_IMPLEMENTATION_DEFAULT;

const struct sol_mainloop_implementation *sol_mainloop_get_implementation(void);

bool sol_mainloop_set_implementation(const struct sol_mainloop_implementation *impl);

int sol_argc(void);

char **sol_argv(void);

void sol_set_args(int argc, char *argv[]);

typedef struct sol_main_callbacks {
#ifndef SOL_NO_API_VERSION
#define SOL_MAIN_CALLBACKS_API_VERSION (1)
    uint16_t api_version; 
#endif
    uint16_t flags; 
    void (*startup)(void); 
    void (*shutdown)(void); 
} sol_main_callbacks;

int sol_mainloop_default_main(const struct sol_main_callbacks *callbacks, int argc, char *argv[]);

#ifdef __cplusplus
}
#endif