path: root/idlc/c_gen/c_proxy_body_gen_cb.h

/*
 * Copyright (c) 2017 Samsung Electronics Co., Ltd.
 *
 * 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.
 */

#ifndef IDLC_C_GEN_C_PROXY_BODY_GEN_CB_H_
#define IDLC_C_GEN_C_PROXY_BODY_GEN_CB_H_

const char CB_INTERFACE_STRUCT[] =
R"__c_cb(
struct ##_s {
    char *stub_appid;
    rpc_port_proxy_h proxy;
    rpc_port_h port;
    rpc_port_proxy_##_callback_s callback;
    void *user_data;
    GList *delegates;
    GRecMutex mutex;
};
)__c_cb";

const char CB_DELEGATE_STRUCT[] =
R"__c_cb(
struct ##_s {
    rpc_port_parcelable_t parcelable;
    int id;
    int seq_id;
    ## callback;
    bool once;
    void *user_data;
};
)__c_cb";

const char CB_DELEGATE_SERIALIZER[] =
R"__c_cb(
static void __##_to(rpc_port_parcel_h parcel, void *data)
{
    struct ##_s *handle = data;

    if (!handle) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Invalid parameter");
        return;
    }

    rpc_port_parcel_write_int32(parcel, handle->id);
    rpc_port_parcel_write_int32(parcel, handle->seq_id);
    rpc_port_parcel_write_bool(parcel, handle->once);
}
)__c_cb";

const char CB_DELEGATE_DESERIALIZER[] =
R"__c_cb(
static void __##_from(rpc_port_parcel_h parcel, void *data)
{
    struct ##_s *handle = data;

    if (!handle) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Invalid parameter");
        return;
    }

    rpc_port_parcel_read_int32(parcel, &handle->id);
    rpc_port_parcel_read_int32(parcel, &handle->seq_id);
    rpc_port_parcel_read_bool(parcel, &handle->once);
}
)__c_cb";

const char CB_DELEGATE_CTOR[] =
R"__c_cb(
rpc_port_##_h rpc_port_##_create(## callback, bool once, void *user_data)
{
    struct ##_s *handle;
    static int seq_num;

    handle = calloc(1, sizeof(struct ##_s));
    if (!handle) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Out of memory");
        return NULL;
    }

    handle->parcelable.to = __##_to;
    handle->parcelable.from= __##_from;
    handle->id = $$_DELEGATE_$$;
    handle->seq_id = seq_num++;
    handle->callback = callback;
    handle->once = once;
    handle->user_data = user_data;

    return handle;
}
)__c_cb";

const char CB_DELEGATE_DISPOSER[] =
R"__c_cb(
int rpc_port_proxy_##_dispose(rpc_port_proxy_$$_h proxy, rpc_port_##_h delegate)
{
    struct ##_s *handle;
    GList *iter;

    if (!proxy || !delegate) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Invalid handle %p %p", proxy, delegate);
        return -1;
    }

    iter = proxy->delegates;
    while (iter) {
        handle = (struct ##_s *)iter->data;
        if (handle == delegate) {
            proxy->delegates = g_list_remove_link(proxy->delegates, iter);
            free(handle);
            g_list_free(iter);
            return 0;
        }
        iter = g_list_next(iter);
    }

    return -1;
}
)__c_cb";

const char CB_DELEGATE_INVOKER[] =
R"__c_cb(
static void __$$_delegate_$$(GList **list, rpc_port_parcel_h parcel, int seq_id, int id)
{
$$
    do {
        struct ##_s *handle;
        GList *iter;

        iter = *list;
        while (iter) {
            handle = (struct ##_s *)iter->data;
            if (handle->seq_id == seq_id && handle->id == id) {
                $$
                if (handle->once) {
                    *list = g_list_remove_link(*list, iter);
                    free(handle);
                    g_list_free(iter);
                }
                break;
            }
            iter = g_list_next(iter);
        }
    } while (0);
$$
}
)__c_cb";

const char CB_PROCESS_RECEIVED_EVENT[] =
R"__c_cb(
static void __##_process_received_event(GList **list, rpc_port_parcel_h parcel)
{
$$
}
)__c_cb";

