mbtk/libmbtk_lib/gnss/mbtk_gnss_5311.c

/**
 *   \file mbtk_gnss_5311.c
 *   \brief gnss module.
 *
 *  Detailed description
 *   \Author:  Sniper <yq.wang@mobiletek.cn>
 *   \Version: 1.0.0
 *   \Date: 2023-12-20
 */
#if 1
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include <errno.h>
#include <pthread.h>
#include <sys/epoll.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/un.h>
#include <netinet/in.h>



#include <libubox/blobmsg_json.h>
#include <libubus.h>

#include "mbtk_gnss_5311.h"

/**********************************DEFINE***********************************/
#define MBTK_GNSS_UBUS_SERVER "gps"
#define MBTK_GNSS_UBUS_INIT "gnss_init"
#define MBTK_GNSS_UBUS_INIT_PARAM "gnss_init_param"
#define MBTK_GNSS_UBUS_SLEEP "gnss_sleep"
#define MBTK_GNSS_UBUS_SLEEP_PARAM "gnss_sleep_param"
#define MBTK_GNSS_UBUS_SET "gnss_setting"
#define MBTK_GNSS_UBUS_SET_PARAM "gnss_setting_param"
#define MBTK_GNSS_UBUS_GET_STATUS "gnss_get_state"
#define MBTK_GNSS_UBUS_AGPS_SERVER "server_name"
#define MBTK_GNSS_UBUS_ALAM_FLAG "alam_flag"
#define MBTK_GNSS_UBUS_GET_AGPS "gnss_get_agps"
#define MBTK_GNSS_UBUS_SET_AGPS "gnss_set_agps"

#define MBTK_RESULT_FAIL -1
#define MBTK_RESULT_SUCCESS 0

#define MBTK_GNSS_CLOSE 0
#define MBTK_GNSS_OPEN 1

#define MBTK_GNSS_WAKEUP 0
#define MBTK_GNSS_SLEEP 1

#define DATABITS	CS8
#define BAUD		B115200
#define STOPBITS	0
#define PARITYON	0
#define PARITY		0

#define MBTK_GNSS_NMEA_PORT "/dev/tty_gnss_nmea"

#define GNSS_SOCK_PATH "/tmp/mbtk_gnss_sock"

static int sock_listen_fd = -1;

typedef enum {
    GNSS_CMD_INIT = 0,
    GNSS_CMD_DEINIT,
    GNSS_CMD_SETTING,
    GNSS_CMD_DL
} gnss_cmd_enum;

/**********************************DEFINE***********************************/

/**********************************VARIABLE***********************************/
const struct blobmsg_policy mbtk_gnss_ubus_cb_policy[] = {
    [0] = {
        .name = "event",
        .type = BLOBMSG_TYPE_INT32,
    },
};

const struct blobmsg_policy mbtk_gnss_state_resp_cb_policy[] = {
    [0] = {
        .name = "gps_state_resp",
        .type = BLOBMSG_TYPE_STRING,
    },
};

static int mbtk_gnss_uloop_init = 0;
static struct ubus_context *mbtk_gnss_ctx = NULL;
static int mbtk_gnss_status = MBTK_GNSS_CLOSE;
static mbtk_gnss_nmea_status nmea_state = {0};
/**********************************VARIABLE***********************************/

/**********************************FUNC***********************************/
struct ubus_context *mbtk_get_ubus_ctx(void)
{
     if (!mbtk_gnss_uloop_init)
     {
         return NULL;
     }
     if (mbtk_gnss_ctx != NULL)
     {
         return mbtk_gnss_ctx;
     }
     
     mbtk_gnss_ctx = ubus_connect(NULL);
     if (!mbtk_gnss_ctx)
     {
         LOGE("[mbtk_gnss_api] ubus_connect connect fail.");
         return NULL;
     }

     ubus_add_uloop(mbtk_gnss_ctx);
     return mbtk_gnss_ctx;
}

