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#ifndef SATELLITE_STATUS_H
17#define SATELLITE_STATUS_H
18
19#include <mutex>
20#include <parcel.h>
21#include <vector>
22
23namespace OHOS {
24namespace Location {
25class SatelliteStatus : public Parcelable {
26public:
27    SatelliteStatus();
28    explicit SatelliteStatus(SatelliteStatus &satelliteStatus);
29    ~SatelliteStatus() override = default;
30
31    inline int GetSatellitesNumber() const
32    {
33        return satellitesNumber_;
34    }
35
36    inline void SetSatellitesNumber(int num)
37    {
38        satellitesNumber_ = num;
39    }
40
41    inline std::vector<int> GetSatelliteIds() const
42    {
43        return satelliteIds_;
44    }
45
46    inline void SetSatelliteIds(std::vector<int> ids)
47    {
48        std::unique_lock<std::mutex> lock(mutex_);
49        for (std::vector<int>::iterator it = ids.begin(); it != ids.end(); ++it) {
50            satelliteIds_.push_back(*it);
51        }
52    }
53
54    inline void SetSatelliteId(int id)
55    {
56        std::unique_lock<std::mutex> lock(mutex_);
57        satelliteIds_.push_back(id);
58    }
59
60    inline std::vector<double> GetCarrierToNoiseDensitys() const
61    {
62        return carrierToNoiseDensitys_;
63    }
64
65    inline void SetCarrierToNoiseDensitys(std::vector<double> cn0)
66    {
67        std::unique_lock<std::mutex> lock(mutex_);
68        for (std::vector<double>::iterator it = cn0.begin(); it != cn0.end(); ++it) {
69            carrierToNoiseDensitys_.push_back(*it);
70        }
71    }
72
73    inline void SetCarrierToNoiseDensity(double cn0)
74    {
75        std::unique_lock<std::mutex> lock(mutex_);
76        carrierToNoiseDensitys_.push_back(cn0);
77    }
78
79    inline std::vector<double> GetAltitudes() const
80    {
81        return altitudes_;
82    }
83
84    inline void SetAltitudes(std::vector<double> altitudes)
85    {
86        std::unique_lock<std::mutex> lock(mutex_);
87        for (std::vector<double>::iterator it = altitudes.begin(); it != altitudes.end(); ++it) {
88            altitudes_.push_back(*it);
89        }
90    }
91
92    inline void SetAltitude(double altitude)
93    {
94        std::unique_lock<std::mutex> lock(mutex_);
95        altitudes_.push_back(altitude);
96    }
97
98    inline std::vector<double> GetAzimuths() const
99    {
100        return azimuths_;
101    }
102
103    inline void SetAzimuths(std::vector<double> azimuths)
104    {
105        std::unique_lock<std::mutex> lock(mutex_);
106        for (std::vector<double>::iterator it = azimuths.begin(); it != azimuths.end(); ++it) {
107            azimuths_.push_back(*it);
108        }
109    }
110
111    inline void SetAzimuth(double azimuth)
112    {
113        std::unique_lock<std::mutex> lock(mutex_);
114        azimuths_.push_back(azimuth);
115    }
116
117    inline std::vector<double> GetCarrierFrequencies() const
118    {
119        return carrierFrequencies_;
120    }
121
122    inline void SetCarrierFrequencies(std::vector<double> cfs)
123    {
124        std::unique_lock<std::mutex> lock(mutex_);
125        for (std::vector<double>::iterator it = cfs.begin(); it != cfs.end(); ++it) {
126            carrierFrequencies_.push_back(*it);
127        }
128    }
129
130    inline void SetCarrierFrequencie(double cf)
131    {
132        std::unique_lock<std::mutex> lock(mutex_);
133        carrierFrequencies_.push_back(cf);
134    }
135
136    inline std::vector<int> GetConstellationTypes() const
137    {
138        return constellationTypes_;
139    }
140
141    inline void SetConstellationTypes(std::vector<int> types)
142    {
143        std::unique_lock<std::mutex> lock(mutex_);
144        for (std::vector<int>::iterator it = types.begin(); it != types.end(); ++it) {
145            constellationTypes_.push_back(*it);
146        }
147    }
148
149    inline void SetConstellationType(int type)
150    {
151        std::unique_lock<std::mutex> lock(mutex_);
152        constellationTypes_.push_back(type);
153    }
154
155    inline std::vector<int> GetSatelliteAdditionalInfoList()
156    {
157        std::unique_lock<std::mutex> lock(mutex_);
158        return additionalInfoList_;
159    }
160
161    inline void SetSatelliteAdditionalInfo(int additionalInfo)
162    {
163        std::unique_lock<std::mutex> lock(mutex_);
164        additionalInfoList_.push_back(additionalInfo);
165    }
166
167    inline void SetSatelliteAdditionalInfoList(std::vector<int> additionalInfo)
168    {
169        std::unique_lock<std::mutex> lock(mutex_);
170        for (std::vector<int>::iterator it = additionalInfo.begin();
171            it != additionalInfo.end(); ++it) {
172            additionalInfoList_.push_back(*it);
173        }
174    }
175
176    void ReadFromParcel(Parcel& parcel);
177    bool Marshalling(Parcel& parcel) const override;
178    static std::unique_ptr<SatelliteStatus> Unmarshalling(Parcel& parcel);
179private:
180    int satellitesNumber_;
181    std::vector<int> satelliteIds_;
182    std::vector<double> carrierToNoiseDensitys_;
183    std::vector<double> altitudes_;
184    std::vector<double> azimuths_;
185    std::vector<double> carrierFrequencies_;
186    std::vector<int> constellationTypes_;
187    std::vector<int> additionalInfoList_;
188    std::mutex mutex_;
189};
190} // namespace Location
191} // namespace OHOS
192#endif // SATELLITE_STATUS_H
193