• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2021 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.uwb.support.fira;
18 
19 import static java.util.Objects.requireNonNull;
20 
21 import android.os.PersistableBundle;
22 import android.uwb.UwbManager;
23 
24 import androidx.annotation.NonNull;
25 
26 import com.google.uwb.support.base.FlagEnum;
27 
28 import java.util.ArrayList;
29 import java.util.Collection;
30 import java.util.EnumSet;
31 import java.util.List;
32 
33 /**
34  * Defines parameters for FIRA capability.
35  *
36  * <p>This is returned as a bundle from the service API {@link UwbManager#getSpecificationInfo}.
37  */
38 public class FiraSpecificationParams extends FiraParams {
39     private static final int BUNDLE_VERSION_1 = 1;
40     private static final int BUNDLE_VERSION_2 = 2;
41     private static final int BUNDLE_VERSION_CURRENT = BUNDLE_VERSION_2;
42 
43     private final FiraProtocolVersion mMinPhyVersionSupported;
44     private final FiraProtocolVersion mMaxPhyVersionSupported;
45     private final FiraProtocolVersion mMinMacVersionSupported;
46     private final FiraProtocolVersion mMaxMacVersionSupported;
47 
48     private final List<Integer> mSupportedChannels;
49 
50     private final EnumSet<AoaCapabilityFlag> mAoaCapabilities;
51 
52     private final EnumSet<DeviceRoleCapabilityFlag> mDeviceRoleCapabilities;
53 
54     private final boolean mHasBlockStridingSupport;
55 
56     private final boolean mHasHoppingPreferenceSupport;
57 
58     private final boolean mHasExtendedMacAddressSupport;
59 
60     private final boolean mHasNonDeferredModeSupport;
61 
62     private final boolean mHasInitiationTimeSupport;
63 
64     private final boolean mHasRssiReportingSupport;
65 
66     private final boolean mHasDiagnosticsSupport;
67 
68     private final int mMinRangingInterval;
69 
70     private final int mMinSlotDurationUs;
71 
72     private final int mMaxRangingSessionNumber;
73 
74     private final EnumSet<MultiNodeCapabilityFlag> mMultiNodeCapabilities;
75 
76     private final EnumSet<RangingTimeStructCapabilitiesFlag> mRangingTimeStructCapabilities;
77 
78     private final EnumSet<SchedulingModeCapabilitiesFlag> mSchedulingModeCapabilities;
79 
80     private final EnumSet<CcConstraintLengthCapabilitiesFlag> mCcConstraintLengthCapabilities;
81 
82     private final EnumSet<PrfCapabilityFlag> mPrfCapabilities;
83 
84     private final EnumSet<RangingRoundCapabilityFlag> mRangingRoundCapabilities;
85 
86     private final EnumSet<RframeCapabilityFlag> mRframeCapabilities;
87 
88     private final EnumSet<StsCapabilityFlag> mStsCapabilities;
89 
90     private final EnumSet<PsduDataRateCapabilityFlag> mPsduDataRateCapabilities;
91 
92     private final EnumSet<BprfParameterSetCapabilityFlag> mBprfParameterSetCapabilities;
93 
94     private final EnumSet<HprfParameterSetCapabilityFlag> mHprfParameterSetCapabilities;
95 
96     private final Integer mMaxMessageSize;
97 
98     private final Integer mMaxDataPacketPayloadSize;
99 
100     private final EnumSet<RangeDataNtfConfigCapabilityFlag> mRangeDataNtfConfigCapabilities;
101 
102     private final int mDeviceType;
103 
104     private final boolean mSuspendRangingSupport;
105 
106     private final int mSessionKeyLength;
107 
108     private final int mDtTagMaxActiveRr;
109 
110     private final boolean mHasBackgroundRangingSupport;
111 
112     private final boolean mHasDtTagBlockSkippingSupport;
113 
114     private final boolean mHasPsduLengthSupport;
115 
116     private final String mCountryCode;
117 
118     private final int mUciVersion;
119 
120     private static final String KEY_MIN_PHY_VERSION = "min_phy_version";
121     private static final String KEY_MAX_PHY_VERSION = "max_phy_version";
122     private static final String KEY_MIN_MAC_VERSION = "min_mac_version";
123     private static final String KEY_MAX_MAC_VERSION = "max_mac_version";
124 
125     private static final String KEY_SUPPORTED_CHANNELS = "channels";
126     private static final String KEY_AOA_CAPABILITIES = "aoa_capabilities";
127     private static final String KEY_DEVICE_ROLE_CAPABILITIES = "device_role_capabilities";
128     private static final String KEY_BLOCK_STRIDING_SUPPORT = "block_striding";
129     private static final String KEY_HOPPING_PREFERENCE_SUPPORT = "hopping_preference";
130     private static final String KEY_EXTENDED_MAC_ADDRESS_SUPPORT = "extended_mac_address";
131     private static final String KEY_NON_DEFERRED_MODE_SUPPORT = "non_deferred_mode";
132     private static final String KEY_INITIATION_TIME_SUPPORT = "initiation_time";
133     private static final String KEY_RSSI_REPORTING_SUPPORT = "rssi_reporting";
134     private static final String KEY_DIAGNOSTICS_SUPPORT = "diagnostics";
135     private static final String KEY_MIN_RANGING_INTERVAL = "min_ranging_interval";
136     private static final String KEY_MIN_SLOT_DURATION = "min_slot_duration";
137     private static final String KEY_MAX_RANGING_SESSION_NUMBER = "max_ranging_session_number";
138     private static final String KEY_MULTI_NODE_CAPABILITIES = "multi_node_capabilities";
139     private static final String KEY_RANGING_TIME_STRUCT_CAPABILITIES =
140             "ranging_time_struct_capabilities";
141     private static final String KEY_SCHEDULING_MODE_CAPABILITIES = "scheduling_mode_capabilities";
142     private static final String KEY_CC_CONSTRAINT_LENGTH_CAPABILITIES =
143             "cc_constraint_length_capabilities";
144     private static final String KEY_PRF_CAPABILITIES = "prf_capabilities";
145     private static final String KEY_RANGING_ROUND_CAPABILITIES =
146             "ranging_round_capabilities";
147     private static final String KEY_RFRAME_CAPABILITIES = "rframe_capabilities";
148     private static final String KEY_STS_CAPABILITIES = "sts_capabilities";
149     private static final String KEY_PSDU_DATA_RATE_CAPABILITIES = "psdu_data_rate_capabilities";
150     private static final String KEY_BPRF_PARAMETER_SET_CAPABILITIES =
151             "bprf_parameter_set_capabilities";
152     private static final String KEY_HPRF_PARAMETER_SET_CAPABILITIES =
153             "hprf_parameter_set_capabilities";
154     private static final String KEY_MAX_MESSAGE_SIZE = "max_message_size";
155     private static final String KEY_MAX_DATA_PACKET_PAYLOAD_SIZE = "max_data_packet_payload_size";
156     private static final String KEY_RANGE_DATA_NTF_CONFIG_CAPABILITIES =
157             "range_data_ntf_config_capabilities";
158     private static final String KEY_DEVICE_TYPE =
159             "device_type";
160     private static final String KEY_SUSPEND_RANGING_SUPPORT =
161             "suspend_ranging_support";
162     private static final String KEY_SESSION_KEY_LENGTH =
163             "session_key_length";
164     public static final String DT_TAG_MAX_ACTIVE_RR = "dt_tag_max_active_rr";
165 
166     public static final String KEY_BACKGROUND_RANGING_SUPPORT = "background_ranging_support";
167 
168     public static final String KEY_DT_TAG_BLOCK_SKIPPING_SUPPORT = "dt_tag_block_skipping";
169 
170     public static final String KEY_PSDU_LENGTH_SUPPORT = "psdu_length_support";
171 
172     public static final String KEY_COUNTRY_CODE = "country_code";
173 
174     public static final String KEY_UCI_VERSION = "uci_version";
175 
176     public static final int DEFAULT_MAX_RANGING_SESSIONS_NUMBER = 5;
177 
FiraSpecificationParams( FiraProtocolVersion minPhyVersionSupported, FiraProtocolVersion maxPhyVersionSupported, FiraProtocolVersion minMacVersionSupported, FiraProtocolVersion maxMacVersionSupported, List<Integer> supportedChannels, EnumSet<AoaCapabilityFlag> aoaCapabilities, EnumSet<DeviceRoleCapabilityFlag> deviceRoleCapabilities, boolean hasBlockStridingSupport, boolean hasHoppingPreferenceSupport, boolean hasExtendedMacAddressSupport, boolean hasNonDeferredModeSupport, boolean hasInitiationTimeSupport, boolean hasRssiReportingSupport, boolean hasDiagnosticsSupport, int minRangingInterval, int minSlotDurationUs, int maxRangingSessionNumber, EnumSet<MultiNodeCapabilityFlag> multiNodeCapabilities, EnumSet<RangingTimeStructCapabilitiesFlag> rangingTimeStructCapabilities, EnumSet<SchedulingModeCapabilitiesFlag> schedulingModeCapabilities, EnumSet<CcConstraintLengthCapabilitiesFlag> ccConstraintLengthCapabilities, EnumSet<PrfCapabilityFlag> prfCapabilities, EnumSet<RangingRoundCapabilityFlag> rangingRoundCapabilities, EnumSet<RframeCapabilityFlag> rframeCapabilities, EnumSet<StsCapabilityFlag> stsCapabilities, EnumSet<PsduDataRateCapabilityFlag> psduDataRateCapabilities, EnumSet<BprfParameterSetCapabilityFlag> bprfParameterSetCapabilities, EnumSet<HprfParameterSetCapabilityFlag> hprfParameterSetCapabilities, Integer maxMessageSize, Integer maxDataPacketPayloadSize, EnumSet<RangeDataNtfConfigCapabilityFlag> rangeDataNtfConfigCapabilities, int deviceType, boolean suspendRangingSupport, int sessionKeyLength, int dtTagMaxActiveRr, boolean hasBackgroundRangingSupport, boolean hasDtTagBlockSkippingSupport, boolean hasPsduLengthSupport, String countryCode, int uciVersion)178     private FiraSpecificationParams(
179             FiraProtocolVersion minPhyVersionSupported,
180             FiraProtocolVersion maxPhyVersionSupported,
181             FiraProtocolVersion minMacVersionSupported,
182             FiraProtocolVersion maxMacVersionSupported,
183             List<Integer> supportedChannels,
184             EnumSet<AoaCapabilityFlag> aoaCapabilities,
185             EnumSet<DeviceRoleCapabilityFlag> deviceRoleCapabilities,
186             boolean hasBlockStridingSupport,
187             boolean hasHoppingPreferenceSupport,
188             boolean hasExtendedMacAddressSupport,
189             boolean hasNonDeferredModeSupport,
190             boolean hasInitiationTimeSupport,
191             boolean hasRssiReportingSupport,
192             boolean hasDiagnosticsSupport,
193             int minRangingInterval,
194             int minSlotDurationUs,
195             int maxRangingSessionNumber,
196             EnumSet<MultiNodeCapabilityFlag> multiNodeCapabilities,
197             EnumSet<RangingTimeStructCapabilitiesFlag> rangingTimeStructCapabilities,
198             EnumSet<SchedulingModeCapabilitiesFlag> schedulingModeCapabilities,
199             EnumSet<CcConstraintLengthCapabilitiesFlag> ccConstraintLengthCapabilities,
200             EnumSet<PrfCapabilityFlag> prfCapabilities,
201             EnumSet<RangingRoundCapabilityFlag> rangingRoundCapabilities,
202             EnumSet<RframeCapabilityFlag> rframeCapabilities,
203             EnumSet<StsCapabilityFlag> stsCapabilities,
204             EnumSet<PsduDataRateCapabilityFlag> psduDataRateCapabilities,
205             EnumSet<BprfParameterSetCapabilityFlag> bprfParameterSetCapabilities,
206             EnumSet<HprfParameterSetCapabilityFlag> hprfParameterSetCapabilities,
207             Integer maxMessageSize,
208             Integer maxDataPacketPayloadSize,
209             EnumSet<RangeDataNtfConfigCapabilityFlag> rangeDataNtfConfigCapabilities,
210             int deviceType, boolean suspendRangingSupport, int sessionKeyLength,
211             int dtTagMaxActiveRr, boolean hasBackgroundRangingSupport,
212             boolean hasDtTagBlockSkippingSupport, boolean hasPsduLengthSupport,
213             String countryCode,
214             int uciVersion) {
215         mMinPhyVersionSupported = minPhyVersionSupported;
216         mMaxPhyVersionSupported = maxPhyVersionSupported;
217         mMinMacVersionSupported = minMacVersionSupported;
218         mMaxMacVersionSupported = maxMacVersionSupported;
219         mSupportedChannels = supportedChannels;
220         mAoaCapabilities = aoaCapabilities;
221         mDeviceRoleCapabilities = deviceRoleCapabilities;
222         mHasBlockStridingSupport = hasBlockStridingSupport;
223         mHasHoppingPreferenceSupport = hasHoppingPreferenceSupport;
224         mHasExtendedMacAddressSupport = hasExtendedMacAddressSupport;
225         mHasNonDeferredModeSupport = hasNonDeferredModeSupport;
226         mHasInitiationTimeSupport = hasInitiationTimeSupport;
227         mHasRssiReportingSupport = hasRssiReportingSupport;
228         mHasDiagnosticsSupport = hasDiagnosticsSupport;
229         mMinRangingInterval = minRangingInterval;
230         mMinSlotDurationUs = minSlotDurationUs;
231         mMaxRangingSessionNumber = maxRangingSessionNumber;
232         mMultiNodeCapabilities = multiNodeCapabilities;
233         mRangingTimeStructCapabilities = rangingTimeStructCapabilities;
234         mSchedulingModeCapabilities = schedulingModeCapabilities;
235         mCcConstraintLengthCapabilities = ccConstraintLengthCapabilities;
236         mPrfCapabilities = prfCapabilities;
237         mRangingRoundCapabilities = rangingRoundCapabilities;
238         mRframeCapabilities = rframeCapabilities;
239         mStsCapabilities = stsCapabilities;
240         mPsduDataRateCapabilities = psduDataRateCapabilities;
241         mBprfParameterSetCapabilities = bprfParameterSetCapabilities;
242         mHprfParameterSetCapabilities = hprfParameterSetCapabilities;
243         mMaxMessageSize = maxMessageSize;
244         mMaxDataPacketPayloadSize = maxDataPacketPayloadSize;
245         mRangeDataNtfConfigCapabilities = rangeDataNtfConfigCapabilities;
246         mDeviceType = deviceType;
247         mSuspendRangingSupport = suspendRangingSupport;
248         mSessionKeyLength = sessionKeyLength;
249         mDtTagMaxActiveRr = dtTagMaxActiveRr;
250         mHasBackgroundRangingSupport = hasBackgroundRangingSupport;
251         mHasDtTagBlockSkippingSupport = hasDtTagBlockSkippingSupport;
252         mHasPsduLengthSupport = hasPsduLengthSupport;
253         mCountryCode = countryCode;
254         mUciVersion = uciVersion;
255     }
256 
257     @Override
getBundleVersion()258     protected int getBundleVersion() {
259         return BUNDLE_VERSION_CURRENT;
260     }
261 
getMinPhyVersionSupported()262     public FiraProtocolVersion getMinPhyVersionSupported() {
263         return mMinPhyVersionSupported;
264     }
265 
getMaxPhyVersionSupported()266     public FiraProtocolVersion getMaxPhyVersionSupported() {
267         return mMaxPhyVersionSupported;
268     }
269 
getMinMacVersionSupported()270     public FiraProtocolVersion getMinMacVersionSupported() {
271         return mMinMacVersionSupported;
272     }
273 
getMaxMacVersionSupported()274     public FiraProtocolVersion getMaxMacVersionSupported() {
275         return mMaxMacVersionSupported;
276     }
277 
getSupportedChannels()278     public List<Integer> getSupportedChannels() {
279         return mSupportedChannels;
280     }
281 
getAoaCapabilities()282     public EnumSet<AoaCapabilityFlag> getAoaCapabilities() {
283         return mAoaCapabilities;
284     }
285 
getDeviceRoleCapabilities()286     public EnumSet<DeviceRoleCapabilityFlag> getDeviceRoleCapabilities() {
287         return mDeviceRoleCapabilities;
288     }
289 
hasBlockStridingSupport()290     public boolean hasBlockStridingSupport() {
291         return mHasBlockStridingSupport;
292     }
293 
hasHoppingPreferenceSupport()294     public boolean hasHoppingPreferenceSupport() {
295         return mHasHoppingPreferenceSupport;
296     }
297 
hasExtendedMacAddressSupport()298     public boolean hasExtendedMacAddressSupport() {
299         return mHasExtendedMacAddressSupport;
300     }
301 
hasNonDeferredModeSupport()302     public boolean hasNonDeferredModeSupport() {
303         return mHasNonDeferredModeSupport;
304     }
305 
hasInitiationTimeSupport()306     public boolean hasInitiationTimeSupport() {
307         return mHasInitiationTimeSupport;
308     }
309 
310     /** get a boolean whether rssi reporting is supported. */
hasRssiReportingSupport()311     public boolean hasRssiReportingSupport() {
312         return mHasRssiReportingSupport;
313     }
314 
315     /** get a boolean whether diagnostics is supported. */
hasDiagnosticsSupport()316     public boolean hasDiagnosticsSupport() {
317         return mHasDiagnosticsSupport;
318     }
319 
getMinRangingInterval()320     public int getMinRangingInterval() {
321         return mMinRangingInterval;
322     }
323 
getMinSlotDurationUs()324     public int getMinSlotDurationUs() {
325         return mMinSlotDurationUs;
326     }
327 
getMaxRangingSessionNumber()328     public int getMaxRangingSessionNumber() {
329         return mMaxRangingSessionNumber;
330     }
331 
getMultiNodeCapabilities()332     public EnumSet<MultiNodeCapabilityFlag> getMultiNodeCapabilities() {
333         return mMultiNodeCapabilities;
334     }
335 
getRangingTimeStructCapabilities()336     public EnumSet<RangingTimeStructCapabilitiesFlag> getRangingTimeStructCapabilities() {
337         return mRangingTimeStructCapabilities;
338     }
339 
getSchedulingModeCapabilities()340     public EnumSet<SchedulingModeCapabilitiesFlag> getSchedulingModeCapabilities() {
341         return mSchedulingModeCapabilities;
342     }
343 
getCcConstraintLengthCapabilities()344     public EnumSet<CcConstraintLengthCapabilitiesFlag> getCcConstraintLengthCapabilities() {
345         return mCcConstraintLengthCapabilities;
346     }
347 
getPrfCapabilities()348     public EnumSet<PrfCapabilityFlag> getPrfCapabilities() {
349         return mPrfCapabilities;
350     }
351 
getRangingRoundCapabilities()352     public EnumSet<RangingRoundCapabilityFlag> getRangingRoundCapabilities() {
353         return mRangingRoundCapabilities;
354     }
355 
getRframeCapabilities()356     public EnumSet<RframeCapabilityFlag> getRframeCapabilities() {
357         return mRframeCapabilities;
358     }
359 
getStsCapabilities()360     public EnumSet<StsCapabilityFlag> getStsCapabilities() {
361         return mStsCapabilities;
362     }
363 
getPsduDataRateCapabilities()364     public EnumSet<PsduDataRateCapabilityFlag> getPsduDataRateCapabilities() {
365         return mPsduDataRateCapabilities;
366     }
367 
getBprfParameterSetCapabilities()368     public EnumSet<BprfParameterSetCapabilityFlag> getBprfParameterSetCapabilities() {
369         return mBprfParameterSetCapabilities;
370     }
371 
getHprfParameterSetCapabilities()372     public EnumSet<HprfParameterSetCapabilityFlag> getHprfParameterSetCapabilities() {
373         return mHprfParameterSetCapabilities;
374     }
375 
getRangeDataNtfConfigCapabilities()376     public EnumSet<RangeDataNtfConfigCapabilityFlag> getRangeDataNtfConfigCapabilities() {
377         return mRangeDataNtfConfigCapabilities;
378     }
379 
getMaxMessageSize()380     public Integer getMaxMessageSize() {
381         return mMaxMessageSize;
382     }
383 
getMaxDataPacketPayloadSize()384     public Integer getMaxDataPacketPayloadSize() {
385         return mMaxDataPacketPayloadSize;
386     }
387 
getDeviceType()388     public int getDeviceType() {
389         return mDeviceType;
390     }
391 
hasSuspendRangingSupport()392     public boolean hasSuspendRangingSupport() {
393         return mSuspendRangingSupport;
394     }
395 
getSessionKeyLength()396     public int getSessionKeyLength() {
397         return mSessionKeyLength;
398     }
399 
getDtTagMaxActiveRr()400     public int getDtTagMaxActiveRr() {
401         return mDtTagMaxActiveRr;
402     }
403 
hasBackgroundRangingSupport()404     public boolean hasBackgroundRangingSupport() {
405         return mHasBackgroundRangingSupport;
406     }
407 
hasDtTagBlockSkippingSupport()408     public boolean hasDtTagBlockSkippingSupport() {
409         return mHasDtTagBlockSkippingSupport;
410     }
411 
hasPsduLengthSupport()412     public boolean hasPsduLengthSupport() {
413         return mHasPsduLengthSupport;
414     }
415 
getCountryCode()416     public String getCountryCode() {
417         return mCountryCode;
418     }
419 
getUciVersionSupported()420     public int getUciVersionSupported() {
421         return mUciVersion;
422     }
423 
toIntArray(List<Integer> data)424     private static int[] toIntArray(List<Integer> data) {
425         int[] res = new int[data.size()];
426         for (int i = 0; i < data.size(); i++) {
427             res[i] = data.get(i);
428         }
429         return res;
430     }
431 
432     @Override
toBundle()433     public PersistableBundle toBundle() {
434         PersistableBundle bundle = super.toBundle();
435         bundle.putString(KEY_MIN_PHY_VERSION, mMinPhyVersionSupported.toString());
436         bundle.putString(KEY_MAX_PHY_VERSION, mMaxPhyVersionSupported.toString());
437         bundle.putString(KEY_MIN_MAC_VERSION, mMinMacVersionSupported.toString());
438         bundle.putString(KEY_MAX_MAC_VERSION, mMaxMacVersionSupported.toString());
439         bundle.putIntArray(KEY_SUPPORTED_CHANNELS, toIntArray(mSupportedChannels));
440         bundle.putInt(KEY_AOA_CAPABILITIES, FlagEnum.toInt(mAoaCapabilities));
441         bundle.putInt(KEY_DEVICE_ROLE_CAPABILITIES, FlagEnum.toInt(mDeviceRoleCapabilities));
442         bundle.putBoolean(KEY_BLOCK_STRIDING_SUPPORT, mHasBlockStridingSupport);
443         bundle.putBoolean(KEY_HOPPING_PREFERENCE_SUPPORT, mHasHoppingPreferenceSupport);
444         bundle.putBoolean(KEY_EXTENDED_MAC_ADDRESS_SUPPORT, mHasExtendedMacAddressSupport);
445         bundle.putBoolean(KEY_NON_DEFERRED_MODE_SUPPORT, mHasNonDeferredModeSupport);
446         bundle.putBoolean(KEY_INITIATION_TIME_SUPPORT, mHasInitiationTimeSupport);
447         bundle.putBoolean(KEY_RSSI_REPORTING_SUPPORT, mHasRssiReportingSupport);
448         bundle.putBoolean(KEY_DIAGNOSTICS_SUPPORT, mHasDiagnosticsSupport);
449         bundle.putInt(KEY_MIN_RANGING_INTERVAL, mMinRangingInterval);
450         bundle.putInt(KEY_MIN_SLOT_DURATION, mMinSlotDurationUs);
451         bundle.putInt(KEY_MAX_RANGING_SESSION_NUMBER, mMaxRangingSessionNumber);
452         bundle.putInt(KEY_MULTI_NODE_CAPABILITIES, FlagEnum.toInt(mMultiNodeCapabilities));
453         bundle.putInt(KEY_RANGING_TIME_STRUCT_CAPABILITIES,
454                 FlagEnum.toInt(mRangingTimeStructCapabilities));
455         bundle.putInt(KEY_SCHEDULING_MODE_CAPABILITIES,
456                 FlagEnum.toInt(mSchedulingModeCapabilities));
457         bundle.putInt(KEY_CC_CONSTRAINT_LENGTH_CAPABILITIES,
458                 FlagEnum.toInt(mCcConstraintLengthCapabilities));
459         bundle.putInt(KEY_PRF_CAPABILITIES, FlagEnum.toInt(mPrfCapabilities));
460         bundle.putInt(KEY_RANGING_ROUND_CAPABILITIES, FlagEnum.toInt(mRangingRoundCapabilities));
461         bundle.putInt(KEY_RFRAME_CAPABILITIES, FlagEnum.toInt(mRframeCapabilities));
462         bundle.putInt(KEY_STS_CAPABILITIES, FlagEnum.toInt(mStsCapabilities));
463         bundle.putInt(KEY_PSDU_DATA_RATE_CAPABILITIES, FlagEnum.toInt(mPsduDataRateCapabilities));
464         bundle.putInt(KEY_BPRF_PARAMETER_SET_CAPABILITIES,
465                 FlagEnum.toInt(mBprfParameterSetCapabilities));
466         bundle.putLong(KEY_HPRF_PARAMETER_SET_CAPABILITIES,
467                 FlagEnum.toLong(mHprfParameterSetCapabilities));
468         bundle.putInt(KEY_MAX_MESSAGE_SIZE, mMaxMessageSize);
469         bundle.putInt(KEY_MAX_DATA_PACKET_PAYLOAD_SIZE, mMaxDataPacketPayloadSize);
470         bundle.putInt(KEY_RANGE_DATA_NTF_CONFIG_CAPABILITIES,
471                 FlagEnum.toInt(mRangeDataNtfConfigCapabilities));
472         bundle.putInt(KEY_DEVICE_TYPE, mDeviceType);
473         bundle.putBoolean(KEY_SUSPEND_RANGING_SUPPORT, mSuspendRangingSupport);
474         bundle.putInt(KEY_SESSION_KEY_LENGTH, mSessionKeyLength);
475         bundle.putInt(DT_TAG_MAX_ACTIVE_RR, mDtTagMaxActiveRr);
476         bundle.putBoolean(KEY_BACKGROUND_RANGING_SUPPORT, mHasBackgroundRangingSupport);
477         bundle.putBoolean(KEY_DT_TAG_BLOCK_SKIPPING_SUPPORT, mHasDtTagBlockSkippingSupport);
478         bundle.putBoolean(KEY_PSDU_LENGTH_SUPPORT, mHasPsduLengthSupport);
479         bundle.putString(KEY_COUNTRY_CODE, mCountryCode);
480         bundle.putInt(KEY_UCI_VERSION, mUciVersion);
481         return bundle;
482     }
483 
fromBundle(PersistableBundle bundle)484     public static FiraSpecificationParams fromBundle(PersistableBundle bundle) {
485         if (!isCorrectProtocol(bundle)) {
486             throw new IllegalArgumentException("Invalid protocol");
487         }
488 
489         switch (getBundleVersion(bundle)) {
490             case BUNDLE_VERSION_1:
491                 return parseVersion1(bundle).build();
492             case BUNDLE_VERSION_2:
493                 return parseVersion2(bundle).build();
494             default:
495                 throw new IllegalArgumentException("Invalid bundle version");
496         }
497     }
498 
toIntList(int[] data)499     private static List<Integer> toIntList(int[] data) {
500         List<Integer> res = new ArrayList<>();
501         for (int datum : data) {
502             res.add(datum);
503         }
504         return res;
505     }
506 
parseVersion2(PersistableBundle bundle)507     private static FiraSpecificationParams.Builder parseVersion2(PersistableBundle bundle) {
508         FiraSpecificationParams.Builder builder = parseVersion1(bundle);
509         builder.setDeviceType(bundle.getInt(KEY_DEVICE_TYPE));
510         builder.setSuspendRangingSupport(bundle.getBoolean(KEY_SUSPEND_RANGING_SUPPORT));
511         builder.setSessionKeyLength(bundle.getInt(KEY_SESSION_KEY_LENGTH));
512         builder.setDtTagMaxActiveRr(bundle.getInt(DT_TAG_MAX_ACTIVE_RR, 0));
513         builder.setBackgroundRangingSupport(bundle.getBoolean(KEY_BACKGROUND_RANGING_SUPPORT));
514         builder.setDtTagBlockSkippingSupport(bundle.getBoolean(KEY_DT_TAG_BLOCK_SKIPPING_SUPPORT));
515         builder.setPsduLengthSupport(bundle.getBoolean(KEY_PSDU_LENGTH_SUPPORT));
516         builder.setUciVersionSupported(bundle.getInt(KEY_UCI_VERSION, 1));
517         builder.setCountryCode(bundle.getString(KEY_COUNTRY_CODE));
518         return builder;
519     }
520 
parseVersion1(PersistableBundle bundle)521     private static FiraSpecificationParams.Builder parseVersion1(PersistableBundle bundle) {
522         FiraSpecificationParams.Builder builder = new FiraSpecificationParams.Builder();
523         List<Integer> supportedChannels =
524                 toIntList(requireNonNull(bundle.getIntArray(KEY_SUPPORTED_CHANNELS)));
525         builder.setMinPhyVersionSupported(
526                         FiraProtocolVersion.fromString(bundle.getString(KEY_MIN_PHY_VERSION)))
527                 .setMaxPhyVersionSupported(
528                         FiraProtocolVersion.fromString(bundle.getString(KEY_MAX_PHY_VERSION)))
529                 .setMinMacVersionSupported(
530                         FiraProtocolVersion.fromString(bundle.getString(KEY_MIN_MAC_VERSION)))
531                 .setMaxMacVersionSupported(
532                         FiraProtocolVersion.fromString(bundle.getString(KEY_MAX_MAC_VERSION)))
533                 .setSupportedChannels(supportedChannels)
534                 .setAoaCapabilities(
535                         FlagEnum.toEnumSet(
536                                 bundle.getInt(KEY_AOA_CAPABILITIES), AoaCapabilityFlag.values()))
537                 .setDeviceRoleCapabilities(
538                         FlagEnum.toEnumSet(
539                                 bundle.getInt(KEY_DEVICE_ROLE_CAPABILITIES),
540                                 DeviceRoleCapabilityFlag.values()))
541                 .hasBlockStridingSupport(bundle.getBoolean(KEY_BLOCK_STRIDING_SUPPORT))
542                 .hasHoppingPreferenceSupport(bundle.getBoolean(KEY_HOPPING_PREFERENCE_SUPPORT))
543                 .hasExtendedMacAddressSupport(bundle.getBoolean(KEY_EXTENDED_MAC_ADDRESS_SUPPORT))
544                 .hasNonDeferredModeSupport(bundle.getBoolean(KEY_NON_DEFERRED_MODE_SUPPORT))
545                 .hasInitiationTimeSupport(bundle.getBoolean(KEY_INITIATION_TIME_SUPPORT))
546                 .setMinRangingIntervalSupported(bundle.getInt(KEY_MIN_RANGING_INTERVAL, -1))
547                 .setMinSlotDurationSupportedUs(bundle.getInt(KEY_MIN_SLOT_DURATION, -1))
548                 .setMultiNodeCapabilities(
549                         FlagEnum.toEnumSet(
550                                 bundle.getInt(KEY_MULTI_NODE_CAPABILITIES),
551                                 MultiNodeCapabilityFlag.values()))
552                 .setRangingTimeStructCapabilities(
553                         FlagEnum.toEnumSet(
554                                 bundle.getInt(KEY_RANGING_TIME_STRUCT_CAPABILITIES),
555                                 RangingTimeStructCapabilitiesFlag.values()))
556                 .setSchedulingModeCapabilities(
557                         FlagEnum.toEnumSet(
558                                 bundle.getInt(KEY_SCHEDULING_MODE_CAPABILITIES),
559                                 SchedulingModeCapabilitiesFlag.values()))
560                 .setCcConstraintLengthCapabilities(
561                         FlagEnum.toEnumSet(
562                                 bundle.getInt(KEY_CC_CONSTRAINT_LENGTH_CAPABILITIES),
563                                 CcConstraintLengthCapabilitiesFlag.values()))
564                 .setPrfCapabilities(
565                         FlagEnum.toEnumSet(
566                                 bundle.getInt(KEY_PRF_CAPABILITIES), PrfCapabilityFlag.values()))
567                 .setRangingRoundCapabilities(
568                         FlagEnum.toEnumSet(
569                                 bundle.getInt(KEY_RANGING_ROUND_CAPABILITIES),
570                                 RangingRoundCapabilityFlag.values()))
571                 .setRframeCapabilities(
572                         FlagEnum.toEnumSet(
573                                 bundle.getInt(KEY_RFRAME_CAPABILITIES),
574                                 RframeCapabilityFlag.values()))
575                 .setStsCapabilities(
576                         FlagEnum.toEnumSet(
577                                 bundle.getInt(KEY_STS_CAPABILITIES), StsCapabilityFlag.values()))
578                 .setPsduDataRateCapabilities(
579                         FlagEnum.toEnumSet(
580                                 bundle.getInt(KEY_PSDU_DATA_RATE_CAPABILITIES),
581                                 PsduDataRateCapabilityFlag.values()))
582                 .setBprfParameterSetCapabilities(
583                         FlagEnum.toEnumSet(
584                                 bundle.getInt(KEY_BPRF_PARAMETER_SET_CAPABILITIES),
585                                 BprfParameterSetCapabilityFlag.values()))
586                 .setMaxMessageSize(bundle.getInt(KEY_MAX_MESSAGE_SIZE))
587                 .setMaxDataPacketPayloadSize(bundle.getInt(KEY_MAX_DATA_PACKET_PAYLOAD_SIZE))
588                 .setHprfParameterSetCapabilities(
589                         FlagEnum.longToEnumSet(
590                                 bundle.getLong(KEY_HPRF_PARAMETER_SET_CAPABILITIES),
591                                 HprfParameterSetCapabilityFlag.values()));
592         // Newer params need to be backward compatible with existing devices.
593         if (bundle.containsKey(KEY_RANGE_DATA_NTF_CONFIG_CAPABILITIES)) {
594             builder.setRangeDataNtfConfigCapabilities(
595                     FlagEnum.toEnumSet(
596                             bundle.getInt(KEY_RANGE_DATA_NTF_CONFIG_CAPABILITIES),
597                             RangeDataNtfConfigCapabilityFlag.values()));
598         }
599         if (bundle.containsKey(KEY_RSSI_REPORTING_SUPPORT)) {
600             builder.hasRssiReportingSupport(bundle.getBoolean(KEY_RSSI_REPORTING_SUPPORT));
601         }
602         if (bundle.containsKey(KEY_DIAGNOSTICS_SUPPORT)) {
603             builder.hasDiagnosticsSupport(bundle.getBoolean(KEY_DIAGNOSTICS_SUPPORT));
604         }
605         if (bundle.containsKey(KEY_MAX_RANGING_SESSION_NUMBER)) {
606             builder.setMaxRangingSessionNumberSupported(
607                     bundle.getInt(KEY_MAX_RANGING_SESSION_NUMBER));
608         }
609         return builder;
610     }
611 
612     /** Builder */
613     public static class Builder {
614         // Set all default protocol version to FiRa 1.1
615         private FiraProtocolVersion mMinPhyVersionSupported = new FiraProtocolVersion(1, 1);
616         private FiraProtocolVersion mMaxPhyVersionSupported = new FiraProtocolVersion(1, 1);
617         private FiraProtocolVersion mMinMacVersionSupported = new FiraProtocolVersion(1, 1);
618         private FiraProtocolVersion mMaxMacVersionSupported = new FiraProtocolVersion(1, 1);
619 
620         private List<Integer> mSupportedChannels = new ArrayList<>();
621 
622         private EnumSet<AoaCapabilityFlag> mAoaCapabilities =
623                 EnumSet.noneOf(AoaCapabilityFlag.class);
624 
625         // Controller-intiator, Cotrolee-responder are mandatory.
626         private EnumSet<DeviceRoleCapabilityFlag> mDeviceRoleCapabilities =
627                 EnumSet.of(
628                         DeviceRoleCapabilityFlag.HAS_CONTROLLER_INITIATOR_SUPPORT,
629                         DeviceRoleCapabilityFlag.HAS_CONTROLEE_RESPONDER_SUPPORT);
630 
631         // Enable/Disable ntf config is mandatory.
632         private EnumSet<RangeDataNtfConfigCapabilityFlag> mRangeDataNtfConfigCapabilities =
633                 EnumSet.noneOf(RangeDataNtfConfigCapabilityFlag.class);
634 
635         private boolean mHasBlockStridingSupport = false;
636 
637         private boolean mHasHoppingPreferenceSupport = false;
638 
639         private boolean mHasExtendedMacAddressSupport = false;
640 
641         private boolean mHasNonDeferredModeSupport = false;
642 
643         private boolean mHasInitiationTimeSupport = false;
644 
645         private boolean mHasRssiReportingSupport = false;
646 
647         private boolean mHasDiagnosticsSupport = false;
648 
649         private int mMinRangingInterval = -1;
650 
651         private int mMinSlotDurationUs = -1;
652 
653         private int mMaxRangingSessionNumber = DEFAULT_MAX_RANGING_SESSIONS_NUMBER;
654 
655         private String mCountryCode = null;
656 
657         private int mUciVersion = 1;
658 
659         // Unicast support is mandatory
660         private EnumSet<MultiNodeCapabilityFlag> mMultiNodeCapabilities =
661                 EnumSet.of(MultiNodeCapabilityFlag.HAS_UNICAST_SUPPORT);
662 
663         private EnumSet<RangingTimeStructCapabilitiesFlag> mRangingTimeStructCapabilities =
664                 EnumSet.of(
665                         RangingTimeStructCapabilitiesFlag.HAS_INTERVAL_BASED_SCHEDULING_SUPPORT,
666                         RangingTimeStructCapabilitiesFlag.HAS_BLOCK_BASED_SCHEDULING_SUPPORT);
667 
668         private EnumSet<SchedulingModeCapabilitiesFlag> mSchedulingModeCapabilities =
669                 EnumSet.of(
670                         SchedulingModeCapabilitiesFlag.HAS_CONTENTION_BASED_RANGING_SUPPORT,
671                         SchedulingModeCapabilitiesFlag.HAS_TIME_SCHEDULED_RANGING_SUPPORT,
672                         SchedulingModeCapabilitiesFlag.HAS_HYBRID_SCHEDULED_RANGING_SUPPORT);
673 
674         private EnumSet<CcConstraintLengthCapabilitiesFlag> mCcConstraintLengthCapabilities =
675                 EnumSet.of(
676                         CcConstraintLengthCapabilitiesFlag.HAS_CONSTRAINT_LENGTH_3_SUPPORT,
677                         CcConstraintLengthCapabilitiesFlag.HAS_CONSTRAINT_LENGTH_7_SUPPORT);
678 
679         // BPRF mode is mandatory
680         private EnumSet<PrfCapabilityFlag> mPrfCapabilities =
681                 EnumSet.of(PrfCapabilityFlag.HAS_BPRF_SUPPORT);
682 
683         // DS-TWR is mandatory
684         private EnumSet<RangingRoundCapabilityFlag> mRangingRoundCapabilities =
685                 EnumSet.of(RangingRoundCapabilityFlag.HAS_DS_TWR_SUPPORT);
686 
687         // SP3 RFrame is mandatory
688         private EnumSet<RframeCapabilityFlag> mRframeCapabilities =
689                 EnumSet.of(RframeCapabilityFlag.HAS_SP3_RFRAME_SUPPORT);
690 
691         // STATIC STS is mandatory
692         private EnumSet<StsCapabilityFlag> mStsCapabilities =
693                 EnumSet.of(StsCapabilityFlag.HAS_STATIC_STS_SUPPORT);
694 
695         // 6.81Mb/s PSDU data rate is mandatory
696         private EnumSet<PsduDataRateCapabilityFlag> mPsduDataRateCapabilities =
697                 EnumSet.of(PsduDataRateCapabilityFlag.HAS_6M81_SUPPORT);
698 
699         private EnumSet<BprfParameterSetCapabilityFlag> mBprfParameterSetCapabilities =
700                 EnumSet.noneOf(BprfParameterSetCapabilityFlag.class);
701 
702         private EnumSet<HprfParameterSetCapabilityFlag> mHprfParameterSetCapabilities =
703                 EnumSet.noneOf(HprfParameterSetCapabilityFlag.class);
704 
705         private Integer mMaxMessageSize = 0;
706 
707         private Integer mMaxDataPacketPayloadSize = 0;
708 
709         // Default to Controlee
710         private int mDeviceType = RANGING_DEVICE_TYPE_CONTROLEE;
711 
712         // Default to no suspend ranging support
713         private boolean mSuspendRangingSupport = false;
714 
715         // Default to 256 bits key length not supported
716         private int mSessionKeyLength = 0;
717 
718         //Default to 0 i.e., DT tag role not supported.
719         private int mDtTagMaxActiveRr = 0;
720 
721         //Default is false. i.e., no background ranging support.
722         private boolean mHasBackgroundRangingSupport = false;
723 
724         // DT_TAG_BLOCK_SKIPPING.
725         private boolean mHasDtTagBlockSkippingSupport = false;
726 
727         // PSDU_LENGTH_SUPPORT.
728         private boolean mHasPsduLengthSupport = false;
729 
setMinPhyVersionSupported( FiraProtocolVersion version)730         public FiraSpecificationParams.Builder setMinPhyVersionSupported(
731                 FiraProtocolVersion version) {
732             mMinPhyVersionSupported = version;
733             return this;
734         }
735 
setMaxPhyVersionSupported( FiraProtocolVersion version)736         public FiraSpecificationParams.Builder setMaxPhyVersionSupported(
737                 FiraProtocolVersion version) {
738             mMaxPhyVersionSupported = version;
739             return this;
740         }
741 
setMinMacVersionSupported( FiraProtocolVersion version)742         public FiraSpecificationParams.Builder setMinMacVersionSupported(
743                 FiraProtocolVersion version) {
744             mMinMacVersionSupported = version;
745             return this;
746         }
747 
setMaxMacVersionSupported( FiraProtocolVersion version)748         public FiraSpecificationParams.Builder setMaxMacVersionSupported(
749                 FiraProtocolVersion version) {
750             mMaxMacVersionSupported = version;
751             return this;
752         }
753 
setSupportedChannels( List<Integer> supportedChannels)754         public FiraSpecificationParams.Builder setSupportedChannels(
755                 List<Integer> supportedChannels) {
756             mSupportedChannels = List.copyOf(supportedChannels);
757             return this;
758         }
759 
setAoaCapabilities( Collection<AoaCapabilityFlag> aoaCapabilities)760         public FiraSpecificationParams.Builder setAoaCapabilities(
761                 Collection<AoaCapabilityFlag> aoaCapabilities) {
762             mAoaCapabilities.addAll(aoaCapabilities);
763             return this;
764         }
765 
setDeviceRoleCapabilities( Collection<DeviceRoleCapabilityFlag> deviceRoleCapabilities)766         public FiraSpecificationParams.Builder setDeviceRoleCapabilities(
767                 Collection<DeviceRoleCapabilityFlag> deviceRoleCapabilities) {
768             mDeviceRoleCapabilities.addAll(deviceRoleCapabilities);
769             return this;
770         }
771 
hasBlockStridingSupport(boolean value)772         public FiraSpecificationParams.Builder hasBlockStridingSupport(boolean value) {
773             mHasBlockStridingSupport = value;
774             return this;
775         }
776 
hasHoppingPreferenceSupport(boolean value)777         public FiraSpecificationParams.Builder hasHoppingPreferenceSupport(boolean value) {
778             mHasHoppingPreferenceSupport = value;
779             return this;
780         }
781 
hasExtendedMacAddressSupport(boolean value)782         public FiraSpecificationParams.Builder hasExtendedMacAddressSupport(boolean value) {
783             mHasExtendedMacAddressSupport = value;
784             return this;
785         }
786 
hasNonDeferredModeSupport(boolean value)787         public FiraSpecificationParams.Builder hasNonDeferredModeSupport(boolean value) {
788             mHasNonDeferredModeSupport = value;
789             return this;
790         }
791 
hasInitiationTimeSupport(boolean value)792         public FiraSpecificationParams.Builder hasInitiationTimeSupport(boolean value) {
793             mHasInitiationTimeSupport = value;
794             return this;
795         }
796 
797         /** Set whether rssi reporting is supported. */
hasRssiReportingSupport(boolean value)798         public FiraSpecificationParams.Builder hasRssiReportingSupport(boolean value) {
799             mHasRssiReportingSupport = value;
800             return this;
801         }
802 
803         /** Set whether diagnostics is supported. */
hasDiagnosticsSupport(boolean value)804         public FiraSpecificationParams.Builder hasDiagnosticsSupport(boolean value) {
805             mHasDiagnosticsSupport = value;
806             return this;
807         }
808 
809         /**
810          * Set minimum supported ranging interval
811          * @param value : minimum ranging interval supported
812          * @return FiraSpecificationParams builder
813          */
setMinRangingIntervalSupported(int value)814         public FiraSpecificationParams.Builder setMinRangingIntervalSupported(int value) {
815             mMinRangingInterval = value;
816             return this;
817         }
818 
819         /**
820          * Set minimum supported slot duration in microsecond
821          * @param value : minimum slot duration supported in microsecond
822          * @return FiraSpecificationParams builder
823          */
setMinSlotDurationSupportedUs(int value)824         public FiraSpecificationParams.Builder setMinSlotDurationSupportedUs(int value) {
825             mMinSlotDurationUs = value;
826             return this;
827         }
828 
829         /**
830          * Set maximum supported ranging session number
831          * @param value : maximum ranging session number supported
832          * @return FiraSpecificationParams builder
833          */
setMaxRangingSessionNumberSupported(int value)834         public FiraSpecificationParams.Builder setMaxRangingSessionNumberSupported(int value) {
835             mMaxRangingSessionNumber = value;
836             return this;
837         }
838 
setMultiNodeCapabilities( Collection<MultiNodeCapabilityFlag> multiNodeCapabilities)839         public FiraSpecificationParams.Builder setMultiNodeCapabilities(
840                 Collection<MultiNodeCapabilityFlag> multiNodeCapabilities) {
841             mMultiNodeCapabilities.addAll(multiNodeCapabilities);
842             return this;
843         }
844 
setRangingTimeStructCapabilities( Collection<RangingTimeStructCapabilitiesFlag> rangingTimeStructCapabilities)845         public FiraSpecificationParams.Builder setRangingTimeStructCapabilities(
846                 Collection<RangingTimeStructCapabilitiesFlag> rangingTimeStructCapabilities) {
847             mRangingTimeStructCapabilities.addAll(rangingTimeStructCapabilities);
848             return this;
849         }
850 
setSchedulingModeCapabilities( Collection<SchedulingModeCapabilitiesFlag> schedulingModeCapabilities)851         public FiraSpecificationParams.Builder setSchedulingModeCapabilities(
852                 Collection<SchedulingModeCapabilitiesFlag> schedulingModeCapabilities) {
853             mSchedulingModeCapabilities.addAll(schedulingModeCapabilities);
854             return this;
855         }
856 
setCcConstraintLengthCapabilities( Collection<CcConstraintLengthCapabilitiesFlag> ccConstraintLengthCapabilities)857         public FiraSpecificationParams.Builder setCcConstraintLengthCapabilities(
858                 Collection<CcConstraintLengthCapabilitiesFlag> ccConstraintLengthCapabilities) {
859             mCcConstraintLengthCapabilities.addAll(ccConstraintLengthCapabilities);
860             return this;
861         }
862 
setPrfCapabilities( Collection<PrfCapabilityFlag> prfCapabilities)863         public FiraSpecificationParams.Builder setPrfCapabilities(
864                 Collection<PrfCapabilityFlag> prfCapabilities) {
865             mPrfCapabilities.addAll(prfCapabilities);
866             return this;
867         }
868 
setRangingRoundCapabilities( Collection<RangingRoundCapabilityFlag> rangingRoundCapabilities)869         public FiraSpecificationParams.Builder setRangingRoundCapabilities(
870                 Collection<RangingRoundCapabilityFlag> rangingRoundCapabilities) {
871             mRangingRoundCapabilities.addAll(rangingRoundCapabilities);
872             return this;
873         }
874 
setRframeCapabilities( Collection<RframeCapabilityFlag> rframeCapabilities)875         public FiraSpecificationParams.Builder setRframeCapabilities(
876                 Collection<RframeCapabilityFlag> rframeCapabilities) {
877             mRframeCapabilities.addAll(rframeCapabilities);
878             return this;
879         }
880 
setStsCapabilities( Collection<StsCapabilityFlag> stsCapabilities)881         public FiraSpecificationParams.Builder setStsCapabilities(
882                 Collection<StsCapabilityFlag> stsCapabilities) {
883             mStsCapabilities.addAll(stsCapabilities);
884             return this;
885         }
886 
setPsduDataRateCapabilities( Collection<PsduDataRateCapabilityFlag> psduDataRateCapabilities)887         public FiraSpecificationParams.Builder setPsduDataRateCapabilities(
888                 Collection<PsduDataRateCapabilityFlag> psduDataRateCapabilities) {
889             mPsduDataRateCapabilities.addAll(psduDataRateCapabilities);
890             return this;
891         }
892 
setBprfParameterSetCapabilities( Collection<BprfParameterSetCapabilityFlag> bprfParameterSetCapabilities)893         public FiraSpecificationParams.Builder setBprfParameterSetCapabilities(
894                 Collection<BprfParameterSetCapabilityFlag> bprfParameterSetCapabilities) {
895             mBprfParameterSetCapabilities.addAll(bprfParameterSetCapabilities);
896             return this;
897         }
898 
setHprfParameterSetCapabilities( Collection<HprfParameterSetCapabilityFlag> hprfParameterSetCapabilities)899         public FiraSpecificationParams.Builder setHprfParameterSetCapabilities(
900                 Collection<HprfParameterSetCapabilityFlag> hprfParameterSetCapabilities) {
901             mHprfParameterSetCapabilities.addAll(hprfParameterSetCapabilities);
902             return this;
903         }
904 
setRangeDataNtfConfigCapabilities( Collection<RangeDataNtfConfigCapabilityFlag> rangeDataNtfConfigCapabilities)905         public FiraSpecificationParams.Builder setRangeDataNtfConfigCapabilities(
906                 Collection<RangeDataNtfConfigCapabilityFlag> rangeDataNtfConfigCapabilities) {
907             mRangeDataNtfConfigCapabilities.addAll(rangeDataNtfConfigCapabilities);
908             return this;
909         }
910 
setMaxMessageSize(Integer value)911         public FiraSpecificationParams.Builder setMaxMessageSize(Integer value) {
912             mMaxMessageSize = value;
913             return this;
914         }
915 
setMaxDataPacketPayloadSize(Integer value)916         public FiraSpecificationParams.Builder setMaxDataPacketPayloadSize(Integer value) {
917             mMaxDataPacketPayloadSize = value;
918             return this;
919         }
920 
setDeviceType(Integer value)921         public FiraSpecificationParams.Builder setDeviceType(Integer value) {
922             mDeviceType = value;
923             return this;
924 
925         }
926 
setSuspendRangingSupport(Boolean value)927         public FiraSpecificationParams.Builder setSuspendRangingSupport(Boolean value) {
928             mSuspendRangingSupport = value;
929             return this;
930         }
931 
setSessionKeyLength(Integer value)932         public FiraSpecificationParams.Builder setSessionKeyLength(Integer value) {
933             mSessionKeyLength = value;
934             return this;
935         }
936 
setDtTagMaxActiveRr(int value)937         public FiraSpecificationParams.Builder setDtTagMaxActiveRr(int value) {
938             mDtTagMaxActiveRr = value;
939             return this;
940         }
941 
setBackgroundRangingSupport(boolean value)942         public FiraSpecificationParams.Builder setBackgroundRangingSupport(boolean value) {
943             mHasBackgroundRangingSupport = value;
944             return this;
945         }
946 
setDtTagBlockSkippingSupport(boolean value)947         public FiraSpecificationParams.Builder setDtTagBlockSkippingSupport(boolean value) {
948             mHasDtTagBlockSkippingSupport = value;
949             return this;
950         }
951 
setPsduLengthSupport(boolean value)952         public FiraSpecificationParams.Builder setPsduLengthSupport(boolean value) {
953             mHasPsduLengthSupport = value;
954             return this;
955         }
956 
setCountryCode(String value)957         public FiraSpecificationParams.Builder setCountryCode(String value) {
958             mCountryCode = value;
959             return this;
960         }
961 
setUciVersionSupported( int uciVersion)962         public FiraSpecificationParams.Builder setUciVersionSupported(
963                 int uciVersion) {
964             mUciVersion = uciVersion;
965             return this;
966         }
967 
Builder()968         public Builder() {}
969 
Builder(@onNull FiraSpecificationParams params)970         public Builder(@NonNull FiraSpecificationParams params) {
971             mMinPhyVersionSupported = params.mMinPhyVersionSupported;
972             mMaxPhyVersionSupported = params.mMaxPhyVersionSupported;
973             mMinMacVersionSupported = params.mMinMacVersionSupported;
974             mMaxMacVersionSupported = params.mMaxMacVersionSupported;
975             mSupportedChannels = params.mSupportedChannels;
976             mAoaCapabilities = params.mAoaCapabilities;
977             mDeviceRoleCapabilities = params.mDeviceRoleCapabilities;
978             mHasBlockStridingSupport = params.mHasBlockStridingSupport;
979             mHasHoppingPreferenceSupport = params.mHasHoppingPreferenceSupport;
980             mHasExtendedMacAddressSupport = params.mHasExtendedMacAddressSupport;
981             mHasNonDeferredModeSupport = params.mHasNonDeferredModeSupport;
982             mHasInitiationTimeSupport = params.mHasInitiationTimeSupport;
983             mHasRssiReportingSupport = params.mHasRssiReportingSupport;
984             mHasDiagnosticsSupport = params.mHasDiagnosticsSupport;
985             mMinRangingInterval = params.mMinRangingInterval;
986             mMinSlotDurationUs = params.mMinSlotDurationUs;
987             mMaxRangingSessionNumber = params.mMaxRangingSessionNumber;
988             mMultiNodeCapabilities = params.mMultiNodeCapabilities;
989             mRangingTimeStructCapabilities = params.mRangingTimeStructCapabilities;
990             mSchedulingModeCapabilities = params.mSchedulingModeCapabilities;
991             mCcConstraintLengthCapabilities = params.mCcConstraintLengthCapabilities;
992             mPrfCapabilities = params.mPrfCapabilities;
993             mRangingRoundCapabilities = params.mRangingRoundCapabilities;
994             mRframeCapabilities = params.mRframeCapabilities;
995             mStsCapabilities = params.mStsCapabilities;
996             mPsduDataRateCapabilities = params.mPsduDataRateCapabilities;
997             mBprfParameterSetCapabilities = params.mBprfParameterSetCapabilities;
998             mHprfParameterSetCapabilities = params.mHprfParameterSetCapabilities;
999             mMaxMessageSize = params.mMaxMessageSize;
1000             mMaxDataPacketPayloadSize = params.mMaxDataPacketPayloadSize;
1001             mRangeDataNtfConfigCapabilities = params.mRangeDataNtfConfigCapabilities;
1002             mDeviceType = params.mDeviceType;
1003             mSuspendRangingSupport = params.mSuspendRangingSupport;
1004             mSessionKeyLength = params.mSessionKeyLength;
1005             mDtTagMaxActiveRr = params.mDtTagMaxActiveRr;
1006             mHasBackgroundRangingSupport = params.mHasBackgroundRangingSupport;
1007             mHasDtTagBlockSkippingSupport = params.mHasDtTagBlockSkippingSupport;
1008             mHasPsduLengthSupport = params.mHasPsduLengthSupport;
1009             mCountryCode = params.mCountryCode;
1010         }
1011 
build()1012         public FiraSpecificationParams build() {
1013             return new FiraSpecificationParams(
1014                     mMinPhyVersionSupported,
1015                     mMaxPhyVersionSupported,
1016                     mMinMacVersionSupported,
1017                     mMaxMacVersionSupported,
1018                     mSupportedChannels,
1019                     mAoaCapabilities,
1020                     mDeviceRoleCapabilities,
1021                     mHasBlockStridingSupport,
1022                     mHasHoppingPreferenceSupport,
1023                     mHasExtendedMacAddressSupport,
1024                     mHasNonDeferredModeSupport,
1025                     mHasInitiationTimeSupport,
1026                     mHasRssiReportingSupport,
1027                     mHasDiagnosticsSupport,
1028                     mMinRangingInterval,
1029                     mMinSlotDurationUs,
1030                     mMaxRangingSessionNumber,
1031                     mMultiNodeCapabilities,
1032                     mRangingTimeStructCapabilities,
1033                     mSchedulingModeCapabilities,
1034                     mCcConstraintLengthCapabilities,
1035                     mPrfCapabilities,
1036                     mRangingRoundCapabilities,
1037                     mRframeCapabilities,
1038                     mStsCapabilities,
1039                     mPsduDataRateCapabilities,
1040                     mBprfParameterSetCapabilities,
1041                     mHprfParameterSetCapabilities,
1042                     mMaxMessageSize,
1043                     mMaxDataPacketPayloadSize,
1044                     mRangeDataNtfConfigCapabilities,
1045                     mDeviceType,
1046                     mSuspendRangingSupport,
1047                     mSessionKeyLength,
1048                     mDtTagMaxActiveRr,
1049                     mHasBackgroundRangingSupport,
1050                     mHasDtTagBlockSkippingSupport,
1051                     mHasPsduLengthSupport,
1052                     mCountryCode,
1053                     mUciVersion);
1054         }
1055     }
1056 }
1057