int mbtk_gnss_ubus_uloop_init(void)
{
    int ret = -1;
    if(mbtk_gnss_uloop_init == 0)
    {
        ret = uloop_init();
        if(ret != 0)
        {
            LOGE("[mbtk_gnss_api] uloop_init fail.ret = [%d]", ret);
            return MBTK_RESULT_FAIL;
        }

        if(mbtk_gnss_ctx != NULL)
        {
            LOGE("[mbtk_gnss_api] mbtk_gnss_ctx not NULL.");
            return MBTK_RESULT_FAIL;
        }

        mbtk_gnss_ctx = ubus_connect(NULL);
        if(!mbtk_gnss_ctx)
        {
            LOGE("[mbtk_gnss_api] ubus_connect fail.");
            return MBTK_RESULT_FAIL;
        }

        ubus_add_uloop(mbtk_gnss_ctx);
    }
    mbtk_gnss_uloop_init = 1;
    return MBTK_RESULT_SUCCESS;
}


int mbtk_gnss_ubus_uloop_deinit(void)
{
    if(mbtk_gnss_uloop_init == 1)
    {
        if(mbtk_gnss_ctx != NULL)
        {
            ubus_free(mbtk_gnss_ctx);
            mbtk_gnss_ctx = NULL;
        }

        uloop_done();
        mbtk_gnss_uloop_init = 0;
    }
    return MBTK_RESULT_SUCCESS;
}

static void mbtk_gnss_ubus_result_callback(struct ubus_request *req, int type, struct blob_attr *msg)
{
    UNUSED(type);
    
    struct blob_attr *tb[1];
    struct blob_attr *cur = NULL;
    unsigned int event;
    MBTK_GNSS_5311_RESULT_TYPE* ubus_gnss_result = (MBTK_GNSS_5311_RESULT_TYPE *)req->priv;
    int rc;

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    rc = blobmsg_parse(mbtk_gnss_ubus_cb_policy, 1, tb, blob_data(msg), blob_len(msg));
    if (rc < 0)
    {
        LOGE("[mbtk_gnss_api] blobmsg_parse fail.rc = [%d]", rc);
        *ubus_gnss_result = MBTK_GNSS_RESULT_FAIL;
        return;
    }

    /*parse first parameter*/
    cur = tb[0];
    if (!cur)
    {
        LOGE("[mbtk_gnss_api] cur is NULL.");
        *ubus_gnss_result = MBTK_GNSS_RESULT_FAIL;
        return;
    }

    event = blobmsg_get_u32(cur);
    LOGE("[mbtk_gnss_api] get event = [%d].", event);
    
    switch(event)
    {
        case ASR_GPS_INITIAL_SUCCESS:
        case ASR_GPS_INITIALED:
            {
                *ubus_gnss_result = MBTK_GNSS_RESULT_OPEN_SUCCESS;
                break;
            }
        case ASR_GPS_INITIAL_FAILED:
            {
                *ubus_gnss_result = MBTK_GNSS_RESULT_OPEN_FAIL;
                break;
            }
        case ASR_GPS_DOWNLOAD_SUCCESS:
            {
                *ubus_gnss_result = MBTK_GNSS_RESULT_DOWNLOAD_SUCCESS;
                break;
            }
        case ASR_GPS_DOWNLOAD_FAIL:
            {
                *ubus_gnss_result = MBTK_GNSS_RESULT_DOWNLOAD_FAIL;
                break;
            }
        case ASR_GPS_SEND_DATA_SUCCESS:
            {
                *ubus_gnss_result = MBTK_GNSS_RESULT_SEND_SUCCESS;
                break;
            }
        case ASR_GPS_SEND_DATA_FAIL:
            {
                *ubus_gnss_result = MBTK_GNSS_RESULT_SEND_FAIL;
                break;
            }
        case ASR_GPS_DEINIT_SUCCESS:
            {
                *ubus_gnss_result = MBTK_GNSS_RESULT_CLOSE_SUCCESS;
                break;
            }
        case ASR_GPS_DEINIT_FAIL:
            {
                *ubus_gnss_result = MBTK_GNSS_RESULT_CLOSE_FAIL;
                break;
            }
        default:
            {
                break;
            }
    }

    return;
}

static void mbtk_gnss_state_get_callback(struct ubus_request *req, int type, struct blob_attr *msg)
{
    UNUSED(type);
    
    struct blob_attr *tb[1];
    struct blob_attr *cur;
    char *gps_state = NULL;
    int rc;
    char *outString = (char *)req->priv;

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    rc = blobmsg_parse(mbtk_gnss_state_resp_cb_policy, 1, tb, blob_data(msg), blob_len(msg));
    if (rc < 0)
    {
        LOGE("[mbtk_gnss_api] blobmsg_parse fail.rc = [%d]", rc);
        return;
    }

    /*parse first parameter*/
    cur = tb[0];
    if (!cur)
    {
        LOGE("[mbtk_gnss_api] cur is NULL.");
        return;
    }

    gps_state = blobmsg_get_string(cur);
    LOGE("[mbtk_gnss_api] get status = [%s].", gps_state);
    memset(outString, 0x0, 128);
    memcpy(outString, gps_state, strlen(gps_state));

    return;
}

