1  /*
2   * Copyright (c) 2022 Huawei Device Co., Ltd.
3   * Licensed under the Apache License, Version 2.0 (the "License");
4   * you may not use this file except in compliance with the License.
5   * You may obtain a copy of the License at
6   *
7   *     http://www.apache.org/licenses/LICENSE-2.0
8   *
9   * Unless required by applicable law or agreed to in writing, software
10   * distributed under the License is distributed on an "AS IS" BASIS,
11   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12   * See the License for the specific language governing permissions and
13   * limitations under the License.
14   */
15  
16  #include "location_vendor_interface.h"
17  
18  #include <dlfcn.h>
19  #include <hdf_log.h>
20  
21  #include "gnss_interface_impl.h"
22  
23  namespace OHOS {
24  namespace HDI {
25  namespace Location {
26  namespace {
27  const std::string VENDOR_NAME = "vendorGnssAdapter.so";
28  } // namespace
29  
30  std::mutex LocationVendorInterface::mutex_;
31  LocationVendorInterface* LocationVendorInterface::instance_ = nullptr;
32  
LocationVendorInterface()33  LocationVendorInterface::LocationVendorInterface()
34  {
35      Init();
36      HDF_LOGI("%{public}s constructed.", __func__);
37  }
38  
~LocationVendorInterface()39  LocationVendorInterface::~LocationVendorInterface()
40  {
41      CleanUp();
42      HDF_LOGI("%{public}s destructed.", __func__);
43  }
44  
GetInstance()45  LocationVendorInterface* LocationVendorInterface::GetInstance()
46  {
47      if (instance_ == nullptr) {
48          std::lock_guard<std::mutex> lock(mutex_);
49          if (instance_ == nullptr) {
50              instance_ = new LocationVendorInterface();
51          }
52      }
53      return instance_;
54  }
55  
DestroyInstance()56  void LocationVendorInterface::DestroyInstance()
57  {
58      std::lock_guard<std::mutex> lock(mutex_);
59      if (instance_ != nullptr) {
60          delete instance_;
61          instance_ = nullptr;
62      }
63  }
64  
Init()65  void LocationVendorInterface::Init()
66  {
67      HDF_LOGI("%{public}s.", __func__);
68      vendorHandle_ = dlopen(VENDOR_NAME.c_str(), RTLD_LAZY);
69      if (!vendorHandle_) {
70          HDF_LOGE("%{public}s:dlopen %{public}s failed: %{public}s", __func__, VENDOR_NAME.c_str(), dlerror());
71          return;
72      }
73      GnssVendorDevice *gnssDevice = static_cast<GnssVendorDevice *>(dlsym(vendorHandle_, "GnssVendorInterface"));
74      if (gnssDevice == nullptr) {
75          HDF_LOGE("%{public}s:dlsym GnssInterface failed.", __func__);
76          return;
77      }
78      vendorInterface_ = gnssDevice->getGnssInterface();
79      if (vendorInterface_ == nullptr) {
80          HDF_LOGE("%{public}s:getGnssInterface failed.", __func__);
81          return;
82      }
83  }
84  
GetGnssVendorInterface() const85  const GnssVendorInterface *LocationVendorInterface::GetGnssVendorInterface() const
86  {
87      if (vendorInterface_ == nullptr) {
88          HDF_LOGE("%{public}s:GetGnssVendorInterface() failed.", __func__);
89      }
90      return vendorInterface_;
91  }
92  
GetModuleInterface(int moduleId) const93  const void *LocationVendorInterface::GetModuleInterface(int moduleId) const
94  {
95      auto vendorInterface = GetGnssVendorInterface();
96      if (vendorInterface == nullptr) {
97          HDF_LOGE("%{public}s:can not get vendorInterface.", __func__);
98          return nullptr;
99      }
100      auto moduleInterface = vendorInterface->getGnssModuleIface(moduleId);
101      if (moduleInterface == nullptr) {
102          HDF_LOGE("%{public}s:can not get moduleInterface.", __func__);
103      }
104      return moduleInterface;
105  }
106  
CleanUp()107  void LocationVendorInterface::CleanUp()
108  {
109      if (vendorInterface_ == nullptr) {
110          return;
111      }
112      vendorInterface_ = nullptr;
113      dlclose(vendorHandle_);
114      vendorHandle_ = nullptr;
115  }
116  } // Location
117  } // HDI
118  } // OHOS
119