const char CB_PROCESS_RECEIVED_EVENT_IMPL[] =
R"__c_cb(int id;
int seq_id;
bool once;

rpc_port_parcel_read_int32(parcel, &id);
rpc_port_parcel_read_int32(parcel, &seq_id);
rpc_port_parcel_read_bool(parcel, &once);

if (id > 0 && id < (sizeof(__##_delegate_table) / sizeof(__##_delegate_table[0]))) {
    if (__##_delegate_table[id])
        __##_delegate_table[id](list, parcel, seq_id, id);
} else {
    dlog_print(DLOG_WARN, LOG_TAG, "Unknown id(%d)", id);
})__c_cb";

const char CB_CONSUME_COMMAND[] =
R"__c_cb(
static rpc_port_parcel_h __##_consume_command(rpc_port_proxy_##_h h)
{
    rpc_port_parcel_h parcel = NULL;
    int cmd = -1;

    do {
        rpc_port_parcel_create_from_port(&parcel, h->port);
        if (!parcel)
            break;

        rpc_port_parcel_read_int32(parcel, &cmd);
        if (cmd == ##_METHOD_Result)
            return parcel;

        __##_process_received_event(&h->delegates, parcel);
        rpc_port_parcel_destroy(parcel);
        parcel = NULL;
    } while (true);

    return NULL;
}
)__c_cb";

const char CB_ON_CONNECTED[] =
R"__c_cb(
static void __##_on_connected(const char *endpoint, const char *port_name, rpc_port_h port, void *data)
{
    rpc_port_proxy_##_h handle = data;

    handle->port = port;
    if (handle->callback.connected)
        handle->callback.connected(handle, handle->user_data);
    dlog_print(DLOG_INFO, LOG_TAG, "[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name);
}
)__c_cb";

const char CB_ON_DISCONNECTED[] =
R"__c_cb(
static void __##_on_disconnected(const char *endpoint, const char *port_name, void *data)
{
    rpc_port_proxy_##_h handle = data;

    handle->port = NULL;
    if (handle->callback.disconnected)
        handle->callback.disconnected(handle, handle->user_data);
    dlog_print(DLOG_INFO, LOG_TAG, "[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name);
}
)__c_cb";

const char CB_ON_REJECTED[] =
R"__c_cb(
static void __##_on_rejected(const char *endpoint, const char *port_name, void *data)
{
    rpc_port_proxy_##_h handle = data;

    handle->port = NULL;
    if (handle->callback.rejected)
        handle->callback.rejected(handle, handle->user_data);
    dlog_print(DLOG_INFO, LOG_TAG, "[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name);
}
)__c_cb";

const char CB_ON_RECEIVED[] =
R"__c_cb(
static void __##_on_received(const char *endpoint, const char *port_name, void *data)
{
    rpc_port_proxy_##_h handle = data;
    rpc_port_parcel_h parcel_received;
    int cmd = -1;

    if (g_rec_mutex_trylock(&handle->mutex) == FALSE) {
        dlog_print(DLOG_WARN, LOG_TAG, "Failed to try to lock the mutex");
        return;
    }

    rpc_port_parcel_create_from_port(&parcel_received, handle->port);
    rpc_port_parcel_read_int32(parcel_received, &cmd);
    if (cmd != ##_METHOD_Callback) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Invalid protocol");
        rpc_port_parcel_destroy(parcel_received);
        g_rec_mutex_unlock(&handle->mutex);
        return;
    }

    __##_process_received_event(&handle->delegates, parcel_received);
    rpc_port_parcel_destroy(parcel_received);
    dlog_print(DLOG_INFO, LOG_TAG, "[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name);
    g_rec_mutex_unlock(&handle->mutex);
}
)__c_cb";

const char CB_INTERFACE_METHODS[] =
R"__c_cb(
$$rpc_port_proxy_##_invoke_$$(rpc_port_proxy_##_h h$$)
{
    rpc_port_parcel_h parcel;
$$

    if (!h$$) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Invalid parameter");
        return$$;
    }

    if (!h->port) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Not connected");
        return$$;
    }

    rpc_port_parcel_create(&parcel);
    rpc_port_parcel_write_int32(parcel, ##_METHOD_$$);
$$
    rpc_port_parcel_send(parcel, h->port);
    rpc_port_parcel_destroy(parcel);
$$
}
)__c_cb";