static void mbtk_gnss_open_port(int *fd_ptr, const char *file_path, int flag, int tty)
{

	int fd = -1;

	if((fd = open(file_path, flag)) < 0)
	{
        LOGE("[mbtk_gnss_api] Open %s fail errno = [%d].", file_path, errno);
		return;
	}

    LOGE("[mbtk_gnss_api] Open %s success.", file_path);
	if (tty)
    {
		/* set newtio */
		struct termios newtio;
		memset(&newtio, 0, sizeof(newtio));
		//(void)fcntl(fd, F_SETFL, 0);

		/* no flow control for uart by default */
		newtio.c_cflag = BAUD | DATABITS | STOPBITS | PARITYON | PARITY | CLOCAL | CREAD;
		newtio.c_iflag = IGNPAR;
        //newtio.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
		newtio.c_oflag = 0;
		newtio.c_lflag = 0;    /* disable ECHO, ICANON, etc... */

		newtio.c_cc[VERASE]   = 0x8;      /* del */
		newtio.c_cc[VEOF]     = 4;      /* Ctrl-d */
		newtio.c_cc[VMIN]     = 1;      /* blocking read until 1 character arrives */
		newtio.c_cc[VEOL]     = 0xD;      /* '\0' */

		tcflush(fd, TCIOFLUSH);
		tcsetattr(fd, TCSANOW, &newtio);
	}

	*fd_ptr = fd;
}

static int epoll_deregister(int epoll_fd,int fd )
{
    int  ret;
    do {
        ret = epoll_ctl( epoll_fd, EPOLL_CTL_DEL, fd, NULL );
    } while (ret < 0 && errno == EINTR);
    return ret;
}

static int epoll_register(int epoll_fd, int fd)
{
    struct epoll_event  ev;
    int    ret, flags;

    /* important: make the fd non-blocking */
    flags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);

    ev.events  = EPOLLIN;
    ev.data.fd = fd;
    do {
        ret = epoll_ctl( epoll_fd, EPOLL_CTL_ADD, fd, &ev );
    } while (ret < 0 && errno == EINTR);
    
    return ret;
}


static void *gnss_nmea_thread(void* arg)
{
    int                 epoll_fd= epoll_create(2);
    int                 started    = 0;
    int                 nmea_fd     = nmea_state.fd;
    int                 control_fd = nmea_state.control[1];
    int                 i          = 0;
    int                 fd= -1;
    int                 len = 0;
    int                 offset = 0;
    char                nmea_buf[1025] = {0};
    struct epoll_event  events[2];
    int                 ne, nevents;
    int                 ret = -1;
    char                cmd = 0;
    char                c;

    int pos = 0;
    int overflow = 0;
    char in[128] = {0};

    /* register control file descriptors for polling  */
    epoll_register( epoll_fd, control_fd );
    epoll_register( epoll_fd, nmea_fd );

    LOGE("[mbtk_gnss_api] gnss_nmea_thread running");

    for (;;)
    {
        nevents = -1;
        nevents = epoll_wait( epoll_fd, events, 2, -1 );
        if (nevents < 0)
        {
            if (errno != EINTR)
            {
                LOGE("[mbtk_gnss_api] epoll_wait() unexpected error: %s", strerror(errno));
            }
            continue;
        }

        for (ne = 0; ne < nevents; ne++)
        {
            if ((events[ne].events & (EPOLLERR|EPOLLHUP)) != 0)
            {
                LOGE("[mbtk_gnss_api] EPOLLERR or EPOLLHUP after epoll_wait()!");
                return NULL;
            }

            if ((events[ne].events & EPOLLIN) != 0) 
            {
                fd = events[ne].data.fd;

                if (fd == control_fd)
                {
                    do {
                            ret = read( fd, &cmd, 1 );
                    } while (ret < 0 && errno == EINTR);
                    LOGE("[mbtk_gnss_api] entry nmea thread quit cmd = [%d]!", cmd);
                    if (cmd == 1)
                    {
                        epoll_deregister( epoll_fd, control_fd );
                        epoll_deregister( epoll_fd, nmea_fd );
                        LOGE("[mbtk_gnss_api] gnss thread quitting on demand");
                        return NULL;
                    }
                }
                else if (fd == nmea_fd)
                {
                    memset(nmea_buf, 0x0, 1024);
                    len = read(fd, nmea_buf, 1024);
                    if(len > 0)
                    {
                        for(offset = 0; offset < len; offset++)
                        {
                            c = nmea_buf[offset];
                            if(pos == 0 && c != '$')
                            {
                                continue;
                            }
                            
                            if (overflow) {
                                overflow = (c != '\n');
                                continue;
                            }

                            if (pos >= (int) sizeof(in)-1 )
                            {
                                overflow = 1;
                                pos      = 0;
                                continue;
                            }

                            in[pos] = c;
                            pos += 1;

                            if (c == '\n')
                            {
                                if(nmea_state.callbacks != NULL)
                                {
                                    nmea_state.callbacks((void *)in, pos);
                                }
                                memset(in, 0x0, pos);
                                pos = 0;
                            }
                        }
                    }
                    else
                    {
                        LOGE("[mbtk_gnss_api] read() fail:%d, errno = %d\n", len, errno);
                    }
                }
                else
                {
                    LOGE("[mbtk_gnss_api] epoll_wait() returned unkown fd %d ?", fd);
                }
            }
        }
    }
}

