psmattas/device_motorola_sanders-lineage
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sanders: gps: update to LA.UM.7.6.r1-02000-89xx.0 tag

Browse Source
This commit is contained in:
therootlord
2018-09-12 13:45:48 -03:00
parent 8a6b5c05e7
commit 0a41b9dc1a
150 changed files with 4794 additions and 4130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
gps/utils/Android.mk
View File

@@ -11,8 +11,7 @@ include $(CLEAR_VARS)
LOCAL_SHARED_LIBRARIES := \
libutils \
libcutils \
liblog \
libloc_pla
liblog
LOCAL_SRC_FILES += \
loc_log.cpp \
@@ -20,13 +19,13 @@ LOCAL_SRC_FILES += \
msg_q.c \
linked_list.c \
loc_target.cpp \
platform_lib_abstractions/elapsed_millis_since_boot.cpp \
LocHeap.cpp \
LocTimer.cpp \
LocThread.cpp \
MsgTask.cpp \
loc_misc_utils.cpp \
loc_nmea.cpp
loc_nmea.cpp \
LocIpc.cpp
# Flag -std=c++11 is not accepted by compiler when LOCAL_CLANG is set to true
LOCAL_CFLAGS += \
@@ -41,12 +40,12 @@ LOCAL_LDFLAGS += -Wl,--export-dynamic
## Includes
LOCAL_HEADER_LIBRARIES := \
libutils_headers \
libloc_pla_headers \
liblocation_api_headers
LOCAL_MODULE := libgps.utils
LOCAL_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib
LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64
LOCAL_VENDOR_MODULE := true
LOCAL_MODULE_TAGS := optional
LOCAL_PRELINK_MODULE := false
@@ -60,6 +59,5 @@ LOCAL_MODULE := libgps.utils_headers
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
include $(BUILD_HEADER_LIBRARY)
include $(addsuffix /Android.mk, $(addprefix $(LOCAL_PATH)/, platform_lib_abstractions))
endif # not BUILD_TINY_ANDROID
endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE

237
gps/utils/LocIpc.cpp Normal file
View File

@@ -0,0 +1,237 @@
/* Copyright (c) 2017-2018 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.
*
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <log_util.h>
#include "LocIpc.h"
namespace loc_util {
#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "LocSvc_LocIpc"
#define LOC_MSG_BUF_LEN 8192
#define LOC_MSG_HEAD "$MSGLEN$"
#define LOC_MSG_ABORT "LocIpcMsg::ABORT"
class LocIpcRunnable : public LocRunnable {
friend LocIpc;
public:
LocIpcRunnable(LocIpc& locIpc, const std::string& ipcName)
: mLocIpc(locIpc), mIpcName(ipcName) {}
bool run() override {
if (!mLocIpc.startListeningBlocking(mIpcName)) {
LOC_LOGe("listen to socket failed");
}
return false;
}
private:
LocIpc& mLocIpc;
const std::string mIpcName;
};
bool LocIpc::startListeningNonBlocking(const std::string& name) {
mRunnable = new LocIpcRunnable(*this, name);
std::string threadName("LocIpc-");
threadName.append(name);
return mThread.start(threadName.c_str(), mRunnable);
}
bool LocIpc::startListeningBlocking(const std::string& name) {
int fd = socket(AF_UNIX, SOCK_DGRAM, 0);
if (fd < 0) {
LOC_LOGe("create socket error. reason:%s", strerror(errno));
return false;
}
if ((unlink(name.c_str()) < 0) && (errno != ENOENT)) {
LOC_LOGw("unlink socket error. reason:%s", strerror(errno));
}
struct sockaddr_un addr = { .sun_family = AF_UNIX };
snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", name.c_str());
umask(0157);
if (::bind(fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
LOC_LOGe("bind socket error. reason:%s", strerror(errno));
::close(fd);
fd = -1;
return false;
}
mIpcFd = fd;
// inform that the socket is ready to receive message
onListenerReady();
ssize_t nBytes = 0;
std::string msg = "";
std::string abort = LOC_MSG_ABORT;
while (1) {
msg.resize(LOC_MSG_BUF_LEN);
nBytes = ::recvfrom(mIpcFd, (void*)(msg.data()), msg.size(), 0, NULL, NULL);
if (nBytes < 0) {
break;
} else if (nBytes == 0) {
continue;
}
if (strncmp(msg.data(), abort.c_str(), abort.length()) == 0) {
LOC_LOGi("recvd abort msg.data %s", msg.data());
break;
}
if (strncmp(msg.data(), LOC_MSG_HEAD, sizeof(LOC_MSG_HEAD) - 1)) {
// short message
msg.resize(nBytes);
onReceive(msg);
} else {
// long message
size_t msgLen = 0;
sscanf(msg.data(), LOC_MSG_HEAD"%zu", &msgLen);
msg.resize(msgLen);
size_t msgLenReceived = 0;
while ((msgLenReceived < msgLen) && (nBytes > 0)) {
nBytes = recvfrom(mIpcFd, (void*)&(msg[msgLenReceived]),
msg.size() - msgLenReceived, 0, NULL, NULL);
msgLenReceived += nBytes;
}
if (nBytes > 0) {
onReceive(msg);
} else {
break;
}
}
}
if (mStopRequested) {
mStopRequested = false;
return true;
} else {
LOC_LOGe("cannot read socket. reason:%s", strerror(errno));
(void)::close(mIpcFd);
mIpcFd = -1;
return false;
}
}
void LocIpc::stopListening() {
const char *socketName = nullptr;
mStopRequested = true;
if (mRunnable) {
std::string abort = LOC_MSG_ABORT;
socketName = (reinterpret_cast<LocIpcRunnable *>(mRunnable))->mIpcName.c_str();
send(socketName, abort);
mRunnable = nullptr;
}
if (mIpcFd >= 0) {
if (::close(mIpcFd)) {
LOC_LOGe("cannot close socket:%s", strerror(errno));
}
mIpcFd = -1;
}
//delete from the file system at the end
if (socketName) {
unlink(socketName);
}
}
bool LocIpc::send(const char name[], const std::string& data) {
return send(name, (const uint8_t*)data.c_str(), data.length());
}
bool LocIpc::send(const char name[], const uint8_t data[], uint32_t length) {
bool result = true;
int fd = ::socket(AF_UNIX, SOCK_DGRAM, 0);
if (fd < 0) {
LOC_LOGe("create socket error. reason:%s", strerror(errno));
return false;
}
struct sockaddr_un addr = { .sun_family = AF_UNIX };
snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", name);
result = sendData(fd, addr, data, length);
(void)::close(fd);
return result;
}
bool LocIpc::sendData(int fd, const sockaddr_un &addr, const uint8_t data[], uint32_t length) {
bool result = true;
if (length <= LOC_MSG_BUF_LEN) {
if (::sendto(fd, data, length, 0,
(struct sockaddr*)&addr, sizeof(addr)) < 0) {
LOC_LOGe("cannot send to socket. reason:%s", strerror(errno));
result = false;
}
} else {
std::string head = LOC_MSG_HEAD;
head.append(std::to_string(length));
if (::sendto(fd, head.c_str(), head.length(), 0,
(struct sockaddr*)&addr, sizeof(addr)) < 0) {
LOC_LOGe("cannot send to socket. reason:%s", strerror(errno));
result = false;
} else {
size_t sentBytes = 0;
while(sentBytes < length) {
size_t partLen = length - sentBytes;
if (partLen > LOC_MSG_BUF_LEN) {
partLen = LOC_MSG_BUF_LEN;
}
ssize_t rv = ::sendto(fd, data + sentBytes, partLen, 0,
(struct sockaddr*)&addr, sizeof(addr));
if (rv < 0) {
LOC_LOGe("cannot send to socket. reason:%s", strerror(errno));
result = false;
break;
}
sentBytes += rv;
}
}
}
return result;
}
}

153
gps/utils/LocIpc.h Normal file
View File

@@ -0,0 +1,153 @@
/* Copyright (c) 2017-2018 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.
*
*/
#ifndef __LOC_SOCKET__
#define __LOC_SOCKET__
#include <string>
#include <memory>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <LocThread.h>
namespace loc_util {
class LocIpcSender;
class LocIpc {
friend LocIpcSender;
public:
inline LocIpc() : mIpcFd(-1), mStopRequested(false), mRunnable(nullptr) {}
inline virtual ~LocIpc() { stopListening(); }
// Listen for new messages in current thread. Calling this funciton will
// block current thread. The listening can be stopped by calling stopListening().
//
// Argument name is the path of the unix local socket to be listened.
// The function will return true on success, and false on failure.
bool startListeningBlocking(const std::string& name);
// Create a new LocThread and listen for new messages in it.
// Calling this function will return immediately and won't block current thread.
// The listening can be stopped by calling stopListening().
//
// Argument name is the path of the unix local socket to be be listened.
// The function will return true on success, and false on failure.
bool startListeningNonBlocking(const std::string& name);
// Stop listening to new messages.
void stopListening();
// Send out a message.
// Call this function to send a message in argument data to socket in argument name.
//
// Argument name contains the name of the target unix socket. data contains the
// message to be sent out. Convert your message to a string before calling this function.
// The function will return true on success, and false on failure.
static bool send(const char name[], const std::string& data);
static bool send(const char name[], const uint8_t data[], uint32_t length);
protected:
// Callback function for receiving incoming messages.
// Override this function in your derived class to process incoming messages.
// For each received message, this callback function will be called once.
// This callback function will be called in the calling thread of startListeningBlocking
// or in the new LocThread created by startListeningNonBlocking.
//
// Argument data contains the received message. You need to parse it.
inline virtual void onReceive(const std::string& /*data*/) {}
// LocIpc client can overwrite this function to get notification
// when the socket for LocIpc is ready to receive messages.
inline virtual void onListenerReady() {}
private:
static bool sendData(int fd, const sockaddr_un& addr,
const uint8_t data[], uint32_t length);
int mIpcFd;
bool mStopRequested;
LocThread mThread;
LocRunnable *mRunnable;
};
class LocIpcSender {
public:
// Constructor of LocIpcSender class
//
// Argument destSocket contains the full path name of destination socket.
// This class hides generated fd and destination address object from user.
inline LocIpcSender(const char* destSocket):
LocIpcSender(std::make_shared<int>(::socket(AF_UNIX, SOCK_DGRAM, 0)), destSocket) {
if (-1 == *mSocket) {
mSocket = nullptr;
}
}
// Replicate a new LocIpcSender object with new destination socket.
inline LocIpcSender* replicate(const char* destSocket) {
return (nullptr == mSocket) ? nullptr : new LocIpcSender(mSocket, destSocket);
}
inline ~LocIpcSender() {
if (nullptr != mSocket && mSocket.unique()) {
::close(*mSocket);
}
}
// Send out a message.
// Call this function to send a message
//
// Argument data and length contains the message to be sent out.
// Return true when succeeded
inline bool send(const uint8_t data[], uint32_t length) {
bool rtv = false;
if (nullptr != mSocket && nullptr != data) {
rtv = LocIpc::sendData(*mSocket, mDestAddr, data, length);
}
return rtv;
}
private:
std::shared_ptr<int> mSocket;
struct sockaddr_un mDestAddr;
inline LocIpcSender(
const std::shared_ptr<int>& mySocket, const char* destSocket) : mSocket(mySocket) {
if ((nullptr != mSocket) && (-1 != *mSocket) && (nullptr != destSocket)) {
mDestAddr.sun_family = AF_UNIX;
snprintf(mDestAddr.sun_path, sizeof(mDestAddr.sun_path), "%s", destSocket);
}
}
};
}
#endif //__LOC_SOCKET__

2
gps/utils/LocThread.cpp
View File