const char CB_INTERFACE_CTOR[] =
R"__c_cb(
static struct ##_s *__create_##(const char *stub_appid, rpc_port_proxy_##_callback_s *callback, void *user_data)
{
    struct ##_s *handle;

    handle = calloc(1, sizeof(struct ##_s));
    if (!handle) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Out of memory");
        return NULL;
    }

    handle->stub_appid = strdup(stub_appid);
    if (!handle->stub_appid) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Out of memory");
        free(handle);
        return NULL;
    }

    rpc_port_proxy_create(&handle->proxy);
    if (!handle->proxy) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Failed to create proxy");
        free(handle->stub_appid);
        free(handle);
        return NULL;
    }

    g_rec_mutex_init(&handle->mutex);

    handle->callback = *callback;
    handle->user_data = user_data;

    return handle;
}
)__c_cb";

const char CB_INTERFACE_DTOR[] =
R"__c_cb(
static void __destroy_##(struct ##_s *h)
{
    if (!h)
        return;

    g_rec_mutex_clear(&h->mutex);

    if (h->delegates)
        g_list_free_full(h->delegates, free);

    if (h->proxy)
        rpc_port_proxy_destroy(h->proxy);

    if (h->stub_appid)
        free(h->stub_appid);

    free(h);
}
)__c_cb";

const char CB_INTERFACE_CONNECT[] =
R"__c_cb(
int rpc_port_proxy_##_connect(const char *stub_appid, rpc_port_proxy_##_callback_s *callback, void *user_data, rpc_port_proxy_##_h *h)
{
    struct ##_s *handle;
    int r;

    if (!stub_appid || !callback || !h) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Invalid parameter");
        return -1;
    }

    handle = __create_##(stub_appid, callback, user_data);
    if (!handle)
        return -1;

    r = rpc_port_proxy_add_connected_event_cb(handle->proxy, __##_on_connected, handle);
    if (r != 0) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Failed to add connected event cb. err = %d", r);
        __destroy_##(handle);
        return r;
    }

    r = rpc_port_proxy_add_disconnected_event_cb(handle->proxy, __##_on_disconnected, handle);
    if (r != 0) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Failed to add disconnected event cb. err = %d", r);
        __destroy_##(handle);
        return r;
    }

    r = rpc_port_proxy_add_rejected_event_cb(handle->proxy, __##_on_rejected, handle);
    if (r != 0) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Failed to add rejected event cb. err = %d", r);
        __destroy_##(handle);
        return r;
    }

    r = rpc_port_proxy_add_received_event_cb(handle->proxy, __##_on_received, handle);
    if (r != 0) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Failed to add received event cb. err = %d", r);
        __destroy_##(handle);
        return r;
    }

    r = rpc_port_proxy_connect(handle->proxy, stub_appid, "##");
    if (r != 0) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Failed to connect ##(%s)", stub_appid);
        __destroy_##(handle);
        return r;
    }

    *h = handle;

    return 0;
}
)__c_cb";

const char CB_INTERFACE_DISCONNECT[] =
R"__c_cb(
int rpc_port_proxy_##_disconnect(rpc_port_proxy_##_h h)
{
    if (!h) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Invalid parameter");
        return -1;
    }

    __destroy_##(h);
    return 0;
}
)__c_cb";

const char CB_DELEGATE_BLOCK[] =
R"__c_cb(
do {
    struct ##_s *handle = $$;

    rpc_port_parcel_write(parcel, &handle->parcelable, handle);
    h->delegates = g_list_append(h->delegates, handle);
} while (0);
)__c_cb";

const char CB_RECEIVE_BLOCK[] =
R"__c_cb(
g_rec_mutex_lock(&h->mutex);
do {
    rpc_port_parcel_h parcel_received;
$$
    parcel_received = __$$_consume_command(h);
    if (!parcel_received) {
        dlog_print(DLOG_ERROR, LOG_TAG, "Invalid protocol");
        break;
    }

$$
    rpc_port_parcel_destroy(parcel_received);
} while (0);
g_rec_mutex_unlock(&h->mutex);
)__c_cb";

#endif  // IDLC_C_GEN_C_PROXY_BODY_GEN_CB_H_