static int mbtk_gnss_nmea_thread_init(void)
{
    if(nmea_state.init == 1)
    {
        LOGE("[mbtk_gnss_api] nmea thread is open.");
        return MBTK_RESULT_SUCCESS;
    }

    mbtk_gnss_open_port(&nmea_state.fd, MBTK_GNSS_NMEA_PORT, O_RDWR | O_NONBLOCK | O_NOCTTY, 1);

    if (socketpair( AF_LOCAL, SOCK_STREAM, 0, nmea_state.control ) < 0 ) 
    {
        LOGE("[mbtk_gnss_api] could not create thread control socket pair: %s", strerror(errno));

        /*close the control socket pair && Retry again.*/
        if(nmea_state.control[0] > 0)
        {
            close( nmea_state.control[0] );
            nmea_state.control[0] = -1;
        }
        
        if(nmea_state.control[1] > 0)
        {
            close( nmea_state.control[1] );
            nmea_state.control[1] = -1;
        }
        return MBTK_RESULT_FAIL;
    }

    pthread_create(&nmea_state.thread, NULL, gnss_nmea_thread, NULL);
    if ( !nmea_state.thread )
    {
        LOGE("[mbtk_gnss_api] could not create gps thread: %s", strerror(errno));
        return MBTK_RESULT_FAIL;
    }

    nmea_state.gnss_msg_state = MBTK_GNSS_MSG_NMEA_INFO;
    nmea_state.init = 1;
    return MBTK_RESULT_SUCCESS;
}

static int mbtk_gnss_nmea_thread_deinit(void)
{
    // tell the thread to quit, and wait for it
    if(nmea_state.init == 1)
    {
        char   cmd = 1;
        void*  dummy = NULL;
        write( nmea_state.control[0], &cmd, 1 );
        pthread_join(nmea_state.thread, &dummy);

        // close the control socket pair
        if(nmea_state.control[0] > 0)
        {
            close( nmea_state.control[0] );
            nmea_state.control[0] = -1;
        }
        if(nmea_state.control[1] > 0)
        {
            close( nmea_state.control[1] );
            nmea_state.control[1] = -1;
        }

        LOGE("[mbtk_gnss_api] %s: deinit", __FUNCTION__);

        // close connection to the QEMU GPS daemon
        if(nmea_state.fd)
        {
            close(nmea_state.fd);
            nmea_state.fd   = -1;
        }

        nmea_state.callbacks = NULL;
        nmea_state.gnss_msg_state = MBTK_GNSS_MSG_NMEA_INFO;
        nmea_state.init = 0;
    }

    return MBTK_RESULT_SUCCESS;
}

