AGnss.cpp 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219
  1. /*
  2. * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
  3. * Not a Contribution
  4. */
  5. /*
  6. * Copyright (C) 2016 The Android Open Source Project
  7. *
  8. * Licensed under the Apache License, Version 2.0 (the "License");
  9. * you may not use this file except in compliance with the License.
  10. * You may obtain a copy of the License at
  11. *
  12. * http://www.apache.org/licenses/LICENSE-2.0
  13. *
  14. * Unless required by applicable law or agreed to in writing, software
  15. * distributed under the License is distributed on an "AS IS" BASIS,
  16. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17. * See the License for the specific language governing permissions and
  18. * limitations under the License.
  19. */
  20. #define LOG_TAG "LocSvc_AGnssInterface"
  21. #include <log_util.h>
  22. #include "Gnss.h"
  23. #include "AGnss.h"
  24. namespace android {
  25. namespace hardware {
  26. namespace gnss {
  27. namespace V2_1 {
  28. namespace implementation {
  29. static AGnss* spAGnss = nullptr;
  30. AGnss::AGnss(Gnss* gnss) : mGnss(gnss), mType(LOC_AGPS_TYPE_INVALID) {
  31. spAGnss = this;
  32. }
  33. AGnss::~AGnss() {
  34. spAGnss = nullptr;
  35. }
  36. void AGnss::agnssStatusIpV4Cb(AGnssExtStatusIpV4 status) {
  37. if (nullptr != spAGnss) {
  38. spAGnss->statusCb(status.type, status.status);
  39. }
  40. }
  41. void AGnss::statusCb(AGpsExtType type, LocAGpsStatusValue status) {
  42. V2_0::IAGnssCallback::AGnssType aType;
  43. IAGnssCallback::AGnssStatusValue aStatus;
  44. // cache the AGps Type
  45. mType = type;
  46. switch (type) {
  47. case LOC_AGPS_TYPE_SUPL:
  48. aType = IAGnssCallback::AGnssType::SUPL;
  49. break;
  50. case LOC_AGPS_TYPE_SUPL_ES:
  51. aType = IAGnssCallback::AGnssType::SUPL_EIMS;
  52. break;
  53. default:
  54. LOC_LOGE("invalid type: %d", type);
  55. return;
  56. }
  57. switch (status) {
  58. case LOC_GPS_REQUEST_AGPS_DATA_CONN:
  59. aStatus = IAGnssCallback::AGnssStatusValue::REQUEST_AGNSS_DATA_CONN;
  60. break;
  61. case LOC_GPS_RELEASE_AGPS_DATA_CONN:
  62. aStatus = IAGnssCallback::AGnssStatusValue::RELEASE_AGNSS_DATA_CONN;
  63. break;
  64. case LOC_GPS_AGPS_DATA_CONNECTED:
  65. aStatus = IAGnssCallback::AGnssStatusValue::AGNSS_DATA_CONNECTED;
  66. break;
  67. case LOC_GPS_AGPS_DATA_CONN_DONE:
  68. aStatus = IAGnssCallback::AGnssStatusValue::AGNSS_DATA_CONN_DONE;
  69. break;
  70. case LOC_GPS_AGPS_DATA_CONN_FAILED:
  71. aStatus = IAGnssCallback::AGnssStatusValue::AGNSS_DATA_CONN_FAILED;
  72. break;
  73. default:
  74. LOC_LOGE("invalid status: %d", status);
  75. return;
  76. }
  77. mMutex.lock();
  78. auto aGnssCbIface = mAGnssCbIface;
  79. mMutex.unlock();
  80. if (aGnssCbIface != nullptr) {
  81. auto r = aGnssCbIface->agnssStatusCb(aType, aStatus);
  82. if (!r.isOk()) {
  83. LOC_LOGw("Error invoking AGNSS status cb %s", r.description().c_str());
  84. }
  85. }
  86. else {
  87. LOC_LOGw("setCallback has not been called yet");
  88. }
  89. }
  90. Return<void> AGnss::setCallback(const sp<V2_0::IAGnssCallback>& callback) {
  91. if(mGnss == nullptr || mGnss->getGnssInterface() == nullptr){
  92. LOC_LOGE("Null GNSS interface");
  93. return Void();
  94. }
  95. // Save the interface
  96. mMutex.lock();
  97. mAGnssCbIface = callback;
  98. mMutex.unlock();
  99. AgpsCbInfo cbInfo = {};
  100. cbInfo.statusV4Cb = (void*)agnssStatusIpV4Cb;
  101. cbInfo.atlType = AGPS_ATL_TYPE_SUPL | AGPS_ATL_TYPE_SUPL_ES;
  102. mGnss->getGnssInterface()->agpsInit(cbInfo);
  103. return Void();
  104. }
  105. Return<bool> AGnss::dataConnClosed() {
  106. if(mGnss == nullptr || mGnss->getGnssInterface() == nullptr){
  107. LOC_LOGE("Null GNSS interface");
  108. return false;
  109. }
  110. mGnss->getGnssInterface()->agpsDataConnClosed(LOC_AGPS_TYPE_SUPL);
  111. return true;
  112. }
  113. Return<bool> AGnss::dataConnFailed() {
  114. if(mGnss == nullptr || mGnss->getGnssInterface() == nullptr){
  115. LOC_LOGE("Null GNSS interface");
  116. return false;
  117. }
  118. mGnss->getGnssInterface()->agpsDataConnFailed(LOC_AGPS_TYPE_SUPL);
  119. return true;
  120. }
  121. Return<bool> AGnss::dataConnOpen(uint64_t /*networkHandle*/, const hidl_string& apn,
  122. V2_0::IAGnss::ApnIpType apnIpType) {
  123. if (mGnss == nullptr || mGnss->getGnssInterface() == nullptr){
  124. LOC_LOGE("Null GNSS interface");
  125. return false;
  126. }
  127. std::string apnString(apn.c_str());
  128. // During Emergency SUPL, an apn name of "sos" means that no
  129. // apn was found, like in the simless case, so apn is cleared
  130. if (LOC_AGPS_TYPE_SUPL_ES == mType && "sos" == apnString) {
  131. LOC_LOGD("dataConnOpen APN name = [sos] cleared");
  132. apnString.clear();
  133. }
  134. LOC_LOGD("dataConnOpen APN name = [%s]", apnString.c_str());
  135. AGpsBearerType bearerType;
  136. switch (apnIpType) {
  137. case IAGnss::ApnIpType::IPV4:
  138. bearerType = AGPS_APN_BEARER_IPV4;
  139. break;
  140. case IAGnss::ApnIpType::IPV6:
  141. bearerType = AGPS_APN_BEARER_IPV6;
  142. break;
  143. case IAGnss::ApnIpType::IPV4V6:
  144. bearerType = AGPS_APN_BEARER_IPV4V6;
  145. break;
  146. default:
  147. bearerType = AGPS_APN_BEARER_IPV4;
  148. break;
  149. }
  150. mGnss->getGnssInterface()->agpsDataConnOpen(
  151. LOC_AGPS_TYPE_SUPL, apnString.c_str(), apnString.size(), (int)bearerType);
  152. return true;
  153. }
  154. Return<bool> AGnss::setServer(V2_0::IAGnssCallback::AGnssType type,
  155. const hidl_string& hostname,
  156. int32_t port) {
  157. if (mGnss == nullptr) {
  158. LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
  159. return false;
  160. }
  161. GnssConfig config;
  162. memset(&config, 0, sizeof(GnssConfig));
  163. config.size = sizeof(GnssConfig);
  164. config.flags = GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT;
  165. config.assistanceServer.size = sizeof(GnssConfigSetAssistanceServer);
  166. if (type == IAGnssCallback::AGnssType::SUPL) {
  167. config.assistanceServer.type = GNSS_ASSISTANCE_TYPE_SUPL;
  168. } else if (type == IAGnssCallback::AGnssType::C2K) {
  169. config.assistanceServer.type = GNSS_ASSISTANCE_TYPE_C2K;
  170. } else if (type == IAGnssCallback::AGnssType::SUPL_EIMS) {
  171. config.assistanceServer.type = GNSS_ASSISTANCE_TYPE_SUPL_EIMS;
  172. } else if (type == IAGnssCallback::AGnssType::SUPL_IMS) {
  173. config.assistanceServer.type = GNSS_ASSISTANCE_TYPE_SUPL_IMS;
  174. } else {
  175. LOC_LOGE("%s]: invalid AGnssType: %d", __FUNCTION__, static_cast<uint8_t>(type));
  176. return false;
  177. }
  178. config.assistanceServer.hostName = strdup(hostname.c_str());
  179. config.assistanceServer.port = port;
  180. return mGnss->updateConfiguration(config);
  181. }
  182. } // namespace implementation
  183. } // namespace V2_1
  184. } // namespace gnss
  185. } // namespace hardware
  186. } // namespace android