Home | History | Annotate | Download | only in core 
      1 /* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
      2  *
      3  * Redistribution and use in source and binary forms, with or without
      4  * modification, are permitted provided that the following conditions are
      5  * met:
      6  *     * Redistributions of source code must retain the above copyright
      7  *       notice, this list of conditions and the following disclaimer.
      8  *     * Redistributions in binary form must reproduce the above
      9  *       copyright notice, this list of conditions and the following
     10  *       disclaimer in the documentation and/or other materials provided
     11  *       with the distribution.
     12  *     * Neither the name of The Linux Foundation, nor the names of its
     13  *       contributors may be used to endorse or promote products derived
     14  *       from this software without specific prior written permission.
     15  *
     16  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
     17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
     19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
     20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
     23  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
     25  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
     26  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27  *
     28  */
     29 #define LOG_NDDEBUG 0
     30 #define LOG_TAG "LocSvc_DualCtx"
     31 
     32 #include <cutils/sched_policy.h>
     33 #include <unistd.h>
     34 #include <LocDualContext.h>
     35 #include <msg_q.h>
     36 #include <log_util.h>
     37 #include <loc_log.h>
     38 
     39 namespace loc_core {
     40 
     41 // nothing exclude for foreground
     42 const LOC_API_ADAPTER_EVENT_MASK_T
     43 LocDualContext::mFgExclMask = 0;
     44 // excluded events for background clients
     45 const LOC_API_ADAPTER_EVENT_MASK_T
     46 LocDualContext::mBgExclMask =
     47     (LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT |
     48      LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
     49      LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT |
     50      LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT |
     51      LOC_API_ADAPTER_BIT_IOCTL_REPORT |
     52      LOC_API_ADAPTER_BIT_STATUS_REPORT |
     53      LOC_API_ADAPTER_BIT_GEOFENCE_GEN_ALERT |
     54      LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT);
     55 
     56 const MsgTask* LocDualContext::mMsgTask = NULL;
     57 ContextBase* LocDualContext::mFgContext = NULL;
     58 ContextBase* LocDualContext::mBgContext = NULL;
     59 ContextBase* LocDualContext::mInjectContext = NULL;
     60 // the name must be shorter than 15 chars
     61 const char* LocDualContext::mLocationHalName = "Loc_hal_worker";
     62 const char* LocDualContext::mLBSLibName = "liblbs_core.so";
     63 
     64 pthread_mutex_t LocDualContext::mGetLocContextMutex = PTHREAD_MUTEX_INITIALIZER;
     65 
     66 const MsgTask* LocDualContext::getMsgTask(LocThread::tCreate tCreator,
     67                                           const char* name, bool joinable)
     68 {
     69     if (NULL == mMsgTask) {
     70         mMsgTask = new MsgTask(tCreator, name, joinable);
     71     }
     72     return mMsgTask;
     73 }
     74 
     75 inline
     76 const MsgTask* LocDualContext::getMsgTask(const char* name, bool joinable) {
     77     return getMsgTask((LocThread::tCreate)NULL, name, joinable);
     78 }
     79 
     80 ContextBase* LocDualContext::getLocFgContext(LocThread::tCreate tCreator,
     81             LocMsg* firstMsg, const char* name, bool joinable)
     82 {
     83     pthread_mutex_lock(&LocDualContext::mGetLocContextMutex);
     84     LOC_LOGD("%s:%d]: querying ContextBase with tCreator", __func__, __LINE__);
     85     if (NULL == mFgContext) {
     86         LOC_LOGD("%s:%d]: creating msgTask with tCreator", __func__, __LINE__);
     87         const MsgTask* msgTask = getMsgTask(tCreator, name, joinable);
     88         mFgContext = new LocDualContext(msgTask,
     89                                         mFgExclMask);
     90     }
     91     if(NULL == mInjectContext) {
     92         LOC_LOGD("%s:%d]: mInjectContext is FgContext", __func__, __LINE__);
     93         mInjectContext = mFgContext;
     94         injectFeatureConfig(mInjectContext);
     95     }
     96     pthread_mutex_unlock(&LocDualContext::mGetLocContextMutex);
     97 
     98     if (firstMsg) {
     99         mFgContext->sendMsg(firstMsg);
    100     }
    101 
    102     return mFgContext;
    103 }
    104 
    105 ContextBase* LocDualContext::getLocBgContext(LocThread::tCreate tCreator,
    106             LocMsg* firstMsg, const char* name, bool joinable)
    107 {
    108     pthread_mutex_lock(&LocDualContext::mGetLocContextMutex);
    109     LOC_LOGD("%s:%d]: querying ContextBase with tCreator", __func__, __LINE__);
    110     if (NULL == mBgContext) {
    111         LOC_LOGD("%s:%d]: creating msgTask with tCreator", __func__, __LINE__);
    112         const MsgTask* msgTask = getMsgTask(tCreator, name, joinable);
    113         mBgContext = new LocDualContext(msgTask,
    114                                         mBgExclMask);
    115     }
    116     if(NULL == mInjectContext) {
    117         LOC_LOGD("%s:%d]: mInjectContext is BgContext", __func__, __LINE__);
    118         mInjectContext = mBgContext;
    119         injectFeatureConfig(mInjectContext);
    120     }
    121     pthread_mutex_unlock(&LocDualContext::mGetLocContextMutex);
    122 
    123     if (firstMsg) {
    124         mBgContext->sendMsg(firstMsg);
    125     }
    126 
    127     return mBgContext;
    128 }
    129 
    130 void LocDualContext :: injectFeatureConfig(ContextBase *curContext)
    131 {
    132     LOC_LOGD("%s:%d]: Enter", __func__, __LINE__);
    133     if(curContext == mInjectContext) {
    134         LOC_LOGD("%s:%d]: Calling LBSProxy (%p) to inject feature config",
    135                  __func__, __LINE__, ((LocDualContext *)mInjectContext)->mLBSProxy);
    136         ((LocDualContext *)mInjectContext)->mLBSProxy->injectFeatureConfig(curContext);
    137     }
    138     LOC_LOGD("%s:%d]: Exit", __func__, __LINE__);
    139 }
    140 
    141 LocDualContext::LocDualContext(const MsgTask* msgTask,
    142                                LOC_API_ADAPTER_EVENT_MASK_T exMask) :
    143     ContextBase(msgTask, exMask, mLBSLibName)
    144 {
    145 }
    146 
    147 }
    148