int mbtk_invoke_reply_data_cb(const char *service, const char *method, struct blob_attr *msg,
                         ubus_data_handler_t cb, void *cb_param, int timeout)
{
	struct ubus_context *ctx = NULL;
	int rc = -1;
	uint32_t id;
	struct ubus_request req;

    ctx = mbtk_get_ubus_ctx();
	if(ctx == NULL)
    {
		LOGE("[mbtk_gnss_api] mbtk_get_ubus_ctx fail.");
        return MBTK_RESULT_FAIL;
    }

	/* Look up the target object id by the object path */
    rc = ubus_lookup_id(ctx, service, &id);
	if(rc)
    {
        LOGE("[mbtk_gnss_api] ubus_lookup_id fail.rc = [%d]", rc);
		return MBTK_RESULT_FAIL;
    }

	rc = ubus_invoke(ctx, id, method, msg, cb, cb_param, timeout);
    if(rc)
    {
        LOGE("[mbtk_gnss_api] ubus_invoke fail.rc = [%d]", rc);
		return MBTK_RESULT_FAIL;
    }
	return MBTK_RESULT_SUCCESS;
}

 int mbtk_invoke_noreply(const char *service, const char *method, struct blob_attr *msg)
 {
    struct ubus_context *ctx;
    int rc = -1;
    uint32_t id;
    struct ubus_request req;

    ctx = mbtk_get_ubus_ctx();
    if(ctx == NULL)
    {
    	LOGE("[mbtk_gnss_api] mbtk_get_ubus_ctx fail.");
        return MBTK_RESULT_FAIL;
    }
    /* Look up the target object id by the object path */
    rc = ubus_lookup_id(ctx, service, &id);
    if(rc)
    {
        LOGE("[mbtk_gnss_api] ubus_lookup_id fail.rc = [%d]", rc);
		return MBTK_RESULT_FAIL;
    }

    rc = ubus_invoke_async(ctx, id, method, msg, &req);
    if(rc)
    {
        LOGE("[mbtk_gnss_api] ubus_invoke_async fail.rc = [%d]", rc);
		return MBTK_RESULT_FAIL;
    }

    /* cancel req (on client side) because noreply is needed */
    ubus_abort_request(ctx, &req);
    return MBTK_RESULT_SUCCESS;
 }

 static int mbtk_GPS_process(gnss_cmd_enum cmd, void *arg)
{
    if(sock_listen_fd < 0) {
        sock_listen_fd = socket(AF_LOCAL, SOCK_STREAM, 0);
        if(sock_listen_fd < 0)
        {
            printf("socket() fail[%d].\n", errno);
            return -1;
        }

        struct sockaddr_un cli_addr;
        memset(&cli_addr, 0, sizeof(cli_addr));
        cli_addr.sun_family = AF_LOCAL;
        strcpy(cli_addr.sun_path, GNSS_SOCK_PATH);
        if(connect(sock_listen_fd, (struct sockaddr *)&cli_addr, sizeof(cli_addr)))
        {
            printf("connect() fail[%d].\n", errno);
            close(sock_listen_fd);
            sock_listen_fd = -1;
            return -1;
        }
    }

    char buff[100] = {0};
    if(cmd == GNSS_CMD_INIT) {
        if(arg) {
            sprintf(buff, "gnss_init:%d", *(int*)arg);
        } else {
            return -1;
        }
    } else if(cmd == GNSS_CMD_DEINIT) {
        sprintf(buff, "gnss_deinit");
    } else if(cmd == GNSS_CMD_SETTING) {
        sprintf(buff, "gnss_setting:%s", arg);
    } else if(cmd == GNSS_CMD_DL) {
        sprintf(buff, "gnss_dl:%s", arg);
    } else {
        printf("Unknown cmd.\n");
        return -1;
    }

    write(sock_listen_fd, buff, strlen(buff));

    int len = 0;
    while(1) {
        memset(buff, 0, sizeof(buff));
        len = read(sock_listen_fd, buff, sizeof(buff));
        if(len > 0) {
            printf("RSP : %s\n", buff);
            if(cmd == GNSS_CMD_INIT) {
                if(memcmp(buff, "gnss_init", 9) == 0) {
                    return atoi(buff + 10);
                } else {
                    printf("gnss_init response error.\n");
                    return -1;
                }
            } else if(cmd == GNSS_CMD_DEINIT) {
                if(memcmp(buff, "gnss_deinit", 11) == 0) {
                    return atoi(buff + 12);
                } else {
                    printf("gnss_deinit response error.\n");
                    return -1;
                }
            } else if(cmd == GNSS_CMD_SETTING) {
                if(memcmp(buff, "gnss_setting", 12) == 0) {
                    return atoi(buff + 13);
                } else {
                    printf("gnss_setting response error.\n");
                    return -1;
                }
            } else if(cmd == GNSS_CMD_DL) {
                if(memcmp(buff, "gnss_dl", 7) == 0) {
                    return atoi(buff + 8);
                } else {
                    printf("gnss_dl response error.\n");
                    return -1;
                }
            } else {
                printf("Unknown response.\n");
                return -1;
            }
        } else if(len == 0) {
            printf("RSP is null.\n");
            return -1;
        } else {
            printf("read = %d:errno = %d\n", len, errno);
        }
    }
}

