xref: /hardware/qcom/gps/loc_api/libloc_api_50001/loc_eng_ni.cpp

/* Copyright (c) 2009-2014, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimer in the documentation and/or other materials provided
 *       with the distribution.
 *     * Neither the name of The Linux Foundation, nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#define LOG_NDDEBUG 0
#define LOG_TAG "LocSvc_eng"

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <time.h>
#include <MsgTask.h>

#include <loc_eng.h>

#include "log_util.h"
#include "platform_lib_includes.h"

using namespace loc_core;

/*=============================================================================
 *
 *                             DATA DECLARATION
 *
 *============================================================================*/

/*=============================================================================
 *
 *                             FUNCTION DECLARATIONS
 *
 *============================================================================*/
static void* ni_thread_proc(void *args);

struct LocEngInformNiResponse : public LocMsg {
    LocEngAdapter* mAdapter;
    const GpsUserResponseType mResponse;
    const void *mPayload;
    inline LocEngInformNiResponse(LocEngAdapter* adapter,
                                  GpsUserResponseType resp,
                                  const void* data) :
        LocMsg(), mAdapter(adapter),
        mResponse(resp), mPayload(data)
    {
        locallog();
    }
    inline ~LocEngInformNiResponse()
    {
        // this is a bit weird since mPayload is not
        // allocated by this class.  But there is no better way.
        // mPayload actually won't be NULL here.
        free((void*)mPayload);
    }
    inline virtual void proc() const
    {
        mAdapter->informNiResponse(mResponse, mPayload);
    }
    inline void locallog() const
    {
        LOC_LOGV("LocEngInformNiResponse - "
                 "response: %s\n  mPayload: %p",
                 loc_get_ni_response_name(mResponse),
                 mPayload);
    }
    inline virtual void log() const
    {
        locallog();
    }
};

/*===========================================================================

FUNCTION loc_eng_ni_request_handler

DESCRIPTION
   Displays the NI request and awaits user input. If a previous request is
   in session, it is ignored.

RETURN VALUE
   none

===========================================================================*/
void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data,
                            const GpsNiNotification *notif,
                            const void* passThrough)
{
    ENTRY_LOG();
    char lcs_addr[32]; // Decoded LCS address for UMTS CP NI
    loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;
    loc_eng_ni_session_s_type* pSession = NULL;

    if (NULL == loc_eng_data.ni_notify_cb) {
        EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet.");
        return;
    }

    if (notif->ni_type == GPS_NI_TYPE_EMERGENCY_SUPL) {
        if (NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
            LOC_LOGW("loc_eng_ni_request_handler, supl es NI in progress, new supl es NI ignored, type: %d",
                     notif->ni_type);
            if (NULL != passThrough) {
                free((void*)passThrough);
            }
        } else {
            pSession = &loc_eng_ni_data_p->sessionEs;
        }
    } else {
        if (NULL != loc_eng_ni_data_p->session.rawRequest ||
            NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
            LOC_LOGW("loc_eng_ni_request_handler, supl NI in progress, new supl NI ignored, type: %d",
                     notif->ni_type);
            if (NULL != passThrough) {
                free((void*)passThrough);
            }
        } else {
            pSession = &loc_eng_ni_data_p->session;
        }
    }


    if (pSession) {
        /* Save request */
        pSession->rawRequest = (void*)passThrough;
        pSession->reqID = ++loc_eng_ni_data_p->reqIDCounter;
        pSession->adapter = loc_eng_data.adapter;

        /* Fill in notification */
        ((GpsNiNotification*)notif)->notification_id = pSession->reqID;

        if (notif->notify_flags == GPS_NI_PRIVACY_OVERRIDE)
        {
            loc_eng_mute_one_session(loc_eng_data);
        }

        /* Log requestor ID and text for debugging */
        LOC_LOGI("Notification: notif_type: %d, timeout: %d, default_resp: %d", notif->ni_type, notif->timeout, notif->default_response);
        LOC_LOGI("              requestor_id: %s (encoding: %d)", notif->requestor_id, notif->requestor_id_encoding);
        LOC_LOGI("              text: %s text (encoding: %d)", notif->text, notif->text_encoding);
        if (notif->extras[0])
        {
            LOC_LOGI("              extras: %s", notif->extras);
        }

        /* For robustness, spawn a thread at this point to timeout to clear up the notification status, even though
         * the OEM layer in java does not do so.
         **/
        pSession->respTimeLeft = 5 + (notif->timeout != 0 ? notif->timeout : LOC_NI_NO_RESPONSE_TIME);
        LOC_LOGI("Automatically sends 'no response' in %d seconds (to clear status)\n", pSession->respTimeLeft);

        int rc = 0;
        rc = pthread_create(&pSession->thread, NULL, ni_thread_proc, pSession);
        if (rc)
        {
            LOC_LOGE("Loc NI thread is not created.\n");
        }
        rc = pthread_detach(pSession->thread);
        if (rc)
        {
            LOC_LOGE("Loc NI thread is not detached.\n");
        }

        CALLBACK_LOG_CALLFLOW("ni_notify_cb - id", %d, notif->notification_id);
        loc_eng_data.ni_notify_cb((GpsNiNotification*)notif);
    }
    EXIT_LOG(%s, VOID_RET);
}

