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 "gnss_ability_skeleton.h"
17
18 #include "ipc_skeleton.h"
19
20 #include "common_utils.h"
21 #include "constant_definition.h"
22 #include "gnss_ability.h"
23
24 namespace OHOS {
25 namespace Location {
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)26 int GnssAbilityStub::OnRemoteRequest(uint32_t code,
27 MessageParcel &data, MessageParcel &reply, MessageOption &option)
28 {
29 pid_t callingPid = IPCSkeleton::GetCallingPid();
30 pid_t callingUid = IPCSkeleton::GetCallingUid();
31 LBSLOGI(GNSS, "OnRemoteRequest cmd = %{public}u, flags= %{public}d, pid= %{public}d, uid= %{public}d",
32 code, option.GetFlags(), callingPid, callingUid);
33
34 if (data.ReadInterfaceToken() != GetDescriptor()) {
35 LBSLOGE(GNSS, "invalid token.");
36 reply.WriteInt32(ERRCODE_SERVICE_UNAVAILABLE);
37 return ERRCODE_SERVICE_UNAVAILABLE;
38 }
39
40 int ret = ERRCODE_SUCCESS;
41 switch (code) {
42 case SEND_LOCATION_REQUEST: // fall through
43 case SET_MOCKED_LOCATIONS: {
44 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
45 return ERRCODE_PERMISSION_DENIED;
46 }
47 SendMessage(code, data, reply);
48 break;
49 }
50 case SET_ENABLE: {
51 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
52 return ERRCODE_PERMISSION_DENIED;
53 }
54 reply.WriteInt32(SetEnable(data.ReadBool()));
55 break;
56 }
57 case REFRESH_REQUESTS: {
58 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
59 return ERRCODE_PERMISSION_DENIED;
60 }
61 reply.WriteInt32(RefrashRequirements());
62 break;
63 }
64 case REG_GNSS_STATUS: {
65 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
66 return ERRCODE_PERMISSION_DENIED;
67 }
68 sptr<IRemoteObject> client = data.ReadObject<IRemoteObject>();
69 reply.WriteInt32(RegisterGnssStatusCallback(client, callingUid));
70 break;
71 }
72 case UNREG_GNSS_STATUS: {
73 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
74 return ERRCODE_PERMISSION_DENIED;
75 }
76 sptr<IRemoteObject> client = data.ReadObject<IRemoteObject>();
77 reply.WriteInt32(UnregisterGnssStatusCallback(client));
78 break;
79 }
80 case REG_NMEA: {
81 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
82 return ERRCODE_PERMISSION_DENIED;
83 }
84 sptr<IRemoteObject> client = data.ReadObject<IRemoteObject>();
85 reply.WriteInt32(RegisterNmeaMessageCallback(client, callingUid));
86 break;
87 }
88 case UNREG_NMEA: {
89 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
90 return ERRCODE_PERMISSION_DENIED;
91 }
92 sptr<IRemoteObject> client = data.ReadObject<IRemoteObject>();
93 reply.WriteInt32(UnregisterNmeaMessageCallback(client));
94 break;
95 }
96 case REG_CACHED: {
97 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
98 return ERRCODE_PERMISSION_DENIED;
99 }
100 std::unique_ptr<CachedGnssLocationsRequest> requestConfig = std::make_unique<CachedGnssLocationsRequest>();
101 requestConfig->reportingPeriodSec = data.ReadInt32();
102 requestConfig->wakeUpCacheQueueFull = data.ReadBool();
103 sptr<IRemoteObject> callback = data.ReadObject<IRemoteObject>();
104 reply.WriteInt32(RegisterCachedCallback(requestConfig, callback));
105 break;
106 }
107 case UNREG_CACHED: {
108 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
109 return ERRCODE_PERMISSION_DENIED;
110 }
111 sptr<IRemoteObject> callback = data.ReadObject<IRemoteObject>();
112 reply.WriteInt32(UnregisterCachedCallback(callback));
113 break;
114 }
115 case GET_CACHED_SIZE: {
116 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
117 return ERRCODE_PERMISSION_DENIED;
118 }
119 int size = -1;
120 reply.WriteInt32(GetCachedGnssLocationsSize(size));
121 reply.WriteInt32(size);
122 break;
123 }
124 case FLUSH_CACHED: {
125 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
126 return ERRCODE_PERMISSION_DENIED;
127 }
128 reply.WriteInt32(FlushCachedGnssLocations());
129 break;
130 }
131 case SEND_COMMANDS: {
132 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
133 return ERRCODE_PERMISSION_DENIED;
134 }
135 std::unique_ptr<LocationCommand> locationCommand = std::make_unique<LocationCommand>();
136 locationCommand->scenario = data.ReadInt32();
137 locationCommand->command = data.ReadBool();
138 reply.WriteInt32(SendCommand(locationCommand));
139 break;
140 }
141 case ENABLE_LOCATION_MOCK: {
142 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
143 return ERRCODE_PERMISSION_DENIED;
144 }
145 reply.WriteInt32(EnableMock());
146 break;
147 }
148 case DISABLE_LOCATION_MOCK: {
149 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
150 return ERRCODE_PERMISSION_DENIED;
151 }
152 reply.WriteInt32(DisableMock());
153 break;
154 }
155 case ADD_FENCE_INFO: {
156 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
157 return ERRCODE_PERMISSION_DENIED;
158 }
159 std::unique_ptr<GeofenceRequest> request = std::make_unique<GeofenceRequest>();
160 request->scenario = data.ReadInt32();
161 request->geofence.latitude = data.ReadDouble();
162 request->geofence.longitude = data.ReadDouble();
163 request->geofence.radius = data.ReadDouble();
164 request->geofence.expiration = data.ReadDouble();
165 reply.WriteInt32(AddFence(request));
166 break;
167 }
168 case REMOVE_FENCE_INFO: {
169 if (!CommonUtils::CheckCallingPermission(callingUid, callingPid, reply)) {
170 return ERRCODE_PERMISSION_DENIED;
171 }
172 std::unique_ptr<GeofenceRequest> request = std::make_unique<GeofenceRequest>();
173 request->scenario = data.ReadInt32();
174 request->geofence.latitude = data.ReadDouble();
175 request->geofence.longitude = data.ReadDouble();
176 request->geofence.radius = data.ReadDouble();
177 request->geofence.expiration = data.ReadDouble();
178 reply.WriteInt32(RemoveFence(request));
179 break;
180 }
181 default:
182 ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
183 }
184 return ret;
185 }
186 } // namespace Location
187 } // namespace OHOS