/**********************************FUNC***********************************/

/**********************************API***********************************/
MBTK_GNSS_5311_RESULT_TYPE mbtk_gnss_init(void)
{
    int ret = MBTK_RESULT_FAIL;

    ret = mbtk_gnss_ubus_uloop_init();
    if(ret < 0)
    {
        LOGE("[mbtk_gnss_api] mbtk_gnss_uloopinit fail.");
        return MBTK_GNSS_RESULT_FAIL;
    }

#ifndef MBTK_SG_SUPPORT
    ret = mbtk_gnss_nmea_thread_init();
    if(ret != 0)
    {
        LOGE("[mbtk_gnss_api] mbtk_gnss_nmea_thread_init fail.");
        return MBTK_GNSS_RESULT_FAIL;
    }
#endif
    return MBTK_GNSS_RESULT_SUCCESS;
}

MBTK_GNSS_5311_RESULT_TYPE mbtk_gnss_deinit(void)
{
    mbtk_gnss_nmea_thread_deinit();
    mbtk_gnss_ubus_uloop_deinit();
    return MBTK_GNSS_RESULT_SUCCESS;
}


MBTK_GNSS_5311_RESULT_TYPE mbtk_gnss_open(void)
{
    if (mbtk_gnss_uloop_init == 0)
    {
        LOGE("[mbtk_gnss_api] gnss not init.");
        return MBTK_GNSS_RESULT_FAIL;
    }
    
    int ret = -1;
    MBTK_GNSS_5311_RESULT_TYPE ubus_gnss_result = MBTK_GNSS_RESULT_SUCCESS;
    uint gps_init_val = MBTK_GNSS_OPEN;
  

    ret = mbtk_GPS_process(GNSS_CMD_INIT, &gps_init_val);

    if (-1 == ret)
    {
        LOGE("[mbtk_gnss_api] mbtk_gnss_open fail.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    
    mbtk_gnss_status = MBTK_GNSS_OPEN;
    return MBTK_GNSS_RESULT_SUCCESS;
}

MBTK_GNSS_5311_RESULT_TYPE mbtk_gnss_close(void)
{
    if (mbtk_gnss_uloop_init == 0)
    {
        LOGE("[mbtk_gnss_api] gnss not init.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    int ret = -1;

    ret = mbtk_GPS_process(GNSS_CMD_DEINIT, NULL);

    if (-1 == ret)
    {
        LOGE("[mbtk_gnss_api] mbtk_gnss_close fail.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    mbtk_gnss_status = MBTK_GNSS_CLOSE;
    return MBTK_GNSS_RESULT_SUCCESS;
}

MBTK_GNSS_5311_RESULT_TYPE mbtk_gnss_sleep(void)
{
    if (mbtk_gnss_uloop_init == 0)
    {
        LOGE("[mbtk_gnss_api] gnss not init.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    if(mbtk_gnss_status == MBTK_GNSS_CLOSE)
    {
        LOGE("[mbtk_gnss_api] gnss not open.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    int ret = -1;
    struct blob_buf outBlob;
    unsigned int gps_sleep_val = MBTK_GNSS_SLEEP;
    memset(&outBlob, 0, sizeof(outBlob));
    
    blob_buf_init(&outBlob, 0);
    blobmsg_add_u32(&outBlob, MBTK_GNSS_UBUS_SLEEP_PARAM, (unsigned int)gps_sleep_val);

    ret = mbtk_invoke_noreply(MBTK_GNSS_UBUS_SERVER, MBTK_GNSS_UBUS_SLEEP, outBlob.head);
    blob_buf_free(&outBlob);
    if (ret != 0)
    {
        LOGE("[mbtk_gnss_api] mbtk_invoke_noreply fail.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    return MBTK_GNSS_RESULT_SUCCESS;
}

MBTK_GNSS_5311_RESULT_TYPE mbtk_gnss_wakeup(void)
{
    if (mbtk_gnss_uloop_init == 0)
    {
        LOGE("[mbtk_gnss_api] gnss not init.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    if(mbtk_gnss_status == MBTK_GNSS_CLOSE)
    {
        LOGE("[mbtk_gnss_api] gnss not open.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    int ret = -1;
    struct blob_buf outBlob;
    unsigned int gps_sleep_val = MBTK_GNSS_WAKEUP;
    memset(&outBlob, 0, sizeof(outBlob));
    
    blob_buf_init(&outBlob, 0);
    blobmsg_add_u32(&outBlob, MBTK_GNSS_UBUS_SLEEP_PARAM, (unsigned int)gps_sleep_val);

    ret = mbtk_invoke_noreply(MBTK_GNSS_UBUS_SERVER, MBTK_GNSS_UBUS_SLEEP, outBlob.head);
    blob_buf_free(&outBlob);
    if (ret != 0)
    {
        LOGE("[mbtk_gnss_api] mbtk_invoke_noreply fail.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    return MBTK_GNSS_RESULT_SUCCESS;
}

MBTK_GNSS_5311_RESULT_TYPE mbtk_gnss_param_config(const char *param_buf, int param_buf_len)
{
    if (mbtk_gnss_uloop_init == 0)
    {
        LOGE("[mbtk_gnss_api] gnss not init.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    if(mbtk_gnss_status == MBTK_GNSS_CLOSE)
    {
        LOGE("[mbtk_gnss_api] gnss not open.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    if(param_buf == NULL || param_buf_len <= 0)
    {
        LOGE("[mbtk_gnss_api] param is error.");
        return MBTK_GNSS_RESULT_FAIL;
    }
    
    int ret = -1;
    LOGE("[mbtk_gnss_api] set command [%s].", param_buf);
      
    ret = mbtk_GPS_process(GNSS_CMD_SETTING, param_buf);
   if (-1 == ret)
    {
        LOGE("[mbtk_gnss_api] mbtk_gnss_setting fail.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    return MBTK_GNSS_RESULT_SUCCESS;
}

MBTK_GNSS_5311_RESULT_TYPE mbtk_gnss_get_status(const char *status_buf, int status_buf_len, int *get_status_len)
{
    if (mbtk_gnss_uloop_init == 0)
    {
        LOGE("[mbtk_gnss_api] gnss not init.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    if(mbtk_gnss_status == MBTK_GNSS_CLOSE)
    {
        LOGE("[mbtk_gnss_api] gnss not open.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    int ret = -1;
    char status[128] = {0};
    int status_len = 0;

    ret = mbtk_invoke_reply_data_cb(MBTK_GNSS_UBUS_SERVER, MBTK_GNSS_UBUS_GET_STATUS, NULL, mbtk_gnss_state_get_callback, status, 4000);
    if (ret != 0)
    {
        LOGE("[mbtk_gnss_api] mbtk_invoke_reply_data_cb fail.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    status_len = strlen(status);
    if(status_len > 0 && status_len < status_buf_len)
    {
        memcpy(status_buf, status, status_len);
        *get_status_len = status_len;
    }
    else
    {
        LOGE("[mbtk_gnss_api] status_len[%d] error.", status_len);
        return MBTK_GNSS_RESULT_FAIL;
    }

    return MBTK_GNSS_RESULT_SUCCESS;
}

MBTK_GNSS_5311_RESULT_TYPE mbtk_gnss_set_nmea_out_type(MBTK_GNSS_MSG_INFO_TYPE type)
{
    if(mbtk_gnss_uloop_init == 0)
    {
        LOGE("[mbtk_gnss_api] gnss not init.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    if(type == MBTK_GNSS_MSG_LOCATION_INFO)
    {
        nmea_state.gnss_msg_state = type;
    }
    else if(type == MBTK_GNSS_MSG_NMEA_INFO)
    {
        nmea_state.gnss_msg_state = type;
    }
    else
    {
        return MBTK_GNSS_RESULT_FAIL;
    }
    
    return MBTK_GNSS_RESULT_SUCCESS;
}


MBTK_GNSS_5311_RESULT_TYPE mbtk_gnss_add_nmea_out_func(mbtk_gnss_nmea_func_t cb)
{
    if(mbtk_gnss_uloop_init == 0)
    {
        LOGE("[mbtk_gnss_api] gnss not init.");
        return MBTK_GNSS_RESULT_FAIL;
    }

    if(cb == NULL)
    {
        LOGE("[mbtk_gnss_api] cb is NULL.");
        return MBTK_GNSS_RESULT_FAIL;
    }
    nmea_state.callbacks = cb;

    return MBTK_GNSS_RESULT_SUCCESS;
}

MBTK_GNSS_5311_RESULT_TYPE mbtk_gnss_5311_download_tle(char *host, int alam_flag)
{
    if (mbtk_gnss_uloop_init == 0)
    {
        LOGE("[mbtk_gnss_api] gnss not init.");
        return MBTK_GNSS_RESULT_DOWNLOAD_FAIL;
    }

    if(mbtk_gnss_status == MBTK_GNSS_CLOSE)
    {
        LOGE("[mbtk_gnss_api] gnss not open.");
        return MBTK_GNSS_RESULT_DOWNLOAD_FAIL;
    }

    int ret = -1;
    MBTK_GNSS_5311_RESULT_TYPE ubus_gnss_result = MBTK_GNSS_RESULT_DOWNLOAD_SUCCESS;
    struct blob_buf outBlob;
    memset(&outBlob, 0, sizeof(outBlob));
    
    blob_buf_init(&outBlob, 0);
    blobmsg_add_string(&outBlob, MBTK_GNSS_UBUS_AGPS_SERVER, host);
    blobmsg_add_u32(&outBlob, MBTK_GNSS_UBUS_ALAM_FLAG, alam_flag);

    //UBUS_STATUS_OK
    ret = mbtk_invoke_reply_data_cb(MBTK_GNSS_UBUS_SERVER, MBTK_GNSS_UBUS_GET_AGPS, outBlob.head,
                                    (ubus_data_handler_t *)mbtk_gnss_ubus_result_callback, &ubus_gnss_result, 8000);
    blob_buf_free(&outBlob);
    if (ret != 0)
    {
        LOGE("[mbtk_gnss_api] mbtk_invoke_reply_data_cb fail.");
        return MBTK_GNSS_RESULT_DOWNLOAD_FAIL;
    }

    if(ubus_gnss_result != MBTK_GNSS_RESULT_DOWNLOAD_SUCCESS)
    {
        LOGE("[mbtk_gnss_api] ubus_gnss_result = [%d].", ubus_gnss_result);
        return MBTK_GNSS_RESULT_DOWNLOAD_FAIL;
    }

    return MBTK_GNSS_RESULT_DOWNLOAD_SUCCESS;
}

MBTK_GNSS_5311_RESULT_TYPE mbtk_gnss_injectEphemeris(void)
{
    if (mbtk_gnss_uloop_init == 0)
    {
        LOGE("[mbtk_gnss_api] gnss not init.");
        return MBTK_GNSS_RESULT_SEND_FAIL;
    }

    if(mbtk_gnss_status == MBTK_GNSS_CLOSE)
    {
        LOGE("[mbtk_gnss_api] gnss not open.");
        return MBTK_GNSS_RESULT_SEND_FAIL;
    }

    int ret = -1;
    MBTK_GNSS_5311_RESULT_TYPE ubus_gnss_result = MBTK_GNSS_RESULT_SUCCESS;

    //UBUS_STATUS_OK
    ret = mbtk_invoke_reply_data_cb(MBTK_GNSS_UBUS_SERVER, MBTK_GNSS_UBUS_SET_AGPS, NULL,
                                    (ubus_data_handler_t *)mbtk_gnss_ubus_result_callback, &ubus_gnss_result, 8000);
    if (ret != 0)
    {
        LOGE("[mbtk_gnss_api] mbtk_invoke_reply_data_cb fail.");
        return MBTK_GNSS_RESULT_SEND_FAIL;
    }

    if(ubus_gnss_result != MBTK_GNSS_RESULT_SEND_SUCCESS)
    {
        LOGE("[mbtk_gnss_api] ubus_gnss_result = [%d].", ubus_gnss_result);
        return MBTK_GNSS_RESULT_SEND_FAIL;
    }

    return MBTK_GNSS_RESULT_SEND_SUCCESS;
}

/**********************************API***********************************/

#endif