/*===========================================================================

FUNCTION ni_thread_proc

===========================================================================*/
static void* ni_thread_proc(void *args)
{
    ENTRY_LOG();

    loc_eng_ni_session_s_type* pSession = (loc_eng_ni_session_s_type*)args;
    int rc = 0;          /* return code from pthread calls */

    struct timeval present_time;
    struct timespec expire_time;

    LOC_LOGD("Starting Loc NI thread...\n");
    pthread_mutex_lock(&pSession->tLock);
    /* Calculate absolute expire time */
    gettimeofday(&present_time, NULL);
    expire_time.tv_sec  = present_time.tv_sec + pSession->respTimeLeft;
    expire_time.tv_nsec = present_time.tv_usec * 1000;
    LOC_LOGD("ni_thread_proc-Time out set for abs time %ld with delay %d sec\n",
             (long) expire_time.tv_sec, pSession->respTimeLeft );

    while (!pSession->respRecvd)
    {
        rc = pthread_cond_timedwait(&pSession->tCond,
                                    &pSession->tLock,
                                    &expire_time);
        if (rc == ETIMEDOUT)
        {
            pSession->resp = GPS_NI_RESPONSE_NORESP;
            LOC_LOGD("ni_thread_proc-Thread time out after valting for specified time. Ret Val %d\n",rc );
            break;
        }
    }
    LOC_LOGD("ni_thread_proc-Java layer has sent us a user response and return value from "
             "pthread_cond_timedwait = %d\n",rc );
    pSession->respRecvd = FALSE; /* Reset the user response flag for the next session*/

    LOC_LOGD("pSession->resp is %d\n",pSession->resp);

    // adding this check to support modem restart, in which case, we need the thread
    // to exit without calling sending data. We made sure that rawRequest is NULL in
    // loc_eng_ni_reset_on_engine_restart()
    LocEngAdapter* adapter = pSession->adapter;
    LocEngInformNiResponse *msg = NULL;

    if (NULL != pSession->rawRequest) {
        if (pSession->resp != GPS_NI_RESPONSE_IGNORE) {
            LOC_LOGD("pSession->resp != GPS_NI_RESPONSE_IGNORE \n");
            msg = new LocEngInformNiResponse(adapter,
                                             pSession->resp,
                                             pSession->rawRequest);
        } else {
            LOC_LOGD("this is the ignore reply for SUPL ES\n");
            free(pSession->rawRequest);
        }
        pSession->rawRequest = NULL;
    }
    pthread_mutex_unlock(&pSession->tLock);

    pSession->respTimeLeft = 0;
    pSession->reqID = 0;

    if (NULL != msg) {
        LOC_LOGD("ni_thread_proc: adapter->sendMsg(msg)\n");
        adapter->sendMsg(msg);
    }

    EXIT_LOG(%s, VOID_RET);
    return NULL;
}

void loc_eng_ni_reset_on_engine_restart(loc_eng_data_s_type &loc_eng_data)
{
    ENTRY_LOG();
    loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;

    if (NULL == loc_eng_data.ni_notify_cb) {
        EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet.");
        return;
    }

    // only if modem has requested but then died.
    if (NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
        free(loc_eng_ni_data_p->sessionEs.rawRequest);
        loc_eng_ni_data_p->sessionEs.rawRequest = NULL;

        pthread_mutex_lock(&loc_eng_ni_data_p->sessionEs.tLock);
        // the goal is to wake up ni_thread_proc
        // and let it exit.
        loc_eng_ni_data_p->sessionEs.respRecvd = TRUE;
        pthread_cond_signal(&loc_eng_ni_data_p->sessionEs.tCond);
        pthread_mutex_unlock(&loc_eng_ni_data_p->sessionEs.tLock);
    }

    if (NULL != loc_eng_ni_data_p->session.rawRequest) {
        free(loc_eng_ni_data_p->session.rawRequest);
        loc_eng_ni_data_p->session.rawRequest = NULL;

        pthread_mutex_lock(&loc_eng_ni_data_p->session.tLock);
        // the goal is to wake up ni_thread_proc
        // and let it exit.
        loc_eng_ni_data_p->session.respRecvd = TRUE;
        pthread_cond_signal(&loc_eng_ni_data_p->session.tCond);
        pthread_mutex_unlock(&loc_eng_ni_data_p->session.tLock);
    }

    EXIT_LOG(%s, VOID_RET);
}

