Fix implementation related to TIDL 69/263169/5
authorHwankyu Jhun <h.jhun@samsung.com>
Fri, 27 Aug 2021 06:32:36 +0000 (15:32 +0900)
committerHwanKyu Jhun <h.jhun@samsung.com>
Thu, 7 Oct 2021 07:06:22 +0000 (07:06 +0000)
APIs that are generated by tidlc are changed.

Requires:
 - https://review.tizen.org/gerrit/#/c/platform/core/appfw/tidl/+/263601/

Change-Id: I39d19db04b43d8f06fd73f56f68452be8d6d1173
Signed-off-by: Hwankyu Jhun <h.jhun@samsung.com>
client/tts_proxy.c [deleted file]
client/tts_proxy.h [deleted file]
client/tts_tidl.c
packaging/tts.spec
server/ttsd_stub.c [deleted file]
server/ttsd_stub.h [deleted file]
server/ttsd_tidl.c

diff --git a/client/tts_proxy.c b/client/tts_proxy.c
deleted file mode 100644 (file)
index be1f874..0000000
+++ /dev/null
@@ -1,1353 +0,0 @@
-/*
- * Generated by tidlc 1.4.9.
- */
-
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-#include <pthread.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <libgen.h>
-#include <glib.h>
-#include <dlog.h>
-#include <rpc-port.h>
-#include <rpc-port-parcel.h>
-
-#include "tts_proxy.h"
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-
-#define LOG_TAG "RPC_PORT_PROXY"
-
-#ifdef _E
-#undef _E
-#endif
-
-#ifdef _W
-#undef _W
-#endif
-
-#ifdef _I
-#undef _I
-#endif
-
-#ifdef _D
-#undef _D
-#endif
-
-#define _E(fmt, ...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _W(fmt, ...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _I(fmt, ...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _D(fmt, ...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-
-typedef void (*proxy_delegate)(GList **list, rpc_port_parcel_h parcel, int seq_id, int id);
-
-struct array_char_s {
-       rpc_port_parcelable_t parcelable;
-       char *array_chars;
-       int array_chars_size;
-};
-
-static void __array_char_to(rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_array_char_h h = data;
-
-       if (!parcel || !h) {
-               _E("Invalid parameter");
-               return;
-       }
-
-       rpc_port_parcel_write_array_count(parcel, h->array_chars_size);
-       do {
-               for (int i = 0; i < h->array_chars_size; i++) {
-                       rpc_port_parcel_write_byte(parcel, h->array_chars[i]);
-               }
-       } while (0);
-}
-
-static void __array_char_from(rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_array_char_h h = data;
-
-       if (!parcel || !h) {
-               _E("Invalid parameter");
-               return;
-       }
-
-       do {
-               rpc_port_parcel_read_array_count(parcel, &h->array_chars_size);
-
-               h->array_chars = calloc(h->array_chars_size, sizeof(*h->array_chars));
-               if (!h->array_chars) {
-                       _E("Out of memory");
-                       return;
-               }
-
-               for (int i = 0; i < h->array_chars_size; i++) {
-                       char value = 0;
-
-                       rpc_port_parcel_read_byte(parcel, &value);
-                       h->array_chars[i] = value;
-               }
-       } while (0);
-}
-
-int rpc_port_array_char_create(rpc_port_array_char_h *h)
-{
-       struct array_char_s *handle;
-
-       if (!h) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       handle = calloc(1, sizeof(struct array_char_s));
-       if (!handle) {
-               _E("Out of memory");
-               return -1;
-       }
-
-       handle->parcelable.to = __array_char_to;
-       handle->parcelable.from = __array_char_from;
-
-       *h = handle;
-
-       return 0;
-}
-
-int rpc_port_array_char_destroy(rpc_port_array_char_h h)
-{
-       if (!h) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       if (h->array_chars)
-               free(h->array_chars);
-
-       free(h);
-
-       return 0;
-}
-
-int rpc_port_array_char_clone(rpc_port_array_char_h h, rpc_port_array_char_h *clone)
-{
-       rpc_port_array_char_h handle = NULL;
-
-       if (!h || !clone) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       rpc_port_array_char_create(&handle);
-       if (!handle) {
-               _E("Failed to create array_char handle");
-               return -1;
-       }
-
-       do {
-               if (h->array_chars_size == 0) {
-                       _W("array_chars is empty");
-                       break;
-               }
-
-               handle->array_chars = calloc(h->array_chars_size, sizeof(*h->array_chars));
-               if (!handle->array_chars) {
-                       _E("Out of memory");
-                       rpc_port_array_char_destroy(handle);
-                       return -1;
-               }
-               handle->array_chars_size = h->array_chars_size;
-
-               for (int i = 0; i < h->array_chars_size; i++) {
-                       handle->array_chars[i] = h->array_chars[i];
-               }
-       } while (0);
-
-       *clone = handle;
-
-       return 0;
-}
-
-int rpc_port_array_char_set_array_chars(rpc_port_array_char_h h, char *array_chars, int array_chars_size)
-{
-       if (!h) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       if (h->array_chars)
-               free(h->array_chars);
-
-       h->array_chars = NULL;
-
-       do {
-               h->array_chars = calloc(array_chars_size, sizeof(*array_chars));
-               if (!h->array_chars) {
-                       _E("Out of memory");
-                       return -1;
-               }
-               h->array_chars_size = array_chars_size;
-
-               for (int i = 0; i < h->array_chars_size; i++) {
-                       h->array_chars[i] = array_chars[i];
-               }
-       } while (0);
-
-       return 0;
-}
-
-int rpc_port_array_char_get_array_chars(rpc_port_array_char_h h, char **array_chars, int *array_chars_size)
-{
-       if (!h || !array_chars || !array_chars_size) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       do {
-               if (h->array_chars_size == 0) {
-                       _W("array_chars is empty");
-                       break;
-               }
-
-               *array_chars = calloc(h->array_chars_size, sizeof(*h->array_chars));
-               if (!*array_chars) {
-                       _E("Out of memory");
-                       return -1;
-               }
-               *array_chars_size = h->array_chars_size;
-
-               for (int i = 0; i < h->array_chars_size; i++) {
-                       (*array_chars)[i] = h->array_chars[i];
-               }
-       } while (0);
-
-       return 0;
-}
-
-enum tts_method_e {
-       tts_METHOD_Result,
-       tts_METHOD_Callback,
-       tts_METHOD_register_cb,
-       tts_METHOD_register_cb_sync,
-       tts_METHOD_set_mode,
-       tts_METHOD_initialize,
-       tts_METHOD_finalize,
-       tts_METHOD_add_text,
-       tts_METHOD_stop,
-       tts_METHOD_pause,
-       tts_METHOD_play_pcm,
-       tts_METHOD_stop_pcm,
-       tts_METHOD_set_private,
-       tts_METHOD_get_private,
-       tts_METHOD_play,
-       tts_METHOD_add_pcm,
-};
-
-enum tts_delegate_e {
-       tts_DELEGATE_notify_cb = 1,
-};
-
-struct tts_s {
-       char *stub_appid;
-       rpc_port_proxy_h proxy;
-       rpc_port_h port;
-       rpc_port_h callback_port;
-       rpc_port_proxy_tts_callback_s callback;
-       void *user_data;
-       GList *delegates;
-       GRecMutex mutex;
-};
-
-struct tts_notify_cb_s {
-       rpc_port_parcelable_t parcelable;
-       int id;
-       int seq_id;
-       tts_notify_cb callback;
-       bool once;
-       void *user_data;
-};
-
-static void __tts_notify_cb_to(rpc_port_parcel_h parcel, void *data)
-{
-       struct tts_notify_cb_s *handle = data;
-
-       if (!handle) {
-               _E("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);
-       _I("id(%d), seq_id(%d), once(%s)", handle->id, handle->seq_id, handle->once ? "true" : "false");
-}
-
-static void __tts_notify_cb_from(rpc_port_parcel_h parcel, void *data)
-{
-       struct tts_notify_cb_s *handle = data;
-
-       if (!handle) {
-               _E("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);
-       _I("id(%d), seq_id(%d), once(%s)", handle->id, handle->seq_id, handle->once ? "true" : "false");
-}
-
-rpc_port_tts_notify_cb_h rpc_port_tts_notify_cb_create(tts_notify_cb callback, bool once, void *user_data)
-{
-       struct tts_notify_cb_s *handle;
-       static int seq_num;
-
-       handle = calloc(1, sizeof(struct tts_notify_cb_s));
-       if (!handle) {
-               _E("Out of memory");
-               return NULL;
-       }
-
-       handle->parcelable.to = __tts_notify_cb_to;
-       handle->parcelable.from= __tts_notify_cb_from;
-       handle->id = tts_DELEGATE_notify_cb;
-       handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1;
-       handle->callback = callback;
-       handle->once = once;
-       handle->user_data = user_data;
-       _I("id(%d), seq_id(%d)", handle->id, handle->seq_id);
-
-       return handle;
-}
-
-int rpc_port_tts_notify_cb_destroy(rpc_port_tts_notify_cb_h delegate)
-{
-       if (!delegate) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       free(delegate);
-
-       return 0;
-}
-
-int rpc_port_proxy_tts_notify_cb_dispose(rpc_port_proxy_tts_h proxy, rpc_port_tts_notify_cb_h delegate)
-{
-       struct tts_notify_cb_s *handle;
-       GList *iter;
-
-       if (!proxy || !delegate) {
-               _E("Invalid handle %p %p", proxy, delegate);
-               return -1;
-       }
-
-       iter = proxy->delegates;
-       while (iter) {
-               handle = (struct tts_notify_cb_s *)iter->data;
-               if (handle == delegate) {
-                       _W("id(%d), seq_id(%d), once(%s)", handle->id, handle->seq_id, handle->once ? "true" : "false");
-                       proxy->delegates = g_list_remove_link(proxy->delegates, iter);
-                       free(handle);
-                       g_list_free(iter);
-                       return 0;
-               }
-               iter = g_list_next(iter);
-       }
-
-       return -1;
-}
-
-static void __tts_delegate_notify_cb(GList **list, rpc_port_parcel_h parcel, int seq_id, int id)
-{
-       int pid = -1;
-       int uid = -1;
-       bundle *msg = NULL;
-
-       rpc_port_parcel_read_int32(parcel, &pid);
-       rpc_port_parcel_read_int32(parcel, &uid);
-       rpc_port_parcel_read_bundle(parcel, &msg);
-
-       do {
-               struct tts_notify_cb_s *handle;
-               GList *iter;
-
-               iter = *list;
-               while (iter) {
-                       handle = (struct tts_notify_cb_s *)iter->data;
-                       if (handle->seq_id == seq_id && handle->id == id) {
-                               bool once = handle->once;
-
-                               _W("Invoke id(%d), seq_id(%d)", id, seq_id);
-                               handle->callback(handle->user_data, pid, uid, msg);
-
-                               if (once) {
-                                       _W("Dispose");
-                                       *list = g_list_remove_link(*list, iter);
-                                       free(handle);
-                                       g_list_free(iter);
-                               }
-                               break;
-                       }
-                       iter = g_list_next(iter);
-               }
-       } while (0);
-
-       bundle_free(msg);
-}
-
-static proxy_delegate __tts_delegate_table[] = {
-       [tts_DELEGATE_notify_cb] = __tts_delegate_notify_cb,
-};
-
-static void __tts_process_received_event(GList **list, rpc_port_parcel_h parcel)
-{
-       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);
-       _W("id(%d), seq_id(%d)", id, seq_id);
-
-       if (id > 0 && id < (sizeof(__tts_delegate_table) / sizeof(__tts_delegate_table[0]))) {
-               if (__tts_delegate_table[id])
-                       __tts_delegate_table[id](list, parcel, seq_id, id);
-       } else {
-               _W("Unknown id(%d)", id);
-       }
-}
-
-static rpc_port_parcel_h __tts_consume_command(rpc_port_proxy_tts_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 == tts_METHOD_Result)
-                       return parcel;
-
-               rpc_port_parcel_destroy(parcel);
-               parcel = NULL;
-       } while (true);
-
-       return NULL;
-}
-
-static void __tts_on_connected(const char *endpoint, const char *port_name, rpc_port_h port, void *data)
-{
-       rpc_port_proxy_tts_h handle = data;
-
-       handle->port = port;
-       rpc_port_proxy_get_port(handle->proxy, RPC_PORT_PORT_CALLBACK, &handle->callback_port);
-       if (handle->callback.connected)
-               handle->callback.connected(handle, handle->user_data);
-       _I("[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name);
-}
-
-static void __tts_on_disconnected(const char *endpoint, const char *port_name, void *data)
-{
-       rpc_port_proxy_tts_h handle = data;
-
-       handle->port = NULL;
-       if (handle->callback.disconnected)
-               handle->callback.disconnected(handle, handle->user_data);
-       _I("[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name);
-}
-
-static void __tts_on_rejected(const char *endpoint, const char *port_name, void *data)
-{
-       rpc_port_proxy_tts_h handle = data;
-
-       handle->port = NULL;
-       if (handle->callback.rejected)
-               handle->callback.rejected(handle, handle->user_data);
-       _I("[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name);
-}
-
-static void __tts_on_received(const char *endpoint, const char *port_name, void *data)
-{
-       rpc_port_proxy_tts_h handle = data;
-       rpc_port_parcel_h parcel_received = NULL;
-       int cmd = -1;
-
-       rpc_port_parcel_create_from_port(&parcel_received, handle->callback_port);
-       if (!parcel_received) {
-               _E("Failed to create parcel from port(%s)", port_name);
-               return;
-       }
-
-       rpc_port_parcel_read_int32(parcel_received, &cmd);
-       if (cmd != tts_METHOD_Callback) {
-               _E("Invalid protocol");
-               rpc_port_parcel_destroy(parcel_received);
-               return;
-       }
-
-       __tts_process_received_event(&handle->delegates, parcel_received);
-       rpc_port_parcel_destroy(parcel_received);
-       _I("[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name);
-}
-
-void rpc_port_proxy_tts_invoke_register_cb(rpc_port_proxy_tts_h h, int pid, int uid, rpc_port_tts_notify_cb_h callback)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-
-       if (!h || !callback) {
-               _E("Invalid parameter");
-               return;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_register_cb);
-       rpc_port_parcel_write_int32(parcel, pid);
-       rpc_port_parcel_write_int32(parcel, uid);
-
-       do {
-               struct tts_notify_cb_s *handle = callback;
-
-               rpc_port_parcel_write(parcel, &handle->parcelable, handle);
-               h->delegates = g_list_append(h->delegates, handle);
-       } while (0);
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-       set_last_result(r);
-}
-
-int rpc_port_proxy_tts_invoke_register_cb_sync(rpc_port_proxy_tts_h h, int pid, int uid, rpc_port_tts_notify_cb_h callback)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-       int ret = -1;
-
-       if (!h || !callback) {
-               _E("Invalid parameter");
-               return ret;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return ret;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_register_cb_sync);
-       rpc_port_parcel_write_int32(parcel, pid);
-       rpc_port_parcel_write_int32(parcel, uid);
-
-       do {
-               struct tts_notify_cb_s *handle = callback;
-
-               rpc_port_parcel_write(parcel, &handle->parcelable, handle);
-               h->delegates = g_list_append(h->delegates, handle);
-       } while (0);
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       g_rec_mutex_lock(&h->mutex);
-       do {
-               rpc_port_parcel_h parcel_received;
-
-               parcel_received = __tts_consume_command(h);
-               if (!parcel_received) {
-                       _E("Invalid protocol");
-                       r = RPC_PORT_ERROR_IO_ERROR;
-                       break;
-               }
-
-               rpc_port_parcel_read_int32(parcel_received, &ret);
-
-               rpc_port_parcel_destroy(parcel_received);
-       } while (0);
-       g_rec_mutex_unlock(&h->mutex);
-       set_last_result(r);
-
-       return ret;
-}
-
-int rpc_port_proxy_tts_invoke_set_mode(rpc_port_proxy_tts_h h, int mode)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-       int ret = -1;
-
-       if (!h) {
-               _E("Invalid parameter");
-               return ret;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return ret;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_set_mode);
-       rpc_port_parcel_write_int32(parcel, mode);
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       g_rec_mutex_lock(&h->mutex);
-       do {
-               rpc_port_parcel_h parcel_received;
-
-               parcel_received = __tts_consume_command(h);
-               if (!parcel_received) {
-                       _E("Invalid protocol");
-                       r = RPC_PORT_ERROR_IO_ERROR;
-                       break;
-               }
-
-               rpc_port_parcel_read_int32(parcel_received, &ret);
-
-               rpc_port_parcel_destroy(parcel_received);
-       } while (0);
-       g_rec_mutex_unlock(&h->mutex);
-       set_last_result(r);
-
-       return ret;
-}
-
-int rpc_port_proxy_tts_invoke_initialize(rpc_port_proxy_tts_h h, int pid, int uid, bool *credential_needed)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-       int ret = -1;
-
-       if (!h || !credential_needed) {
-               _E("Invalid parameter");
-               return ret;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return ret;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_initialize);
-       rpc_port_parcel_write_int32(parcel, pid);
-       rpc_port_parcel_write_int32(parcel, uid);
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       g_rec_mutex_lock(&h->mutex);
-       do {
-               rpc_port_parcel_h parcel_received;
-               bool out_credential_needed;
-
-               parcel_received = __tts_consume_command(h);
-               if (!parcel_received) {
-                       _E("Invalid protocol");
-                       r = RPC_PORT_ERROR_IO_ERROR;
-                       break;
-               }
-
-               rpc_port_parcel_read_bool(parcel_received, &out_credential_needed);
-               *credential_needed = out_credential_needed;
-               rpc_port_parcel_read_int32(parcel_received, &ret);
-
-               rpc_port_parcel_destroy(parcel_received);
-       } while (0);
-       g_rec_mutex_unlock(&h->mutex);
-       set_last_result(r);
-
-       return ret;
-}
-
-int rpc_port_proxy_tts_invoke_finalize(rpc_port_proxy_tts_h h, int uid)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-       int ret = -1;
-
-       if (!h) {
-               _E("Invalid parameter");
-               return ret;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return ret;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_finalize);
-       rpc_port_parcel_write_int32(parcel, uid);
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       g_rec_mutex_lock(&h->mutex);
-       do {
-               rpc_port_parcel_h parcel_received;
-
-               parcel_received = __tts_consume_command(h);
-               if (!parcel_received) {
-                       _E("Invalid protocol");
-                       r = RPC_PORT_ERROR_IO_ERROR;
-                       break;
-               }
-
-               rpc_port_parcel_read_int32(parcel_received, &ret);
-
-               rpc_port_parcel_destroy(parcel_received);
-       } while (0);
-       g_rec_mutex_unlock(&h->mutex);
-       set_last_result(r);
-
-       return ret;
-}
-
-int rpc_port_proxy_tts_invoke_add_text(rpc_port_proxy_tts_h h, int uid, const char *text, const char *lang, int vctype, int speed, int uttid, const char *credential)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-       int ret = -1;
-
-       if (!h) {
-               _E("Invalid parameter");
-               return ret;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return ret;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_add_text);
-       rpc_port_parcel_write_int32(parcel, uid);
-       rpc_port_parcel_write_string(parcel, text ? text : "");
-       rpc_port_parcel_write_string(parcel, lang ? lang : "");
-       rpc_port_parcel_write_int32(parcel, vctype);
-       rpc_port_parcel_write_int32(parcel, speed);
-       rpc_port_parcel_write_int32(parcel, uttid);
-       rpc_port_parcel_write_string(parcel, credential ? credential : "");
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       g_rec_mutex_lock(&h->mutex);
-       do {
-               rpc_port_parcel_h parcel_received;
-
-               parcel_received = __tts_consume_command(h);
-               if (!parcel_received) {
-                       _E("Invalid protocol");
-                       r = RPC_PORT_ERROR_IO_ERROR;
-                       break;
-               }
-
-               rpc_port_parcel_read_int32(parcel_received, &ret);
-
-               rpc_port_parcel_destroy(parcel_received);
-       } while (0);
-       g_rec_mutex_unlock(&h->mutex);
-       set_last_result(r);
-
-       return ret;
-}
-
-int rpc_port_proxy_tts_invoke_stop(rpc_port_proxy_tts_h h, int uid)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-       int ret = -1;
-
-       if (!h) {
-               _E("Invalid parameter");
-               return ret;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return ret;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_stop);
-       rpc_port_parcel_write_int32(parcel, uid);
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       g_rec_mutex_lock(&h->mutex);
-       do {
-               rpc_port_parcel_h parcel_received;
-
-               parcel_received = __tts_consume_command(h);
-               if (!parcel_received) {
-                       _E("Invalid protocol");
-                       r = RPC_PORT_ERROR_IO_ERROR;
-                       break;
-               }
-
-               rpc_port_parcel_read_int32(parcel_received, &ret);
-
-               rpc_port_parcel_destroy(parcel_received);
-       } while (0);
-       g_rec_mutex_unlock(&h->mutex);
-       set_last_result(r);
-
-       return ret;
-}
-
-int rpc_port_proxy_tts_invoke_pause(rpc_port_proxy_tts_h h, int uid)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-       int ret = -1;
-
-       if (!h) {
-               _E("Invalid parameter");
-               return ret;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return ret;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_pause);
-       rpc_port_parcel_write_int32(parcel, uid);
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       g_rec_mutex_lock(&h->mutex);
-       do {
-               rpc_port_parcel_h parcel_received;
-
-               parcel_received = __tts_consume_command(h);
-               if (!parcel_received) {
-                       _E("Invalid protocol");
-                       r = RPC_PORT_ERROR_IO_ERROR;
-                       break;
-               }
-
-               rpc_port_parcel_read_int32(parcel_received, &ret);
-
-               rpc_port_parcel_destroy(parcel_received);
-       } while (0);
-       g_rec_mutex_unlock(&h->mutex);
-       set_last_result(r);
-
-       return ret;
-}
-
-int rpc_port_proxy_tts_invoke_play_pcm(rpc_port_proxy_tts_h h, int uid)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-       int ret = -1;
-
-       if (!h) {
-               _E("Invalid parameter");
-               return ret;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return ret;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_play_pcm);
-       rpc_port_parcel_write_int32(parcel, uid);
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       g_rec_mutex_lock(&h->mutex);
-       do {
-               rpc_port_parcel_h parcel_received;
-
-               parcel_received = __tts_consume_command(h);
-               if (!parcel_received) {
-                       _E("Invalid protocol");
-                       r = RPC_PORT_ERROR_IO_ERROR;
-                       break;
-               }
-
-               rpc_port_parcel_read_int32(parcel_received, &ret);
-
-               rpc_port_parcel_destroy(parcel_received);
-       } while (0);
-       g_rec_mutex_unlock(&h->mutex);
-       set_last_result(r);
-
-       return ret;
-}
-
-int rpc_port_proxy_tts_invoke_stop_pcm(rpc_port_proxy_tts_h h, int uid)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-       int ret = -1;
-
-       if (!h) {
-               _E("Invalid parameter");
-               return ret;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return ret;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_stop_pcm);
-       rpc_port_parcel_write_int32(parcel, uid);
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       g_rec_mutex_lock(&h->mutex);
-       do {
-               rpc_port_parcel_h parcel_received;
-
-               parcel_received = __tts_consume_command(h);
-               if (!parcel_received) {
-                       _E("Invalid protocol");
-                       r = RPC_PORT_ERROR_IO_ERROR;
-                       break;
-               }
-
-               rpc_port_parcel_read_int32(parcel_received, &ret);
-
-               rpc_port_parcel_destroy(parcel_received);
-       } while (0);
-       g_rec_mutex_unlock(&h->mutex);
-       set_last_result(r);
-
-       return ret;
-}
-
-int rpc_port_proxy_tts_invoke_set_private(rpc_port_proxy_tts_h h, int uid, const char *key, const char *priv_data)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-       int ret = -1;
-
-       if (!h) {
-               _E("Invalid parameter");
-               return ret;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return ret;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_set_private);
-       rpc_port_parcel_write_int32(parcel, uid);
-       rpc_port_parcel_write_string(parcel, key ? key : "");
-       rpc_port_parcel_write_string(parcel, priv_data ? priv_data : "");
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       g_rec_mutex_lock(&h->mutex);
-       do {
-               rpc_port_parcel_h parcel_received;
-
-               parcel_received = __tts_consume_command(h);
-               if (!parcel_received) {
-                       _E("Invalid protocol");
-                       r = RPC_PORT_ERROR_IO_ERROR;
-                       break;
-               }
-
-               rpc_port_parcel_read_int32(parcel_received, &ret);
-
-               rpc_port_parcel_destroy(parcel_received);
-       } while (0);
-       g_rec_mutex_unlock(&h->mutex);
-       set_last_result(r);
-
-       return ret;
-}
-
-int rpc_port_proxy_tts_invoke_get_private(rpc_port_proxy_tts_h h, int uid, const char *key, char **priv_data)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-       int ret = -1;
-
-       if (!h || !priv_data) {
-               _E("Invalid parameter");
-               return ret;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return ret;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_get_private);
-       rpc_port_parcel_write_int32(parcel, uid);
-       rpc_port_parcel_write_string(parcel, key ? key : "");
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       g_rec_mutex_lock(&h->mutex);
-       do {
-               rpc_port_parcel_h parcel_received;
-               char *out_priv_data;
-
-               parcel_received = __tts_consume_command(h);
-               if (!parcel_received) {
-                       _E("Invalid protocol");
-                       r = RPC_PORT_ERROR_IO_ERROR;
-                       break;
-               }
-
-               rpc_port_parcel_read_string(parcel_received, &out_priv_data);
-               *priv_data = out_priv_data;
-               rpc_port_parcel_read_int32(parcel_received, &ret);
-
-               rpc_port_parcel_destroy(parcel_received);
-       } while (0);
-       g_rec_mutex_unlock(&h->mutex);
-       set_last_result(r);
-
-       return ret;
-}
-
-int rpc_port_proxy_tts_invoke_play(rpc_port_proxy_tts_h h, int uid, const char *credential)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-       int ret = -1;
-
-       if (!h) {
-               _E("Invalid parameter");
-               return ret;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return ret;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_play);
-       rpc_port_parcel_write_int32(parcel, uid);
-       rpc_port_parcel_write_string(parcel, credential ? credential : "");
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       g_rec_mutex_lock(&h->mutex);
-       do {
-               rpc_port_parcel_h parcel_received;
-
-               parcel_received = __tts_consume_command(h);
-               if (!parcel_received) {
-                       _E("Invalid protocol");
-                       r = RPC_PORT_ERROR_IO_ERROR;
-                       break;
-               }
-
-               rpc_port_parcel_read_int32(parcel_received, &ret);
-
-               rpc_port_parcel_destroy(parcel_received);
-       } while (0);
-       g_rec_mutex_unlock(&h->mutex);
-       set_last_result(r);
-
-       return ret;
-}
-
-int rpc_port_proxy_tts_invoke_add_pcm(rpc_port_proxy_tts_h h, int uid, int event, rpc_port_array_char_h pcm_data, int data_size, int audio_type, int rate)
-{
-       rpc_port_parcel_h parcel;
-       int r;
-       int ret = -1;
-
-       if (!h || !pcm_data) {
-               _E("Invalid parameter");
-               return ret;
-       }
-
-       if (!h->port) {
-               _E("Not connected");
-               return ret;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_add_pcm);
-       rpc_port_parcel_write_int32(parcel, uid);
-       rpc_port_parcel_write_int32(parcel, event);
-       rpc_port_parcel_write(parcel, &pcm_data->parcelable, pcm_data);
-       rpc_port_parcel_write_int32(parcel, data_size);
-       rpc_port_parcel_write_int32(parcel, audio_type);
-       rpc_port_parcel_write_int32(parcel, rate);
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       if (r != RPC_PORT_ERROR_NONE) {
-               _E("Failed to send parcel. result(%d)", r);
-               r = RPC_PORT_ERROR_IO_ERROR;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       g_rec_mutex_lock(&h->mutex);
-       do {
-               rpc_port_parcel_h parcel_received;
-
-               parcel_received = __tts_consume_command(h);
-               if (!parcel_received) {
-                       _E("Invalid protocol");
-                       r = RPC_PORT_ERROR_IO_ERROR;
-                       break;
-               }
-
-               rpc_port_parcel_read_int32(parcel_received, &ret);
-
-               rpc_port_parcel_destroy(parcel_received);
-       } while (0);
-       g_rec_mutex_unlock(&h->mutex);
-       set_last_result(r);
-
-       return ret;
-}
-
-static struct tts_s *__create_tts(const char *stub_appid, rpc_port_proxy_tts_callback_s *callback, void *user_data)
-{
-       struct tts_s *handle;
-
-       handle = calloc(1, sizeof(struct tts_s));
-       if (!handle) {
-               _E("Out of memory");
-               return NULL;
-       }
-
-       handle->stub_appid = strdup(stub_appid);
-       if (!handle->stub_appid) {
-               _E("Out of memory");
-               free(handle);
-               return NULL;
-       }
-
-       rpc_port_proxy_create(&handle->proxy);
-       if (!handle->proxy) {
-               _E("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;
-}
-
-static void __destroy_tts(struct tts_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);
-}
-
-int rpc_port_proxy_tts_create(const char *stub_appid, rpc_port_proxy_tts_callback_s *callback, void *user_data, rpc_port_proxy_tts_h *h)
-{
-       struct tts_s *handle;
-       int r;
-
-       if (!stub_appid || !callback || !h) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       handle = __create_tts(stub_appid, callback, user_data);
-       if (!handle)
-               return -1;
-
-       r = rpc_port_proxy_add_connected_event_cb(handle->proxy, __tts_on_connected, handle);
-       if (r != 0) {
-               _E("Failed to add connected event cb. err = %d", r);
-               __destroy_tts(handle);
-               return r;
-       }
-
-       r = rpc_port_proxy_add_disconnected_event_cb(handle->proxy, __tts_on_disconnected, handle);
-       if (r != 0) {
-               _E("Failed to add disconnected event cb. err = %d", r);
-               __destroy_tts(handle);
-               return r;
-       }
-
-       r = rpc_port_proxy_add_rejected_event_cb(handle->proxy, __tts_on_rejected, handle);
-       if (r != 0) {
-               _E("Failed to add rejected event cb. err = %d", r);
-               __destroy_tts(handle);
-               return r;
-       }
-
-       r = rpc_port_proxy_add_received_event_cb(handle->proxy, __tts_on_received, handle);
-       if (r != 0) {
-               _E("Failed to add received event cb. err = %d", r);
-               __destroy_tts(handle);
-               return r;
-       }
-
-       *h = handle;
-
-       return 0;
-}
-
-int rpc_port_proxy_tts_connect(rpc_port_proxy_tts_h h)
-{
-       int r;
-
-       if (!h || !h->proxy) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       r = rpc_port_proxy_connect(h->proxy, h->stub_appid, "tts");
-       if (r != 0) {
-               _E("Failed to connect tts(%s)", h->stub_appid);
-               return r;
-       }
-
-       return 0;
-}
-
-int rpc_port_proxy_tts_destroy(rpc_port_proxy_tts_h h)
-{
-       if (!h) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       __destroy_tts(h);
-       return 0;
-}
-
-int rpc_port_proxy_tts_connect_sync(rpc_port_proxy_tts_h h)
-{
-       int r;
-
-       if (!h || !h->proxy) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       r = rpc_port_proxy_connect_sync(h->proxy, h->stub_appid, "tts");
-       if (r != 0) {
-               _E("Failed to connect sync tts(%s)", h->stub_appid);
-               return r;
-       }
-
-       return 0;
-}
diff --git a/client/tts_proxy.h b/client/tts_proxy.h
deleted file mode 100644 (file)
index 3d9d969..0000000
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Generated by tidlc 1.4.9.
- */
-
-#pragma once
-
-#include <stdbool.h>
-#include <bundle.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct array_char_s *rpc_port_array_char_h;
-
-int rpc_port_array_char_create(rpc_port_array_char_h *h);
-
-int rpc_port_array_char_destroy(rpc_port_array_char_h h);
-
-int rpc_port_array_char_clone(rpc_port_array_char_h h, rpc_port_array_char_h *clone);
-
-int rpc_port_array_char_set_array_chars(rpc_port_array_char_h h, char *array_chars, int array_chars_size);
-
-int rpc_port_array_char_get_array_chars(rpc_port_array_char_h h, char **array_chars, int *array_chars_size);
-
-typedef struct tts_s *rpc_port_proxy_tts_h;
-
-typedef struct {
-       void (*connected)(rpc_port_proxy_tts_h h, void *user_data);
-       void (*disconnected)(rpc_port_proxy_tts_h h, void *user_data);
-       void (*rejected)(rpc_port_proxy_tts_h h, void *user_data);
-} rpc_port_proxy_tts_callback_s;
-
-typedef struct tts_notify_cb_s *rpc_port_tts_notify_cb_h;
-
-typedef void (*tts_notify_cb)(void *user_data, int pid, int uid, bundle *msg);
-
-rpc_port_tts_notify_cb_h rpc_port_tts_notify_cb_create(tts_notify_cb callback, bool once, void *user_data);
-
-int rpc_port_tts_notify_cb_destroy(rpc_port_tts_notify_cb_h delegate);
-
-int rpc_port_proxy_tts_notify_cb_dispose(rpc_port_proxy_tts_h proxy, rpc_port_tts_notify_cb_h delegate);
-
-int rpc_port_proxy_tts_create(const char *stub_appid,
-        rpc_port_proxy_tts_callback_s *callback, void *user_data,
-        rpc_port_proxy_tts_h *h);
-
-int rpc_port_proxy_tts_connect(rpc_port_proxy_tts_h h);
-
-int rpc_port_proxy_tts_destroy(rpc_port_proxy_tts_h h);
-
-void rpc_port_proxy_tts_invoke_register_cb(rpc_port_proxy_tts_h h, int pid, int uid, rpc_port_tts_notify_cb_h callback);
-
-int rpc_port_proxy_tts_invoke_register_cb_sync(rpc_port_proxy_tts_h h, int pid, int uid, rpc_port_tts_notify_cb_h callback);
-
-int rpc_port_proxy_tts_invoke_set_mode(rpc_port_proxy_tts_h h, int mode);
-
-int rpc_port_proxy_tts_invoke_initialize(rpc_port_proxy_tts_h h, int pid, int uid, bool *credential_needed);
-
-int rpc_port_proxy_tts_invoke_finalize(rpc_port_proxy_tts_h h, int uid);
-
-int rpc_port_proxy_tts_invoke_add_text(rpc_port_proxy_tts_h h, int uid, const char *text, const char *lang, int vctype, int speed, int uttid, const char *credential);
-
-int rpc_port_proxy_tts_invoke_stop(rpc_port_proxy_tts_h h, int uid);
-
-int rpc_port_proxy_tts_invoke_pause(rpc_port_proxy_tts_h h, int uid);
-
-int rpc_port_proxy_tts_invoke_play_pcm(rpc_port_proxy_tts_h h, int uid);
-
-int rpc_port_proxy_tts_invoke_stop_pcm(rpc_port_proxy_tts_h h, int uid);
-
-int rpc_port_proxy_tts_invoke_set_private(rpc_port_proxy_tts_h h, int uid, const char *key, const char *priv_data);
-
-int rpc_port_proxy_tts_invoke_get_private(rpc_port_proxy_tts_h h, int uid, const char *key, char **priv_data);
-
-int rpc_port_proxy_tts_invoke_play(rpc_port_proxy_tts_h h, int uid, const char *credential);
-
-int rpc_port_proxy_tts_invoke_add_pcm(rpc_port_proxy_tts_h h, int uid, int event, rpc_port_array_char_h pcm_data, int data_size, int audio_type, int rate);
-
-int rpc_port_proxy_tts_connect_sync(rpc_port_proxy_tts_h h);
-
-#ifdef __cplusplus
-}
-#endif
index 1f47365c5136fbede00e6164ef2292fa5d15c8da..290e9501c060eeac0424740da4c2ce87ba89344c 100644 (file)
@@ -25,7 +25,7 @@ typedef struct {
        int uid;
        bool connected;
        rpc_port_proxy_tts_h rpc_h;
-       rpc_port_tts_notify_cb_h notify_cb_h;
+       rpc_port_proxy_tts_notify_cb_h notify_cb_h;
        char* engine_app_id;
 } tts_tidl_info_s;
 
@@ -369,7 +369,9 @@ int tts_tidl_request_hello(int uid)
                info->notify_cb_h = NULL;
        }
 