@@ -29,7 +29,7 @@
#include <LocThread.h>
#include <string.h>
#include <pthread.h>
#include <platform_lib_macros.h>
#include <loc_pla.h>
class LocThreadDelegate {
LocRunnable* mRunnable;

4
gps/utils/LocTimer.cpp
View File

@@ -27,13 +27,15 @@
*
*/
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <errno.h>
#include <loc_timer.h>
#include <sys/timerfd.h>
#include <sys/epoll.h>
#include <log_util.h>
#include <loc_timer.h>
#include <LocTimer.h>
#include <LocHeap.h>
#include <LocThread.h>

2
gps/utils/LocTimer.h
View File

@@ -31,7 +31,7 @@
#define __LOC_TIMER_CPP_H__
#include <stddef.h>
#include <platform_lib_includes.h>
#include <loc_pla.h>
// opaque class to provide service implementation.
class LocTimerDelegate;

192
gps/utils/LocUnorderedSetMap.h Normal file
View File

@@ -0,0 +1,192 @@
/* Copyright (c) 2015, 2017 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.
*
*/
#ifndef __LOC_UNORDERDED_SETMAP_H__
#define __LOC_UNORDERDED_SETMAP_H__
#include <algorithm>
#include <unordered_set>
#include <unordered_map>
using std::unordered_set;
using std::unordered_map;
namespace loc_util {
// Trim from *fromSet* any elements that also exist in *rVals*.
// The optional *goneVals*, if not null, will be populated with removed elements.
template <typename T>
inline static void trimSet(unordered_set<T>& fromSet, const unordered_set<T>& rVals,
unordered_set<T>* goneVals) {
for (auto val : rVals) {
if (fromSet.erase(val) > 0 && nullptr != goneVals) {
goneVals->insert(val);
}
}
}
// this method is destructive to the input unordered_sets.
// the return set is the interset extracted out from the two input sets, *s1* and *s2*.
// *s1* and *s2* will be left with the intersect removed from them.
template <typename T>
static unordered_set<T> removeAndReturnInterset(unordered_set<T>& s1, unordered_set<T>& s2) {
unordered_set<T> common(0);
for (auto b = s2.begin(); b != s2.end(); b++) {
auto a = find(s1.begin(), s1.end(), *b);
if (a != s1.end()) {
// this is a common item of both l1 and l2, remove from both
// but after we add to common
common.insert(*a);
s1.erase(a);
s2.erase(b);
}
}
return common;
}
template <typename KEY, typename VAL>
class LocUnorderedSetMap {
unordered_map<KEY, unordered_set<VAL>> mMap;
// Trim the VALs pointed to by *iter*, with everything that also exist in *rVals*.
// If the set becomes empty, remove the map entry. *goneVals*, if not null, records
// the trimmed VALs.
bool trimOrRemove(typename unordered_map<KEY, unordered_set<VAL>>::iterator iter,
const unordered_set<VAL>& rVals, unordered_set<VAL>* goneVals) {
trimSet<VAL>(iter->second, rVals, goneVals);
bool removeEntry = (iter->second.empty());
if (removeEntry) {
mMap.erase(iter);
}
return removeEntry;
}
public:
inline LocUnorderedSetMap() {}
inline LocUnorderedSetMap(size_t size) : mMap(size) {}
inline bool empty() { return mMap.empty(); }
// This gets the raw pointer to the VALs pointed to by *key*
// If the entry is not in the map, nullptr will be returned.
inline unordered_set<VAL>* getValSetPtr(const KEY& key) {
auto entry = mMap.find(key);
return (entry != mMap.end()) ? &(entry->second) : nullptr;
}
// This gets a copy of VALs pointed to by *key*
// If the entry is not in the map, an empty set will be returned.
inline unordered_set<VAL> getValSet(const KEY& key) {
auto entry = mMap.find(key);
return (entry != mMap.end()) ? entry->second : unordered_set<VAL>(0);
}
// This gets all the KEYs from the map
inline unordered_set<KEY> getKeys() {
unordered_set<KEY> keys(0);
for (auto entry : mMap) {
keys.insert(entry.first);
}
return keys;
}
inline bool remove(const KEY& key) {
return mMap.erase(key) > 0;
}
// This looks into all the entries keyed by *keys*. Remove any VALs from the entries
// that also exist in *rVals*. If the entry is left with an empty set, the entry will
// be removed. The optional parameters *goneKeys* and *goneVals* will record the KEYs
// (or entries) and the collapsed VALs removed from the map, respectively.
inline void trimOrRemove(unordered_set<KEY>&& keys, const unordered_set<VAL>& rVals,
unordered_set<KEY>* goneKeys, unordered_set<VAL>* goneVals) {
trimOrRemove(keys, rVals, goneKeys, goneVals);
}
inline void trimOrRemove(unordered_set<KEY>& keys, const unordered_set<VAL>& rVals,
unordered_set<KEY>* goneKeys, unordered_set<VAL>* goneVals) {
for (auto key : keys) {
auto iter = mMap.find(key);
if (iter != mMap.end() && trimOrRemove(iter, rVals, goneVals) && nullptr != goneKeys) {
goneKeys->insert(iter->first);
}
}
}
// This adds all VALs from *newVals* to the map entry keyed by *key*. Or if it
// doesn't exist yet, add the set to the map.
bool add(const KEY& key, const unordered_set<VAL>& newVals) {
bool newEntryAdded = false;
if (!newVals.empty()) {
auto iter = mMap.find(key);
if (iter != mMap.end()) {
iter->second.insert(newVals.begin(), newVals.end());
} else {
mMap[key] = newVals;
newEntryAdded = true;
}
}
return newEntryAdded;
}
// This adds to each of entries in the map keyed by *keys* with the VALs in the
// *enwVals*. If there new entries added (new key in *keys*), *newKeys*, if not
// null, would be populated with those keys.
inline void add(const unordered_set<KEY>& keys, const unordered_set<VAL>&& newVals,
unordered_set<KEY>* newKeys) {
add(keys, newVals, newKeys);
}
inline void add(const unordered_set<KEY>& keys, const unordered_set<VAL>& newVals,
unordered_set<KEY>* newKeys) {
for (auto key : keys) {
if (add(key, newVals) && nullptr != newKeys) {
newKeys->insert(key);
}
}
}
// This puts *newVals* into the map keyed by *key*, and returns the VALs that are
// in effect removed from the keyed VAL set in the map entry.
// This call would also remove those same VALs from *newVals*.
inline unordered_set<VAL> update(const KEY& key, unordered_set<VAL>& newVals) {
unordered_set<VAL> goneVals(0);
if (newVals.empty()) {
mMap.erase(key);
} else {
auto curVals = mMap[key];
mMap[key] = newVals;
goneVals = removeAndReturnInterset(curVals, newVals);
}
return goneVals;
}
};
} // namespace loc_util
#endif // #ifndef __LOC_UNORDERDED_SETMAP_H__

46
gps/utils/Makefile.am
View File

@@ -1,14 +1,17 @@
ACLOCAL_AMFLAGS = -I m4
AM_CFLAGS = -Wundef \
-MD \
-Wno-trigraphs \
-g -O0 \
-fno-inline \
-fno-short-enums \
-fpic \
-I./ \
-std=c++11 \
$(LOCPLA_CFLAGS)
AM_CPPFLAGS = -Wundef \
-I./ \
-std=c++11 \
$(LOCPLA_CFLAGS)
libgps_utils_so_la_h_sources = \
libgps_utils_la_h_sources = \
msg_q.h \
linked_list.h \
loc_cfg.h \
@@ -19,13 +22,15 @@ libgps_utils_so_la_h_sources = \
LocHeap.h \
LocThread.h \
LocTimer.h \
LocIpc.h \
loc_misc_utils.h \
loc_nmea.h \
gps_extended_c.h \
gps_extended.h \
loc_gps.h
loc_gps.h \
log_util.h
libgps_utils_so_la_c_sources = \
libgps_utils_la_c_sources = \
linked_list.c \
msg_q.c \
loc_cfg.cpp \
@@ -34,31 +39,32 @@ libgps_utils_so_la_c_sources = \
LocHeap.cpp \
LocTimer.cpp \
LocThread.cpp \
LocIpc.cpp \
MsgTask.cpp \
loc_misc_utils.cpp \
loc_nmea.cpp
library_includedir = $(pkgincludedir)
library_include_HEADERS = $(libgps_utils_so_la_h_sources)
library_include_HEADERS = $(libgps_utils_la_h_sources)
libgps_utils_so_la_SOURCES = $(libgps_utils_so_la_c_sources)
libgps_utils_la_SOURCES = $(libgps_utils_la_c_sources)
if USE_GLIB
libgps_utils_so_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
libgps_utils_so_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libgps_utils_so_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
libgps_utils_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
libgps_utils_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libgps_utils_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libgps_utils_so_la_CFLAGS = $(AM_CFLAGS)
libgps_utils_so_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
libgps_utils_so_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
libgps_utils_la_CFLAGS = $(AM_CFLAGS)
libgps_utils_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
libgps_utils_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif
libgps_utils_so_la_LIBADD = -lcutils -lstdc++ -llog $(LOCPLA_LIBS)
libgps_utils_la_LIBADD = $(CUTILS_LIBS)
#Create and Install libraries
lib_LTLIBRARIES = libgps_utils_so.la
library_includedir = $(pkgincludedir)
pkgconfigdir = $(libdir)/pkgconfig
lib_LTLIBRARIES = libgps_utils.la
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = gps-utils.pc
EXTRA_DIST = $(pkgconfig_DATA)

5
gps/utils/MsgTask.cpp
View File

@@ -32,8 +32,9 @@
#include <unistd.h>
#include <MsgTask.h>
#include <msg_q.h>
#include <log_util.h>
#include <loc_log.h>
#include <platform_lib_includes.h>
#include <loc_pla.h>
static void LocMsgDestroy(void* msg) {
delete (LocMsg*)msg;
@@ -82,7 +83,7 @@ void MsgTask::sendMsg(const LocMsg* msg) const {
void MsgTask::prerun() {
// make sure we do not run in background scheduling group
platform_lib_abstraction_set_sched_policy(platform_lib_abstraction_gettid(), PLA_SP_FOREGROUND);
set_sched_policy(gettid(), SP_FOREGROUND);
}
bool MsgTask::run() {

29
gps/utils/configure.ac
View File

@@ -28,9 +28,32 @@ AC_PROG_LN_S
AC_PROG_MAKE_SET
PKG_PROG_PKG_CONFIG
PKG_CHECK_MODULES([LOCPLA], [loc-pla])
AC_SUBST([LOCPLA_CFLAGS])
AC_SUBST([LOCPLA_LIBS])
# Checks for libraries.
PKG_CHECK_MODULES([CUTILS], [libcutils])
AC_SUBST([CUTILS_CFLAGS])
AC_SUBST([CUTILS_LIBS])
AC_ARG_WITH([core_includes],
AC_HELP_STRING([--with-core-includes=@<:@dir@:>@],
[Specify the location of the core headers]),
[core_incdir=$withval],
with_core_includes=no)
if test "x$with_core_includes" != "xno"; then
CPPFLAGS="${CPPFLAGS} -I${core_incdir}"
fi
AC_ARG_WITH([locpla_includes],
AC_HELP_STRING([--with-locpla-includes=@<:@dir@:>@],
[specify the path to locpla-includes in loc-pla_git.bb]),
[locpla_incdir=$withval],
with_locpla_includes=no)
if test "x$with_locpla_includes" != "xno"; then
AC_SUBST(LOCPLA_CFLAGS, "-I${locpla_incdir}")
fi
AC_SUBST([CPPFLAGS])
AC_ARG_WITH([glib],
AC_HELP_STRING([--with-glib],

2
gps/utils/gps-utils.pc.in
View File

@@ -6,5 +6,5 @@ includedir=@includedir@
Name: gps-utils
Description: QTI GPS Location utils
Version: @VERSION
Libs: -L${libdir} -lgps_utils_so
Libs: -L${libdir} -lgps_utils
Cflags: -I${includedir}/gps-utils

58
gps/utils/gps_extended_c.h
View File

@@ -115,7 +115,9 @@ enum loc_registration_mask_status {
typedef enum {
LOC_SUPPORTED_FEATURE_ODCPI_2_V02 = 0, /**< Support ODCPI version 2 feature */
LOC_SUPPORTED_FEATURE_WIFI_AP_DATA_INJECT_2_V02, /**< Support Wifi AP data inject version 2 feature */
LOC_SUPPORTED_FEATURE_DEBUG_NMEA_V02 /**< Support debug NMEA feature */
LOC_SUPPORTED_FEATURE_DEBUG_NMEA_V02, /**< Support debug NMEA feature */
LOC_SUPPORTED_FEATURE_GNSS_ONLY_POSITION_REPORT, /**< Support GNSS Only position reports */
LOC_SUPPORTED_FEATURE_FDCL /**< Support FDCL */
} loc_supported_feature_enum;
typedef struct {
@@ -308,6 +310,10 @@ typedef uint32_t GpsLocationExtendedFlags;
#define GPS_LOCATION_EXTENDED_HAS_POS_DYNAMICS_DATA 0x10000
/** GpsLocationExtended has GPS Time */
#define GPS_LOCATION_EXTENDED_HAS_GPS_TIME 0x20000
/** GpsLocationExtended has Extended Dilution of Precision */
#define GPS_LOCATION_EXTENDED_HAS_EXT_DOP 0x40000
/** GpsLocationExtended has Elapsed Time */
#define GPS_LOCATION_EXTENDED_HAS_ELAPSED_TIME 0x80000
typedef uint32_t LocNavSolutionMask;
/* Bitmask to specify whether SBAS ionospheric correction is used */
@@ -393,6 +399,29 @@ typedef struct {
float pitch;
}LocPositionDynamics;
typedef struct {
/** Position dilution of precision.
Range: 1 (highest accuracy) to 50 (lowest accuracy) */
float PDOP;
/** Horizontal dilution of precision.
Range: 1 (highest accuracy) to 50 (lowest accuracy) */
float HDOP;
/** Vertical dilution of precision.
Range: 1 (highest accuracy) to 50 (lowest accuracy) */
float VDOP;
/** geometric dilution of precision.
Range: 1 (highest accuracy) to 50 (lowest accuracy) */
float GDOP;
/** time dilution of precision.
Range: 1 (highest accuracy) to 50 (lowest accuracy) */
float TDOP;
}LocExtDOP;
/* GPS Time structure */
typedef struct {
@@ -451,6 +480,10 @@ typedef struct {
LocPositionDynamics bodyFrameData;
/** GPS Time */
GPSTimeStruct gpsTime;
/** Elapsed Time */
int64_t elapsedTime;
/** Dilution of precision associated with this position*/
LocExtDOP extDOP;
} GpsLocationExtended;
enum loc_sess_status {
@@ -559,7 +592,8 @@ enum loc_api_adapter_event_index {
LOC_API_ADAPTER_REPORT_GENFENCE_DWELL_REPORT, // Geofence dwell report
LOC_API_ADAPTER_REQUEST_SRN_DATA, // request srn data from AP
LOC_API_ADAPTER_REQUEST_POSITION_INJECTION, // Position injection request
LOC_API_ADAPTER_BATCH_STATUS, // batch status
LOC_API_ADAPTER_BATCH_STATUS, // batch status
LOC_API_ADAPTER_FDCL_SERVICE_REQ, // FDCL service request
LOC_API_ADAPTER_EVENT_MAX
};
@@ -595,9 +629,10 @@ enum loc_api_adapter_event_index {
#define LOC_API_ADAPTER_BIT_REQUEST_SRN_DATA (1<<LOC_API_ADAPTER_REQUEST_SRN_DATA)
#define LOC_API_ADAPTER_BIT_POSITION_INJECTION_REQUEST (1<<LOC_API_ADAPTER_REQUEST_POSITION_INJECTION)
#define LOC_API_ADAPTER_BIT_BATCH_STATUS (1<<LOC_API_ADAPTER_BATCH_STATUS)
#define LOC_API_ADAPTER_BIT_FDCL_SERVICE_REQ (1ULL<<LOC_API_ADAPTER_FDCL_SERVICE_REQ)
typedef unsigned int LOC_API_ADAPTER_EVENT_MASK_T;
typedef uint64_t LOC_API_ADAPTER_EVENT_MASK_T;
typedef enum loc_api_adapter_msg_to_check_supported {
LOC_API_ADAPTER_MESSAGE_LOCATION_BATCHING, // Batching 1.0
@@ -1262,6 +1297,20 @@ struct AGnssExtStatusIpV6 {
uint8_t ipV6Addr[16];
};
/* ODCPI Request Info */
enum OdcpiRequestType {
ODCPI_REQUEST_TYPE_START,
ODCPI_REQUEST_TYPE_STOP
};
struct OdcpiRequestInfo {
size_t size;
OdcpiRequestType type;
uint32_t tbfMillis;
bool isEmergencyMode;
};
/* Callback to send ODCPI request to framework */
typedef std::function<void(const OdcpiRequestInfo& request)> OdcpiRequestCallback;
/*
* Callback with AGNSS(IpV4) status information.
*
@@ -1282,6 +1331,9 @@ typedef void (*LocAgpsOpenResultCb)(bool isSuccess, AGpsExtType agpsType, const
typedef void (*LocAgpsCloseResultCb)(bool isSuccess, AGpsExtType agpsType, void* userDataPtr);
/* Shared resources of LocIpc */
#define LOC_IPC_HAL "/dev/socket/location/socket_hal"
#define LOC_IPC_XTRA "/dev/socket/location/xtra/socket_xtra"
#ifdef __cplusplus
}

7
gps/utils/linked_list.c
View File

@@ -26,14 +26,15 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define LOG_TAG "LocSvc_utils_ll"
#include "linked_list.h"
#include <stdio.h>
#include <string.h>
#define LOG_TAG "LocSvc_utils_ll"
#include <platform_lib_includes.h>
#include <stdlib.h>
#include <stdint.h>
#include <loc_pla.h>
#include <log_util.h>
typedef struct list_element {
struct list_element* next;

755
gps/utils/loc_cfg.cpp
View File

@@ -1,4 +1,4 @@
/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
/* Copyright (c) 2011-2015, 2018 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
@@ -37,13 +37,16 @@
#include <ctype.h>
#include <unistd.h>
#include <time.h>
#include <pwd.h>
#include <errno.h>
#include <loc_cfg.h>
#include <platform_lib_includes.h>
#include <loc_pla.h>
#include <loc_target.h>
#include <loc_misc_utils.h>
#ifdef USE_GLIB
#include <glib.h>
#endif
#include "platform_lib_includes.h"
#include "log_util.h"
/*=============================================================================
*
@@ -54,12 +57,14 @@
/* Parameter data */
static uint32_t DEBUG_LEVEL = 0xff;
static uint32_t TIMESTAMP = 0;
static uint32_t LOC_MODEM_EMULATOR = 0;
/* Parameter spec table */
static const loc_param_s_type loc_param_table[] =
{
{"DEBUG_LEVEL", &DEBUG_LEVEL, NULL, 'n'},
{"TIMESTAMP", &TIMESTAMP, NULL, 'n'},
{"DEBUG_LEVEL", &DEBUG_LEVEL, NULL, 'n'},
{"TIMESTAMP", &TIMESTAMP, NULL, 'n'},
{"LOC_MODEM_EMULATOR", &LOC_MODEM_EMULATOR, NULL, 'n'},
};
static const int loc_param_num = sizeof(loc_param_table) / sizeof(loc_param_s_type);
@@ -71,6 +76,28 @@ typedef struct loc_param_v_type
double param_double_value;
}loc_param_v_type;
// Reference below arrays wherever needed to avoid duplicating
// same conf path string over and again in location code.
const char LOC_PATH_GPS_CONF[] = LOC_PATH_GPS_CONF_STR;
const char LOC_PATH_IZAT_CONF[] = LOC_PATH_IZAT_CONF_STR;
const char LOC_PATH_FLP_CONF[] = LOC_PATH_FLP_CONF_STR;
const char LOC_PATH_LOWI_CONF[] = LOC_PATH_LOWI_CONF_STR;
const char LOC_PATH_SAP_CONF[] = LOC_PATH_SAP_CONF_STR;
const char LOC_PATH_APDR_CONF[] = LOC_PATH_APDR_CONF_STR;
const char LOC_PATH_XTWIFI_CONF[] = LOC_PATH_XTWIFI_CONF_STR;
const char LOC_PATH_QUIPC_CONF[] = LOC_PATH_QUIPC_CONF_STR;
/*===========================================================================
FUNCTION loc_modem_emulator_enabled
DESCRIPTION
Provides access to Modem Emulator config item.
===========================================================================*/
uint32_t loc_modem_emulator_enabled()
{
return LOC_MODEM_EMULATOR;
}
/*===========================================================================
FUNCTION loc_set_config_entry
@@ -381,9 +408,6 @@ void loc_read_conf(const char* conf_file_name, const loc_param_s_type* config_ta
uint32_t table_length)
{
FILE *conf_fp = NULL;
char *lasts;
loc_param_v_type config_value;
uint32_t i;
if((conf_fp = fopen(conf_file_name, "r")) != NULL)
{
@@ -398,3 +422,718 @@ void loc_read_conf(const char* conf_file_name, const loc_param_s_type* config_ta
/* Initialize logging mechanism with parsed data */
loc_logger_init(DEBUG_LEVEL, TIMESTAMP);
}
/*=============================================================================
*
* Define and Structures for Parsing Location Process Configuration File
*
*============================================================================*/
#define MAX_NUM_STRINGS 20
//We can have 8 masks for now
#define CONFIG_MASK_TARGET_ALL 0X01
#define CONFIG_MASK_TARGET_FOUND 0X02
#define CONFIG_MASK_TARGET_CHECK 0X03
#define CONFIG_MASK_BASEBAND_ALL 0X04
#define CONFIG_MASK_BASEBAND_FOUND 0X08
#define CONFIG_MASK_BASEBAND_CHECK 0x0c
#define CONFIG_MASK_AUTOPLATFORM_ALL 0x10
#define CONFIG_MASK_AUTOPLATFORM_FOUND 0x20
#define CONFIG_MASK_AUTOPLATFORM_CHECK 0x30
#define LOC_FEATURE_MASK_GTP_WIFI_BASIC 0x01
#define LOC_FEATURE_MASK_GTP_WIFI_PREMIUM 0X02
#define LOC_FEATURE_MASK_GTP_CELL_BASIC 0X04
#define LOC_FEATURE_MASK_GTP_CELL_PREMIUM 0X08
#define LOC_FEATURE_MASK_GTP_AP_CELL_BASIC LOC_FEATURE_MASK_GTP_CELL_BASIC
#define LOC_FEATURE_MASK_GTP_AP_CELL_PREMIUM LOC_FEATURE_MASK_GTP_CELL_PREMIUM
#define LOC_FEATURE_MASK_SAP_BASIC 0x40
#define LOC_FEATURE_MASK_SAP_PREMIUM 0X80
#define LOC_FEATURE_MASK_GTP_WAA_BASIC 0X100
#define LOC_FEATURE_MASK_GTP_WAA_PREMIUM 0x200
#define LOC_FEATURE_MASK_GTP_MODEM_CELL_BASIC 0X400
#define LOC_FEATURE_MASK_GTP_MODEM_CELL_PREMIUM 0X800
#define LOC_FEATURE_MASK_ODCPI 0x1000
#define LOC_FEATURE_MASK_FREE_WIFI_SCAN_INJECT 0x2000
#define LOC_FEATURE_MASK_SUPL_WIFI 0x4000
#define LOC_FEATURE_MASK_WIFI_SUPPLICANT_INFO 0x8000
typedef struct {
char proc_name[LOC_MAX_PARAM_STRING];
char proc_argument[LOC_MAX_PARAM_STRING];
char proc_status[LOC_MAX_PARAM_STRING];
char group_list[LOC_MAX_PARAM_STRING];
unsigned int premium_feature;
unsigned int loc_feature_mask;
char platform_list[LOC_MAX_PARAM_STRING];
char baseband[LOC_MAX_PARAM_STRING];
unsigned int sglte_target;
char feature_gtp_cell_proc[LOC_MAX_PARAM_STRING];
char feature_gtp_waa[LOC_MAX_PARAM_STRING];
char feature_gtp_cell[LOC_MAX_PARAM_STRING];
char feature_gtp_wifi[LOC_MAX_PARAM_STRING];
char feature_sap[LOC_MAX_PARAM_STRING];
char feature_odcpi[LOC_MAX_PARAM_STRING];
char feature_free_wifi_scan_inject[LOC_MAX_PARAM_STRING];
char feature_supl_wifi[LOC_MAX_PARAM_STRING];
char feature_wifi_supplicant_info[LOC_MAX_PARAM_STRING];
char auto_platform[LOC_MAX_PARAM_STRING];
} loc_launcher_conf;
/* process configuration parameters */
static loc_launcher_conf conf;
/* gps.conf Parameter spec table */
static const loc_param_s_type gps_conf_parameter_table[] = {
{"SGLTE_TARGET", &conf.sglte_target, NULL, 'n'},
};
/* location feature conf, e.g.: izat.conf feature mode table*/
static const loc_param_s_type loc_feature_conf_table[] = {
{"GTP_CELL_PROC", &conf.feature_gtp_cell_proc, NULL, 's'},
{"GTP_CELL", &conf.feature_gtp_cell, NULL, 's'},
{"GTP_WIFI", &conf.feature_gtp_wifi, NULL, 's'},
{"GTP_WAA", &conf.feature_gtp_waa, NULL, 's'},
{"SAP", &conf.feature_sap, NULL, 's'},
{"ODCPI", &conf.feature_odcpi, NULL, 's'},
{"FREE_WIFI_SCAN_INJECT", &conf.feature_free_wifi_scan_inject, NULL, 's'},
{"SUPL_WIFI", &conf.feature_supl_wifi, NULL, 's'},
{"WIFI_SUPPLICANT_INFO", &conf.feature_wifi_supplicant_info, NULL, 's'},
};
/* location process conf, e.g.: izat.conf Parameter spec table */
static const loc_param_s_type loc_process_conf_parameter_table[] = {
{"PROCESS_NAME", &conf.proc_name, NULL, 's'},
{"PROCESS_ARGUMENT", &conf.proc_argument, NULL, 's'},
{"PROCESS_STATE", &conf.proc_status, NULL, 's'},
{"PROCESS_GROUPS", &conf.group_list, NULL, 's'},
{"PREMIUM_FEATURE", &conf.premium_feature, NULL, 'n'},
{"IZAT_FEATURE_MASK", &conf.loc_feature_mask, NULL, 'n'},
{"PLATFORMS", &conf.platform_list, NULL, 's'},
{"BASEBAND", &conf.baseband, NULL, 's'},
{"HARDWARE_TYPE", &conf.auto_platform, NULL, 's'},
};
/*===========================================================================
FUNCTION loc_read_process_conf
DESCRIPTION
Parse the specified conf file and return info for the processes defined.
The format of the file should conform with izat.conf.
PARAMETERS:
conf_file_name: configuration file to read
process_count_ptr: pointer to store number of processes defined in the conf file.
process_info_table_ptr: pointer to store the process info table.
DEPENDENCIES
The file must be in izat.conf format.
RETURN VALUE
0: success
none-zero: failure
SIDE EFFECTS
N/A
NOTES:
On success, memory pointed by (*process_info_table_ptr) must be freed.
===========================================================================*/
int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_ptr,
loc_process_info_s_type** process_info_table_ptr) {
loc_process_info_s_type *child_proc = nullptr;
volatile int i=0;
unsigned int j=0;
gid_t gid_list[LOC_PROCESS_MAX_NUM_GROUPS];
char *split_strings[MAX_NUM_STRINGS];
int name_length=0, group_list_length=0, platform_length=0, baseband_length=0, ngroups=0, ret=0;
int auto_platform_length = 0;
int group_index=0, nstrings=0, status_length=0;
FILE* conf_fp = nullptr;
char platform_name[PROPERTY_VALUE_MAX], baseband_name[PROPERTY_VALUE_MAX];
char autoplatform_name[PROPERTY_VALUE_MAX];
unsigned int loc_service_mask=0;
char config_mask = 0;
unsigned char proc_list_length=0;
int gtp_cell_ap_enabled = 0;
char arg_gtp_waa[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
char arg_gtp_ap_cell[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
char arg_gtp_modem_cell[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
char arg_gtp_wifi[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
char arg_sap[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
char arg_disabled[LOC_PROCESS_MAX_ARG_STR_LENGTH] = LOC_FEATURE_MODE_DISABLED;
char arg_basic[LOC_PROCESS_MAX_ARG_STR_LENGTH] = LOC_FEATURE_MODE_BASIC;
char arg_premium[LOC_PROCESS_MAX_ARG_STR_LENGTH] = LOC_FEATURE_MODE_PREMIUM;
if (process_count_ptr == NULL || process_info_table_ptr == NULL) {
return -1;
}
//Read gps.conf and fill parameter table
UTIL_READ_CONF(LOC_PATH_GPS_CONF, gps_conf_parameter_table);
//Form argument strings
strlcat(arg_gtp_waa, LOC_FEATURE_GTP_WAA, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
strlcat(arg_gtp_ap_cell, LOC_FEATURE_GTP_AP_CELL, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
strlcat(arg_gtp_modem_cell, LOC_FEATURE_GTP_MODEM_CELL, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
strlcat(arg_gtp_wifi, LOC_FEATURE_GTP_WIFI, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
strlcat(arg_sap, LOC_FEATURE_SAP, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
//Get platform name from ro.board.platform property
loc_get_platform_name(platform_name, sizeof(platform_name));
//Get baseband name from ro.baseband property
loc_get_target_baseband(baseband_name, sizeof(baseband_name));
//Identify if this is an automotive platform
loc_get_auto_platform_name(autoplatform_name,sizeof(autoplatform_name));
UTIL_READ_CONF(conf_file_name, loc_feature_conf_table);
//Set service mask for GTP_WIFI
if(strcmp(conf.feature_gtp_wifi, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: GTP WIFI DISABLED", __func__, __LINE__);
}
else if(strcmp(conf.feature_gtp_wifi, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting GTP WIFI to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_GTP_WIFI_BASIC;
}
//conf file has a garbage value
else {
LOC_LOGE("%s:%d]: Unrecognized value for GTP WIFI Mode."\
" Setting GTP WIFI to default mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_GTP_WIFI_BASIC;
}
//Set service mask for GTP_CELL
//Using a temp variable here to indicate wheter GTP cell is
//enabled on the AP or modem. This variable will be used in
//further checks below. An alternative was to compare the
//string again in each place which would've been more expensive
if(strcmp(conf.feature_gtp_cell_proc, "AP") == 0) {
gtp_cell_ap_enabled = 1;
}
if(strcmp(conf.feature_gtp_cell, "PREMIUM") == 0) {
LOC_LOGE("%s:%d]: Error: location feature GTP CELL does not support PREMIUM mode" \
" available modes are BASIC and DISABLED. Starting feature in BASIC mode",
__func__, __LINE__);
if(gtp_cell_ap_enabled) {
loc_service_mask |= LOC_FEATURE_MASK_GTP_AP_CELL_BASIC;
}
else {
loc_service_mask |= LOC_FEATURE_MASK_GTP_MODEM_CELL_BASIC;
}
}
else if(strcmp(conf.feature_gtp_cell, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting GTP CELL to mode: BASIC", __func__, __LINE__);
if(gtp_cell_ap_enabled) {
loc_service_mask |= LOC_FEATURE_MASK_GTP_AP_CELL_BASIC;
}
else {
loc_service_mask |= LOC_FEATURE_MASK_GTP_MODEM_CELL_BASIC;
}
}
else if(strcmp(conf.feature_gtp_cell, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: GTP CELL DISABLED", __func__, __LINE__);
}
//conf file has a garbage value
else {
LOC_LOGE("%s:%d]: Unrecognized value for GTP CELL Mode." \
" Setting GTP CELL to default mode: BASIC", __func__, __LINE__);
if(gtp_cell_ap_enabled) {
loc_service_mask |= LOC_FEATURE_MASK_GTP_AP_CELL_BASIC;
}
else {
loc_service_mask |= LOC_FEATURE_MASK_GTP_MODEM_CELL_BASIC;
}
}
//Set service mask for GTP_WAA
if(strcmp(conf.feature_gtp_waa, "PREMIUM") == 0) {
LOC_LOGE("%s:%d]: Error: location feature GTP WAA does not support PREMIUM mode" \
" available modes are BASIC and DISABLED. Starting feature in BASIC mode",
__func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_GTP_WAA_BASIC;
}
else if(strcmp(conf.feature_gtp_waa, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting GTP WAA to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_GTP_WAA_BASIC;
}
else if(strcmp(conf.feature_gtp_waa, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: GTP WAA DISABLED", __func__, __LINE__);
}
//conf file has a garbage value
else {
LOC_LOGE("%s:%d]: Unrecognized value for GTP WAA Mode."\
" Setting GTP WAA to default mode: DISABLED", __func__, __LINE__);
}
//Set service mask for SAP
if(strcmp(conf.feature_sap, "PREMIUM") == 0) {
LOC_LOGD("%s:%d]: Setting SAP to mode: PREMIUM", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_SAP_PREMIUM;
}
else if(strcmp(conf.feature_sap, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting SAP to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_SAP_BASIC;
}
else if(strcmp(conf.feature_sap, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: Setting SAP to mode: DISABLED", __func__, __LINE__);
}
else {
LOC_LOGE("%s:%d]: Unrecognized value for SAP Mode."\
" Setting SAP to default mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_SAP_BASIC;
}
// Set service mask for ODCPI
if(strcmp(conf.feature_odcpi, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting ODCPI to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_ODCPI;
}
else if(strcmp(conf.feature_odcpi, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: Setting ODCPI to mode: DISABLED", __func__, __LINE__);
}
else if(strcmp(conf.feature_odcpi, "PREMIUM") == 0) {
LOC_LOGD("%s:%d]: Unrecognized value for ODCPI mode."\
"Setting ODCPI to default mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_ODCPI;
}
// Set service mask for FREE_WIFI_SCAN_INJECT
if(strcmp(conf.feature_free_wifi_scan_inject, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting FREE_WIFI_SCAN_INJECT to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_FREE_WIFI_SCAN_INJECT;
}
else if(strcmp(conf.feature_free_wifi_scan_inject, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: Setting FREE_WIFI_SCAN_INJECT to mode: DISABLED", __func__, __LINE__);
}
else if(strcmp(conf.feature_free_wifi_scan_inject, "PREMIUM") == 0) {
LOC_LOGD("%s:%d]: Unrecognized value for FREE_WIFI_SCAN_INJECT mode."\
"Setting FREE_WIFI_SCAN_INJECT to default mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_FREE_WIFI_SCAN_INJECT;
}
// Set service mask for SUPL_WIFI
if(strcmp(conf.feature_supl_wifi, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting SUPL_WIFI to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_SUPL_WIFI;
}
else if(strcmp(conf.feature_supl_wifi, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: Setting SUPL_WIFI to mode: DISABLED", __func__, __LINE__);
}
else if(strcmp(conf.feature_supl_wifi, "PREMIUM") == 0) {
LOC_LOGD("%s:%d]: Unrecognized value for SUPL_WIFI mode."\
"Setting SUPL_WIFI to default mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_SUPL_WIFI;
}
// Set service mask for WIFI_SUPPLICANT_INFO
if(strcmp(conf.feature_wifi_supplicant_info, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting WIFI_SUPPLICANT_INFO to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_WIFI_SUPPLICANT_INFO;
}
else if(strcmp(conf.feature_wifi_supplicant_info, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: Setting WIFI_SUPPLICANT_INFO to mode: DISABLED", __func__, __LINE__);
}
else if(strcmp(conf.feature_wifi_supplicant_info, "PREMIUM") == 0) {
LOC_LOGD("%s:%d]: Unrecognized value for WIFI_SUPPLICANT_INFO mode."\
"Setting LOC_FEATURE_MASK_WIFI_SUPPLICANT_INFO to default mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_WIFI_SUPPLICANT_INFO;
}
LOC_LOGD("%s:%d]: loc_service_mask: %x\n", __func__, __LINE__, loc_service_mask);
if((conf_fp = fopen(conf_file_name, "r")) == NULL) {
LOC_LOGE("%s:%d]: Error opening %s %s\n", __func__,
__LINE__, conf_file_name, strerror(errno));
ret = -1;
goto err;
}
//Parse through the file to find out how many processes are to be launched
proc_list_length = 0;
do {
conf.proc_name[0] = 0;
//Here note that the 3rd parameter is passed as 1.
//This is so that only the first parameter in the table which is "PROCESS_NAME"
//is read. We do not want to read the entire block of parameters at this time
//since we are only counting the number of processes to launch.
//Therefore, only counting the occurrences of PROCESS_NAME parameter
//should suffice
if(loc_read_conf_r(conf_fp, loc_process_conf_parameter_table, 1)) {
LOC_LOGE("%s:%d]: Unable to read conf file. Failing\n", __func__, __LINE__);
ret = -1;
goto err;
}
name_length=(int)strlen(conf.proc_name);
if(name_length) {
proc_list_length++;
LOC_LOGD("Process name:%s", conf.proc_name);
}
} while(name_length);
LOC_LOGD("Process cnt = %d", proc_list_length);
child_proc = (loc_process_info_s_type *)calloc(proc_list_length, sizeof(loc_process_info_s_type));
if(child_proc == NULL) {
LOC_LOGE("%s:%d]: ERROR: Malloc returned NULL\n", __func__, __LINE__);
ret = -1;
goto err;
}
//Move file descriptor to the beginning of the file
//so that the parameters can be read
rewind(conf_fp);
for(j=0; j<proc_list_length; j++) {
//Set defaults for all the child process structs
child_proc[j].proc_status = DISABLED;
memset(child_proc[j].group_list, 0, sizeof(child_proc[j].group_list));
config_mask=0;
if(loc_read_conf_r(conf_fp, loc_process_conf_parameter_table,
sizeof(loc_process_conf_parameter_table)/sizeof(loc_process_conf_parameter_table[0]))) {
LOC_LOGE("%s:%d]: Unable to read conf file. Failing\n", __func__, __LINE__);
ret = -1;
goto err;
}
name_length=(int)strlen(conf.proc_name);
group_list_length=(int)strlen(conf.group_list);
platform_length = (int)strlen(conf.platform_list);
baseband_length = (int)strlen(conf.baseband);
status_length = (int)strlen(conf.proc_status);
auto_platform_length = (int)strlen(conf.auto_platform);
if(!name_length || !group_list_length || !platform_length ||
!baseband_length || !status_length || !auto_platform_length) {
LOC_LOGE("%s:%d]: Error: i: %d; One of the parameters not specified in conf file",
__func__, __LINE__, i);
continue;
}
if(strcmp(conf.proc_status, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: Process %s is disabled in conf file",
__func__, __LINE__, conf.proc_name);
child_proc[j].proc_status = DISABLED_FROM_CONF;
continue;
}
else if(strcmp(conf.proc_status, "ENABLED") == 0) {
LOC_LOGD("%s:%d]: Process %s is enabled in conf file",
__func__, __LINE__, conf.proc_name);
}
//Since strlcpy copies length-1 characters, we add 1 to name_length
if((name_length+1) > LOC_MAX_PARAM_STRING) {
LOC_LOGE("%s:%d]: i: %d; Length of name parameter too long. Max length: %d",
__func__, __LINE__, i, LOC_MAX_PARAM_STRING);
continue;
}
strlcpy(child_proc[j].name[0], conf.proc_name, sizeof (child_proc[j].name[0]));
child_proc[j].num_groups = 0;
ngroups = loc_util_split_string(conf.group_list, split_strings, MAX_NUM_STRINGS, ' ');
#ifdef __ANDROID__
for(i=0; i<ngroups; i++) {
struct passwd* pwd = getpwnam(split_strings[i]);
if (pwd) {
child_proc[j].group_list[i] = pwd->pw_gid;
child_proc[j].num_groups++;
LOC_LOGD("%s:%d]:Group %s = %d matches child_group: %d\n",
__func__, __LINE__, split_strings[i],
pwd->pw_gid,child_proc[j].group_list[i]);
}
}
#endif
nstrings = loc_util_split_string(conf.platform_list, split_strings, MAX_NUM_STRINGS, ' ');
if(strcmp("all", split_strings[0]) == 0) {
if (nstrings == 1 || (nstrings == 2 && (strcmp("exclude", split_strings[1]) == 0))) {
LOC_LOGD("%s:%d]: Enabled for all targets\n", __func__, __LINE__);
config_mask |= CONFIG_MASK_TARGET_ALL;
}
else if (nstrings > 2 && (strcmp("exclude", split_strings[1]) == 0)) {
config_mask |= CONFIG_MASK_TARGET_FOUND;
for (i=2; i<nstrings; i++) {
if(strcmp(platform_name, split_strings[i]) == 0) {
LOC_LOGD("%s:%d]: Disabled platform %s\n", __func__, __LINE__, platform_name);
config_mask &= ~CONFIG_MASK_TARGET_FOUND;
break;
}
}
}
}
else {
for(i=0; i<nstrings; i++) {
if(strcmp(platform_name, split_strings[i]) == 0) {
LOC_LOGD("%s:%d]: Matched platform: %s\n",
__func__, __LINE__, split_strings[i]);
config_mask |= CONFIG_MASK_TARGET_FOUND;
break;
}
}
}
nstrings = loc_util_split_string(conf.baseband, split_strings, MAX_NUM_STRINGS, ' ');
if(strcmp("all", split_strings[0]) == 0) {
if (nstrings == 1 || (nstrings == 2 && (strcmp("exclude", split_strings[1]) == 0))) {
LOC_LOGD("%s:%d]: Enabled for all basebands\n", __func__, __LINE__);
config_mask |= CONFIG_MASK_BASEBAND_ALL;
}
else if (nstrings > 2 && (strcmp("exclude", split_strings[1]) == 0)) {
config_mask |= CONFIG_MASK_BASEBAND_FOUND;
for (i=2; i<nstrings; i++) {
if(strcmp(baseband_name, split_strings[i]) == 0) {
LOC_LOGD("%s:%d]: Disabled band %s\n", __func__, __LINE__, baseband_name);
config_mask &= ~CONFIG_MASK_BASEBAND_FOUND;
break;
}
}
}
}
else {
for(i=0; i<nstrings; i++) {
if(strcmp(baseband_name, split_strings[i]) == 0) {
LOC_LOGD("%s:%d]: Matched baseband: %s\n",
__func__, __LINE__, split_strings[i]);
config_mask |= CONFIG_MASK_BASEBAND_FOUND;
break;
}
//Since ro.baseband is not a reliable source for detecting sglte
//the alternative is to read the SGLTE_TARGET parameter from gps.conf
//this parameter is read into conf_sglte_target
else if((strcmp("sglte", split_strings[i]) == 0 ) && conf.sglte_target) {
LOC_LOGD("%s:%d]: Matched baseband SGLTE\n", __func__, __LINE__);
config_mask |= CONFIG_MASK_BASEBAND_FOUND;
break;
}
}
}
nstrings = loc_util_split_string(conf.auto_platform, split_strings, MAX_NUM_STRINGS, ' ');
if(strcmp("all", split_strings[0]) == 0) {
LOC_LOGD("%s:%d]: Enabled for all auto platforms\n", __func__, __LINE__);
config_mask |= CONFIG_MASK_AUTOPLATFORM_ALL;
}
else {
for(i=0; i<nstrings; i++) {
if(strcmp(autoplatform_name, split_strings[i]) == 0) {
LOC_LOGD("%s:%d]: Matched auto platform: %s\n",
__func__, __LINE__, split_strings[i]);
config_mask |= CONFIG_MASK_AUTOPLATFORM_FOUND;
break;
}
}
}
if((config_mask & CONFIG_MASK_TARGET_CHECK) &&
(config_mask & CONFIG_MASK_BASEBAND_CHECK) &&
(config_mask & CONFIG_MASK_AUTOPLATFORM_CHECK) &&
(child_proc[j].proc_status != DISABLED_FROM_CONF)) {
//Set args
//The first argument passed through argv is usually the name of the
//binary when started from commandline.
//getopt() seems to ignore this first argument and hence we assign it
//to the process name for consistency with command line args
i = 0;
char* temp_arg = ('/' == child_proc[j].name[0][0]) ?
(strrchr(child_proc[j].name[0], '/') + 1) : child_proc[j].name[0];
strlcpy (child_proc[j].args[i++], temp_arg, sizeof (child_proc[j].args[i++]));
if(conf.premium_feature) {
if(conf.loc_feature_mask & loc_service_mask) {
LOC_LOGD("%s:%d]: Enabled. %s has service mask: %x\n",
__func__, __LINE__, child_proc[j].name[0], conf.loc_feature_mask);
child_proc[j].proc_status = ENABLED;
if(conf.loc_feature_mask &
(LOC_FEATURE_MASK_GTP_WIFI_BASIC | LOC_FEATURE_MASK_GTP_WIFI_PREMIUM)) {
if(loc_service_mask & LOC_FEATURE_MASK_GTP_WIFI_BASIC) {
strlcpy(child_proc[j].args[i++], arg_gtp_wifi,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_basic,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else if(loc_service_mask & LOC_FEATURE_MASK_GTP_WIFI_PREMIUM) {
strlcpy(child_proc[j].args[i++], arg_gtp_wifi,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_premium,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else
{
strlcpy(child_proc[j].args[i++], arg_gtp_wifi,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
}
if(conf.loc_feature_mask &
(LOC_FEATURE_MASK_GTP_CELL_BASIC | LOC_FEATURE_MASK_GTP_CELL_PREMIUM )) {
if(loc_service_mask & LOC_FEATURE_MASK_GTP_AP_CELL_BASIC){
strlcpy(child_proc[j].args[i++], arg_gtp_ap_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_basic,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_gtp_modem_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else if(loc_service_mask & LOC_FEATURE_MASK_GTP_AP_CELL_PREMIUM){
strlcpy(child_proc[j].args[i++], arg_gtp_ap_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_premium,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_gtp_modem_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else if(loc_service_mask & LOC_FEATURE_MASK_GTP_MODEM_CELL_BASIC) {
strlcpy(child_proc[j].args[i++], arg_gtp_modem_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_basic,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_gtp_ap_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else if(loc_service_mask & LOC_FEATURE_MASK_GTP_MODEM_CELL_PREMIUM) {
strlcpy(child_proc[j].args[i++], arg_gtp_modem_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_premium,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_gtp_ap_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else {
strlcpy(child_proc[j].args[i++], arg_gtp_ap_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_gtp_modem_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
}
if(conf.loc_feature_mask &
(LOC_FEATURE_MASK_GTP_WAA_BASIC | LOC_FEATURE_MASK_GTP_WAA_PREMIUM)) {
if(loc_service_mask & LOC_FEATURE_MASK_GTP_WAA_BASIC) {
strlcpy(child_proc[j].args[i++], arg_gtp_waa,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_basic,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else if(loc_service_mask & LOC_FEATURE_MASK_GTP_WAA_PREMIUM) {
strlcpy(child_proc[j].args[i++], arg_gtp_waa,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_premium,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else
{
strlcpy(child_proc[j].args[i++], arg_gtp_waa,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
}
if(conf.loc_feature_mask &
(LOC_FEATURE_MASK_SAP_BASIC | LOC_FEATURE_MASK_SAP_PREMIUM)) {
if(loc_service_mask & LOC_FEATURE_MASK_SAP_BASIC) {
strlcpy(child_proc[j].args[i++], arg_sap,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_basic,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else if(loc_service_mask & LOC_FEATURE_MASK_SAP_PREMIUM) {
strlcpy(child_proc[j].args[i++], arg_sap,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_premium,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else
{
strlcpy(child_proc[j].args[i++], arg_sap,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
}
IF_LOC_LOGD {
LOC_LOGD("%s:%d]: %s args\n", __func__, __LINE__, child_proc[j].name[0]);
for(unsigned int k=0; k<LOC_PROCESS_MAX_NUM_ARGS; k++) {
if(child_proc[j].args[k][0] != '\0') {
LOC_LOGD("%s:%d]: k: %d, %s\n", __func__, __LINE__, k,
child_proc[j].args[k]);
}
}
LOC_LOGD("%s:%d]: \n", __func__, __LINE__);
}
}
else {
LOC_LOGD("%s:%d]: Disabled. %s has service mask: %x \n",
__func__, __LINE__, child_proc[j].name[0], conf.loc_feature_mask);
}
}
else {
LOC_LOGD("%s:%d]: %s not a premium feature. Enabled\n",
__func__, __LINE__, child_proc[j].name[0]);
child_proc[j].proc_status = ENABLED;
}
/*Fill up the remaining arguments from configuration file*/
LOC_LOGD("%s] Parsing Process_Arguments from Configuration: %s \n",
__func__, conf.proc_argument);
if(0 != conf.proc_argument[0])
{
/**************************************
** conf_proc_argument is shared by all the programs getting launched,
** hence copy to process specific argument string and parse the same.
***************************************/
strlcpy(child_proc[j].argumentString, conf.proc_argument,
sizeof(child_proc[j].argumentString));
char *temp_args[LOC_PROCESS_MAX_NUM_ARGS];
memset (temp_args, 0, sizeof (temp_args));
loc_util_split_string(child_proc[j].argumentString, &temp_args[i],
(LOC_PROCESS_MAX_NUM_ARGS - i), ' ');
// copy argument from the pointer to the memory
for (unsigned int index = i; index < LOC_PROCESS_MAX_NUM_ARGS; index++) {
if (temp_args[index] == NULL) {
break;
}
strlcpy (child_proc[j].args[index], temp_args[index],
sizeof (child_proc[j].args[index]));
}
}
}
else {
LOC_LOGD("%s:%d]: Process %s is disabled\n",
__func__, __LINE__, child_proc[j].name[0]);
}
}
err:
if (conf_fp) {
fclose(conf_fp);
}
if (ret != 0) {
LOC_LOGE("%s:%d]: ret: %d", __func__, __LINE__, ret);
if (child_proc) {
free (child_proc);
child_proc = nullptr;
}
*process_count_ptr = 0;
*process_info_table_ptr = nullptr;
}
else {
*process_count_ptr = proc_list_length;
*process_info_table_ptr = child_proc;
}
return ret;
}

53
gps/utils/loc_cfg.h
View File

@@ -1,4 +1,4 @@
/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
/* Copyright (c) 2011-2015, 2018 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
@@ -32,11 +32,29 @@
#include <stdio.h>
#include <stdint.h>
#include <sys/types.h>
#include <unistd.h>
#include <grp.h>
#define LOC_MAX_PARAM_NAME 80
#define LOC_MAX_PARAM_STRING 80
#define LOC_MAX_PARAM_LINE (LOC_MAX_PARAM_NAME + LOC_MAX_PARAM_STRING)
#define LOC_FEATURE_MODE_DISABLED "DISABLED"
#define LOC_FEATURE_MODE_BASIC "BASIC"
#define LOC_FEATURE_MODE_PREMIUM "PREMIUM"
#define LOC_FEATURE_GTP_AP_CELL "gtp-ap-cell"
#define LOC_FEATURE_GTP_MODEM_CELL "gtp-modem-cell"
#define LOC_FEATURE_GTP_CELL_ENH "gtp-cell-enh"
#define LOC_FEATURE_GTP_WIFI "gtp-wifi"
#define LOC_FEATURE_GTP_WAA "gtp-waa"
#define LOC_FEATURE_SAP "sap"
#define LOC_PROCESS_MAX_NUM_GROUPS 20
#define LOC_PROCESS_MAX_NUM_ARGS 25
#define LOC_PROCESS_MAX_ARG_STR_LENGTH 32
#define UTIL_UPDATE_CONF(conf_data, len, config_table) \
loc_update_conf((conf_data), (len), (config_table), \
sizeof(config_table) / sizeof(config_table[0]))
@@ -62,6 +80,23 @@ typedef struct
'f' for double */
} loc_param_s_type;
typedef enum {
ENABLED,
RUNNING,
DISABLED,
DISABLED_FROM_CONF
} loc_process_e_status;
typedef struct {
loc_process_e_status proc_status;
pid_t proc_id;
char name[2][LOC_MAX_PARAM_STRING];
gid_t group_list[LOC_PROCESS_MAX_NUM_GROUPS];
unsigned char num_groups;
char args[LOC_PROCESS_MAX_NUM_ARGS][LOC_PROCESS_MAX_ARG_STR_LENGTH];
char argumentString[LOC_MAX_PARAM_STRING];
} loc_process_info_s_type;
/*=============================================================================
*
* MODULE EXTERNAL DATA
@@ -84,6 +119,22 @@ int loc_read_conf_r(FILE *conf_fp, const loc_param_s_type* config_table,
uint32_t table_length);
int loc_update_conf(const char* conf_data, int32_t length,
const loc_param_s_type* config_table, uint32_t table_length);
// Below are the location conf file paths
extern const char LOC_PATH_GPS_CONF[];
extern const char LOC_PATH_IZAT_CONF[];
extern const char LOC_PATH_FLP_CONF[];
extern const char LOC_PATH_LOWI_CONF[];
extern const char LOC_PATH_SAP_CONF[];
extern const char LOC_PATH_APDR_CONF[];
extern const char LOC_PATH_XTWIFI_CONF[];
extern const char LOC_PATH_QUIPC_CONF[];
int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_ptr,
loc_process_info_s_type** process_info_table_ptr);
uint32_t loc_modem_emulator_enabled();
#ifdef __cplusplus
}
#endif

3
gps/utils/loc_log.cpp
View File

@@ -32,9 +32,10 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include "log_util.h"
#include "loc_log.h"
#include "msg_q.h"
#include <platform_lib_includes.h>
#include <loc_pla.h>
#define BUFFER_SIZE 120

2
gps/utils/loc_misc_utils.cpp
View File

@@ -30,7 +30,7 @@
#define LOG_TAG "LocSvc_misc_utils"
#include <stdio.h>
#include <string.h>
#include <platform_lib_log_util.h>
#include <log_util.h>
#include <loc_misc_utils.h>
#include <ctype.h>

108
gps/utils/loc_nmea.cpp
View File

@@ -31,7 +31,8 @@
#define LOG_TAG "LocSvc_nmea"
#include <loc_nmea.h>
#include <math.h>
#include <platform_lib_includes.h>
#include <log_util.h>
#include <loc_pla.h>
#define GLONASS_SV_ID_OFFSET 64
#define MAX_SATELLITES_IN_USE 12
@@ -51,6 +52,7 @@ typedef struct loc_nmea_sv_meta_s
uint32_t mask;
uint32_t svCount;
uint32_t svIdOffset;
uint32_t signalId;
uint32_t systemId;
} loc_nmea_sv_meta;
@@ -71,8 +73,6 @@ typedef struct loc_sv_cache_info_s
float vdop;
} loc_sv_cache_info;
static loc_sv_cache_info sv_cache_info;
/*===========================================================================
FUNCTION loc_nmea_sv_meta_init
@@ -90,6 +90,7 @@ SIDE EFFECTS
===========================================================================*/
static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta,
loc_sv_cache_info& sv_cache_info,
GnssSvType svType,
bool needCombine)
{
@@ -103,6 +104,7 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta,
sv_meta.talker[1] = 'P';
sv_meta.mask = sv_cache_info.gps_used_mask;
sv_meta.svCount = sv_cache_info.gps_count;
sv_meta.signalId = 1;
sv_meta.systemId = SYSTEM_ID_GPS;
break;
case GNSS_SV_TYPE_GLONASS:
@@ -112,6 +114,7 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta,
sv_meta.svCount = sv_cache_info.glo_count;
// GLONASS SV ids are from 65-96
sv_meta.svIdOffset = GLONASS_SV_ID_OFFSET;
sv_meta.signalId = 1;
sv_meta.systemId = SYSTEM_ID_GLONASS;
break;
case GNSS_SV_TYPE_GALILEO:
@@ -119,6 +122,7 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta,
sv_meta.talker[1] = 'A';
sv_meta.mask = sv_cache_info.gal_used_mask;
sv_meta.svCount = sv_cache_info.gal_count;
sv_meta.signalId = 7;
sv_meta.systemId = SYSTEM_ID_GALILEO;
break;
case GNSS_SV_TYPE_QZSS:
@@ -127,6 +131,7 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta,
sv_meta.mask = sv_cache_info.qzss_used_mask;
sv_meta.svCount = sv_cache_info.qzss_count;
// QZSS SV ids are from 193-197. So keep svIdOffset 0
sv_meta.signalId = 0;
sv_meta.systemId = SYSTEM_ID_QZSS;
break;
case GNSS_SV_TYPE_BEIDOU:
@@ -135,6 +140,7 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta,
sv_meta.mask = sv_cache_info.bds_used_mask;
sv_meta.svCount = sv_cache_info.bds_count;
// BDS SV ids are from 201-235. So keep svIdOffset 0
sv_meta.signalId = 0;
sv_meta.systemId = SYSTEM_ID_BEIDOU;
break;
default:
@@ -260,13 +266,14 @@ static uint32_t loc_nmea_generate_GSA(const GpsLocationExtended &locationExtende
fixType = '3'; // 3D fix
// Start printing the sentence
// Format: $--GSA,a,x,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,p.p,h.h,v.v*cc
// Format: $--GSA,a,x,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,p.p,h.h,v.v,s*cc
// a : Mode : A : Automatic, allowed to automatically switch 2D/3D
// x : Fixtype : 1 (no fix), 2 (2D fix), 3 (3D fix)
// xx : 12 SV ID
// p.p : Position DOP (Dilution of Precision)
// h.h : Horizontal DOP
// v.v : Vertical DOP
// s : GNSS System Id
// cc : Checksum value
length = snprintf(pMarker, lengthRemaining, "$%sGSA,A,%c,", talker, fixType);
@@ -329,7 +336,7 @@ DESCRIPTION
Generate NMEA GSV sentences generated based on sv report
Currently below sentences are generated:
- $GPGSV: GPS Satellites in View
- $GNGSV: GLONASS Satellites in View
- $GLGSV: GLONASS Satellites in View
- $GAGSV: GALILEO Satellites in View
DEPENDENCIES
@@ -368,7 +375,7 @@ static void loc_nmea_generate_GSV(const GnssSvNotification &svNotify,
if (svCount <= 0)
{
// no svs in view, so just send a blank $--GSV sentence
snprintf(sentence, lengthRemaining, "$%sGSV,1,1,0,", talker);
snprintf(sentence, lengthRemaining, "$%sGSV,1,1,0,%d", talker, sv_meta_p->signalId);
length = loc_nmea_put_checksum(sentence, bufSize);
nmeaArraystr.push_back(sentence);
return;
@@ -430,15 +437,10 @@ static void loc_nmea_generate_GSV(const GnssSvNotification &svNotify,
}
// The following entries are specific to QZSS and BDS
if ((sv_meta_p->svType == GNSS_SV_TYPE_QZSS) ||
(sv_meta_p->svType == GNSS_SV_TYPE_BEIDOU))
{
// last one is System id and second last is Signal Id which is always zero
length = snprintf(pMarker, lengthRemaining,",%d,%d",0,sv_meta_p->systemId);
pMarker += length;
lengthRemaining -= length;
}
// append signalId
length = snprintf(pMarker, lengthRemaining,",%d",sv_meta_p->signalId);
pMarker += length;
lengthRemaining -= length;
length = loc_nmea_put_checksum(sentence, bufSize);
nmeaArraystr.push_back(sentence);
@@ -495,7 +497,20 @@ void loc_nmea_generate_pos(const UlpLocation &location,
int utcMinutes = pTm->tm_min;
int utcSeconds = pTm->tm_sec;
int utcMSeconds = (location.gpsLocation.timestamp)%1000;
loc_sv_cache_info sv_cache_info = {};
if (GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA & locationExtended.flags) {
sv_cache_info.gps_used_mask =
(uint32_t)locationExtended.gnss_sv_used_ids.gps_sv_used_ids_mask;
sv_cache_info.glo_used_mask =
(uint32_t)locationExtended.gnss_sv_used_ids.glo_sv_used_ids_mask;
sv_cache_info.gal_used_mask =
(uint32_t)locationExtended.gnss_sv_used_ids.gal_sv_used_ids_mask;
sv_cache_info.qzss_used_mask =
(uint32_t)locationExtended.gnss_sv_used_ids.bds_sv_used_ids_mask;
sv_cache_info.bds_used_mask =
(uint32_t)locationExtended.gnss_sv_used_ids.qzss_sv_used_ids_mask;
}
if (generate_nmea) {
char talker[3] = {'G', 'P', '\0'};
uint32_t svUsedCount = 0;
@@ -506,7 +521,8 @@ void loc_nmea_generate_pos(const UlpLocation &location,
// -------------------
count = loc_nmea_generate_GSA(locationExtended, sentence, sizeof(sentence),
loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_GPS, true), nmeaArraystr);
loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_GPS, true),
nmeaArraystr);
if (count > 0)
{
svUsedCount += count;
@@ -519,7 +535,8 @@ void loc_nmea_generate_pos(const UlpLocation &location,
// -------------------
count = loc_nmea_generate_GSA(locationExtended, sentence, sizeof(sentence),
loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_GLONASS, true), nmeaArraystr);
loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_GLONASS, true),
nmeaArraystr);
if (count > 0)
{
svUsedCount += count;
@@ -532,7 +549,8 @@ void loc_nmea_generate_pos(const UlpLocation &location,
// -------------------
count = loc_nmea_generate_GSA(locationExtended, sentence, sizeof(sentence),
loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_GALILEO, true), nmeaArraystr);
loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_GALILEO, true),
nmeaArraystr);
if (count > 0)
{
svUsedCount += count;
@@ -545,7 +563,8 @@ void loc_nmea_generate_pos(const UlpLocation &location,
// --------------------------
count = loc_nmea_generate_GSA(locationExtended, sentence, sizeof(sentence),
loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_QZSS, false), nmeaArraystr);
loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_QZSS, false),
nmeaArraystr);
if (count > 0)
{
svUsedCount += count;
@@ -556,7 +575,8 @@ void loc_nmea_generate_pos(const UlpLocation &location,
// ---$PQGSA/$GNGSA (BEIDOU)---
// ----------------------------
count = loc_nmea_generate_GSA(locationExtended, sentence, sizeof(sentence),
loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_BEIDOU, false), nmeaArraystr);
loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_BEIDOU, false),
nmeaArraystr);
if (count > 0)
{
svUsedCount += count;
@@ -787,6 +807,14 @@ void loc_nmea_generate_pos(const UlpLocation &location,
else // A means autonomous
length = snprintf(pMarker, lengthRemaining, "%c", 'A');
pMarker += length;
lengthRemaining -= length;
// hardcode Navigation Status field to 'V'
length = snprintf(pMarker, lengthRemaining, ",%c", 'V');
pMarker += length;
lengthRemaining -= length;
length = loc_nmea_put_checksum(sentence, sizeof(sentence));
nmeaArraystr.push_back(sentence);
@@ -920,13 +948,6 @@ void loc_nmea_generate_pos(const UlpLocation &location,
length = loc_nmea_put_checksum(sentence, sizeof(sentence));
nmeaArraystr.push_back(sentence);
// clear the cache so they can't be used again
sv_cache_info.gps_used_mask = 0;
sv_cache_info.glo_used_mask = 0;
sv_cache_info.gal_used_mask = 0;
sv_cache_info.qzss_used_mask = 0;
sv_cache_info.bds_used_mask = 0;
}
//Send blank NMEA reports for non-final fixes
else {
@@ -946,7 +967,7 @@ void loc_nmea_generate_pos(const UlpLocation &location,
length = loc_nmea_put_checksum(sentence, sizeof(sentence));
nmeaArraystr.push_back(sentence);
strlcpy(sentence, "$GPRMC,,V,,,,,,,,,,N", sizeof(sentence));
strlcpy(sentence, "$GPRMC,,V,,,,,,,,,,N,V", sizeof(sentence));
length = loc_nmea_put_checksum(sentence, sizeof(sentence));
nmeaArraystr.push_back(sentence);
@@ -982,27 +1003,11 @@ void loc_nmea_generate_sv(const GnssSvNotification &svNotify,
ENTRY_LOG();
char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0};
char* pMarker = sentence;
int lengthRemaining = sizeof(sentence);
int length = 0;
int svCount = svNotify.count;
int sentenceCount = 0;
int sentenceNumber = 1;
int svNumber = 1;
loc_sv_cache_info sv_cache_info = {};
//Count GPS SVs for saparating GPS from GLONASS and throw others
sv_cache_info.gps_used_mask = 0;
sv_cache_info.glo_used_mask = 0;
sv_cache_info.gal_used_mask = 0;
sv_cache_info.qzss_used_mask = 0;
sv_cache_info.bds_used_mask = 0;
sv_cache_info.gps_count = 0;
sv_cache_info.glo_count = 0;
sv_cache_info.gal_count = 0;
sv_cache_info.qzss_count = 0;
sv_cache_info.bds_count = 0;
for(svNumber=1; svNumber <= svCount; svNumber++) {
if (GNSS_SV_TYPE_GPS == svNotify.gnssSvs[svNumber - 1].type)
{
@@ -1072,35 +1077,38 @@ void loc_nmea_generate_sv(const GnssSvNotification &svNotify,
// ------------------
loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence),
loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_GPS, false), nmeaArraystr);
loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_GPS, false), nmeaArraystr);
// ------------------
// ------$GLGSV------
// ------------------
loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence),
loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_GLONASS, false), nmeaArraystr);
loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_GLONASS, false),
nmeaArraystr);
// ------------------
// ------$GAGSV------
// ------------------
loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence),
loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_GALILEO, false), nmeaArraystr);
loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_GALILEO, false),
nmeaArraystr);
// -------------------------
// ------$PQGSV (QZSS)------
// -------------------------
loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence),
loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_QZSS, false), nmeaArraystr);
loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_QZSS, false), nmeaArraystr);
// ---------------------------
// ------$PQGSV (BEIDOU)------
// ---------------------------
loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence),
loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_BEIDOU, false), nmeaArraystr);
loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_BEIDOU, false),
nmeaArraystr);
EXIT_LOG(%d, 0);
}

19
gps/utils/loc_target.cpp
View File

@@ -27,6 +27,7 @@
*
*/
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -34,10 +35,10 @@
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <cutils/properties.h>
#include <log_util.h>
#include "loc_target.h"
#include "loc_log.h"
#include <platform_lib_includes.h>
#include <loc_pla.h>
#define APQ8064_ID_1 "109"
#define APQ8064_ID_2 "153"
@@ -205,17 +206,3 @@ detected:
LOC_LOGW("HAL: %s returned %d", __FUNCTION__, gTarget);
return gTarget;
}
/*Reads the property ro.lean to identify if this is a lean target
Returns:
0 if not a lean and mean target
1 if this is a lean and mean target
*/
int loc_identify_lean_target()
{
int ret = 0;
char lean_target[PROPERTY_VALUE_MAX];
property_get("ro.lean", lean_target, "");
LOC_LOGD("%s:%d]: lean target: %s\n", __func__, __LINE__, lean_target);
return !(strncmp(lean_target, "true", PROPERTY_VALUE_MAX));
}

6
gps/utils/loc_target.h
View File

@@ -55,12 +55,6 @@ void loc_get_platform_name(char *platform_name, int array_length);
of atleast PROPERTY_VALUE_MAX*/
void loc_get_auto_platform_name(char *platform_name, int array_length);
/*Reads the property ro.lean to identify if this is a lean target
Returns:
0 if not a lean and mean target
1 if this is a lean and mean target*/
int loc_identify_lean_target();
/* Please remember to update 'target_name' in loc_log.cpp,
if do any changes to this enum. */
typedef enum {

3
gps/utils/loc_timer.h
View File

@@ -34,7 +34,8 @@
extern "C" {
#endif /* __cplusplus */
#include <stddef.h>
#include <platform_lib_includes.h>
#include <stdint.h>
#include <loc_pla.h>
/*
user_data: client context pointer, passthrough. Originally received
from calling client when loc_timer_start() is called.

16
gps/utils/log_util.h
View File

@@ -30,22 +30,23 @@
#ifndef __LOG_UTIL_H__
#define __LOG_UTIL_H__
#ifndef USE_GLIB
#if defined (USE_ANDROID_LOGGING) || defined (ANDROID)
// Android and LE targets with logcat support
#include <utils/Log.h>
#endif /* USE_GLIB */
#ifdef USE_GLIB
#elif defined (USE_GLIB)
// LE targets with no logcat support
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <cutils/log.h>
#ifndef LOG_TAG
#define LOG_TAG "GPS_UTILS"
#endif /* LOG_TAG */
#endif // LOG_TAG
#endif /* USE_GLIB */
#endif /* #if defined (USE_ANDROID_LOGGING) || defined (ANDROID) */
#ifdef __cplusplus
extern "C"
@@ -140,6 +141,7 @@ extern char* get_timestamp(char* str, unsigned long buf_size);
#define LOC_LOG_HEAD(fmt) "%s:%d] " fmt
#define LOC_LOGv(fmt,...) LOC_LOGV(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOC_LOGw(fmt,...) LOC_LOGW(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOC_LOGi(fmt,...) LOC_LOGI(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOC_LOGd(fmt,...) LOC_LOGD(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOC_LOGe(fmt,...) LOC_LOGE(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__)

8
gps/utils/msg_q.c
View File

@@ -26,14 +26,14 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "msg_q.h"
#define LOG_TAG "LocSvc_utils_q"
#include <platform_lib_includes.h>
#include "linked_list.h"
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <loc_pla.h>
#include <log_util.h>
#include "linked_list.h"
#include "msg_q.h"
typedef struct msg_q {
void* msg_list; /* Linked list to store information */

5
gps/utils/platform_lib_abstractions/Android.mk
View File

@@ -1,5 +0,0 @@
ifneq ($(BUILD_TINY_ANDROID),true)
include $(call all-subdir-makefiles)
endif

46
gps/utils/platform_lib_abstractions/elapsed_millis_since_boot.cpp
View File

@@ -1,46 +0,0 @@
/* Copyright (c) 2013, 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.
*/
#include <stdlib.h>
#include <sys/time.h>
#include "platform_lib_time.h"
int64_t systemTime(int /*clock*/)
{
struct timeval t;
t.tv_sec = t.tv_usec = 0;
gettimeofday(&t, NULL);
return t.tv_sec*1000000LL + t.tv_usec;
}
int64_t elapsedMillisSinceBoot()
{
int64_t t_us = systemTime(0);
return (int64_t) t_us / 1000LL;
}

5
gps/utils/platform_lib_abstractions/loc_pla/Android.mk
View File

@@ -1,5 +0,0 @@
ifneq ($(BUILD_TINY_ANDROID),true)
include $(call all-subdir-makefiles)
endif

10
gps/utils/platform_lib_abstractions/loc_pla/Makefile.am
View File

@@ -1,10 +0,0 @@
# Makefile.am for gps loc-pla
#
ACLOCAL_AMFLAGS = -I m4
SUBDIRS = src
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = loc-pla.pc
EXTRA_DIST = $(pkgconfig_DATA)

61
gps/utils/platform_lib_abstractions/loc_pla/configure.ac
View File

@@ -1,61 +0,0 @@
# configure.ac -- Autoconf script for gps loc-pla
#
# Process this file with autoconf to produce a configure script
# Requires autoconf tool later than 2.61
AC_PREREQ(2.61)
# Initialize the gps loc-pla package version 1.0.0
AC_INIT([loc-pla],1.0.0)
# Does not strictly follow GNU Coding standards
AM_INIT_AUTOMAKE([foreign])
# Disables auto rebuilding of configure, Makefile.ins
AM_MAINTAINER_MODE
# Verifies the --srcdir is correct by checking for the path
AC_CONFIG_SRCDIR([include/platform_lib_includes.h])
# defines some macros variable to be included by source
AC_CONFIG_HEADERS([config.h])
AC_CONFIG_MACRO_DIR([m4])
# Checks for programs.
AC_PROG_LIBTOOL
AC_PROG_CXX
AC_PROG_CC
AM_PROG_CC_C_O
AC_PROG_AWK
AC_PROG_CPP
AC_PROG_INSTALL
AC_PROG_LN_S
AC_PROG_MAKE_SET
PKG_PROG_PKG_CONFIG
# Checks for libraries.
PKG_CHECK_MODULES([LOCSTUB], [loc-stub])
AC_SUBST([LOCSTUB_CFLAGS])
AC_SUBST([LOCSTUB_LIBS])
AC_ARG_WITH([glib],
AC_HELP_STRING([--with-glib],
[enable glib, building HLOS systems which use glib]))
if (test "x${with_glib}" = "xyes"); then
AC_DEFINE(ENABLE_USEGLIB, 1, [Define if HLOS systems uses glib])
PKG_CHECK_MODULES(GTHREAD, gthread-2.0 >= 2.16, dummy=yes,
AC_MSG_ERROR(GThread >= 2.16 is required))
PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.16, dummy=yes,
AC_MSG_ERROR(GLib >= 2.16 is required))
GLIB_CFLAGS="$GLIB_CFLAGS $GTHREAD_CFLAGS"
GLIB_LIBS="$GLIB_LIBS $GTHREAD_LIBS"
AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)
fi
AM_CONDITIONAL(USE_GLIB, test "x${with_glib}" = "xyes")
AC_CONFIG_FILES([ \
Makefile \
src/Makefile \
loc-pla.pc \
])
AC_OUTPUT

45
gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_gettid.h
View File

@@ -1,45 +0,0 @@
/* Copyright (c) 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.
*/
#ifndef __PLATFORM_LIB_GETTID_H__
#define __PLATFORM_LIB_GETTID_H__
#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifdef USE_GLIB
const char* getprogname();
#endif /* USE_GLIB */
pid_t platform_lib_abstraction_gettid();
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __PLATFORM_LIB_GETTID_H__ */

39
gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_includes.h
View File

@@ -1,39 +0,0 @@
/* Copyright (c) 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.
*/
#ifndef __PLATFORM_LIB_INCLUDES_H__
#define __PLATFORM_LIB_INCLUDES_H__
#include "platform_lib_gettid.h"
#include "platform_lib_log_util.h"
#include "platform_lib_macros.h"
#include "platform_lib_property_service.h"
#include "platform_lib_sched_policy.h"
#include "platform_lib_time.h"
#endif /* __PLATFORM_LIB_INCLUDES_H__ */

174
gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_log_util.h
View File

@@ -1,174 +0,0 @@
/* Copyright (c) 2011-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.
*/
#ifndef __PLATFORM_LIB_LOG_UTIL_H__
#define __PLATFORM_LIB_LOG_UTIL_H__
#include "platform_lib_macros.h"
#ifndef USE_GLIB
#include <log_util.h>
#else
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#ifndef LOG_TAG
#define LOG_TAG "GPS_UTILS"
#endif /* LOG_TAG */
#ifdef __cplusplus
extern "C"
{
#endif
/*=============================================================================
*
* LOC LOGGER TYPE DECLARATION
*
*============================================================================*/
/* LOC LOGGER */
typedef struct loc_logger_s
{
unsigned long DEBUG_LEVEL;
unsigned long TIMESTAMP;
} loc_logger_s_type;
/*=============================================================================
*
* EXTERNAL DATA
*
*============================================================================*/
extern loc_logger_s_type loc_logger;
// Logging Improvements
extern const char *loc_logger_boolStr[];
extern const char *boolStr[];
extern const char VOID_RET[];
extern const char FROM_AFW[];
extern const char TO_MODEM[];
extern const char FROM_MODEM[];
extern const char TO_AFW[];
extern const char EXIT_TAG[];
extern const char ENTRY_TAG[];
extern const char EXIT_ERROR_TAG[];
/*=============================================================================
*
* MODULE EXPORTED FUNCTIONS
*
*============================================================================*/
void loc_logger_init(unsigned long debug, unsigned long timestamp);
char* get_timestamp(char* str, unsigned long buf_size);
#ifndef DEBUG_DMN_LOC_API
/* LOGGING MACROS */
/*loc_logger.DEBUG_LEVEL is initialized to 0xff in loc_cfg.cpp
if that value remains unchanged, it means gps.conf did not
provide a value and we default to the initial value to use
Android's logging levels*/
#define IF_LOC_LOGE if((loc_logger.DEBUG_LEVEL >= 1) && (loc_logger.DEBUG_LEVEL <= 5))
#define IF_LOC_LOGW if((loc_logger.DEBUG_LEVEL >= 2) && (loc_logger.DEBUG_LEVEL <= 5))
#define IF_LOC_LOGI if((loc_logger.DEBUG_LEVEL >= 3) && (loc_logger.DEBUG_LEVEL <= 5))
#define IF_LOC_LOGD if((loc_logger.DEBUG_LEVEL >= 4) && (loc_logger.DEBUG_LEVEL <= 5))
#define IF_LOC_LOGV if((loc_logger.DEBUG_LEVEL >= 5) && (loc_logger.DEBUG_LEVEL <= 5))
#define LOC_LOGE(...) IF_LOC_LOGE { ALOGE(__VA_ARGS__); }
#define LOC_LOGW(...) IF_LOC_LOGW { ALOGW(__VA_ARGS__); }
#define LOC_LOGI(...) IF_LOC_LOGI { ALOGI(__VA_ARGS__); }
#define LOC_LOGD(...) IF_LOC_LOGD { ALOGD(__VA_ARGS__); }
#define LOC_LOGV(...) IF_LOC_LOGV { ALOGV(__VA_ARGS__); }
#else /* DEBUG_DMN_LOC_API */
#define LOC_LOGE(...) ALOGE(__VA_ARGS__)
#define LOC_LOGW(...) ALOGW(__VA_ARGS__)
#define LOC_LOGI(...) ALOGI(__VA_ARGS__)
#define LOC_LOGD(...) ALOGD(__VA_ARGS__)
#define LOC_LOGV(...) ALOGV(__VA_ARGS__)
#endif /* DEBUG_DMN_LOC_API */
/*=============================================================================
*
* LOGGING IMPROVEMENT MACROS
*
*============================================================================*/
#define LOG_(LOC_LOG, ID, WHAT, SPEC, VAL) \
do { \
if (loc_logger.TIMESTAMP) { \
char ts[32]; \
LOC_LOG("[%s] %s %s line %d " #SPEC, \
get_timestamp(ts, sizeof(ts)), ID, WHAT, __LINE__, VAL); \
} else { \
LOC_LOG("%s %s line %d " #SPEC, \
ID, WHAT, __LINE__, VAL); \
} \
} while(0)
#define LOC_LOG_HEAD(fmt) "%s:%d] " fmt
#define LOC_LOGv(fmt,...) LOC_LOGV(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOC_LOGw(fmt,...) LOC_LOGW(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOC_LOGd(fmt,...) LOC_LOGD(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOC_LOGe(fmt,...) LOC_LOGE(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOG_I(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGI, ID, WHAT, SPEC, VAL)
#define LOG_V(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGV, ID, WHAT, SPEC, VAL)
#define LOG_E(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGE, ID, WHAT, SPEC, VAL)
#define ENTRY_LOG() LOG_V(ENTRY_TAG, __FUNCTION__, %s, "")
#define EXIT_LOG(SPEC, VAL) LOG_V(EXIT_TAG, __FUNCTION__, SPEC, VAL)
#define EXIT_LOG_WITH_ERROR(SPEC, VAL) \
if (VAL != 0) { \
LOG_E(EXIT_ERROR_TAG, __FUNCTION__, SPEC, VAL); \
} else { \
LOG_V(EXIT_TAG, __FUNCTION__, SPEC, VAL); \
}
// Used for logging callflow from Android Framework
#define ENTRY_LOG_CALLFLOW() LOG_I(FROM_AFW, __FUNCTION__, %s, "")
// Used for logging callflow to Modem
#define EXIT_LOG_CALLFLOW(SPEC, VAL) LOG_I(TO_MODEM, __FUNCTION__, SPEC, VAL)
// Used for logging callflow from Modem(TO_MODEM, __FUNCTION__, %s, "")
#define MODEM_LOG_CALLFLOW(SPEC, VAL) LOG_I(FROM_MODEM, __FUNCTION__, SPEC, VAL)
// Used for logging callflow to Android Framework
#define CALLBACK_LOG_CALLFLOW(CB, SPEC, VAL) LOG_I(TO_AFW, CB, SPEC, VAL)
#ifdef __cplusplus
}
#endif
#endif /* USE_GLIB */
#endif /* __PLATFORM_LIB_LOG_UTIL_H__ */

85
gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_macros.h
View File

@@ -1,85 +0,0 @@
/* Copyright (c) 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.
*/
#ifndef __PLATFORM_LIB_MACROS_H__
#define __PLATFORM_LIB_MACROS_H__
#ifdef __cplusplus
extern "C" {
#endif
#ifdef USE_GLIB
#include <sys/time.h>
#include <string.h>
#include <stdlib.h>
#ifndef OFF_TARGET
#include <glib.h>
#define strlcat g_strlcat
#define strlcpy g_strlcpy
#else
#define strlcat strncat
#define strlcpy strncpy
#endif
#define TS_PRINTF(format, x...) \
{ \
struct timeval tv; \
struct timezone tz; \
int hh, mm, ss; \
gettimeofday(&tv, &tz); \
hh = tv.tv_sec/3600%24; \
mm = (tv.tv_sec%3600)/60; \
ss = tv.tv_sec%60; \
fprintf(stdout,"%02d:%02d:%02d.%06ld]" format "\n", hh, mm, ss, tv.tv_usec,##x); \
}
#define ALOGE(format, x...) TS_PRINTF("E/%s (%d): " format , LOG_TAG, getpid(), ##x)
#define ALOGW(format, x...) TS_PRINTF("W/%s (%d): " format , LOG_TAG, getpid(), ##x)
#define ALOGI(format, x...) TS_PRINTF("I/%s (%d): " format , LOG_TAG, getpid(), ##x)
#define ALOGD(format, x...) TS_PRINTF("D/%s (%d): " format , LOG_TAG, getpid(), ##x)
#define ALOGV(format, x...) TS_PRINTF("V/%s (%d): " format , LOG_TAG, getpid(), ##x)
#endif /* USE_GLIB */
// Below are the location conf file paths
extern const char LOC_PATH_GPS_CONF[];
extern const char LOC_PATH_IZAT_CONF[];
extern const char LOC_PATH_FLP_CONF[];
extern const char LOC_PATH_LOWI_CONF[];
extern const char LOC_PATH_SAP_CONF[];
extern const char LOC_PATH_APDR_CONF[];
extern const char LOC_PATH_XTWIFI_CONF[];
extern const char LOC_PATH_QUIPC_CONF[];
#ifdef __cplusplus
}
#endif /*__cplusplus */
#endif /* __PLATFORM_LIB_MACROS_H__ */

44
gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_property_service.h
View File

@@ -1,44 +0,0 @@
/* Copyright (c) 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.
*/
#ifndef __PLATFORM_LIB_PROPERTY_SERVICE_H__
#define __PLATFORM_LIB_PROPERTY_SERVICE_H__
#ifdef __cplusplus
extern "C" {
#endif
#ifndef PROPERTY_VALUE_MAX
#define PROPERTY_VALUE_MAX 92
#endif
int platform_lib_abstraction_property_get(const char *key, char *value, const char *default_value);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __PLATFORM_LIB_PROPERTY_SERVICE_H__ */

46
gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_sched_policy.h
View File

@@ -1,46 +0,0 @@
/* Copyright (c) 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.
*/
#ifndef __PLATFORM_LIB_SCHED_POLICY_H__
#define __PLATFORM_LIB_SCHED_POLICY_H__
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
PLA_SP_BACKGROUND = 0,
PLA_SP_FOREGROUND = 1,
} PLASchedPolicy;
int platform_lib_abstraction_set_sched_policy(int tid, PLASchedPolicy policy);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __PLATFORM_LIB_SCHED_POLICY_H__ */

36
gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_time.h
View File

@@ -1,36 +0,0 @@
/* Copyright (c) 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.
*/
#ifndef __PLATFORM_LIB_TIME_H__
#define __PLATFORM_LIB_TIME_H__
#include <stdint.h>
int64_t platform_lib_abstraction_elapsed_millis_since_boot();
int64_t platform_lib_abstraction_elapsed_micros_since_boot();
#endif /* __PLATFORM_LIB_TIME_H__ */

10
gps/utils/platform_lib_abstractions/loc_pla/loc-pla.pc.in
View File

@@ -1,10 +0,0 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: loc-pla
Description: QTI GPS Location Platform Library Abstractions
Version: @VERSION@
Libs: -L${libdir} -lloc_pla
Cflags: -I${includedir}/loc-pla

68
gps/utils/platform_lib_abstractions/loc_pla/src/Android.mk
View File

@@ -1,68 +0,0 @@
GNSS_CFLAGS := \
-Werror \
-Wno-error=unused-parameter \
-Wno-error=format \
-Wno-error=macro-redefined \
-Wno-error=reorder \
-Wno-error=missing-braces \
-Wno-error=self-assign \
-Wno-error=enum-conversion \
-Wno-error=logical-op-parentheses \
-Wno-error=null-arithmetic \
-Wno-error=null-conversion \
-Wno-error=parentheses-equality \
-Wno-error=undefined-bool-conversion \
-Wno-error=tautological-compare \
-Wno-error=switch \
-Wno-error=date-time
ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
ifneq ($(BUILD_TINY_ANDROID),true)
#Compile this library only for builds with the latest modem image
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
## Libs
LOCAL_SHARED_LIBRARIES := \
libutils \
libcutils \
liblog \
libloc_stub
LOCAL_SRC_FILES += \
platform_lib_gettid.cpp \
platform_lib_log_util.cpp \
platform_lib_property_service.cpp \
platform_lib_sched_policy.cpp \
platform_lib_time.cpp
LOCAL_CFLAGS += \
-fno-short-enums \
-D_ANDROID_ \
-std=c++11
## Includes
LOCAL_C_INCLUDES:= \
$(LOCAL_PATH)/../include
LOCAL_HEADER_LIBRARIES := \
libgps.utils_headers \
libloc_stub_headers
LOCAL_MODULE := libloc_pla
LOCAL_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib
LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64
LOCAL_MODULE_TAGS := optional
LOCAL_PRELINK_MODULE := false
LOCAL_CFLAGS += $(GNSS_CFLAGS)
include $(BUILD_SHARED_LIBRARY)
include $(CLEAR_VARS)
LOCAL_MODULE := libloc_pla_headers
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/../include
include $(BUILD_HEADER_LIBRARY)
endif # not BUILD_TINY_ANDROID
endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE

39
gps/utils/platform_lib_abstractions/loc_pla/src/Makefile.am
View File

@@ -1,39 +0,0 @@
AM_CFLAGS = \
$(LOCSTUB_CFLAGS) \
-I../include \
-D__func__=__PRETTY_FUNCTION__ \
-fno-short-enums
h_sources = \
../include/platform_lib_gettid.h \
../include/platform_lib_includes.h \
../include/platform_lib_log_util.h \
../include/platform_lib_macros.h \
../include/platform_lib_property_service.h \
../include/platform_lib_sched_policy.h \
../include/platform_lib_time.h
library_includedir = $(pkgincludedir)
library_include_HEADERS = $(h_sources)
libloc_pla_la_SOURCES = \
platform_lib_gettid.cpp \
platform_lib_log_util.cpp \
platform_lib_property_service.cpp \
platform_lib_sched_policy.cpp \
platform_lib_time.cpp
if USE_GLIB
libloc_pla_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
libloc_pla_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libloc_pla_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libloc_pla_la_CFLAGS = $(AM_CFLAGS)
libloc_pla_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
libloc_pla_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif
libloc_pla_la_LIBADD = -lstdc++ -ldl -llog $(LOCSTUB_LIBS)
#Create and Install libraries
lib_LTLIBRARIES = libloc_pla.la

46
gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_gettid.cpp
View File

@@ -1,46 +0,0 @@
/* Copyright (c) 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.
*/
#include "platform_lib_gettid.h"
#ifdef USE_GLIB
#include <loc_stub_gettid.h>
#include <errno.h>
const char* getprogname() {
return program_invocation_short_name;
}
#else
#include <unistd.h>
#endif /* USE_GLIB */
pid_t platform_lib_abstraction_gettid()
{
return gettid();
}

78
gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_log_util.cpp
View File

@@ -1,78 +0,0 @@
/* Copyright (c) 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.
*/
#include "platform_lib_log_util.h"
#include "platform_lib_macros.h"
char * get_timestamp(char *str, unsigned long buf_size)
{
struct timeval tv;
struct timezone tz;
int hh, mm, ss;
gettimeofday(&tv, &tz);
hh = tv.tv_sec/3600%24;
mm = (tv.tv_sec%3600)/60;
ss = tv.tv_sec%60;
snprintf(str, buf_size, "%02d:%02d:%02d.%06ld", hh, mm, ss, tv.tv_usec);
return str;
}
// Below are the location conf file paths
#ifdef __ANDROID__
#define LOC_PATH_GPS_CONF_STR "/vendor/etc/gps.conf"
#define LOC_PATH_IZAT_CONF_STR "/vendor/etc/izat.conf"
#define LOC_PATH_FLP_CONF_STR "/vendor/etc/flp.conf"
#define LOC_PATH_LOWI_CONF_STR "/vendor/etc/lowi.conf"
#define LOC_PATH_SAP_CONF_STR "/vendor/etc/sap.conf"
#define LOC_PATH_APDR_CONF_STR "/vendor/etc/apdr.conf"
#define LOC_PATH_XTWIFI_CONF_STR "/vendor/etc/xtwifi.conf"
#define LOC_PATH_QUIPC_CONF_STR "/vendor/etc/quipc.conf"
#else
#define LOC_PATH_GPS_CONF_STR "/etc/gps.conf"
#define LOC_PATH_IZAT_CONF_STR "/etc/izat.conf"
#define LOC_PATH_FLP_CONF_STR "/etc/flp.conf"
#define LOC_PATH_LOWI_CONF_STR "/etc/lowi.conf"
#define LOC_PATH_SAP_CONF_STR "/etc/sap.conf"
#define LOC_PATH_APDR_CONF_STR "/etc/apdr.conf"
#define LOC_PATH_XTWIFI_CONF_STR "/etc/xtwifi.conf"
#define LOC_PATH_QUIPC_CONF_STR "/etc/quipc.conf"
#endif // __ANDROID__
// Reference below arrays wherever needed to avoid duplicating
// same conf path string over and again in location code.
const char LOC_PATH_GPS_CONF[] = LOC_PATH_GPS_CONF_STR;
const char LOC_PATH_IZAT_CONF[] = LOC_PATH_IZAT_CONF_STR;
const char LOC_PATH_FLP_CONF[] = LOC_PATH_FLP_CONF_STR;
const char LOC_PATH_LOWI_CONF[] = LOC_PATH_LOWI_CONF_STR;
const char LOC_PATH_SAP_CONF[] = LOC_PATH_SAP_CONF_STR;
const char LOC_PATH_APDR_CONF[] = LOC_PATH_APDR_CONF_STR;
const char LOC_PATH_XTWIFI_CONF[] = LOC_PATH_XTWIFI_CONF_STR;
const char LOC_PATH_QUIPC_CONF[] = LOC_PATH_QUIPC_CONF_STR;

39
gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_property_service.cpp
View File

@@ -1,39 +0,0 @@
/* Copyright (c) 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.
*/
#ifdef USE_GLIB
#include <loc_stub_property_service.h>
#else
#include <cutils/properties.h>
#endif /* USE_GLIB */
#include "platform_lib_property_service.h"
int platform_lib_abstraction_property_get(const char *key, char *value, const char *default_value)
{
return property_get(key, value, default_value);
}

41
gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_sched_policy.cpp
View File

@@ -1,41 +0,0 @@
/* Copyright (c) 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.
*/
#include "platform_lib_sched_policy.h"
#ifdef USE_GLIB
#include <loc_stub_sched_policy.h>
#else
#include <cutils/sched_policy.h>
#endif /* USE_GLIB */
int platform_lib_abstraction_set_sched_policy(int tid, PLASchedPolicy policy)
{
return set_sched_policy(tid, (SchedPolicy)policy);
}

59
gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_time.cpp
View File

@@ -1,59 +0,0 @@
/* Copyright (c) 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.
*/
#include "platform_lib_time.h"
#ifdef USE_GLIB
#include <loc_stub_time.h>
#else
#include <utils/SystemClock.h>
#include <utils/Timers.h>
#endif /* USE_GLIB */
int64_t platform_lib_abstraction_elapsed_millis_since_boot()
{
#ifdef USE_GLIB
return elapsedMillisSinceBoot();
#else
//return android::nanoseconds_to_microseconds(systemTime(SYSTEM_TIME_BOOTTIME))/1000;
return nanoseconds_to_microseconds(systemTime(SYSTEM_TIME_BOOTTIME))/1000;
#endif
}
int64_t platform_lib_abstraction_elapsed_micros_since_boot()
{
#ifdef USE_GLIB
return elapsedMicrosSinceBoot();
#else
//return android::nanoseconds_to_microseconds(systemTime(SYSTEM_TIME_BOOTTIME));
return nanoseconds_to_microseconds(systemTime(SYSTEM_TIME_BOOTTIME));
#endif
}

5
gps/utils/platform_lib_abstractions/loc_stub/Android.mk
View File

@@ -1,5 +0,0 @@
ifneq ($(BUILD_TINY_ANDROID),true)
include $(call all-subdir-makefiles)
endif

9
gps/utils/platform_lib_abstractions/loc_stub/Makefile.am
View File

@@ -1,9 +0,0 @@
# Makefile.am for gps loc-stub
ACLOCAL_AMFLAGS = -I m4
SUBDIRS = src
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = loc-stub.pc
EXTRA_DIST = $(pkgconfig_DATA)

67
gps/utils/platform_lib_abstractions/loc_stub/configure.ac
View File

@@ -1,67 +0,0 @@
# configure.ac -- Autoconf script for gps loc-stub
#
# Process this file with autoconf to produce a configure script
# Requires autoconf tool later than 2.61
AC_PREREQ(2.61)
# Initialize the gps loc-stub package version 1.0.0
AC_INIT([loc-stub],1.0.0)
# Does not strictly follow GNU Coding standards
AM_INIT_AUTOMAKE([foreign])
# Disables auto rebuilding of configure, Makefile.ins
AM_MAINTAINER_MODE
# Verifies the --srcdir is correct by checking for the path
AC_CONFIG_SRCDIR([Makefile.am])
# defines some macros variable to be included by source
AC_CONFIG_HEADERS([config.h])
AC_CONFIG_MACRO_DIR([m4])
# Checks for programs.
AC_PROG_LIBTOOL
AC_PROG_CXX
AC_PROG_CC
AM_PROG_CC_C_O
AC_PROG_AWK
AC_PROG_CPP
AC_PROG_INSTALL
AC_PROG_LN_S
AC_PROG_MAKE_SET
PKG_PROG_PKG_CONFIG
# Checks for libraries.
AC_ARG_WITH([hardware_include],
AC_HELP_STRING([--with-hardware-include=@<:@dir@:>@],
[Specify the location of the hardware headers]),
[hardware_incdir=$withval],
with_hardware_include=no)
if test "x$with_hardware_include" != "xno"; then
CPPFLAGS="${CPPFLAGS} -I${hardware_incdir}"
fi
AC_ARG_WITH([glib],
AC_HELP_STRING([--with-glib],
[enable glib, building HLOS systems which use glib]))
if (test "x${with_glib}" = "xyes"); then
AC_DEFINE(ENABLE_USEGLIB, 1, [Define if HLOS systems uses glib])
PKG_CHECK_MODULES(GTHREAD, gthread-2.0 >= 2.16, dummy=yes,
AC_MSG_ERROR(GThread >= 2.16 is required))
PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.16, dummy=yes,
AC_MSG_ERROR(GLib >= 2.16 is required))
GLIB_CFLAGS="$GLIB_CFLAGS $GTHREAD_CFLAGS"
GLIB_LIBS="$GLIB_LIBS $GTHREAD_LIBS"
AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)
fi
AM_CONDITIONAL(USE_GLIB, test "x${with_glib}" = "xyes")
AC_CONFIG_FILES([ \
Makefile \
src/Makefile \
loc-stub.pc
])
AC_OUTPUT

45
gps/utils/platform_lib_abstractions/loc_stub/include/loc_stub_android_runtime.h
View File

@@ -1,45 +0,0 @@
/* Copyright (c) 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.
*/
#ifndef __LOC_STUB_ANDROID_RUNTIME_H__
#define __LOC_STUB_ANDROID_RUNTIME_H__
#include <pthread.h>
namespace android {
class AndroidRuntime
{
public:
/** create a new thread that is visible from Java */
static pthread_t createJavaThread(const char* name, void (*start)(void *),
void* arg);
};
}
#endif /* __LOC_STUB_ANDROID_RUNTIME_H__ */

44
gps/utils/platform_lib_abstractions/loc_stub/include/loc_stub_gettid.h
View File

@@ -1,44 +0,0 @@
/* Copyright (c) 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.
*/
#ifndef __LOC_STUB_GETTID_H__
#define __LOC_STUB_GETTID_H__
#include <pthread.h>
#ifdef __cplusplus
extern "C" {
#endif
pid_t gettid(void);
#ifdef __cplusplus
}
#endif
#endif /* __LOC_STUB_GETTID_H__ */

42
gps/utils/platform_lib_abstractions/loc_stub/include/loc_stub_property_service.h
View File

@@ -1,42 +0,0 @@
/* Copyright (c) 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.
*/
#ifndef __LOC_STUB_PROPERTY_SERVICE_H__
#define __LOC_STUB_PROPERTY_SERVICE_H__
#ifdef __cplusplus
extern "C" {
#endif
int property_get(const char *key, char *value, const char *default_value);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __LOC_STUB_PROPERTY_SERVICE_H__ */

64
gps/utils/platform_lib_abstractions/loc_stub/include/loc_stub_sched_policy.h
View File

@@ -1,64 +0,0 @@
/* Copyright (c) 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.
*/
#ifndef __LOC_STUB_SCHED_POLICY_H__
#define __LOC_STUB_SCHED_POLICY_H__
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
SP_BACKGROUND = 0,
SP_FOREGROUND = 1,
} SchedPolicy;
/*===========================================================================
FUNCTION set_sched_policy
DESCRIPTION
Local copy of this function which bypasses android set_sched_policy
DEPENDENCIES
None
RETURN VALUE
0
SIDE EFFECTS
N/A
===========================================================================*/
int set_sched_policy(int tid, SchedPolicy policy);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __LOC_STUB_SCHED_POLICY_H__ */

46
gps/utils/platform_lib_abstractions/loc_stub/include/loc_stub_time.h
View File

@@ -1,46 +0,0 @@
/* Copyright (c) 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.
*/
#ifndef __LOC_STUB_TIME_H__
#define __LOC_STUB_TIME_H__
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
int64_t systemTime(int clock);
int64_t elapsedMillisSinceBoot();
int64_t elapsedMicrosSinceBoot();
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __LOC_STUB_TIME_H__ */

10
gps/utils/platform_lib_abstractions/loc_stub/loc-stub.pc.in
View File

@@ -1,10 +0,0 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: loc-stub
Description: QTI GPS Location Stub
Version: @VERSION
Libs: -L${libdir} -lloc_stub
Cflags: -I${includedir}/loc-stub

49
gps/utils/platform_lib_abstractions/loc_stub/src/Android.mk
View File

@@ -1,49 +0,0 @@
ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
ifneq ($(BUILD_TINY_ANDROID),true)
#Compile this library only for builds with the latest modem image
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
## Libs
LOCAL_SHARED_LIBRARIES := \
libutils \
libcutils \
liblog
LOCAL_SRC_FILES += \
loc_stub_android_runtime.cpp \
loc_stub_gettid.cpp \
loc_stub_property_service.cpp \
loc_stub_sched_policy.cpp \
loc_stub_time.cpp
LOCAL_CFLAGS += \
-fno-short-enums \
-D_ANDROID_ \
-std=c++11
LOCAL_LDFLAGS += -Wl,--export-dynamic
## Includes
LOCAL_C_INCLUDES:= \
$(LOCAL_PATH)/../include \
LOCAL_MODULE := libloc_stub
LOCAL_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib
LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64
LOCAL_MODULE_TAGS := optional
LOCAL_PRELINK_MODULE := false
LOCAL_CFLAGS += $(GNSS_CFLAGS)
include $(BUILD_SHARED_LIBRARY)
include $(CLEAR_VARS)
LOCAL_MODULE := libloc_stub_headers
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/../include
include $(BUILD_HEADER_LIBRARY)
endif # not BUILD_TINY_ANDROID
endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE

40
gps/utils/platform_lib_abstractions/loc_stub/src/Makefile.am
View File

@@ -1,40 +0,0 @@
AM_CFLAGS = \
-I../include \
-D__func__=__PRETTY_FUNCTION__ \
-fno-short-enums
libloc_stub_la_extra_h = \
../include/utils/Log.h
libloc_stub_la_c_sources = \
loc_stub_android_runtime.cpp \
loc_stub_gettid.cpp \
loc_stub_property_service.cpp \
loc_stub_sched_policy.cpp \
loc_stub_time.cpp
libloc_stub_la_SOURCES = $(libloc_stub_la_c_sources) $(libloc_stub_la_extra_h)
library_include_HEADERS = \
../include/loc_stub_android_runtime.h \
../include/loc_stub_gettid.h \
../include/loc_stub_property_service.h \
../include/loc_stub_sched_policy.h \
../include/loc_stub_time.h
library_includedir = $(pkgincludedir)
if USE_GLIB
libloc_stub_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
libloc_stub_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libloc_stub_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libloc_stub_la_CFLAGS = $(AM_CFLAGS)
libloc_stub_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
libloc_stub_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif
libloc_stub_la_LIBADD = -lstdc++ -ldl -llog
#Create and Install libraries
lib_LTLIBRARIES = libloc_stub.la

41
gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_android_runtime.cpp
View File

@@ -1,41 +0,0 @@
/* Copyright (c) 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.
*/
#include "loc_stub_android_runtime.h"
namespace android {
pthread_t AndroidRuntime::createJavaThread(const char* /*name*/,
void (*start)(void *), void* arg)
{
pthread_t threadId = 0;
pthread_create(&threadId, NULL, (void *(*)(void*))start, arg);
return threadId;
}
}

37
gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_gettid.cpp
View File

@@ -1,37 +0,0 @@
/* Copyright (c) 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.
*/
#include "loc_stub_gettid.h"
#include <sys/syscall.h>
#include <unistd.h>
// Required for off-target environment to compile properly
pid_t gettid(void)
{
return syscall(SYS_gettid);
}

42
gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_property_service.cpp
View File

@@ -1,42 +0,0 @@
/* Copyright (c) 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.
*/
#include "loc_stub_property_service.h"
#include <stdio.h>
#include <string.h>
int property_get(const char *key, char * value, const char */*default_value*/)
{
/* This will disable gps interface
value[0] = '1';
*/
if (strcmp(key, "ro.baseband") == 0) {
memcpy(value, "msm", 4);
}
return 0;
}

50
gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_sched_policy.cpp
View File

@@ -1,50 +0,0 @@
/* Copyright (c) 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.
*/
#include "loc_stub_sched_policy.h"
/*===========================================================================
FUNCTION set_sched_policy
DESCRIPTION
Local copy of this function which bypasses android set_sched_policy
DEPENDENCIES
None
RETURN VALUE
0
SIDE EFFECTS
N/A
===========================================================================*/
int set_sched_policy(int /*tid*/, SchedPolicy /*policy*/)
{
return 0;
}

55
gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_time.cpp
View File

@@ -1,55 +0,0 @@
/* Copyright (c) 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.
*/
#include "loc_stub_time.h"
#include <stdlib.h>
#include <sys/time.h>
#include <time.h>
int64_t systemTime(int /*clock*/)
{
struct timeval t;
t.tv_sec = t.tv_usec = 0;
gettimeofday(&t, NULL);
return t.tv_sec*1000000LL + t.tv_usec;
}
int64_t elapsedMicrosSinceBoot()
{
struct timespec ts;
int64_t time_ms = 0;
clock_gettime(CLOCK_BOOTTIME, &ts);
time_ms += (ts.tv_sec * 1000000000LL); /* Seconds to nanoseconds */
time_ms += ts.tv_nsec; /* Add Nanoseconds */
return time_ms;
}
int64_t elapsedMillisSinceBoot()
{
return (int64_t) (elapsedMicrosSinceBoot() /1000000LL);
}