/*===========================================================================
FUNCTION    loc_eng_ni_init

DESCRIPTION
   This function initializes the NI interface

DEPENDENCIES
   NONE

RETURN VALUE
   None

SIDE EFFECTS
   N/A

===========================================================================*/
void loc_eng_ni_init(loc_eng_data_s_type &loc_eng_data, GpsNiExtCallbacks *callbacks)
{
    ENTRY_LOG_CALLFLOW();

    if(callbacks == NULL)
        EXIT_LOG(%s, "loc_eng_ni_init: failed, cb is NULL");
    else if (NULL == callbacks->notify_cb) {
        EXIT_LOG(%s, "loc_eng_ni_init: failed, no cb.");
    } else if (NULL != loc_eng_data.ni_notify_cb) {
        EXIT_LOG(%s, "loc_eng_ni_init: already inited.");
    } else {
        loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;
        loc_eng_ni_data_p->sessionEs.respTimeLeft = 0;
        loc_eng_ni_data_p->sessionEs.respRecvd = FALSE;
        loc_eng_ni_data_p->sessionEs.rawRequest = NULL;
        loc_eng_ni_data_p->sessionEs.reqID = 0;
        pthread_cond_init(&loc_eng_ni_data_p->sessionEs.tCond, NULL);
        pthread_mutex_init(&loc_eng_ni_data_p->sessionEs.tLock, NULL);

        loc_eng_ni_data_p->session.respTimeLeft = 0;
        loc_eng_ni_data_p->session.respRecvd = FALSE;
        loc_eng_ni_data_p->session.rawRequest = NULL;
        loc_eng_ni_data_p->session.reqID = 0;
        pthread_cond_init(&loc_eng_ni_data_p->session.tCond, NULL);
        pthread_mutex_init(&loc_eng_ni_data_p->session.tLock, NULL);

        loc_eng_data.ni_notify_cb = callbacks->notify_cb;
        EXIT_LOG(%s, VOID_RET);
    }
}

/*===========================================================================
FUNCTION    loc_eng_ni_respond

DESCRIPTION
   This function receives user response from upper layer framework

DEPENDENCIES
   NONE

RETURN VALUE
   None

SIDE EFFECTS
   N/A

===========================================================================*/
void loc_eng_ni_respond(loc_eng_data_s_type &loc_eng_data,
                        int notif_id, GpsUserResponseType user_response)
{
    ENTRY_LOG_CALLFLOW();
    loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;
    loc_eng_ni_session_s_type* pSession = NULL;

    if (NULL == loc_eng_data.ni_notify_cb) {
        EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet.");
        return;
    }

    if (notif_id == loc_eng_ni_data_p->sessionEs.reqID &&
        NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
        pSession = &loc_eng_ni_data_p->sessionEs;
        // ignore any SUPL NI non-Es session if a SUPL NI ES is accepted
        if (user_response == GPS_NI_RESPONSE_ACCEPT &&
            NULL != loc_eng_ni_data_p->session.rawRequest) {
                pthread_mutex_lock(&loc_eng_ni_data_p->session.tLock);
                loc_eng_ni_data_p->session.resp = GPS_NI_RESPONSE_IGNORE;
                loc_eng_ni_data_p->session.respRecvd = TRUE;
                pthread_cond_signal(&loc_eng_ni_data_p->session.tCond);
                pthread_mutex_unlock(&loc_eng_ni_data_p->session.tLock);
        }
    } else if (notif_id == loc_eng_ni_data_p->session.reqID &&
        NULL != loc_eng_ni_data_p->session.rawRequest) {
        pSession = &loc_eng_ni_data_p->session;
    }

    if (pSession) {
        LOC_LOGI("loc_eng_ni_respond: send user response %d for notif %d", user_response, notif_id);
        pthread_mutex_lock(&pSession->tLock);
        pSession->resp = user_response;
        pSession->respRecvd = TRUE;
        pthread_cond_signal(&pSession->tCond);
        pthread_mutex_unlock(&pSession->tLock);
    }
    else {
        LOC_LOGE("loc_eng_ni_respond: notif_id %d not an active session", notif_id);
    }

    EXIT_LOG(%s, VOID_RET);
}