-       info->notify_cb_h = rpc_port_tts_notify_cb_create(__notify_cb, false, NULL);
+       rpc_port_proxy_tts_notify_cb_create(&info->notify_cb_h);
+       rpc_port_proxy_tts_notify_cb_set_callback(info->notify_cb_h, __notify_cb, NULL);
+       rpc_port_proxy_tts_notify_cb_set_once(info->notify_cb_h, false);
        rpc_port_proxy_tts_invoke_register_cb(info->rpc_h, client->pid, uid, info->notify_cb_h);
 
        SLOG(LOG_DEBUG, TAG_TTSC, "<<<<");
@@ -426,7 +428,9 @@ int tts_tidl_request_hello_sync(int uid)
                info->notify_cb_h = NULL;
        }
 
-       info->notify_cb_h = rpc_port_tts_notify_cb_create(__notify_cb, false, NULL);
+       rpc_port_proxy_tts_notify_cb_create(&info->notify_cb_h);
+       rpc_port_proxy_tts_notify_cb_set_callback(info->notify_cb_h, __notify_cb, NULL);
+       rpc_port_proxy_tts_notify_cb_set_once(info->notify_cb_h, false);
        if (0 != rpc_port_proxy_tts_invoke_register_cb_sync(info->rpc_h, client->pid, uid, info->notify_cb_h)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Failed to invoke register");
                return TTS_ERROR_OPERATION_FAILED;
@@ -785,21 +789,21 @@ int tts_tidl_request_add_pcm(int uid, int event, const char* data, int data_size
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       rpc_port_array_char_h pcm_data = NULL;
-       rpc_port_array_char_create(&pcm_data);
+       rpc_port_proxy_array_char_h pcm_data = NULL;
+       rpc_port_proxy_array_char_create(&pcm_data);
        if (NULL == pcm_data) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create data handle");
                return TTS_ERROR_OUT_OF_MEMORY;
        }
 
        if (NULL != data && 0 < data_size) {
-               rpc_port_array_char_set_array_chars(pcm_data, (char*)data, data_size);
+               rpc_port_proxy_array_char_set(pcm_data, (char*)data, data_size);
        } else {
                SLOG(LOG_INFO, TAG_TTSC, "[TIDL] data is empty");
        }
 
        int ret = rpc_port_proxy_tts_invoke_add_pcm(info->rpc_h, uid, event, pcm_data, data_size, audio_type, rate);
-       rpc_port_array_char_destroy(pcm_data);
+       rpc_port_proxy_array_char_destroy(pcm_data);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request pause pcm : Fail to invoke message(%d)", ret);
                return ret;
index 99c3cc704b154708687fb09e93467fd4aa976430..ef3bef0eb906a0bdc20298fae5c7875e4b341024 100644 (file)
@@ -90,13 +90,11 @@ GTest for TTS
 %setup -q -n %{name}-%{version}
 cp %{SOURCE1001} %{SOURCE1002} .
 
-%if 0%{?tidlc:1}
 tidlc -p -l C -i tidl/tts.tidl -o tts_proxy
 tidlc -s -l C -i tidl/tts.tidl -o ttsd_stub
 
 mv tts_proxy* client
 mv ttsd_stub* server
-%endif
 
 %build
 export CFLAGS="$CFLAGS -DTIZEN_ENGINEER_MODE"
diff --git a/server/ttsd_stub.c b/server/ttsd_stub.c
deleted file mode 100644 (file)
index 0d5986e..0000000
+++ /dev/null
@@ -1,1196 +0,0 @@
-/*
- * Generated by tidlc 1.4.9.
- */
-
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-#include <pthread.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <libgen.h>
-#include <glib.h>
-#include <dlog.h>
-#include <rpc-port.h>
-#include <rpc-port-parcel.h>
-
-#include "ttsd_stub.h"
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-
-#define LOG_TAG "RPC_PORT_STUB"
-
-#ifdef _E
-#undef _E
-#endif
-
-#ifdef _W
-#undef _W
-#endif
-
-#ifdef _I
-#undef _I
-#endif
-
-#ifdef _D
-#undef _D
-#endif
-
-#define _E(fmt, ...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _W(fmt, ...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _I(fmt, ...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _D(fmt, ...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-
-typedef int (*stub_method)(rpc_port_h, rpc_port_parcel_h, void *data);
-
-struct array_char_s {
-       rpc_port_parcelable_t parcelable;
-       char *array_chars;
-       int array_chars_size;
-};
-
-static void __array_char_to(rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_array_char_h h = data;
-
-       if (!parcel || !h) {
-               _E("Invalid parameter");
-               return;
-       }
-
-       rpc_port_parcel_write_array_count(parcel, h->array_chars_size);
-       do {
-               for (int i = 0; i < h->array_chars_size; i++) {
-                       rpc_port_parcel_write_byte(parcel, h->array_chars[i]);
-               }
-       } while (0);
-}
-
-static void __array_char_from(rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_array_char_h h = data;
-
-       if (!parcel || !h) {
-               _E("Invalid parameter");
-               return;
-       }
-
-       do {
-               rpc_port_parcel_read_array_count(parcel, &h->array_chars_size);
-
-               h->array_chars = calloc(h->array_chars_size, sizeof(*h->array_chars));
-               if (!h->array_chars) {
-                       _E("Out of memory");
-                       return;
-               }
-
-               for (int i = 0; i < h->array_chars_size; i++) {
-                       char value = 0;
-
-                       rpc_port_parcel_read_byte(parcel, &value);
-                       h->array_chars[i] = value;
-               }
-       } while (0);
-}
-
-int rpc_port_array_char_create(rpc_port_array_char_h *h)
-{
-       struct array_char_s *handle;
-
-       if (!h) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       handle = calloc(1, sizeof(struct array_char_s));
-       if (!handle) {
-               _E("Out of memory");
-               return -1;
-       }
-
-       handle->parcelable.to = __array_char_to;
-       handle->parcelable.from = __array_char_from;
-
-       *h = handle;
-
-       return 0;
-}
-
-int rpc_port_array_char_destroy(rpc_port_array_char_h h)
-{
-       if (!h) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       if (h->array_chars)
-               free(h->array_chars);
-
-       free(h);
-
-       return 0;
-}
-
-int rpc_port_array_char_clone(rpc_port_array_char_h h, rpc_port_array_char_h *clone)
-{
-       rpc_port_array_char_h handle = NULL;
-
-       if (!h || !clone) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       rpc_port_array_char_create(&handle);
-       if (!handle) {
-               _E("Failed to create array_char handle");
-               return -1;
-       }
-
-       do {
-               if (h->array_chars_size == 0) {
-                       _W("array_chars is empty");
-                       break;
-               }
-
-               handle->array_chars = calloc(h->array_chars_size, sizeof(*h->array_chars));
-               if (!handle->array_chars) {
-                       _E("Out of memory");
-                       rpc_port_array_char_destroy(handle);
-                       return -1;
-               }
-               handle->array_chars_size = h->array_chars_size;
-
-               for (int i = 0; i < h->array_chars_size; i++) {
-                       handle->array_chars[i] = h->array_chars[i];
-               }
-       } while (0);
-
-       *clone = handle;
-
-       return 0;
-}
-
-int rpc_port_array_char_set_array_chars(rpc_port_array_char_h h, char *array_chars, int array_chars_size)
-{
-       if (!h) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       if (h->array_chars)
-               free(h->array_chars);
-
-       h->array_chars = NULL;
-
-       do {
-               h->array_chars = calloc(array_chars_size, sizeof(*array_chars));
-               if (!h->array_chars) {
-                       _E("Out of memory");
-                       return -1;
-               }
-               h->array_chars_size = array_chars_size;
-
-               for (int i = 0; i < h->array_chars_size; i++) {
-                       h->array_chars[i] = array_chars[i];
-               }
-       } while (0);
-
-       return 0;
-}
-
-int rpc_port_array_char_get_array_chars(rpc_port_array_char_h h, char **array_chars, int *array_chars_size)
-{
-       if (!h || !array_chars || !array_chars_size) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       do {
-               if (h->array_chars_size == 0) {
-                       _W("array_chars is empty");
-                       break;
-               }
-
-               *array_chars = calloc(h->array_chars_size, sizeof(*h->array_chars));
-               if (!*array_chars) {
-                       _E("Out of memory");
-                       return -1;
-               }
-               *array_chars_size = h->array_chars_size;
-
-               for (int i = 0; i < h->array_chars_size; i++) {
-                       (*array_chars)[i] = h->array_chars[i];
-               }
-       } while (0);
-
-       return 0;
-}
-
-enum tts_method_e {
-       tts_METHOD_Result,
-       tts_METHOD_Callback,
-       tts_METHOD_register_cb,
-       tts_METHOD_register_cb_sync,
-       tts_METHOD_set_mode,
-       tts_METHOD_initialize,
-       tts_METHOD_finalize,
-       tts_METHOD_add_text,
-       tts_METHOD_stop,
-       tts_METHOD_pause,
-       tts_METHOD_play_pcm,
-       tts_METHOD_stop_pcm,
-       tts_METHOD_set_private,
-       tts_METHOD_get_private,
-       tts_METHOD_play,
-       tts_METHOD_add_pcm,
-};
-
-enum tts_delegate_e {
-       tts_DELEGATE_notify_cb = 1,
-};
-
-static rpc_port_stub_h __tts_stub;
-static rpc_port_stub_tts_callback_s __tts_callback;
-static void *__tts_user_data;
-static GList *__tts_contexts;
-
-struct tts_context_s {
-       char *sender;
-       char *instance;
-       rpc_port_h port;
-       void *tag;
-       rpc_port_stub_tts_callback_s callback;
-       void *user_data;
-};
-
-static struct tts_context_s *__create_tts_context(const char *sender, const char *instance)
-{
-       struct tts_context_s *handle;
-
-       handle = calloc(1, sizeof(struct tts_context_s));
-       if (!handle) {
-               _E("Out of memory");
-               return NULL;
-       }
-
-       handle->sender = strdup(sender);
-       if (!handle->sender) {
-               _E("Out of memory");
-               free(handle);
-               return NULL;
-       }
-
-       handle->instance = strdup(instance);
-       if (!handle->instance) {
-               _E("Out of memory");
-               free(handle->sender);
-               free(handle);
-               return NULL;
-       }
-
-       handle->callback = __tts_callback;
-       handle->user_data = __tts_user_data;
-
-       return handle;
-}
-
-static void __destroy_tts_context(gpointer data)
-{
-       struct tts_context_s *handle = data;
-
-       if (!handle) {
-               _E("Critical error!");
-               return;
-       }
-
-       free(handle->instance);
-       free(handle->sender);
-
-       free(handle);
-}
-
-static struct tts_context_s *__find_tts_context(const char *instance)
-{
-       struct tts_context_s *handle;
-       GList *iter;
-
-       iter = __tts_contexts;
-       while (iter) {
-               handle = (struct tts_context_s *)iter->data;
-               if (!strcmp(handle->instance, instance))
-                       return handle;
-               iter = g_list_next(iter);
-       }
-
-       return NULL;
-}
-
-int rpc_port_stub_tts_context_set_tag(rpc_port_stub_tts_context_h ctx, void *tag)
-{
-       if (!ctx) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       ctx->tag = tag;
-
-       return 0;
-}
-
-int rpc_port_stub_tts_context_get_tag(rpc_port_stub_tts_context_h ctx, void **tag)
-{
-       if (!ctx || !tag) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       *tag = ctx->tag;
-
-       return 0;
-}
-
-int rpc_port_stub_tts_context_get_sender(rpc_port_stub_tts_context_h ctx, char **sender)
-{
-       if (!ctx || !sender) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       *sender = strdup(ctx->sender);
-       if (*sender == NULL) {
-               _E("Out of memory");
-               return -1;
-       }
-
-       return 0;
-}
-
-struct tts_notify_cb_s {
-       rpc_port_parcelable_t parcelable;
-       rpc_port_h port;
-       int id;
-       int seq_id;
-       bool once;
-       bool valid;
-};
-
-static void __tts_notify_cb_to(rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_tts_notify_cb_h handle = data;
-
-       if (!handle) {
-               _E("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);
-       _I("id(%d), seq_id(%d), once(%s)", handle->id, handle->seq_id, handle->once ? "true" : "false");
-}
-
-static void __tts_notify_cb_from(rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_tts_notify_cb_h handle = data;
-
-       if (!handle) {
-               _E("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);
-       _I("id(%d), seq_id(%d), once(%s)", handle->id, handle->seq_id, handle->once ? "true" : "false");
-}
-
-static int rpc_port_tts_notify_cb_create(rpc_port_tts_notify_cb_h *h)
-{
-       struct tts_notify_cb_s *handle;
-       static int seq_num;
-
-       if (!h) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       handle = calloc(1, sizeof(struct tts_notify_cb_s));
-       if (!handle) {
-               _E("Out of memory");
-               return -1;
-       }
-
-       handle->parcelable.to = __tts_notify_cb_to;
-       handle->parcelable.from = __tts_notify_cb_from;
-       handle->id = tts_DELEGATE_notify_cb;
-       handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1;
-       handle->once = false;
-       handle->valid = true;
-
-       *h = handle;
-
-       return 0;
-}
-
-int rpc_port_tts_notify_cb_destroy(rpc_port_tts_notify_cb_h h)
-{
-       if (!h) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       free(h);
-
-       return 0;
-}
-
-int rpc_port_tts_notify_cb_clone(rpc_port_tts_notify_cb_h h, rpc_port_tts_notify_cb_h *clone)
-{
-       rpc_port_tts_notify_cb_h handle;
-
-       if (!h || !clone) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       handle = calloc(1, sizeof(struct tts_notify_cb_s));
-       if (!handle) {
-               _E("Out of memory");
-               return -1;
-       }
-
-       handle->parcelable = h->parcelable;
-       handle->port = h->port;
-       handle->id = h->id;
-       handle->seq_id = h->seq_id;
-       handle->once = h->once;
-       handle->valid = h->valid;
-       _I("id(%d), seq_id(%d), once(%s)", handle->id, handle->seq_id, handle->once ? "true" : "false");
-
-       *clone = handle;
-
-       return 0;
-}
-
-int rpc_port_tts_notify_cb_invoke(rpc_port_tts_notify_cb_h h, int pid, int uid, bundle *msg)
-{
-       rpc_port_parcel_h parcel = NULL;
-       int r;
-
-       if (!h || !h->port) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       if (h->once && !h->valid) {
-               _E("Invalid callback");
-               return -1;
-       }
-
-       rpc_port_parcel_create(&parcel);
-       if (!parcel) {
-               _E("Failed to create parcel");
-               return -1;
-       }
-
-       rpc_port_parcel_write_int32(parcel, tts_METHOD_Callback);
-       rpc_port_parcel_write(parcel, &h->parcelable, h);
-       rpc_port_parcel_write_int32(parcel, pid);
-       rpc_port_parcel_write_int32(parcel, uid);
-       rpc_port_parcel_write_bundle(parcel, msg);
-
-       r = rpc_port_parcel_send(parcel, h->port);
-       rpc_port_parcel_destroy(parcel);
-       h->valid = false;
-
-       return r;
-}
-
-int rpc_port_tts_notify_cb_set_port(rpc_port_tts_notify_cb_h h, rpc_port_h port)
-{
-       if (!h || !port) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       h->port = port;
-
-       return 0;
-}
-
-static int __tts_method_register_cb(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int pid;
-       int uid;
-       rpc_port_tts_notify_cb_h callback = NULL;
-
-       rpc_port_parcel_read_int32(parcel, &pid);
-       rpc_port_parcel_read_int32(parcel, &uid);
-       rpc_port_tts_notify_cb_create(&callback);
-
-       if (!callback) {
-               _E("Failed to create handle");
-               return -1;
-       }
-
-       rpc_port_tts_notify_cb_set_port(callback, callback_port);
-       rpc_port_parcel_read(parcel, &callback->parcelable, callback);
-
-       context->callback.register_cb(context, pid, uid, callback, context->user_data);
-
-       rpc_port_tts_notify_cb_destroy(callback);
-       return r;
-}
-
-static int __tts_method_register_cb_sync(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int pid;
-       int uid;
-       rpc_port_tts_notify_cb_h callback = NULL;
-
-       rpc_port_parcel_read_int32(parcel, &pid);
-       rpc_port_parcel_read_int32(parcel, &uid);
-       rpc_port_tts_notify_cb_create(&callback);
-
-       if (!callback) {
-               _E("Failed to create handle");
-               return -1;
-       }
-
-       rpc_port_tts_notify_cb_set_port(callback, callback_port);
-       rpc_port_parcel_read(parcel, &callback->parcelable, callback);
-
-       int ret = context->callback.register_cb_sync(context, pid, uid, callback, context->user_data);
-       do {
-               rpc_port_parcel_h result;
-
-               rpc_port_parcel_create(&result);
-               rpc_port_parcel_write_int32(result, tts_METHOD_Result);
-               rpc_port_parcel_write_int32(result, ret);
-               r = rpc_port_parcel_send(result, port);
-               rpc_port_parcel_destroy(result);
-       } while (0);
-
-       rpc_port_tts_notify_cb_destroy(callback);
-       return r;
-}
-
-static int __tts_method_set_mode(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int mode;
-
-       rpc_port_parcel_read_int32(parcel, &mode);
-
-       int ret = context->callback.set_mode(context, mode, context->user_data);
-       do {
-               rpc_port_parcel_h result;
-
-               rpc_port_parcel_create(&result);
-               rpc_port_parcel_write_int32(result, tts_METHOD_Result);
-               rpc_port_parcel_write_int32(result, ret);
-               r = rpc_port_parcel_send(result, port);
-               rpc_port_parcel_destroy(result);
-       } while (0);
-
-       return r;
-}
-
-static int __tts_method_initialize(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int pid;
-       int uid;
-       bool credential_needed;
-
-       rpc_port_parcel_read_int32(parcel, &pid);
-       rpc_port_parcel_read_int32(parcel, &uid);
-
-       int ret = context->callback.initialize(context, pid, uid, &credential_needed, context->user_data);
-       do {
-               rpc_port_parcel_h result;
-
-               rpc_port_parcel_create(&result);
-               rpc_port_parcel_write_int32(result, tts_METHOD_Result);
-               rpc_port_parcel_write_bool(result, credential_needed);
-               rpc_port_parcel_write_int32(result, ret);
-               r = rpc_port_parcel_send(result, port);
-               rpc_port_parcel_destroy(result);
-       } while (0);
-
-       return r;
-}
-
-static int __tts_method_finalize(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int uid;
-
-       rpc_port_parcel_read_int32(parcel, &uid);
-
-       int ret = context->callback.finalize(context, uid, context->user_data);
-       do {
-               rpc_port_parcel_h result;
-
-               rpc_port_parcel_create(&result);
-               rpc_port_parcel_write_int32(result, tts_METHOD_Result);
-               rpc_port_parcel_write_int32(result, ret);
-               r = rpc_port_parcel_send(result, port);
-               rpc_port_parcel_destroy(result);
-       } while (0);
-
-       return r;
-}
-
-static int __tts_method_add_text(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int uid;
-       char *text;
-       char *lang;
-       int vctype;
-       int speed;
-       int uttid;
-       char *credential;
-
-       rpc_port_parcel_read_int32(parcel, &uid);
-       rpc_port_parcel_read_string(parcel, &text);
-       rpc_port_parcel_read_string(parcel, &lang);
-       rpc_port_parcel_read_int32(parcel, &vctype);
-       rpc_port_parcel_read_int32(parcel, &speed);
-       rpc_port_parcel_read_int32(parcel, &uttid);
-       rpc_port_parcel_read_string(parcel, &credential);
-
-       int ret = context->callback.add_text(context, uid, text, lang, vctype, speed, uttid, credential, context->user_data);
-       do {
-               rpc_port_parcel_h result;
-
-               rpc_port_parcel_create(&result);
-               rpc_port_parcel_write_int32(result, tts_METHOD_Result);
-               rpc_port_parcel_write_int32(result, ret);
-               r = rpc_port_parcel_send(result, port);
-               rpc_port_parcel_destroy(result);
-       } while (0);
-
-       free(text);
-       free(lang);
-
-       free(credential);
-       return r;
-}
-
-static int __tts_method_stop(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int uid;
-
-       rpc_port_parcel_read_int32(parcel, &uid);
-
-       int ret = context->callback.stop(context, uid, context->user_data);
-       do {
-               rpc_port_parcel_h result;
-
-               rpc_port_parcel_create(&result);
-               rpc_port_parcel_write_int32(result, tts_METHOD_Result);
-               rpc_port_parcel_write_int32(result, ret);
-               r = rpc_port_parcel_send(result, port);
-               rpc_port_parcel_destroy(result);
-       } while (0);
-
-       return r;
-}
-
-static int __tts_method_pause(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int uid;
-
-       rpc_port_parcel_read_int32(parcel, &uid);
-
-       int ret = context->callback.pause(context, uid, context->user_data);
-       do {
-               rpc_port_parcel_h result;
-
-               rpc_port_parcel_create(&result);
-               rpc_port_parcel_write_int32(result, tts_METHOD_Result);
-               rpc_port_parcel_write_int32(result, ret);
-               r = rpc_port_parcel_send(result, port);
-               rpc_port_parcel_destroy(result);
-       } while (0);
-
-       return r;
-}
-
-static int __tts_method_play_pcm(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int uid;
-
-       rpc_port_parcel_read_int32(parcel, &uid);
-
-       int ret = context->callback.play_pcm(context, uid, context->user_data);
-       do {
-               rpc_port_parcel_h result;
-
-               rpc_port_parcel_create(&result);
-               rpc_port_parcel_write_int32(result, tts_METHOD_Result);
-               rpc_port_parcel_write_int32(result, ret);
-               r = rpc_port_parcel_send(result, port);
-               rpc_port_parcel_destroy(result);
-       } while (0);
-
-       return r;
-}
-
-static int __tts_method_stop_pcm(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int uid;
-
-       rpc_port_parcel_read_int32(parcel, &uid);
-
-       int ret = context->callback.stop_pcm(context, uid, context->user_data);
-       do {
-               rpc_port_parcel_h result;
-
-               rpc_port_parcel_create(&result);
-               rpc_port_parcel_write_int32(result, tts_METHOD_Result);
-               rpc_port_parcel_write_int32(result, ret);
-               r = rpc_port_parcel_send(result, port);
-               rpc_port_parcel_destroy(result);
-       } while (0);
-
-       return r;
-}
-
-static int __tts_method_set_private(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int uid;
-       char *key;
-       char *priv_data;
-
-       rpc_port_parcel_read_int32(parcel, &uid);
-       rpc_port_parcel_read_string(parcel, &key);
-       rpc_port_parcel_read_string(parcel, &priv_data);
-
-       int ret = context->callback.set_private(context, uid, key, priv_data, context->user_data);
-       do {
-               rpc_port_parcel_h result;
-
-               rpc_port_parcel_create(&result);
-               rpc_port_parcel_write_int32(result, tts_METHOD_Result);
-               rpc_port_parcel_write_int32(result, ret);
-               r = rpc_port_parcel_send(result, port);
-               rpc_port_parcel_destroy(result);
-       } while (0);
-
-       free(key);
-       free(priv_data);
-       return r;
-}
-
-static int __tts_method_get_private(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int uid;
-       char *key;
-       char *priv_data;
-
-       rpc_port_parcel_read_int32(parcel, &uid);
-       rpc_port_parcel_read_string(parcel, &key);
-
-       int ret = context->callback.get_private(context, uid, key, &priv_data, context->user_data);
-       do {
-               rpc_port_parcel_h result;
-
-               rpc_port_parcel_create(&result);
-               rpc_port_parcel_write_int32(result, tts_METHOD_Result);
-               rpc_port_parcel_write_string(result, priv_data ? priv_data : "");
-               rpc_port_parcel_write_int32(result, ret);
-               r = rpc_port_parcel_send(result, port);
-               rpc_port_parcel_destroy(result);
-       } while (0);
-
-       free(key);
-       free(priv_data);
-       return r;
-}
-
-static int __tts_method_play(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int uid;
-       char *credential;
-
-       rpc_port_parcel_read_int32(parcel, &uid);
-       rpc_port_parcel_read_string(parcel, &credential);
-
-       int ret = context->callback.play(context, uid, credential, context->user_data);
-       do {
-               rpc_port_parcel_h result;
-
-               rpc_port_parcel_create(&result);
-               rpc_port_parcel_write_int32(result, tts_METHOD_Result);
-               rpc_port_parcel_write_int32(result, ret);
-               r = rpc_port_parcel_send(result, port);
-               rpc_port_parcel_destroy(result);
-       } while (0);
-
-       free(credential);
-       return r;
-}
-
-static int __tts_method_add_pcm(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
-{
-       rpc_port_stub_tts_context_h context = data;
-       rpc_port_h callback_port;
-       int r;
-
-       r = rpc_port_stub_get_port(__tts_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port);
-       if (r != 0) {
-               _E("Failed to get callback port");
-               return -1;
-       }
-
-       int uid;
-       int event;
-       rpc_port_array_char_h pcm_data = NULL;
-       int data_size;
-       int audio_type;
-       int rate;
-
-       rpc_port_parcel_read_int32(parcel, &uid);
-       rpc_port_parcel_read_int32(parcel, &event);
-       rpc_port_array_char_create(&pcm_data);
-       rpc_port_parcel_read(parcel, &pcm_data->parcelable, pcm_data);
-       rpc_port_parcel_read_int32(parcel, &data_size);
-       rpc_port_parcel_read_int32(parcel, &audio_type);
-       rpc_port_parcel_read_int32(parcel, &rate);
-
-       int ret = context->callback.add_pcm(context, uid, event, pcm_data, data_size, audio_type, rate, context->user_data);
-       do {
-               rpc_port_parcel_h result;
-
-               rpc_port_parcel_create(&result);
-               rpc_port_parcel_write_int32(result, tts_METHOD_Result);
-               rpc_port_parcel_write_int32(result, ret);
-               r = rpc_port_parcel_send(result, port);
-               rpc_port_parcel_destroy(result);
-       } while (0);
-
-       rpc_port_array_char_destroy(pcm_data);
-
-       return r;
-}
-
-static stub_method __tts_method_table[] = {
-       [tts_METHOD_register_cb] = __tts_method_register_cb,
-       [tts_METHOD_register_cb_sync] = __tts_method_register_cb_sync,
-       [tts_METHOD_set_mode] = __tts_method_set_mode,
-       [tts_METHOD_initialize] = __tts_method_initialize,
-       [tts_METHOD_finalize] = __tts_method_finalize,
-       [tts_METHOD_add_text] = __tts_method_add_text,
-       [tts_METHOD_stop] = __tts_method_stop,
-       [tts_METHOD_pause] = __tts_method_pause,
-       [tts_METHOD_play_pcm] = __tts_method_play_pcm,
-       [tts_METHOD_stop_pcm] = __tts_method_stop_pcm,
-       [tts_METHOD_set_private] = __tts_method_set_private,
-       [tts_METHOD_get_private] = __tts_method_get_private,
-       [tts_METHOD_play] = __tts_method_play,
-       [tts_METHOD_add_pcm] = __tts_method_add_pcm,
-};
-
-static void __tts_on_connected(const char *sender, const char *instance, void *data)
-{
-       rpc_port_stub_tts_context_h context;
-
-       _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance);
-       context = __create_tts_context(sender, instance);
-       if (!context)
-               return;
-
-       if (context->callback.create)
-               context->callback.create(context, context->user_data);
-       __tts_contexts = g_list_append(__tts_contexts, context);
-}
-
-static void __tts_on_disconnected(const char *sender, const char *instance, void *data)
-{
-       rpc_port_stub_tts_context_h context;
-
-       _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance);
-       context = __find_tts_context(instance);
-       if (!context)
-               return;
-
-       if (context->callback.terminate)
-               context->callback.terminate(context, context->user_data);
-       __tts_contexts = g_list_remove(__tts_contexts, context);
-       __destroy_tts_context(context);
-}
-
-static int __tts_on_received(const char *sender, const char *instance, rpc_port_h port, void *data)
-{
-       rpc_port_stub_tts_context_h context;
-       rpc_port_parcel_h parcel;
-       int cmd = -1;
-       int r;
-
-       _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance);
-       context = __find_tts_context(instance);
-       if (!context) {
-               _E("Failed to find tts context(%s)", instance);
-               return -1;
-       }
-
-       context->port = port;
-       r = rpc_port_parcel_create_from_port(&parcel, port);
-       if (r != 0) {
-               _E("Failed to create parcel from port");
-               return r;
-       }
-
-       rpc_port_parcel_read_int32(parcel, &cmd);
-       if (cmd > 1 && cmd < (sizeof(__tts_method_table) / sizeof(__tts_method_table[0]))) {
-               if (__tts_method_table[cmd])
-                       r = __tts_method_table[cmd](port, parcel, context);
-       } else {
-               _E("Unknown Command(%d)", cmd);
-               r = -1;
-       }
-
-       rpc_port_parcel_destroy(parcel);
-
-       return r;
-}
-
-static int __tts_add_privileges(void)
-{
-
-       return 0;
-}
-
-int rpc_port_stub_tts_register(rpc_port_stub_tts_callback_s *callback, void *user_data)
-{
-       int r;
-
-       if (__tts_stub) {
-               _W("Already exists");
-               return -1;
-       }
-
-       if (!callback) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       __tts_callback = *callback;
-       __tts_user_data = user_data;
-       r = rpc_port_stub_create(&__tts_stub, "tts");
-       if (r != 0) {
-               _E("Failed to create stub handle");
-               return r;
-       }
-
-       r = rpc_port_stub_add_received_event_cb(__tts_stub, __tts_on_received, NULL);
-       if (r != 0) {
-               _E("Failed to add received event callback");
-               rpc_port_stub_destroy(__tts_stub);
-               __tts_stub = NULL;
-               return r;
-       }
-
-       r = rpc_port_stub_add_connected_event_cb(__tts_stub, __tts_on_connected, NULL);
-       if (r != 0) {
-               _E("Failed to add connected event callback");
-               rpc_port_stub_destroy(__tts_stub);
-               __tts_stub = NULL;
-               return r;
-       }
-
-       r = rpc_port_stub_add_disconnected_event_cb(__tts_stub, __tts_on_disconnected, NULL);
-       if (r != 0) {
-               _E("Failed to add disconnected event callback");
-               rpc_port_stub_destroy(__tts_stub);
-               __tts_stub = NULL;
-               return r;
-       }
-
-       r = __tts_add_privileges();
-       if (r != 0) {
-               _E("Failed to add privileges");
-               rpc_port_stub_destroy(__tts_stub);
-               __tts_stub = NULL;
-               return r;
-       }
-
-       r = rpc_port_stub_listen(__tts_stub);
-       if (r != 0) {
-               _E("Failed to listen stub");
-               rpc_port_stub_destroy(__tts_stub);
-               __tts_stub = NULL;
-               return r;
-       }
-
-       return 0;
-}
-
-int rpc_port_stub_tts_unregister(void)
-{
-       int r;
-
-       if (!__tts_stub)
-               return -1;
-
-       if (__tts_contexts) {
-               g_list_free_full(__tts_contexts, __destroy_tts_context);
-               __tts_contexts = NULL;
-       }
-
-       r = rpc_port_stub_destroy(__tts_stub);
-       __tts_stub = NULL;
-
-       return r;
-}
-
-int rpc_port_stub_tts_get_client_number(unsigned int *n)
-{
-       if (!n) {
-               _E("Invalid parameter");
-               return -1;
-       }
-
-       if (!__tts_stub) {
-               _E("tts Stub is not ready");
-               return -1;
-       }
-
-       *n = g_list_length(__tts_contexts);
-
-       return 0;
-}
diff --git a/server/ttsd_stub.h b/server/ttsd_stub.h
deleted file mode 100644 (file)
index aa976d1..0000000
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Generated by tidlc 1.4.9.
- */
-
-#pragma once
-
-#include <stdbool.h>
-#include <bundle.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct array_char_s *rpc_port_array_char_h;
-
-int rpc_port_array_char_create(rpc_port_array_char_h *h);
-
-int rpc_port_array_char_destroy(rpc_port_array_char_h h);
-
-int rpc_port_array_char_clone(rpc_port_array_char_h h, rpc_port_array_char_h *clone);
-
-int rpc_port_array_char_set_array_chars(rpc_port_array_char_h h, char *array_chars, int array_chars_size);
-
-int rpc_port_array_char_get_array_chars(rpc_port_array_char_h h, char **array_chars, int *array_chars_size);
-
-typedef struct tts_context_s* rpc_port_stub_tts_context_h;
-
-int rpc_port_stub_tts_context_set_tag(rpc_port_stub_tts_context_h ctx, void *tag);
-
-int rpc_port_stub_tts_context_get_tag(rpc_port_stub_tts_context_h ctx, void **tag);
-
-int rpc_port_stub_tts_context_get_sender(rpc_port_stub_tts_context_h ctx, char **sender);
-
-typedef struct tts_notify_cb_s *rpc_port_tts_notify_cb_h;
-
-int rpc_port_tts_notify_cb_destroy(rpc_port_tts_notify_cb_h h);
-
-int rpc_port_tts_notify_cb_clone(rpc_port_tts_notify_cb_h h, rpc_port_tts_notify_cb_h *clone);
-
-int rpc_port_tts_notify_cb_invoke(rpc_port_tts_notify_cb_h h, int pid, int uid, bundle *msg);
-
-typedef struct {
-       void (*create)(rpc_port_stub_tts_context_h context, void *user_data);
-       void (*terminate)(rpc_port_stub_tts_context_h context, void *user_data);
-
-       void (*register_cb)(rpc_port_stub_tts_context_h context, int pid, int uid, rpc_port_tts_notify_cb_h callback, void *user_data);
-       int (*register_cb_sync)(rpc_port_stub_tts_context_h context, int pid, int uid, rpc_port_tts_notify_cb_h callback, void *user_data);
-       int (*set_mode)(rpc_port_stub_tts_context_h context, int mode, void *user_data);
-       int (*initialize)(rpc_port_stub_tts_context_h context, int pid, int uid, bool *credential_needed, void *user_data);
-       int (*finalize)(rpc_port_stub_tts_context_h context, int uid, void *user_data);
-       int (*add_text)(rpc_port_stub_tts_context_h context, int uid, const char *text, const char *lang, int vctype, int speed, int uttid, const char *credential, void *user_data);
-       int (*stop)(rpc_port_stub_tts_context_h context, int uid, void *user_data);
-       int (*pause)(rpc_port_stub_tts_context_h context, int uid, void *user_data);
-       int (*play_pcm)(rpc_port_stub_tts_context_h context, int uid, void *user_data);
-       int (*stop_pcm)(rpc_port_stub_tts_context_h context, int uid, void *user_data);
-       int (*set_private)(rpc_port_stub_tts_context_h context, int uid, const char *key, const char *priv_data, void *user_data);
-       int (*get_private)(rpc_port_stub_tts_context_h context, int uid, const char *key, char **priv_data, void *user_data);
-       int (*play)(rpc_port_stub_tts_context_h context, int uid, const char *credential, void *user_data);
-       int (*add_pcm)(rpc_port_stub_tts_context_h context, int uid, int event, rpc_port_array_char_h pcm_data, int data_size, int audio_type, int rate, void *user_data);
-} rpc_port_stub_tts_callback_s;
-
-int rpc_port_stub_tts_register(rpc_port_stub_tts_callback_s *callback, void *user_data);
-
-int rpc_port_stub_tts_unregister(void);
-
-int rpc_port_stub_tts_get_client_number(unsigned int *n);
-
-#ifdef __cplusplus
-}
-#endif
index 9362074849778e62d94e142030795ebf39b7d204..e11797b49bd8ff34dac03e2d3db1973b54076306 100644 (file)
@@ -24,7 +24,7 @@
 
 typedef struct {
        int uid;
-       rpc_port_tts_notify_cb_h notify_cb_h;
+       rpc_port_stub_tts_notify_cb_h notify_cb_h;
 } tts_tidl_proxy_info_s;
 
 static GList* g_tidl_proxy_infos = NULL;
@@ -68,14 +68,14 @@ void __send_msg(int pid, int uid, bundle* msg)
                return;
        }
 
-       rpc_port_tts_notify_cb_h handle = info->notify_cb_h;
+       rpc_port_stub_tts_notify_cb_h handle = info->notify_cb_h;
        if (NULL == handle) {
                SLOG(LOG_INFO, tts_tag(), "notify callback handle null");
                pthread_mutex_unlock(&g_tidl_proxy_infos_mutex);
                return;
        }
 
-       if (0 != rpc_port_tts_notify_cb_invoke(handle, pid, uid, msg)) {
+       if (0 != rpc_port_stub_tts_notify_cb_invoke(handle, pid, uid, msg)) {
                SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to send msg");
                pthread_mutex_unlock(&g_tidl_proxy_infos_mutex);
                return;
@@ -117,7 +117,7 @@ static void __destroy_client_cb(rpc_port_stub_tts_context_h context, void *user_
                        return;
                }
 
-               rpc_port_tts_notify_cb_destroy(info->notify_cb_h);
+               rpc_port_stub_tts_notify_cb_destroy(info->notify_cb_h);
                info->notify_cb_h = NULL;
 
                g_tidl_proxy_infos = g_list_remove(g_tidl_proxy_infos, info);
@@ -138,7 +138,7 @@ static void __destroy_client_cb(rpc_port_stub_tts_context_h context, void *user_
        free(sender);
 }
 
-static void __register_cb(rpc_port_stub_tts_context_h context, int pid, int uid, rpc_port_tts_notify_cb_h callback, void* user_data)
+static void __register_cb(rpc_port_stub_tts_context_h context, int pid, int uid, rpc_port_stub_tts_notify_cb_h callback, void* user_data)
 {
        SLOG(LOG_ERROR, tts_tag(), ">>>>> TTS REGISTER CALLBACK uid(%d)", uid);
 
@@ -174,11 +174,11 @@ static void __register_cb(rpc_port_stub_tts_context_h context, int pid, int uid,
                }
        } else {
                g_tidl_proxy_infos = g_list_remove(g_tidl_proxy_infos, info);
-               rpc_port_tts_notify_cb_destroy(info->notify_cb_h);
+               rpc_port_stub_tts_notify_cb_destroy(info->notify_cb_h);
                info->notify_cb_h = NULL;
        }
 
-       if (0 != rpc_port_tts_notify_cb_clone(callback, &info->notify_cb_h)) {
+       if (0 != rpc_port_stub_tts_notify_cb_clone(callback, &info->notify_cb_h)) {
                SLOG(LOG_ERROR, tts_tag(), "[TIDL ERROR] Fail to set notify callback");
                free(info);
                pthread_mutex_unlock(&g_tidl_proxy_infos_mutex);
@@ -196,7 +196,7 @@ static void __register_cb(rpc_port_stub_tts_context_h context, int pid, int uid,
        return;
 }
 
-static int __register_cb_sync(rpc_port_stub_tts_context_h context, int pid, int uid, rpc_port_tts_notify_cb_h callback, void* user_data)
+static int __register_cb_sync(rpc_port_stub_tts_context_h context, int pid, int uid, rpc_port_stub_tts_notify_cb_h callback, void* user_data)
 {
        SLOG(LOG_ERROR, tts_tag(), ">>>>> TTS REGISTER CALLBACK synchronously uid(%d)", uid);
 
@@ -214,11 +214,11 @@ static int __register_cb_sync(rpc_port_stub_tts_context_h context, int pid, int
                }
        } else {
                g_tidl_proxy_infos = g_list_remove(g_tidl_proxy_infos, info);
-               rpc_port_tts_notify_cb_destroy(info->notify_cb_h);
+               rpc_port_stub_tts_notify_cb_destroy(info->notify_cb_h);
                info->notify_cb_h = NULL;
        }
 
-       if (0 != rpc_port_tts_notify_cb_clone(callback, &info->notify_cb_h)) {
+       if (0 != rpc_port_stub_tts_notify_cb_clone(callback, &info->notify_cb_h)) {
                SLOG(LOG_ERROR, tts_tag(), "[TIDL ERROR] Fail to set notify callback");
                free(info);
                pthread_mutex_unlock(&g_tidl_proxy_infos_mutex);
@@ -296,7 +296,7 @@ static int __finalize_cb(rpc_port_stub_tts_context_h context, int uid, void *use
                return TTSD_ERROR_INVALID_PARAMETER;
        }
 
-       rpc_port_tts_notify_cb_destroy(info->notify_cb_h);
+       rpc_port_stub_tts_notify_cb_destroy(info->notify_cb_h);
        info->notify_cb_h = NULL;
 
        g_tidl_proxy_infos = g_list_remove(g_tidl_proxy_infos, info);
@@ -416,12 +416,12 @@ static int __play_cb(rpc_port_stub_tts_context_h context, int uid, const char *c
        return TTSE_ERROR_NONE;
 }
 
-static int __add_pcm_cb(rpc_port_stub_tts_context_h context, int uid, int event, rpc_port_array_char_h pcm_data, int data_size, int audio_type, int rate, void *user_data)
+static int __add_pcm_cb(rpc_port_stub_tts_context_h context, int uid, int event, rpc_port_stub_array_char_h pcm_data, int data_size, int audio_type, int rate, void *user_data)
 {
        SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS ADD PCM (%d)", uid);
        char* pcm_data_raw = NULL;
        int pcm_data_size = 0;
-       rpc_port_array_char_get_array_chars(pcm_data, &pcm_data_raw, &pcm_data_size);
+       rpc_port_stub_array_char_get(pcm_data, &pcm_data_raw, &pcm_data_size);
 
        int ret = ttsd_server_add_pcm(uid, event, (void *)pcm_data_raw, data_size, audio_type, rate);
        free(pcm_data_raw);