wifi

package
v0.0.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 22, 2026 License: CC0-1.0 Imports: 5 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	TransactionIWifiGetChip               = binder.FirstCallTransaction + 0
	TransactionIWifiGetChipIds            = binder.FirstCallTransaction + 1
	TransactionIWifiIsStarted             = binder.FirstCallTransaction + 2
	TransactionIWifiRegisterEventCallback = binder.FirstCallTransaction + 3
	TransactionIWifiStart                 = binder.FirstCallTransaction + 4
	TransactionIWifiStop                  = binder.FirstCallTransaction + 5
)
View Source 
const (
	MethodIWifiGetChip               = "getChip"
	MethodIWifiGetChipIds            = "getChipIds"
	MethodIWifiIsStarted             = "isStarted"
	MethodIWifiRegisterEventCallback = "registerEventCallback"
	MethodIWifiStart                 = "start"
	MethodIWifiStop                  = "stop"
)
View Source 
const (
	TransactionIWifiApIfaceGetName                  = binder.FirstCallTransaction + 0
	TransactionIWifiApIfaceGetBridgedInstances      = binder.FirstCallTransaction + 1
	TransactionIWifiApIfaceGetFactoryMacAddress     = binder.FirstCallTransaction + 2
	TransactionIWifiApIfaceSetCountryCode           = binder.FirstCallTransaction + 3
	TransactionIWifiApIfaceResetToFactoryMacAddress = binder.FirstCallTransaction + 4
	TransactionIWifiApIfaceSetMacAddress            = binder.FirstCallTransaction + 5
)
View Source 
const (
	MethodIWifiApIfaceGetName                  = "getName"
	MethodIWifiApIfaceGetBridgedInstances      = "getBridgedInstances"
	MethodIWifiApIfaceGetFactoryMacAddress     = "getFactoryMacAddress"
	MethodIWifiApIfaceSetCountryCode           = "setCountryCode"
	MethodIWifiApIfaceResetToFactoryMacAddress = "resetToFactoryMacAddress"
	MethodIWifiApIfaceSetMacAddress            = "setMacAddress"
)
View Source 
const (
	TransactionIWifiChipConfigureChip                         = binder.FirstCallTransaction + 0
	TransactionIWifiChipCreateApIface                         = binder.FirstCallTransaction + 1
	TransactionIWifiChipCreateBridgedApIface                  = binder.FirstCallTransaction + 2
	TransactionIWifiChipCreateNanIface                        = binder.FirstCallTransaction + 3
	TransactionIWifiChipCreateP2pIface                        = binder.FirstCallTransaction + 4
	TransactionIWifiChipCreateRttController                   = binder.FirstCallTransaction + 5
	TransactionIWifiChipCreateStaIface                        = binder.FirstCallTransaction + 6
	TransactionIWifiChipEnableDebugErrorAlerts                = binder.FirstCallTransaction + 7
	TransactionIWifiChipFlushRingBufferToFile                 = binder.FirstCallTransaction + 8
	TransactionIWifiChipForceDumpToDebugRingBuffer            = binder.FirstCallTransaction + 9
	TransactionIWifiChipGetApIface                            = binder.FirstCallTransaction + 10
	TransactionIWifiChipGetApIfaceNames                       = binder.FirstCallTransaction + 11
	TransactionIWifiChipGetAvailableModes                     = binder.FirstCallTransaction + 12
	TransactionIWifiChipGetFeatureSet                         = binder.FirstCallTransaction + 13
	TransactionIWifiChipGetDebugHostWakeReasonStats           = binder.FirstCallTransaction + 14
	TransactionIWifiChipGetDebugRingBuffersStatus             = binder.FirstCallTransaction + 15
	TransactionIWifiChipGetId                                 = binder.FirstCallTransaction + 16
	TransactionIWifiChipGetMode                               = binder.FirstCallTransaction + 17
	TransactionIWifiChipGetNanIface                           = binder.FirstCallTransaction + 18
	TransactionIWifiChipGetNanIfaceNames                      = binder.FirstCallTransaction + 19
	TransactionIWifiChipGetP2pIface                           = binder.FirstCallTransaction + 20
	TransactionIWifiChipGetP2pIfaceNames                      = binder.FirstCallTransaction + 21
	TransactionIWifiChipGetStaIface                           = binder.FirstCallTransaction + 22
	TransactionIWifiChipGetStaIfaceNames                      = binder.FirstCallTransaction + 23
	TransactionIWifiChipGetSupportedRadioCombinations         = binder.FirstCallTransaction + 24
	TransactionIWifiChipGetWifiChipCapabilities               = binder.FirstCallTransaction + 25
	TransactionIWifiChipGetUsableChannels                     = binder.FirstCallTransaction + 26
	TransactionIWifiChipSetAfcChannelAllowance                = binder.FirstCallTransaction + 27
	TransactionIWifiChipRegisterEventCallback                 = binder.FirstCallTransaction + 28
	TransactionIWifiChipRemoveApIface                         = binder.FirstCallTransaction + 29
	TransactionIWifiChipRemoveIfaceInstanceFromBridgedApIface = binder.FirstCallTransaction + 30
	TransactionIWifiChipRemoveNanIface                        = binder.FirstCallTransaction + 31
	TransactionIWifiChipRemoveP2pIface                        = binder.FirstCallTransaction + 32
	TransactionIWifiChipRemoveStaIface                        = binder.FirstCallTransaction + 33
	TransactionIWifiChipRequestChipDebugInfo                  = binder.FirstCallTransaction + 34
	TransactionIWifiChipRequestDriverDebugDump                = binder.FirstCallTransaction + 35
	TransactionIWifiChipRequestFirmwareDebugDump              = binder.FirstCallTransaction + 36
	TransactionIWifiChipResetTxPowerScenario                  = binder.FirstCallTransaction + 37
	TransactionIWifiChipSelectTxPowerScenario                 = binder.FirstCallTransaction + 38
	TransactionIWifiChipSetCoexUnsafeChannels                 = binder.FirstCallTransaction + 39
	TransactionIWifiChipSetCountryCode                        = binder.FirstCallTransaction + 40
	TransactionIWifiChipSetLatencyMode                        = binder.FirstCallTransaction + 41
	TransactionIWifiChipSetMultiStaPrimaryConnection          = binder.FirstCallTransaction + 42
	TransactionIWifiChipSetMultiStaUseCase                    = binder.FirstCallTransaction + 43
	TransactionIWifiChipStartLoggingToDebugRingBuffer         = binder.FirstCallTransaction + 44
	TransactionIWifiChipStopLoggingToDebugRingBuffer          = binder.FirstCallTransaction + 45
	TransactionIWifiChipTriggerSubsystemRestart               = binder.FirstCallTransaction + 46
	TransactionIWifiChipEnableStaChannelForPeerNetwork        = binder.FirstCallTransaction + 47
	TransactionIWifiChipSetMloMode                            = binder.FirstCallTransaction + 48
	TransactionIWifiChipCreateApOrBridgedApIface              = binder.FirstCallTransaction + 49
	TransactionIWifiChipSetVoipMode                           = binder.FirstCallTransaction + 50
)
View Source 
const (
	MethodIWifiChipConfigureChip                         = "configureChip"
	MethodIWifiChipCreateApIface                         = "createApIface"
	MethodIWifiChipCreateBridgedApIface                  = "createBridgedApIface"
	MethodIWifiChipCreateNanIface                        = "createNanIface"
	MethodIWifiChipCreateP2pIface                        = "createP2pIface"
	MethodIWifiChipCreateRttController                   = "createRttController"
	MethodIWifiChipCreateStaIface                        = "createStaIface"
	MethodIWifiChipEnableDebugErrorAlerts                = "enableDebugErrorAlerts"
	MethodIWifiChipFlushRingBufferToFile                 = "flushRingBufferToFile"
	MethodIWifiChipForceDumpToDebugRingBuffer            = "forceDumpToDebugRingBuffer"
	MethodIWifiChipGetApIface                            = "getApIface"
	MethodIWifiChipGetApIfaceNames                       = "getApIfaceNames"
	MethodIWifiChipGetAvailableModes                     = "getAvailableModes"
	MethodIWifiChipGetFeatureSet                         = "getFeatureSet"
	MethodIWifiChipGetDebugHostWakeReasonStats           = "getDebugHostWakeReasonStats"
	MethodIWifiChipGetDebugRingBuffersStatus             = "getDebugRingBuffersStatus"
	MethodIWifiChipGetId                                 = "getId"
	MethodIWifiChipGetMode                               = "getMode"
	MethodIWifiChipGetNanIface                           = "getNanIface"
	MethodIWifiChipGetNanIfaceNames                      = "getNanIfaceNames"
	MethodIWifiChipGetP2pIface                           = "getP2pIface"
	MethodIWifiChipGetP2pIfaceNames                      = "getP2pIfaceNames"
	MethodIWifiChipGetStaIface                           = "getStaIface"
	MethodIWifiChipGetStaIfaceNames                      = "getStaIfaceNames"
	MethodIWifiChipGetSupportedRadioCombinations         = "getSupportedRadioCombinations"
	MethodIWifiChipGetWifiChipCapabilities               = "getWifiChipCapabilities"
	MethodIWifiChipGetUsableChannels                     = "getUsableChannels"
	MethodIWifiChipSetAfcChannelAllowance                = "setAfcChannelAllowance"
	MethodIWifiChipRegisterEventCallback                 = "registerEventCallback"
	MethodIWifiChipRemoveApIface                         = "removeApIface"
	MethodIWifiChipRemoveIfaceInstanceFromBridgedApIface = "removeIfaceInstanceFromBridgedApIface"
	MethodIWifiChipRemoveNanIface                        = "removeNanIface"
	MethodIWifiChipRemoveP2pIface                        = "removeP2pIface"
	MethodIWifiChipRemoveStaIface                        = "removeStaIface"
	MethodIWifiChipRequestChipDebugInfo                  = "requestChipDebugInfo"
	MethodIWifiChipRequestDriverDebugDump                = "requestDriverDebugDump"
	MethodIWifiChipRequestFirmwareDebugDump              = "requestFirmwareDebugDump"
	MethodIWifiChipResetTxPowerScenario                  = "resetTxPowerScenario"
	MethodIWifiChipSelectTxPowerScenario                 = "selectTxPowerScenario"
	MethodIWifiChipSetCoexUnsafeChannels                 = "setCoexUnsafeChannels"
	MethodIWifiChipSetCountryCode                        = "setCountryCode"
	MethodIWifiChipSetLatencyMode                        = "setLatencyMode"
	MethodIWifiChipSetMultiStaPrimaryConnection          = "setMultiStaPrimaryConnection"
	MethodIWifiChipSetMultiStaUseCase                    = "setMultiStaUseCase"
	MethodIWifiChipStartLoggingToDebugRingBuffer         = "startLoggingToDebugRingBuffer"
	MethodIWifiChipStopLoggingToDebugRingBuffer          = "stopLoggingToDebugRingBuffer"
	MethodIWifiChipTriggerSubsystemRestart               = "triggerSubsystemRestart"
	MethodIWifiChipEnableStaChannelForPeerNetwork        = "enableStaChannelForPeerNetwork"
	MethodIWifiChipSetMloMode                            = "setMloMode"
	MethodIWifiChipCreateApOrBridgedApIface              = "createApOrBridgedApIface"
	MethodIWifiChipSetVoipMode                           = "setVoipMode"
)
View Source 
const (
	TransactionIWifiChipEventCallbackOnChipReconfigureFailure       = binder.FirstCallTransaction + 0
	TransactionIWifiChipEventCallbackOnChipReconfigured             = binder.FirstCallTransaction + 1
	TransactionIWifiChipEventCallbackOnDebugErrorAlert              = binder.FirstCallTransaction + 2
	TransactionIWifiChipEventCallbackOnDebugRingBufferDataAvailable = binder.FirstCallTransaction + 3
	TransactionIWifiChipEventCallbackOnIfaceAdded                   = binder.FirstCallTransaction + 4
	TransactionIWifiChipEventCallbackOnIfaceRemoved                 = binder.FirstCallTransaction + 5
	TransactionIWifiChipEventCallbackOnRadioModeChange              = binder.FirstCallTransaction + 6
)
View Source 
const (
	MethodIWifiChipEventCallbackOnChipReconfigureFailure       = "onChipReconfigureFailure"
	MethodIWifiChipEventCallbackOnChipReconfigured             = "onChipReconfigured"
	MethodIWifiChipEventCallbackOnDebugErrorAlert              = "onDebugErrorAlert"
	MethodIWifiChipEventCallbackOnDebugRingBufferDataAvailable = "onDebugRingBufferDataAvailable"
	MethodIWifiChipEventCallbackOnIfaceAdded                   = "onIfaceAdded"
	MethodIWifiChipEventCallbackOnIfaceRemoved                 = "onIfaceRemoved"
	MethodIWifiChipEventCallbackOnRadioModeChange              = "onRadioModeChange"
)
View Source 
const (
	TransactionIWifiEventCallbackOnFailure          = binder.FirstCallTransaction + 0
	TransactionIWifiEventCallbackOnStart            = binder.FirstCallTransaction + 1
	TransactionIWifiEventCallbackOnStop             = binder.FirstCallTransaction + 2
	TransactionIWifiEventCallbackOnSubsystemRestart = binder.FirstCallTransaction + 3
)
View Source 
const (
	MethodIWifiEventCallbackOnFailure          = "onFailure"
	MethodIWifiEventCallbackOnStart            = "onStart"
	MethodIWifiEventCallbackOnStop             = "onStop"
	MethodIWifiEventCallbackOnSubsystemRestart = "onSubsystemRestart"
)
View Source 
const (
	TransactionIWifiNanIfaceGetName                                 = binder.FirstCallTransaction + 0
	TransactionIWifiNanIfaceConfigRequest                           = binder.FirstCallTransaction + 1
	TransactionIWifiNanIfaceCreateDataInterfaceRequest              = binder.FirstCallTransaction + 2
	TransactionIWifiNanIfaceDeleteDataInterfaceRequest              = binder.FirstCallTransaction + 3
	TransactionIWifiNanIfaceDisableRequest                          = binder.FirstCallTransaction + 4
	TransactionIWifiNanIfaceEnableRequest                           = binder.FirstCallTransaction + 5
	TransactionIWifiNanIfaceGetCapabilitiesRequest                  = binder.FirstCallTransaction + 6
	TransactionIWifiNanIfaceInitiateDataPathRequest                 = binder.FirstCallTransaction + 7
	TransactionIWifiNanIfaceRegisterEventCallback                   = binder.FirstCallTransaction + 8
	TransactionIWifiNanIfaceRespondToDataPathIndicationRequest      = binder.FirstCallTransaction + 9
	TransactionIWifiNanIfaceStartPublishRequest                     = binder.FirstCallTransaction + 10
	TransactionIWifiNanIfaceStartSubscribeRequest                   = binder.FirstCallTransaction + 11
	TransactionIWifiNanIfaceStopPublishRequest                      = binder.FirstCallTransaction + 12
	TransactionIWifiNanIfaceStopSubscribeRequest                    = binder.FirstCallTransaction + 13
	TransactionIWifiNanIfaceTerminateDataPathRequest                = binder.FirstCallTransaction + 14
	TransactionIWifiNanIfaceSuspendRequest                          = binder.FirstCallTransaction + 15
	TransactionIWifiNanIfaceResumeRequest                           = binder.FirstCallTransaction + 16
	TransactionIWifiNanIfaceTransmitFollowupRequest                 = binder.FirstCallTransaction + 17
	TransactionIWifiNanIfaceInitiatePairingRequest                  = binder.FirstCallTransaction + 18
	TransactionIWifiNanIfaceRespondToPairingIndicationRequest       = binder.FirstCallTransaction + 19
	TransactionIWifiNanIfaceInitiateBootstrappingRequest            = binder.FirstCallTransaction + 20
	TransactionIWifiNanIfaceRespondToBootstrappingIndicationRequest = binder.FirstCallTransaction + 21
	TransactionIWifiNanIfaceTerminatePairingRequest                 = binder.FirstCallTransaction + 22
)
View Source 
const (
	MethodIWifiNanIfaceGetName                                 = "getName"
	MethodIWifiNanIfaceConfigRequest                           = "configRequest"
	MethodIWifiNanIfaceCreateDataInterfaceRequest              = "createDataInterfaceRequest"
	MethodIWifiNanIfaceDeleteDataInterfaceRequest              = "deleteDataInterfaceRequest"
	MethodIWifiNanIfaceDisableRequest                          = "disableRequest"
	MethodIWifiNanIfaceEnableRequest                           = "enableRequest"
	MethodIWifiNanIfaceGetCapabilitiesRequest                  = "getCapabilitiesRequest"
	MethodIWifiNanIfaceInitiateDataPathRequest                 = "initiateDataPathRequest"
	MethodIWifiNanIfaceRegisterEventCallback                   = "registerEventCallback"
	MethodIWifiNanIfaceRespondToDataPathIndicationRequest      = "respondToDataPathIndicationRequest"
	MethodIWifiNanIfaceStartPublishRequest                     = "startPublishRequest"
	MethodIWifiNanIfaceStartSubscribeRequest                   = "startSubscribeRequest"
	MethodIWifiNanIfaceStopPublishRequest                      = "stopPublishRequest"
	MethodIWifiNanIfaceStopSubscribeRequest                    = "stopSubscribeRequest"
	MethodIWifiNanIfaceTerminateDataPathRequest                = "terminateDataPathRequest"
	MethodIWifiNanIfaceSuspendRequest                          = "suspendRequest"
	MethodIWifiNanIfaceResumeRequest                           = "resumeRequest"
	MethodIWifiNanIfaceTransmitFollowupRequest                 = "transmitFollowupRequest"
	MethodIWifiNanIfaceInitiatePairingRequest                  = "initiatePairingRequest"
	MethodIWifiNanIfaceRespondToPairingIndicationRequest       = "respondToPairingIndicationRequest"
	MethodIWifiNanIfaceInitiateBootstrappingRequest            = "initiateBootstrappingRequest"
	MethodIWifiNanIfaceRespondToBootstrappingIndicationRequest = "respondToBootstrappingIndicationRequest"
	MethodIWifiNanIfaceTerminatePairingRequest                 = "terminatePairingRequest"
)
View Source 
const (
	IWifiNanIfaceMinDataPathConfigPassphraseLength int32 = 8
	IWifiNanIfaceMaxDataPathConfigPassphraseLength int32 = 63
)
View Source 
const (
	TransactionIWifiNanIfaceEventCallbackEventClusterEvent                              = binder.FirstCallTransaction + 0
	TransactionIWifiNanIfaceEventCallbackEventDataPathConfirm                           = binder.FirstCallTransaction + 1
	TransactionIWifiNanIfaceEventCallbackEventDataPathRequest                           = binder.FirstCallTransaction + 2
	TransactionIWifiNanIfaceEventCallbackEventDataPathScheduleUpdate                    = binder.FirstCallTransaction + 3
	TransactionIWifiNanIfaceEventCallbackEventDataPathTerminated                        = binder.FirstCallTransaction + 4
	TransactionIWifiNanIfaceEventCallbackEventDisabled                                  = binder.FirstCallTransaction + 5
	TransactionIWifiNanIfaceEventCallbackEventFollowupReceived                          = binder.FirstCallTransaction + 6
	TransactionIWifiNanIfaceEventCallbackEventMatch                                     = binder.FirstCallTransaction + 7
	TransactionIWifiNanIfaceEventCallbackEventMatchExpired                              = binder.FirstCallTransaction + 8
	TransactionIWifiNanIfaceEventCallbackEventPublishTerminated                         = binder.FirstCallTransaction + 9
	TransactionIWifiNanIfaceEventCallbackEventSubscribeTerminated                       = binder.FirstCallTransaction + 10
	TransactionIWifiNanIfaceEventCallbackEventTransmitFollowup                          = binder.FirstCallTransaction + 11
	TransactionIWifiNanIfaceEventCallbackEventSuspensionModeChanged                     = binder.FirstCallTransaction + 12
	TransactionIWifiNanIfaceEventCallbackNotifyCapabilitiesResponse                     = binder.FirstCallTransaction + 13
	TransactionIWifiNanIfaceEventCallbackNotifyConfigResponse                           = binder.FirstCallTransaction + 14
	TransactionIWifiNanIfaceEventCallbackNotifyCreateDataInterfaceResponse              = binder.FirstCallTransaction + 15
	TransactionIWifiNanIfaceEventCallbackNotifyDeleteDataInterfaceResponse              = binder.FirstCallTransaction + 16
	TransactionIWifiNanIfaceEventCallbackNotifyDisableResponse                          = binder.FirstCallTransaction + 17
	TransactionIWifiNanIfaceEventCallbackNotifyEnableResponse                           = binder.FirstCallTransaction + 18
	TransactionIWifiNanIfaceEventCallbackNotifyInitiateDataPathResponse                 = binder.FirstCallTransaction + 19
	TransactionIWifiNanIfaceEventCallbackNotifyRespondToDataPathIndicationResponse      = binder.FirstCallTransaction + 20
	TransactionIWifiNanIfaceEventCallbackNotifyStartPublishResponse                     = binder.FirstCallTransaction + 21
	TransactionIWifiNanIfaceEventCallbackNotifyStartSubscribeResponse                   = binder.FirstCallTransaction + 22
	TransactionIWifiNanIfaceEventCallbackNotifyStopPublishResponse                      = binder.FirstCallTransaction + 23
	TransactionIWifiNanIfaceEventCallbackNotifyStopSubscribeResponse                    = binder.FirstCallTransaction + 24
	TransactionIWifiNanIfaceEventCallbackNotifyTerminateDataPathResponse                = binder.FirstCallTransaction + 25
	TransactionIWifiNanIfaceEventCallbackNotifySuspendResponse                          = binder.FirstCallTransaction + 26
	TransactionIWifiNanIfaceEventCallbackNotifyResumeResponse                           = binder.FirstCallTransaction + 27
	TransactionIWifiNanIfaceEventCallbackNotifyTransmitFollowupResponse                 = binder.FirstCallTransaction + 28
	TransactionIWifiNanIfaceEventCallbackEventPairingRequest                            = binder.FirstCallTransaction + 29
	TransactionIWifiNanIfaceEventCallbackEventPairingConfirm                            = binder.FirstCallTransaction + 30
	TransactionIWifiNanIfaceEventCallbackNotifyInitiatePairingResponse                  = binder.FirstCallTransaction + 31
	TransactionIWifiNanIfaceEventCallbackNotifyRespondToPairingIndicationResponse       = binder.FirstCallTransaction + 32
	TransactionIWifiNanIfaceEventCallbackEventBootstrappingRequest                      = binder.FirstCallTransaction + 33
	TransactionIWifiNanIfaceEventCallbackEventBootstrappingConfirm                      = binder.FirstCallTransaction + 34
	TransactionIWifiNanIfaceEventCallbackNotifyInitiateBootstrappingResponse            = binder.FirstCallTransaction + 35
	TransactionIWifiNanIfaceEventCallbackNotifyRespondToBootstrappingIndicationResponse = binder.FirstCallTransaction + 36
	TransactionIWifiNanIfaceEventCallbackNotifyTerminatePairingResponse                 = binder.FirstCallTransaction + 37
)
View Source 
const (
	MethodIWifiNanIfaceEventCallbackEventClusterEvent                              = "eventClusterEvent"
	MethodIWifiNanIfaceEventCallbackEventDataPathConfirm                           = "eventDataPathConfirm"
	MethodIWifiNanIfaceEventCallbackEventDataPathRequest                           = "eventDataPathRequest"
	MethodIWifiNanIfaceEventCallbackEventDataPathScheduleUpdate                    = "eventDataPathScheduleUpdate"
	MethodIWifiNanIfaceEventCallbackEventDataPathTerminated                        = "eventDataPathTerminated"
	MethodIWifiNanIfaceEventCallbackEventDisabled                                  = "eventDisabled"
	MethodIWifiNanIfaceEventCallbackEventFollowupReceived                          = "eventFollowupReceived"
	MethodIWifiNanIfaceEventCallbackEventMatch                                     = "eventMatch"
	MethodIWifiNanIfaceEventCallbackEventMatchExpired                              = "eventMatchExpired"
	MethodIWifiNanIfaceEventCallbackEventPublishTerminated                         = "eventPublishTerminated"
	MethodIWifiNanIfaceEventCallbackEventSubscribeTerminated                       = "eventSubscribeTerminated"
	MethodIWifiNanIfaceEventCallbackEventTransmitFollowup                          = "eventTransmitFollowup"
	MethodIWifiNanIfaceEventCallbackEventSuspensionModeChanged                     = "eventSuspensionModeChanged"
	MethodIWifiNanIfaceEventCallbackNotifyCapabilitiesResponse                     = "notifyCapabilitiesResponse"
	MethodIWifiNanIfaceEventCallbackNotifyConfigResponse                           = "notifyConfigResponse"
	MethodIWifiNanIfaceEventCallbackNotifyCreateDataInterfaceResponse              = "notifyCreateDataInterfaceResponse"
	MethodIWifiNanIfaceEventCallbackNotifyDeleteDataInterfaceResponse              = "notifyDeleteDataInterfaceResponse"
	MethodIWifiNanIfaceEventCallbackNotifyDisableResponse                          = "notifyDisableResponse"
	MethodIWifiNanIfaceEventCallbackNotifyEnableResponse                           = "notifyEnableResponse"
	MethodIWifiNanIfaceEventCallbackNotifyInitiateDataPathResponse                 = "notifyInitiateDataPathResponse"
	MethodIWifiNanIfaceEventCallbackNotifyRespondToDataPathIndicationResponse      = "notifyRespondToDataPathIndicationResponse"
	MethodIWifiNanIfaceEventCallbackNotifyStartPublishResponse                     = "notifyStartPublishResponse"
	MethodIWifiNanIfaceEventCallbackNotifyStartSubscribeResponse                   = "notifyStartSubscribeResponse"
	MethodIWifiNanIfaceEventCallbackNotifyStopPublishResponse                      = "notifyStopPublishResponse"
	MethodIWifiNanIfaceEventCallbackNotifyStopSubscribeResponse                    = "notifyStopSubscribeResponse"
	MethodIWifiNanIfaceEventCallbackNotifyTerminateDataPathResponse                = "notifyTerminateDataPathResponse"
	MethodIWifiNanIfaceEventCallbackNotifySuspendResponse                          = "notifySuspendResponse"
	MethodIWifiNanIfaceEventCallbackNotifyResumeResponse                           = "notifyResumeResponse"
	MethodIWifiNanIfaceEventCallbackNotifyTransmitFollowupResponse                 = "notifyTransmitFollowupResponse"
	MethodIWifiNanIfaceEventCallbackEventPairingRequest                            = "eventPairingRequest"
	MethodIWifiNanIfaceEventCallbackEventPairingConfirm                            = "eventPairingConfirm"
	MethodIWifiNanIfaceEventCallbackNotifyInitiatePairingResponse                  = "notifyInitiatePairingResponse"
	MethodIWifiNanIfaceEventCallbackNotifyRespondToPairingIndicationResponse       = "notifyRespondToPairingIndicationResponse"
	MethodIWifiNanIfaceEventCallbackEventBootstrappingRequest                      = "eventBootstrappingRequest"
	MethodIWifiNanIfaceEventCallbackEventBootstrappingConfirm                      = "eventBootstrappingConfirm"
	MethodIWifiNanIfaceEventCallbackNotifyInitiateBootstrappingResponse            = "notifyInitiateBootstrappingResponse"
	MethodIWifiNanIfaceEventCallbackNotifyRespondToBootstrappingIndicationResponse = "notifyRespondToBootstrappingIndicationResponse"
	MethodIWifiNanIfaceEventCallbackNotifyTerminatePairingResponse                 = "notifyTerminatePairingResponse"
)
View Source 
const (
	TransactionIWifiRttControllerDisableResponder      = binder.FirstCallTransaction + 0
	TransactionIWifiRttControllerEnableResponder       = binder.FirstCallTransaction + 1
	TransactionIWifiRttControllerGetBoundIface         = binder.FirstCallTransaction + 2
	TransactionIWifiRttControllerGetCapabilities       = binder.FirstCallTransaction + 3
	TransactionIWifiRttControllerGetResponderInfo      = binder.FirstCallTransaction + 4
	TransactionIWifiRttControllerRangeCancel           = binder.FirstCallTransaction + 5
	TransactionIWifiRttControllerRangeRequest          = binder.FirstCallTransaction + 6
	TransactionIWifiRttControllerRegisterEventCallback = binder.FirstCallTransaction + 7
	TransactionIWifiRttControllerSetLci                = binder.FirstCallTransaction + 8
	TransactionIWifiRttControllerSetLcr                = binder.FirstCallTransaction + 9
)
View Source 
const (
	MethodIWifiRttControllerDisableResponder      = "disableResponder"
	MethodIWifiRttControllerEnableResponder       = "enableResponder"
	MethodIWifiRttControllerGetBoundIface         = "getBoundIface"
	MethodIWifiRttControllerGetCapabilities       = "getCapabilities"
	MethodIWifiRttControllerGetResponderInfo      = "getResponderInfo"
	MethodIWifiRttControllerRangeCancel           = "rangeCancel"
	MethodIWifiRttControllerRangeRequest          = "rangeRequest"
	MethodIWifiRttControllerRegisterEventCallback = "registerEventCallback"
	MethodIWifiRttControllerSetLci                = "setLci"
	MethodIWifiRttControllerSetLcr                = "setLcr"
)
View Source 
const (
	TransactionIWifiStaIfaceGetName                         = binder.FirstCallTransaction + 0
	TransactionIWifiStaIfaceConfigureRoaming                = binder.FirstCallTransaction + 1
	TransactionIWifiStaIfaceDisableLinkLayerStatsCollection = binder.FirstCallTransaction + 2
	TransactionIWifiStaIfaceEnableLinkLayerStatsCollection  = binder.FirstCallTransaction + 3
	TransactionIWifiStaIfaceEnableNdOffload                 = binder.FirstCallTransaction + 4
	TransactionIWifiStaIfaceGetApfPacketFilterCapabilities  = binder.FirstCallTransaction + 5
	TransactionIWifiStaIfaceGetBackgroundScanCapabilities   = binder.FirstCallTransaction + 6
	TransactionIWifiStaIfaceGetFeatureSet                   = binder.FirstCallTransaction + 7
	TransactionIWifiStaIfaceGetDebugRxPacketFates           = binder.FirstCallTransaction + 8
	TransactionIWifiStaIfaceGetDebugTxPacketFates           = binder.FirstCallTransaction + 9
	TransactionIWifiStaIfaceGetFactoryMacAddress            = binder.FirstCallTransaction + 10
	TransactionIWifiStaIfaceGetLinkLayerStats               = binder.FirstCallTransaction + 11
	TransactionIWifiStaIfaceGetRoamingCapabilities          = binder.FirstCallTransaction + 12
	TransactionIWifiStaIfaceInstallApfPacketFilter          = binder.FirstCallTransaction + 13
	TransactionIWifiStaIfaceReadApfPacketFilterData         = binder.FirstCallTransaction + 14
	TransactionIWifiStaIfaceRegisterEventCallback           = binder.FirstCallTransaction + 15
	TransactionIWifiStaIfaceSetMacAddress                   = binder.FirstCallTransaction + 16
	TransactionIWifiStaIfaceSetRoamingState                 = binder.FirstCallTransaction + 17
	TransactionIWifiStaIfaceSetScanMode                     = binder.FirstCallTransaction + 18
	TransactionIWifiStaIfaceStartBackgroundScan             = binder.FirstCallTransaction + 19
	TransactionIWifiStaIfaceStartDebugPacketFateMonitoring  = binder.FirstCallTransaction + 20
	TransactionIWifiStaIfaceStartRssiMonitoring             = binder.FirstCallTransaction + 21
	TransactionIWifiStaIfaceStartSendingKeepAlivePackets    = binder.FirstCallTransaction + 22
	TransactionIWifiStaIfaceStopBackgroundScan              = binder.FirstCallTransaction + 23
	TransactionIWifiStaIfaceStopRssiMonitoring              = binder.FirstCallTransaction + 24
	TransactionIWifiStaIfaceStopSendingKeepAlivePackets     = binder.FirstCallTransaction + 25
	TransactionIWifiStaIfaceSetDtimMultiplier               = binder.FirstCallTransaction + 26
	TransactionIWifiStaIfaceGetCachedScanData               = binder.FirstCallTransaction + 27
	TransactionIWifiStaIfaceTwtGetCapabilities              = binder.FirstCallTransaction + 28
	TransactionIWifiStaIfaceTwtSessionSetup                 = binder.FirstCallTransaction + 29
	TransactionIWifiStaIfaceTwtSessionUpdate                = binder.FirstCallTransaction + 30
	TransactionIWifiStaIfaceTwtSessionSuspend               = binder.FirstCallTransaction + 31
	TransactionIWifiStaIfaceTwtSessionResume                = binder.FirstCallTransaction + 32
	TransactionIWifiStaIfaceTwtSessionTeardown              = binder.FirstCallTransaction + 33
	TransactionIWifiStaIfaceTwtSessionGetStats              = binder.FirstCallTransaction + 34
)
View Source 
const (
	MethodIWifiStaIfaceGetName                         = "getName"
	MethodIWifiStaIfaceConfigureRoaming                = "configureRoaming"
	MethodIWifiStaIfaceDisableLinkLayerStatsCollection = "disableLinkLayerStatsCollection"
	MethodIWifiStaIfaceEnableLinkLayerStatsCollection  = "enableLinkLayerStatsCollection"
	MethodIWifiStaIfaceEnableNdOffload                 = "enableNdOffload"
	MethodIWifiStaIfaceGetApfPacketFilterCapabilities  = "getApfPacketFilterCapabilities"
	MethodIWifiStaIfaceGetBackgroundScanCapabilities   = "getBackgroundScanCapabilities"
	MethodIWifiStaIfaceGetFeatureSet                   = "getFeatureSet"
	MethodIWifiStaIfaceGetDebugRxPacketFates           = "getDebugRxPacketFates"
	MethodIWifiStaIfaceGetDebugTxPacketFates           = "getDebugTxPacketFates"
	MethodIWifiStaIfaceGetFactoryMacAddress            = "getFactoryMacAddress"
	MethodIWifiStaIfaceGetLinkLayerStats               = "getLinkLayerStats"
	MethodIWifiStaIfaceGetRoamingCapabilities          = "getRoamingCapabilities"
	MethodIWifiStaIfaceInstallApfPacketFilter          = "installApfPacketFilter"
	MethodIWifiStaIfaceReadApfPacketFilterData         = "readApfPacketFilterData"
	MethodIWifiStaIfaceRegisterEventCallback           = "registerEventCallback"
	MethodIWifiStaIfaceSetMacAddress                   = "setMacAddress"
	MethodIWifiStaIfaceSetRoamingState                 = "setRoamingState"
	MethodIWifiStaIfaceSetScanMode                     = "setScanMode"
	MethodIWifiStaIfaceStartBackgroundScan             = "startBackgroundScan"
	MethodIWifiStaIfaceStartDebugPacketFateMonitoring  = "startDebugPacketFateMonitoring"
	MethodIWifiStaIfaceStartRssiMonitoring             = "startRssiMonitoring"
	MethodIWifiStaIfaceStartSendingKeepAlivePackets    = "startSendingKeepAlivePackets"
	MethodIWifiStaIfaceStopBackgroundScan              = "stopBackgroundScan"
	MethodIWifiStaIfaceStopRssiMonitoring              = "stopRssiMonitoring"
	MethodIWifiStaIfaceStopSendingKeepAlivePackets     = "stopSendingKeepAlivePackets"
	MethodIWifiStaIfaceSetDtimMultiplier               = "setDtimMultiplier"
	MethodIWifiStaIfaceGetCachedScanData               = "getCachedScanData"
	MethodIWifiStaIfaceTwtGetCapabilities              = "twtGetCapabilities"
	MethodIWifiStaIfaceTwtSessionSetup                 = "twtSessionSetup"
	MethodIWifiStaIfaceTwtSessionUpdate                = "twtSessionUpdate"
	MethodIWifiStaIfaceTwtSessionSuspend               = "twtSessionSuspend"
	MethodIWifiStaIfaceTwtSessionResume                = "twtSessionResume"
	MethodIWifiStaIfaceTwtSessionTeardown              = "twtSessionTeardown"
	MethodIWifiStaIfaceTwtSessionGetStats              = "twtSessionGetStats"
)
View Source 
const (
	TransactionIWifiStaIfaceEventCallbackOnBackgroundFullScanResult = binder.FirstCallTransaction + 0
	TransactionIWifiStaIfaceEventCallbackOnBackgroundScanFailure    = binder.FirstCallTransaction + 1
	TransactionIWifiStaIfaceEventCallbackOnBackgroundScanResults    = binder.FirstCallTransaction + 2
	TransactionIWifiStaIfaceEventCallbackOnRssiThresholdBreached    = binder.FirstCallTransaction + 3
	TransactionIWifiStaIfaceEventCallbackOnTwtFailure               = binder.FirstCallTransaction + 4
	TransactionIWifiStaIfaceEventCallbackOnTwtSessionCreate         = binder.FirstCallTransaction + 5
	TransactionIWifiStaIfaceEventCallbackOnTwtSessionUpdate         = binder.FirstCallTransaction + 6
	TransactionIWifiStaIfaceEventCallbackOnTwtSessionTeardown       = binder.FirstCallTransaction + 7
	TransactionIWifiStaIfaceEventCallbackOnTwtSessionStats          = binder.FirstCallTransaction + 8
	TransactionIWifiStaIfaceEventCallbackOnTwtSessionSuspend        = binder.FirstCallTransaction + 9
	TransactionIWifiStaIfaceEventCallbackOnTwtSessionResume         = binder.FirstCallTransaction + 10
)
View Source 
const (
	MethodIWifiStaIfaceEventCallbackOnBackgroundFullScanResult = "onBackgroundFullScanResult"
	MethodIWifiStaIfaceEventCallbackOnBackgroundScanFailure    = "onBackgroundScanFailure"
	MethodIWifiStaIfaceEventCallbackOnBackgroundScanResults    = "onBackgroundScanResults"
	MethodIWifiStaIfaceEventCallbackOnRssiThresholdBreached    = "onRssiThresholdBreached"
	MethodIWifiStaIfaceEventCallbackOnTwtFailure               = "onTwtFailure"
	MethodIWifiStaIfaceEventCallbackOnTwtSessionCreate         = "onTwtSessionCreate"
	MethodIWifiStaIfaceEventCallbackOnTwtSessionUpdate         = "onTwtSessionUpdate"
	MethodIWifiStaIfaceEventCallbackOnTwtSessionTeardown       = "onTwtSessionTeardown"
	MethodIWifiStaIfaceEventCallbackOnTwtSessionStats          = "onTwtSessionStats"
	MethodIWifiStaIfaceEventCallbackOnTwtSessionSuspend        = "onTwtSessionSuspend"
	MethodIWifiStaIfaceEventCallbackOnTwtSessionResume         = "onTwtSessionResume"
)
View Source 
const DescriptorIWifi = "android.hardware.wifi.IWifi"
View Source 
const DescriptorIWifiApIface = "android.hardware.wifi.IWifiApIface"
View Source 
const DescriptorIWifiChip = "android.hardware.wifi.IWifiChip"
View Source 
const DescriptorIWifiChipEventCallback = "android.hardware.wifi.IWifiChipEventCallback"
View Source 
const DescriptorIWifiEventCallback = "android.hardware.wifi.IWifiEventCallback"
View Source 
const DescriptorIWifiNanIface = "android.hardware.wifi.IWifiNanIface"
View Source 
const DescriptorIWifiNanIfaceEventCallback = "android.hardware.wifi.IWifiNanIfaceEventCallback"
View Source 
const DescriptorIWifiP2pIface = "android.hardware.wifi.IWifiP2pIface"
View Source 
const DescriptorIWifiRttController = "android.hardware.wifi.IWifiRttController"
View Source 
const DescriptorIWifiRttControllerEventCallback = "android.hardware.wifi.IWifiRttControllerEventCallback"
View Source 
const DescriptorIWifiStaIface = "android.hardware.wifi.IWifiStaIface"
View Source 
const DescriptorIWifiStaIfaceEventCallback = "android.hardware.wifi.IWifiStaIfaceEventCallback"
View Source 
const (
	IWifiChipNoPowerCapConstant int32 = 2147483647
)
View Source 
const (
	MethodIWifiP2pIfaceGetName = "getName"
)
View Source 
const (
	MethodIWifiRttControllerEventCallbackOnResults = "onResults"
)
View Source 
const (
	TransactionIWifiP2pIfaceGetName = binder.FirstCallTransaction + 0
)
View Source 
const (
	TransactionIWifiRttControllerEventCallbackOnResults = binder.FirstCallTransaction + 0
)

Variables

This section is empty.

Functions

This section is empty.

Types

type AfcChannelAllowance 

type AfcChannelAllowance struct {
	AvailableAfcFrequencyInfos []AvailableAfcFrequencyInfo
	AvailableAfcChannelInfos   []AvailableAfcChannelInfo
	AvailabilityExpireTimeMs   int64
}

func (*AfcChannelAllowance) MarshalParcel 

func (s *AfcChannelAllowance) MarshalParcel(
	p *parcel.Parcel,
) error

func (*AfcChannelAllowance) UnmarshalParcel 

func (s *AfcChannelAllowance) UnmarshalParcel(
	p *parcel.Parcel,
) error

type AvailableAfcChannelInfo 

type AvailableAfcChannelInfo struct {
	GlobalOperatingClass int32
	ChannelCfi           int32
	MaxEirpDbm           int32
}

func (*AvailableAfcChannelInfo) MarshalParcel 

func (s *AvailableAfcChannelInfo) MarshalParcel(
	p *parcel.Parcel,
) error

func (*AvailableAfcChannelInfo) UnmarshalParcel 

func (s *AvailableAfcChannelInfo) UnmarshalParcel(
	p *parcel.Parcel,
) error

type AvailableAfcFrequencyInfo 

type AvailableAfcFrequencyInfo struct {
	StartFrequencyMhz int32
	EndFrequencyMhz   int32
	MaxPsd            int32
}

func (*AvailableAfcFrequencyInfo) MarshalParcel 

func (s *AvailableAfcFrequencyInfo) MarshalParcel(
	p *parcel.Parcel,
) error

func (*AvailableAfcFrequencyInfo) UnmarshalParcel 

func (s *AvailableAfcFrequencyInfo) UnmarshalParcel(
	p *parcel.Parcel,
) error

type CachedScanData 

type CachedScanData struct {
	ScannedFrequenciesMhz []int32
	CachedScanResults     []CachedScanResult
}

func (*CachedScanData) MarshalParcel 

func (s *CachedScanData) MarshalParcel(
	p *parcel.Parcel,
) error

func (*CachedScanData) UnmarshalParcel 

func (s *CachedScanData) UnmarshalParcel(
	p *parcel.Parcel,
) error

type CachedScanResult 

type CachedScanResult struct {
	TimeStampInUs   int64
	Ssid            []byte
	Bssid           []byte
	RssiDbm         int32
	FrequencyMhz    int32
	ChannelWidthMhz WifiChannelWidthInMhz
	PreambleType    WifiRatePreamble
}

func (*CachedScanResult) MarshalParcel 

func (s *CachedScanResult) MarshalParcel(
	p *parcel.Parcel,
) error

func (*CachedScanResult) UnmarshalParcel 

func (s *CachedScanResult) UnmarshalParcel(
	p *parcel.Parcel,
) error

type IWifi 

type IWifi interface {
	AsBinder() binder.IBinder
	GetChip(ctx context.Context, chipId int32) (IWifiChip, error)
	GetChipIds(ctx context.Context) ([]int32, error)
	IsStarted(ctx context.Context) (bool, error)
	RegisterEventCallback(ctx context.Context, callback IWifiEventCallback) error
	Start(ctx context.Context) error
	Stop(ctx context.Context) error
}

func NewWifiStub 

func NewWifiStub(
	impl IWifiServer,
) IWifi

NewWifiStub creates a server-side IWifi wrapping the given server implementation. The returned value satisfies IWifi and can be passed to proxy methods; its AsBinder() returns a *binder.StubBinder that is auto-registered with the binder driver on first use.

type IWifiApIface 

type IWifiApIface interface {
	AsBinder() binder.IBinder
	GetName(ctx context.Context) (string, error)
	GetBridgedInstances(ctx context.Context) ([]string, error)
	GetFactoryMacAddress(ctx context.Context) ([]byte, error)
	SetCountryCode(ctx context.Context, code []byte) error
	ResetToFactoryMacAddress(ctx context.Context) error
	SetMacAddress(ctx context.Context, mac []byte) error
}

func NewWifiApIfaceStub 

func NewWifiApIfaceStub(
	impl IWifiApIfaceServer,
) IWifiApIface

NewWifiApIfaceStub creates a server-side IWifiApIface wrapping the given server implementation. The returned value satisfies IWifiApIface and can be passed to proxy methods; its AsBinder() returns a *binder.StubBinder that is auto-registered with the binder driver on first use.

type IWifiApIfaceServer 

type IWifiApIfaceServer interface {
	GetName(ctx context.Context) (string, error)
	GetBridgedInstances(ctx context.Context) ([]string, error)
	GetFactoryMacAddress(ctx context.Context) ([]byte, error)
	SetCountryCode(ctx context.Context, code []byte) error
	ResetToFactoryMacAddress(ctx context.Context) error
	SetMacAddress(ctx context.Context, mac []byte) error
}

IWifiApIfaceServer is the server-side interface that user implementations provide to NewWifiApIfaceStub. It contains only the business methods, without AsBinder (which is provided by the stub itself).

type IWifiChip 

type IWifiChip interface {
	AsBinder() binder.IBinder
	ConfigureChip(ctx context.Context, modeId int32) error
	CreateApIface(ctx context.Context) (IWifiApIface, error)
	CreateBridgedApIface(ctx context.Context) (IWifiApIface, error)
	CreateNanIface(ctx context.Context) (IWifiNanIface, error)
	CreateP2pIface(ctx context.Context) (IWifiP2pIface, error)
	CreateRttController(ctx context.Context, boundIface IWifiStaIface) (IWifiRttController, error)
	CreateStaIface(ctx context.Context) (IWifiStaIface, error)
	EnableDebugErrorAlerts(ctx context.Context, enable bool) error
	FlushRingBufferToFile(ctx context.Context) error
	ForceDumpToDebugRingBuffer(ctx context.Context, ringName string) error
	GetApIface(ctx context.Context, ifname string) (IWifiApIface, error)
	GetApIfaceNames(ctx context.Context) ([]string, error)
	GetAvailableModes(ctx context.Context) ([]IWifiChipChipMode, error)
	GetFeatureSet(ctx context.Context) (int32, error)
	GetDebugHostWakeReasonStats(ctx context.Context) (WifiDebugHostWakeReasonStats, error)
	GetDebugRingBuffersStatus(ctx context.Context) ([]WifiDebugRingBufferStatus, error)
	GetId(ctx context.Context) (int32, error)
	GetMode(ctx context.Context) (int32, error)
	GetNanIface(ctx context.Context, ifname string) (IWifiNanIface, error)
	GetNanIfaceNames(ctx context.Context) ([]string, error)
	GetP2pIface(ctx context.Context, ifname string) (IWifiP2pIface, error)
	GetP2pIfaceNames(ctx context.Context) ([]string, error)
	GetStaIface(ctx context.Context, ifname string) (IWifiStaIface, error)
	GetStaIfaceNames(ctx context.Context) ([]string, error)
	GetSupportedRadioCombinations(ctx context.Context) ([]WifiRadioCombination, error)
	GetWifiChipCapabilities(ctx context.Context) (WifiChipCapabilities, error)
	GetUsableChannels(ctx context.Context, band WifiBand, ifaceModeMask int32, filterMask int32) ([]WifiUsableChannel, error)
	SetAfcChannelAllowance(ctx context.Context, afcChannelAllowance AfcChannelAllowance) error
	RegisterEventCallback(ctx context.Context, callback IWifiChipEventCallback) error
	RemoveApIface(ctx context.Context, ifname string) error
	RemoveIfaceInstanceFromBridgedApIface(ctx context.Context, brIfaceName string, ifaceInstanceName string) error
	RemoveNanIface(ctx context.Context, ifname string) error
	RemoveP2pIface(ctx context.Context, ifname string) error
	RemoveStaIface(ctx context.Context, ifname string) error
	RequestChipDebugInfo(ctx context.Context) (IWifiChipChipDebugInfo, error)
	RequestDriverDebugDump(ctx context.Context) ([]byte, error)
	RequestFirmwareDebugDump(ctx context.Context) ([]byte, error)
	ResetTxPowerScenario(ctx context.Context) error
	SelectTxPowerScenario(ctx context.Context, scenario IWifiChipTxPowerScenario) error
	SetCoexUnsafeChannels(ctx context.Context, unsafeChannels []IWifiChipCoexUnsafeChannel, restrictions int32) error
	SetCountryCode(ctx context.Context, code []byte) error
	SetLatencyMode(ctx context.Context, mode IWifiChipLatencyMode) error
	SetMultiStaPrimaryConnection(ctx context.Context, ifName string) error
	SetMultiStaUseCase(ctx context.Context, useCase IWifiChipMultiStaUseCase) error
	StartLoggingToDebugRingBuffer(ctx context.Context, ringName string, verboseLevel WifiDebugRingBufferVerboseLevel, maxIntervalInSec int32, minDataSizeInBytes int32) error
	StopLoggingToDebugRingBuffer(ctx context.Context) error
	TriggerSubsystemRestart(ctx context.Context) error
	EnableStaChannelForPeerNetwork(ctx context.Context, channelCategoryEnableFlag int32) error
	SetMloMode(ctx context.Context, mode IWifiChipChipMloMode) error
	CreateApOrBridgedApIface(ctx context.Context, iface IfaceConcurrencyType, vendorData []common.OuiKeyedData) (IWifiApIface, error)
	SetVoipMode(ctx context.Context, mode IWifiChipVoipMode) error
}

func NewWifiChipStub 

func NewWifiChipStub(
	impl IWifiChipServer,
) IWifiChip

NewWifiChipStub creates a server-side IWifiChip wrapping the given server implementation. The returned value satisfies IWifiChip and can be passed to proxy methods; its AsBinder() returns a *binder.StubBinder that is auto-registered with the binder driver on first use.

type IWifiChipChannelCategoryMask 

type IWifiChipChannelCategoryMask int32
const (
	IWifiChipChannelCategoryMaskIndoorChannel IWifiChipChannelCategoryMask = (1 << 0)
	IWifiChipChannelCategoryMaskDfsChannel    IWifiChipChannelCategoryMask = (1 << 1)
)

type IWifiChipChipConcurrencyCombination 

type IWifiChipChipConcurrencyCombination struct {
	Limits []IWifiChipChipConcurrencyCombinationLimit
}

func (*IWifiChipChipConcurrencyCombination) MarshalParcel 

func (s *IWifiChipChipConcurrencyCombination) MarshalParcel(
	p *parcel.Parcel,
) error

func (*IWifiChipChipConcurrencyCombination) UnmarshalParcel 

func (s *IWifiChipChipConcurrencyCombination) UnmarshalParcel(
	p *parcel.Parcel,
) error

type IWifiChipChipConcurrencyCombinationLimit 

type IWifiChipChipConcurrencyCombinationLimit struct {
	Types     []IfaceConcurrencyType
	MaxIfaces int32
}

func (*IWifiChipChipConcurrencyCombinationLimit) MarshalParcel 

func (s *IWifiChipChipConcurrencyCombinationLimit) MarshalParcel(
	p *parcel.Parcel,
) error

func (*IWifiChipChipConcurrencyCombinationLimit) UnmarshalParcel 

func (s *IWifiChipChipConcurrencyCombinationLimit) UnmarshalParcel(
	p *parcel.Parcel,
) error

type IWifiChipChipDebugInfo 

type IWifiChipChipDebugInfo struct {
	DriverDescription   string
	FirmwareDescription string
}

func (*IWifiChipChipDebugInfo) MarshalParcel 

func (s *IWifiChipChipDebugInfo) MarshalParcel(
	p *parcel.Parcel,
) error

func (*IWifiChipChipDebugInfo) UnmarshalParcel 

func (s *IWifiChipChipDebugInfo) UnmarshalParcel(
	p *parcel.Parcel,
) error

type IWifiChipChipIfaceCombination 

type IWifiChipChipIfaceCombination struct {
	Limits []IWifiChipChipIfaceCombinationLimit
}

func (*IWifiChipChipIfaceCombination) MarshalParcel 

func (s *IWifiChipChipIfaceCombination) MarshalParcel(
	p *parcel.Parcel,
) error

func (*IWifiChipChipIfaceCombination) UnmarshalParcel 

func (s *IWifiChipChipIfaceCombination) UnmarshalParcel(
	p *parcel.Parcel,
) error

type IWifiChipChipIfaceCombinationLimit 

type IWifiChipChipIfaceCombinationLimit struct {
	Types     []IfaceType
	MaxIfaces int32
}

func (*IWifiChipChipIfaceCombinationLimit) MarshalParcel 

func (s *IWifiChipChipIfaceCombinationLimit) MarshalParcel(
	p *parcel.Parcel,
) error

func (*IWifiChipChipIfaceCombinationLimit) UnmarshalParcel 

func (s *IWifiChipChipIfaceCombinationLimit) UnmarshalParcel(
	p *parcel.Parcel,
) error

type IWifiChipChipMloMode 

type IWifiChipChipMloMode int32
const (
	IWifiChipChipMloModeDEFAULT        IWifiChipChipMloMode = 0
	IWifiChipChipMloModeLowLatency     IWifiChipChipMloMode = 1
	IWifiChipChipMloModeHighThroughput IWifiChipChipMloMode = 2
	IWifiChipChipMloModeLowPower       IWifiChipChipMloMode = 3
)

type IWifiChipChipMode 

type IWifiChipChipMode struct {
	Id                    int32
	AvailableCombinations []IWifiChipChipConcurrencyCombination
}

func (*IWifiChipChipMode) MarshalParcel 

func (s *IWifiChipChipMode) MarshalParcel(
	p *parcel.Parcel,
) error

func (*IWifiChipChipMode) UnmarshalParcel 

func (s *IWifiChipChipMode) UnmarshalParcel(
	p *parcel.Parcel,
) error

type IWifiChipCoexRestriction 

type IWifiChipCoexRestriction int32
const (
	IWifiChipCoexRestrictionWifiDirect IWifiChipCoexRestriction = (1 << 0)
	IWifiChipCoexRestrictionSOFTAP     IWifiChipCoexRestriction = (1 << 1)
	IWifiChipCoexRestrictionWifiAware  IWifiChipCoexRestriction = (1 << 2)
)

type IWifiChipCoexUnsafeChannel 

type IWifiChipCoexUnsafeChannel struct {
	Band        WifiBand
	Channel     int32
	PowerCapDbm int32
}

func (*IWifiChipCoexUnsafeChannel) MarshalParcel 

func (s *IWifiChipCoexUnsafeChannel) MarshalParcel(
	p *parcel.Parcel,
) error

func (*IWifiChipCoexUnsafeChannel) UnmarshalParcel 

func (s *IWifiChipCoexUnsafeChannel) UnmarshalParcel(
	p *parcel.Parcel,
) error

type IWifiChipEventCallback 

type IWifiChipEventCallback interface {
	AsBinder() binder.IBinder
	OnChipReconfigureFailure(ctx context.Context, status WifiStatusCode) error
	OnChipReconfigured(ctx context.Context, modeId int32) error
	OnDebugErrorAlert(ctx context.Context, errorCode int32, debugData []byte) error
	OnDebugRingBufferDataAvailable(ctx context.Context, status WifiDebugRingBufferStatus, data []byte) error
	OnIfaceAdded(ctx context.Context, type_ IfaceType, name string) error
	OnIfaceRemoved(ctx context.Context, type_ IfaceType, name string) error
	OnRadioModeChange(ctx context.Context, radioModeInfos []IWifiChipEventCallbackRadioModeInfo) error
}

func NewWifiChipEventCallbackStub 

func NewWifiChipEventCallbackStub(
	impl IWifiChipEventCallbackServer,
) IWifiChipEventCallback

NewWifiChipEventCallbackStub creates a server-side IWifiChipEventCallback wrapping the given server implementation. The returned value satisfies IWifiChipEventCallback and can be passed to proxy methods; its AsBinder() returns a *binder.StubBinder that is auto-registered with the binder driver on first use.

type IWifiChipEventCallbackIfaceInfo 

type IWifiChipEventCallbackIfaceInfo struct {
	Name    string
	Channel int32
}

func (*IWifiChipEventCallbackIfaceInfo) MarshalParcel 

func (s *IWifiChipEventCallbackIfaceInfo) MarshalParcel(
	p *parcel.Parcel,
) error

func (*IWifiChipEventCallbackIfaceInfo) UnmarshalParcel 

func (s *IWifiChipEventCallbackIfaceInfo) UnmarshalParcel(
	p *parcel.Parcel,
) error

type IWifiChipEventCallbackRadioModeInfo 

type IWifiChipEventCallbackRadioModeInfo struct {
	RadioId    int32
	BandInfo   WifiBand
	IfaceInfos []IWifiChipEventCallbackIfaceInfo
}

func (*IWifiChipEventCallbackRadioModeInfo) MarshalParcel 

func (s *IWifiChipEventCallbackRadioModeInfo) MarshalParcel(
	p *parcel.Parcel,
) error

func (*IWifiChipEventCallbackRadioModeInfo) UnmarshalParcel 

func (s *IWifiChipEventCallbackRadioModeInfo) UnmarshalParcel(
	p *parcel.Parcel,
) error

type IWifiChipEventCallbackServer 

type IWifiChipEventCallbackServer interface {
	OnChipReconfigureFailure(ctx context.Context, status WifiStatusCode) error
	OnChipReconfigured(ctx context.Context, modeId int32) error
	OnDebugErrorAlert(ctx context.Context, errorCode int32, debugData []byte) error
	OnDebugRingBufferDataAvailable(ctx context.Context, status WifiDebugRingBufferStatus, data []byte) error
	OnIfaceAdded(ctx context.Context, type_ IfaceType, name string) error
	OnIfaceRemoved(ctx context.Context, type_ IfaceType, name string) error
	OnRadioModeChange(ctx context.Context, radioModeInfos []IWifiChipEventCallbackRadioModeInfo) error
}

IWifiChipEventCallbackServer is the server-side interface that user implementations provide to NewWifiChipEventCallbackStub. It contains only the business methods, without AsBinder (which is provided by the stub itself).

type IWifiChipFeatureSetMask 

type IWifiChipFeatureSetMask int32
const (
	IWifiChipFeatureSetMaskSetTxPowerLimit        IWifiChipFeatureSetMask = (1 << 0)
	IWifiChipFeatureSetMaskD2dRtt                 IWifiChipFeatureSetMask = (1 << 1)
	IWifiChipFeatureSetMaskD2apRtt                IWifiChipFeatureSetMask = (1 << 2)
	IWifiChipFeatureSetMaskUseBodyHeadSar         IWifiChipFeatureSetMask = (1 << 3)
	IWifiChipFeatureSetMaskSetLatencyMode         IWifiChipFeatureSetMask = (1 << 4)
	IWifiChipFeatureSetMaskP2pRandMac             IWifiChipFeatureSetMask = (1 << 5)
	IWifiChipFeatureSetMaskWIGIG                  IWifiChipFeatureSetMask = (1 << 6)
	IWifiChipFeatureSetMaskSetAfcChannelAllowance IWifiChipFeatureSetMask = (1 << 7)
	IWifiChipFeatureSetMaskT2lmNegotiation        IWifiChipFeatureSetMask = (1 << 8)
	IWifiChipFeatureSetMaskSetVoipMode            IWifiChipFeatureSetMask = (1 << 9)
)

type IWifiChipLatencyMode 

type IWifiChipLatencyMode int32
const (
	IWifiChipLatencyModeNORMAL IWifiChipLatencyMode = 0
	IWifiChipLatencyModeLOW    IWifiChipLatencyMode = 1
)

type IWifiChipMultiStaUseCase 

type IWifiChipMultiStaUseCase byte
const (
	IWifiChipMultiStaUseCaseDualStaTransientPreferPrimary IWifiChipMultiStaUseCase = 0
	IWifiChipMultiStaUseCaseDualStaNonTransientUnbiased   IWifiChipMultiStaUseCase = 1
)

type IWifiChipServer 

type IWifiChipServer interface {
	ConfigureChip(ctx context.Context, modeId int32) error
	CreateApIface(ctx context.Context) (IWifiApIface, error)
	CreateBridgedApIface(ctx context.Context) (IWifiApIface, error)
	CreateNanIface(ctx context.Context) (IWifiNanIface, error)
	CreateP2pIface(ctx context.Context) (IWifiP2pIface, error)
	CreateRttController(ctx context.Context, boundIface IWifiStaIface) (IWifiRttController, error)
	CreateStaIface(ctx context.Context) (IWifiStaIface, error)
	EnableDebugErrorAlerts(ctx context.Context, enable bool) error
	FlushRingBufferToFile(ctx context.Context) error
	ForceDumpToDebugRingBuffer(ctx context.Context, ringName string) error
	GetApIface(ctx context.Context, ifname string) (IWifiApIface, error)
	GetApIfaceNames(ctx context.Context) ([]string, error)
	GetAvailableModes(ctx context.Context) ([]IWifiChipChipMode, error)
	GetFeatureSet(ctx context.Context) (int32, error)
	GetDebugHostWakeReasonStats(ctx context.Context) (WifiDebugHostWakeReasonStats, error)
	GetDebugRingBuffersStatus(ctx context.Context) ([]WifiDebugRingBufferStatus, error)
	GetId(ctx context.Context) (int32, error)
	GetMode(ctx context.Context) (int32, error)
	GetNanIface(ctx context.Context, ifname string) (IWifiNanIface, error)
	GetNanIfaceNames(ctx context.Context) ([]string, error)
	GetP2pIface(ctx context.Context, ifname string) (IWifiP2pIface, error)
	GetP2pIfaceNames(ctx context.Context) ([]string, error)
	GetStaIface(ctx context.Context, ifname string) (IWifiStaIface, error)
	GetStaIfaceNames(ctx context.Context) ([]string, error)
	GetSupportedRadioCombinations(ctx context.Context) ([]WifiRadioCombination, error)
	GetWifiChipCapabilities(ctx context.Context) (WifiChipCapabilities, error)
	GetUsableChannels(ctx context.Context, band WifiBand, ifaceModeMask int32, filterMask int32) ([]WifiUsableChannel, error)
	SetAfcChannelAllowance(ctx context.Context, afcChannelAllowance AfcChannelAllowance) error
	RegisterEventCallback(ctx context.Context, callback IWifiChipEventCallback) error
	RemoveApIface(ctx context.Context, ifname string) error
	RemoveIfaceInstanceFromBridgedApIface(ctx context.Context, brIfaceName string, ifaceInstanceName string) error
	RemoveNanIface(ctx context.Context, ifname string) error
	RemoveP2pIface(ctx context.Context, ifname string) error
	RemoveStaIface(ctx context.Context, ifname string) error
	RequestChipDebugInfo(ctx context.Context) (IWifiChipChipDebugInfo, error)
	RequestDriverDebugDump(ctx context.Context) ([]byte, error)
	RequestFirmwareDebugDump(ctx context.Context) ([]byte, error)
	ResetTxPowerScenario(ctx context.Context) error
	SelectTxPowerScenario(ctx context.Context, scenario IWifiChipTxPowerScenario) error
	SetCoexUnsafeChannels(ctx context.Context, unsafeChannels []IWifiChipCoexUnsafeChannel, restrictions int32) error
	SetCountryCode(ctx context.Context, code []byte) error
	SetLatencyMode(ctx context.Context, mode IWifiChipLatencyMode) error
	SetMultiStaPrimaryConnection(ctx context.Context, ifName string) error
	SetMultiStaUseCase(ctx context.Context, useCase IWifiChipMultiStaUseCase) error
	StartLoggingToDebugRingBuffer(ctx context.Context, ringName string, verboseLevel WifiDebugRingBufferVerboseLevel, maxIntervalInSec int32, minDataSizeInBytes int32) error
	StopLoggingToDebugRingBuffer(ctx context.Context) error
	TriggerSubsystemRestart(ctx context.Context) error
	EnableStaChannelForPeerNetwork(ctx context.Context, channelCategoryEnableFlag int32) error
	SetMloMode(ctx context.Context, mode IWifiChipChipMloMode) error
	CreateApOrBridgedApIface(ctx context.Context, iface IfaceConcurrencyType, vendorData []common.OuiKeyedData) (IWifiApIface, error)
	SetVoipMode(ctx context.Context, mode IWifiChipVoipMode) error
}

IWifiChipServer is the server-side interface that user implementations provide to NewWifiChipStub. It contains only the business methods, without AsBinder (which is provided by the stub itself).

type IWifiChipTxPowerScenario 

type IWifiChipTxPowerScenario int32
const (
	IWifiChipTxPowerScenarioVoiceCall     IWifiChipTxPowerScenario = 0
	IWifiChipTxPowerScenarioOnHeadCellOff IWifiChipTxPowerScenario = 1
	IWifiChipTxPowerScenarioOnHeadCellOn  IWifiChipTxPowerScenario = 2
	IWifiChipTxPowerScenarioOnBodyCellOff IWifiChipTxPowerScenario = 3
	IWifiChipTxPowerScenarioOnBodyCellOn  IWifiChipTxPowerScenario = 4
)

type IWifiChipUsableChannelFilter 

type IWifiChipUsableChannelFilter int32
const (
	IWifiChipUsableChannelFilterCellularCoexistence IWifiChipUsableChannelFilter = (1 << 0)
	IWifiChipUsableChannelFilterCONCURRENCY         IWifiChipUsableChannelFilter = (1 << 1)
	IWifiChipUsableChannelFilterNanInstantMode      IWifiChipUsableChannelFilter = (1 << 2)
)

type IWifiChipVoipMode 

type IWifiChipVoipMode int32
const (
	IWifiChipVoipModeOFF   IWifiChipVoipMode = 0
	IWifiChipVoipModeVOICE IWifiChipVoipMode = 1
)

type IWifiEventCallback 

type IWifiEventCallback interface {
	AsBinder() binder.IBinder
	OnFailure(ctx context.Context, status WifiStatusCode) error
	OnStart(ctx context.Context) error
	OnStop(ctx context.Context) error
	OnSubsystemRestart(ctx context.Context, status WifiStatusCode) error
}

func NewWifiEventCallbackStub 

func NewWifiEventCallbackStub(
	impl IWifiEventCallbackServer,
) IWifiEventCallback

NewWifiEventCallbackStub creates a server-side IWifiEventCallback wrapping the given server implementation. The returned value satisfies IWifiEventCallback and can be passed to proxy methods; its AsBinder() returns a *binder.StubBinder that is auto-registered with the binder driver on first use.

type IWifiEventCallbackServer 

type IWifiEventCallbackServer interface {
	OnFailure(ctx context.Context, status WifiStatusCode) error
	OnStart(ctx context.Context) error
	OnStop(ctx context.Context) error
	OnSubsystemRestart(ctx context.Context, status WifiStatusCode) error
}

IWifiEventCallbackServer is the server-side interface that user implementations provide to NewWifiEventCallbackStub. It contains only the business methods, without AsBinder (which is provided by the stub itself).

type IWifiNanIface 

type IWifiNanIface interface {
	AsBinder() binder.IBinder
	GetName(ctx context.Context) (string, error)
	ConfigRequest(ctx context.Context, cmdId uint16, msg1 NanConfigRequest, msg2 NanConfigRequestSupplemental) error
	CreateDataInterfaceRequest(ctx context.Context, cmdId uint16, ifaceName string) error
	DeleteDataInterfaceRequest(ctx context.Context, cmdId uint16, ifaceName string) error
	DisableRequest(ctx context.Context, cmdId uint16) error
	EnableRequest(ctx context.Context, cmdId uint16, msg1 NanEnableRequest, msg2 NanConfigRequestSupplemental) error
	GetCapabilitiesRequest(ctx context.Context, cmdId uint16) error
	InitiateDataPathRequest(ctx context.Context, cmdId uint16, msg NanInitiateDataPathRequest) error
	RegisterEventCallback(ctx context.Context, callback IWifiNanIfaceEventCallback) error
	RespondToDataPathIndicationRequest(ctx context.Context, cmdId uint16, msg NanRespondToDataPathIndicationRequest) error
	StartPublishRequest(ctx context.Context, cmdId uint16, msg NanPublishRequest) error
	StartSubscribeRequest(ctx context.Context, cmdId uint16, msg NanSubscribeRequest) error
	StopPublishRequest(ctx context.Context, cmdId uint16, sessionId byte) error
	StopSubscribeRequest(ctx context.Context, cmdId uint16, sessionId byte) error
	TerminateDataPathRequest(ctx context.Context, cmdId uint16, ndpInstanceId int32) error
	SuspendRequest(ctx context.Context, cmdId uint16, sessionId byte) error
	ResumeRequest(ctx context.Context, cmdId uint16, sessionId byte) error
	TransmitFollowupRequest(ctx context.Context, cmdId uint16, msg NanTransmitFollowupRequest) error
	InitiatePairingRequest(ctx context.Context, cmdId uint16, msg NanPairingRequest) error
	RespondToPairingIndicationRequest(ctx context.Context, cmdId uint16, msg NanRespondToPairingIndicationRequest) error
	InitiateBootstrappingRequest(ctx context.Context, cmdId uint16, msg NanBootstrappingRequest) error
	RespondToBootstrappingIndicationRequest(ctx context.Context, cmdId uint16, msg NanBootstrappingResponse) error
	TerminatePairingRequest(ctx context.Context, cmdId uint16, pairingInstanceId int32) error
}

func NewWifiNanIfaceStub 

func NewWifiNanIfaceStub(
	impl IWifiNanIfaceServer,
) IWifiNanIface

NewWifiNanIfaceStub creates a server-side IWifiNanIface wrapping the given server implementation. The returned value satisfies IWifiNanIface and can be passed to proxy methods; its AsBinder() returns a *binder.StubBinder that is auto-registered with the binder driver on first use.

type IWifiNanIfaceEventCallback 

type IWifiNanIfaceEventCallback interface {
	AsBinder() binder.IBinder
	EventClusterEvent(ctx context.Context, event NanClusterEventInd) error
	EventDataPathConfirm(ctx context.Context, event NanDataPathConfirmInd) error
	EventDataPathRequest(ctx context.Context, event NanDataPathRequestInd) error
	EventDataPathScheduleUpdate(ctx context.Context, event NanDataPathScheduleUpdateInd) error
	EventDataPathTerminated(ctx context.Context, ndpInstanceId int32) error
	EventDisabled(ctx context.Context, status NanStatus) error
	EventFollowupReceived(ctx context.Context, event NanFollowupReceivedInd) error
	EventMatch(ctx context.Context, event NanMatchInd) error
	EventMatchExpired(ctx context.Context, discoverySessionId byte, peerId int32) error
	EventPublishTerminated(ctx context.Context, sessionId byte, status NanStatus) error
	EventSubscribeTerminated(ctx context.Context, sessionId byte, status NanStatus) error
	EventTransmitFollowup(ctx context.Context, id uint16, status NanStatus) error
	EventSuspensionModeChanged(ctx context.Context, event NanSuspensionModeChangeInd) error
	NotifyCapabilitiesResponse(ctx context.Context, id uint16, status NanStatus, capabilities NanCapabilities) error
	NotifyConfigResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyCreateDataInterfaceResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyDeleteDataInterfaceResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyDisableResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyEnableResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyInitiateDataPathResponse(ctx context.Context, id uint16, status NanStatus, ndpInstanceId int32) error
	NotifyRespondToDataPathIndicationResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyStartPublishResponse(ctx context.Context, id uint16, status NanStatus, sessionId byte) error
	NotifyStartSubscribeResponse(ctx context.Context, id uint16, status NanStatus, sessionId byte) error
	NotifyStopPublishResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyStopSubscribeResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyTerminateDataPathResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifySuspendResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyResumeResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyTransmitFollowupResponse(ctx context.Context, id uint16, status NanStatus) error
	EventPairingRequest(ctx context.Context, event NanPairingRequestInd) error
	EventPairingConfirm(ctx context.Context, event NanPairingConfirmInd) error
	NotifyInitiatePairingResponse(ctx context.Context, id uint16, status NanStatus, pairingInstanceId int32) error
	NotifyRespondToPairingIndicationResponse(ctx context.Context, id uint16, status NanStatus) error
	EventBootstrappingRequest(ctx context.Context, event NanBootstrappingRequestInd) error
	EventBootstrappingConfirm(ctx context.Context, event NanBootstrappingConfirmInd) error
	NotifyInitiateBootstrappingResponse(ctx context.Context, id uint16, status NanStatus, bootstrappingInstanceId int32) error
	NotifyRespondToBootstrappingIndicationResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyTerminatePairingResponse(ctx context.Context, id uint16, status NanStatus) error
}

func NewWifiNanIfaceEventCallbackStub 

func NewWifiNanIfaceEventCallbackStub(
	impl IWifiNanIfaceEventCallbackServer,
) IWifiNanIfaceEventCallback

NewWifiNanIfaceEventCallbackStub creates a server-side IWifiNanIfaceEventCallback wrapping the given server implementation. The returned value satisfies IWifiNanIfaceEventCallback and can be passed to proxy methods; its AsBinder() returns a *binder.StubBinder that is auto-registered with the binder driver on first use.

type IWifiNanIfaceEventCallbackServer 

type IWifiNanIfaceEventCallbackServer interface {
	EventClusterEvent(ctx context.Context, event NanClusterEventInd) error
	EventDataPathConfirm(ctx context.Context, event NanDataPathConfirmInd) error
	EventDataPathRequest(ctx context.Context, event NanDataPathRequestInd) error
	EventDataPathScheduleUpdate(ctx context.Context, event NanDataPathScheduleUpdateInd) error
	EventDataPathTerminated(ctx context.Context, ndpInstanceId int32) error
	EventDisabled(ctx context.Context, status NanStatus) error
	EventFollowupReceived(ctx context.Context, event NanFollowupReceivedInd) error
	EventMatch(ctx context.Context, event NanMatchInd) error
	EventMatchExpired(ctx context.Context, discoverySessionId byte, peerId int32) error
	EventPublishTerminated(ctx context.Context, sessionId byte, status NanStatus) error
	EventSubscribeTerminated(ctx context.Context, sessionId byte, status NanStatus) error
	EventTransmitFollowup(ctx context.Context, id uint16, status NanStatus) error
	EventSuspensionModeChanged(ctx context.Context, event NanSuspensionModeChangeInd) error
	NotifyCapabilitiesResponse(ctx context.Context, id uint16, status NanStatus, capabilities NanCapabilities) error
	NotifyConfigResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyCreateDataInterfaceResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyDeleteDataInterfaceResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyDisableResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyEnableResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyInitiateDataPathResponse(ctx context.Context, id uint16, status NanStatus, ndpInstanceId int32) error
	NotifyRespondToDataPathIndicationResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyStartPublishResponse(ctx context.Context, id uint16, status NanStatus, sessionId byte) error
	NotifyStartSubscribeResponse(ctx context.Context, id uint16, status NanStatus, sessionId byte) error
	NotifyStopPublishResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyStopSubscribeResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyTerminateDataPathResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifySuspendResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyResumeResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyTransmitFollowupResponse(ctx context.Context, id uint16, status NanStatus) error
	EventPairingRequest(ctx context.Context, event NanPairingRequestInd) error
	EventPairingConfirm(ctx context.Context, event NanPairingConfirmInd) error
	NotifyInitiatePairingResponse(ctx context.Context, id uint16, status NanStatus, pairingInstanceId int32) error
	NotifyRespondToPairingIndicationResponse(ctx context.Context, id uint16, status NanStatus) error
	EventBootstrappingRequest(ctx context.Context, event NanBootstrappingRequestInd) error
	EventBootstrappingConfirm(ctx context.Context, event NanBootstrappingConfirmInd) error
	NotifyInitiateBootstrappingResponse(ctx context.Context, id uint16, status NanStatus, bootstrappingInstanceId int32) error
	NotifyRespondToBootstrappingIndicationResponse(ctx context.Context, id uint16, status NanStatus) error
	NotifyTerminatePairingResponse(ctx context.Context, id uint16, status NanStatus) error
}

IWifiNanIfaceEventCallbackServer is the server-side interface that user implementations provide to NewWifiNanIfaceEventCallbackStub. It contains only the business methods, without AsBinder (which is provided by the stub itself).

type IWifiNanIfaceServer 

type IWifiNanIfaceServer interface {
	GetName(ctx context.Context) (string, error)
	ConfigRequest(ctx context.Context, cmdId uint16, msg1 NanConfigRequest, msg2 NanConfigRequestSupplemental) error
	CreateDataInterfaceRequest(ctx context.Context, cmdId uint16, ifaceName string) error
	DeleteDataInterfaceRequest(ctx context.Context, cmdId uint16, ifaceName string) error
	DisableRequest(ctx context.Context, cmdId uint16) error
	EnableRequest(ctx context.Context, cmdId uint16, msg1 NanEnableRequest, msg2 NanConfigRequestSupplemental) error
	GetCapabilitiesRequest(ctx context.Context, cmdId uint16) error
	InitiateDataPathRequest(ctx context.Context, cmdId uint16, msg NanInitiateDataPathRequest) error
	RegisterEventCallback(ctx context.Context, callback IWifiNanIfaceEventCallback) error
	RespondToDataPathIndicationRequest(ctx context.Context, cmdId uint16, msg NanRespondToDataPathIndicationRequest) error
	StartPublishRequest(ctx context.Context, cmdId uint16, msg NanPublishRequest) error
	StartSubscribeRequest(ctx context.Context, cmdId uint16, msg NanSubscribeRequest) error
	StopPublishRequest(ctx context.Context, cmdId uint16, sessionId byte) error
	StopSubscribeRequest(ctx context.Context, cmdId uint16, sessionId byte) error
	TerminateDataPathRequest(ctx context.Context, cmdId uint16, ndpInstanceId int32) error
	SuspendRequest(ctx context.Context, cmdId uint16, sessionId byte) error
	ResumeRequest(ctx context.Context, cmdId uint16, sessionId byte) error
	TransmitFollowupRequest(ctx context.Context, cmdId uint16, msg NanTransmitFollowupRequest) error
	InitiatePairingRequest(ctx context.Context, cmdId uint16, msg NanPairingRequest) error
	RespondToPairingIndicationRequest(ctx context.Context, cmdId uint16, msg NanRespondToPairingIndicationRequest) error
	InitiateBootstrappingRequest(ctx context.Context, cmdId uint16, msg NanBootstrappingRequest) error
	RespondToBootstrappingIndicationRequest(ctx context.Context, cmdId uint16, msg NanBootstrappingResponse) error
	TerminatePairingRequest(ctx context.Context, cmdId uint16, pairingInstanceId int32) error
}

IWifiNanIfaceServer is the server-side interface that user implementations provide to NewWifiNanIfaceStub. It contains only the business methods, without AsBinder (which is provided by the stub itself).

type IWifiP2pIface 

type IWifiP2pIface interface {
	AsBinder() binder.IBinder
	GetName(ctx context.Context) (string, error)
}

func NewWifiP2pIfaceStub 

func NewWifiP2pIfaceStub(
	impl IWifiP2pIfaceServer,
) IWifiP2pIface

NewWifiP2pIfaceStub creates a server-side IWifiP2pIface wrapping the given server implementation. The returned value satisfies IWifiP2pIface and can be passed to proxy methods; its AsBinder() returns a *binder.StubBinder that is auto-registered with the binder driver on first use.

type IWifiP2pIfaceServer 

type IWifiP2pIfaceServer interface {
	GetName(ctx context.Context) (string, error)
}

IWifiP2pIfaceServer is the server-side interface that user implementations provide to NewWifiP2pIfaceStub. It contains only the business methods, without AsBinder (which is provided by the stub itself).

type IWifiRttController 

type IWifiRttController interface {
	AsBinder() binder.IBinder
	DisableResponder(ctx context.Context, cmdId int32) error
	EnableResponder(ctx context.Context, cmdId int32, channelHint WifiChannelInfo, maxDurationInSeconds int32, info RttResponder) error
	GetBoundIface(ctx context.Context) (IWifiStaIface, error)
	GetCapabilities(ctx context.Context) (RttCapabilities, error)
	GetResponderInfo(ctx context.Context) (RttResponder, error)
	RangeCancel(ctx context.Context, cmdId int32, addrs []MacAddress) error
	RangeRequest(ctx context.Context, cmdId int32, rttConfigs []RttConfig) error
	RegisterEventCallback(ctx context.Context, callback IWifiRttControllerEventCallback) error
	SetLci(ctx context.Context, cmdId int32, lci RttLciInformation) error
	SetLcr(ctx context.Context, cmdId int32, lcr RttLcrInformation) error
}

func NewWifiRttControllerStub 

func NewWifiRttControllerStub(
	impl IWifiRttControllerServer,
) IWifiRttController

NewWifiRttControllerStub creates a server-side IWifiRttController wrapping the given server implementation. The returned value satisfies IWifiRttController and can be passed to proxy methods; its AsBinder() returns a *binder.StubBinder that is auto-registered with the binder driver on first use.

type IWifiRttControllerEventCallback 

type IWifiRttControllerEventCallback interface {
	AsBinder() binder.IBinder
	OnResults(ctx context.Context, cmdId int32, results []RttResult) error
}

func NewWifiRttControllerEventCallbackStub 

func NewWifiRttControllerEventCallbackStub(
	impl IWifiRttControllerEventCallbackServer,
) IWifiRttControllerEventCallback

NewWifiRttControllerEventCallbackStub creates a server-side IWifiRttControllerEventCallback wrapping the given server implementation. The returned value satisfies IWifiRttControllerEventCallback and can be passed to proxy methods; its AsBinder() returns a *binder.StubBinder that is auto-registered with the binder driver on first use.

type IWifiRttControllerEventCallbackServer 

type IWifiRttControllerEventCallbackServer interface {
	OnResults(ctx context.Context, cmdId int32, results []RttResult) error
}

IWifiRttControllerEventCallbackServer is the server-side interface that user implementations provide to NewWifiRttControllerEventCallbackStub. It contains only the business methods, without AsBinder (which is provided by the stub itself).

type IWifiRttControllerServer 

type IWifiRttControllerServer interface {
	DisableResponder(ctx context.Context, cmdId int32) error
	EnableResponder(ctx context.Context, cmdId int32, channelHint WifiChannelInfo, maxDurationInSeconds int32, info RttResponder) error
	GetBoundIface(ctx context.Context) (IWifiStaIface, error)
	GetCapabilities(ctx context.Context) (RttCapabilities, error)
	GetResponderInfo(ctx context.Context) (RttResponder, error)
	RangeCancel(ctx context.Context, cmdId int32, addrs []MacAddress) error
	RangeRequest(ctx context.Context, cmdId int32, rttConfigs []RttConfig) error
	RegisterEventCallback(ctx context.Context, callback IWifiRttControllerEventCallback) error
	SetLci(ctx context.Context, cmdId int32, lci RttLciInformation) error
	SetLcr(ctx context.Context, cmdId int32, lcr RttLcrInformation) error
}

IWifiRttControllerServer is the server-side interface that user implementations provide to NewWifiRttControllerStub. It contains only the business methods, without AsBinder (which is provided by the stub itself).

type IWifiServer 

type IWifiServer interface {
	GetChip(ctx context.Context, chipId int32) (IWifiChip, error)
	GetChipIds(ctx context.Context) ([]int32, error)
	IsStarted(ctx context.Context) (bool, error)
	RegisterEventCallback(ctx context.Context, callback IWifiEventCallback) error
	Start(ctx context.Context) error
	Stop(ctx context.Context) error
}

IWifiServer is the server-side interface that user implementations provide to NewWifiStub. It contains only the business methods, without AsBinder (which is provided by the stub itself).

type IWifiStaIface 

type IWifiStaIface interface {
	AsBinder() binder.IBinder
	GetName(ctx context.Context) (string, error)
	ConfigureRoaming(ctx context.Context, config StaRoamingConfig) error
	DisableLinkLayerStatsCollection(ctx context.Context) error
	EnableLinkLayerStatsCollection(ctx context.Context, debug bool) error
	EnableNdOffload(ctx context.Context, enable bool) error
	GetApfPacketFilterCapabilities(ctx context.Context) (StaApfPacketFilterCapabilities, error)
	GetBackgroundScanCapabilities(ctx context.Context) (StaBackgroundScanCapabilities, error)
	GetFeatureSet(ctx context.Context) (int32, error)
	GetDebugRxPacketFates(ctx context.Context) ([]WifiDebugRxPacketFateReport, error)
	GetDebugTxPacketFates(ctx context.Context) ([]WifiDebugTxPacketFateReport, error)
	GetFactoryMacAddress(ctx context.Context) ([]byte, error)
	GetLinkLayerStats(ctx context.Context) (StaLinkLayerStats, error)
	GetRoamingCapabilities(ctx context.Context) (StaRoamingCapabilities, error)
	InstallApfPacketFilter(ctx context.Context, program []byte) error
	ReadApfPacketFilterData(ctx context.Context) ([]byte, error)
	RegisterEventCallback(ctx context.Context, callback IWifiStaIfaceEventCallback) error
	SetMacAddress(ctx context.Context, mac []byte) error
	SetRoamingState(ctx context.Context, state StaRoamingState) error
	SetScanMode(ctx context.Context, enable bool) error
	StartBackgroundScan(ctx context.Context, cmdId int32, params StaBackgroundScanParameters) error
	StartDebugPacketFateMonitoring(ctx context.Context) error
	StartRssiMonitoring(ctx context.Context, cmdId int32, maxRssi int32, minRssi int32) error
	StartSendingKeepAlivePackets(ctx context.Context, cmdId int32, ipPacketData []byte, etherType uint16, srcAddress []byte, dstAddress []byte, periodInMs int32) error
	StopBackgroundScan(ctx context.Context, cmdId int32) error
	StopRssiMonitoring(ctx context.Context, cmdId int32) error
	StopSendingKeepAlivePackets(ctx context.Context, cmdId int32) error
	SetDtimMultiplier(ctx context.Context, multiplier int32) error
	GetCachedScanData(ctx context.Context) (CachedScanData, error)
	TwtGetCapabilities(ctx context.Context) (TwtCapabilities, error)
	TwtSessionSetup(ctx context.Context, cmdId int32, twtRequest TwtRequest) error
	TwtSessionUpdate(ctx context.Context, cmdId int32, sessionId int32, twtRequest TwtRequest) error
	TwtSessionSuspend(ctx context.Context, cmdId int32, sessionId int32) error
	TwtSessionResume(ctx context.Context, cmdId int32, sessionId int32) error
	TwtSessionTeardown(ctx context.Context, cmdId int32, sessionId int32) error
	TwtSessionGetStats(ctx context.Context, cmdId int32, sessionId int32) error
}

func NewWifiStaIfaceStub 

func NewWifiStaIfaceStub(
	impl IWifiStaIfaceServer,
) IWifiStaIface

NewWifiStaIfaceStub creates a server-side IWifiStaIface wrapping the given server implementation. The returned value satisfies IWifiStaIface and can be passed to proxy methods; its AsBinder() returns a *binder.StubBinder that is auto-registered with the binder driver on first use.

type IWifiStaIfaceEventCallback 

type IWifiStaIfaceEventCallback interface {
	AsBinder() binder.IBinder
	OnBackgroundFullScanResult(ctx context.Context, cmdId int32, bucketsScanned int32, result StaScanResult) error
	OnBackgroundScanFailure(ctx context.Context, cmdId int32) error
	OnBackgroundScanResults(ctx context.Context, cmdId int32, scanDatas []StaScanData) error
	OnRssiThresholdBreached(ctx context.Context, cmdId int32, currBssid []byte, currRssi int32) error
	OnTwtFailure(ctx context.Context, cmdId int32, error_ IWifiStaIfaceEventCallbackTwtErrorCode) error
	OnTwtSessionCreate(ctx context.Context, cmdId int32, twtSession TwtSession) error
	OnTwtSessionUpdate(ctx context.Context, cmdId int32, twtSession TwtSession) error
	OnTwtSessionTeardown(ctx context.Context, cmdId int32, twtSessionId int32, reasonCode IWifiStaIfaceEventCallbackTwtTeardownReasonCode) error
	OnTwtSessionStats(ctx context.Context, cmdId int32, twtSessionId int32, twtSessionStats TwtSessionStats) error
	OnTwtSessionSuspend(ctx context.Context, cmdId int32, twtSessionId int32) error
	OnTwtSessionResume(ctx context.Context, cmdId int32, twtSessionId int32) error
}

func NewWifiStaIfaceEventCallbackStub 

func NewWifiStaIfaceEventCallbackStub(
	impl IWifiStaIfaceEventCallbackServer,
) IWifiStaIfaceEventCallback

NewWifiStaIfaceEventCallbackStub creates a server-side IWifiStaIfaceEventCallback wrapping the given server implementation. The returned value satisfies IWifiStaIfaceEventCallback and can be passed to proxy methods; its AsBinder() returns a *binder.StubBinder that is auto-registered with the binder driver on first use.

type IWifiStaIfaceEventCallbackServer 

type IWifiStaIfaceEventCallbackServer interface {
	OnBackgroundFullScanResult(ctx context.Context, cmdId int32, bucketsScanned int32, result StaScanResult) error
	OnBackgroundScanFailure(ctx context.Context, cmdId int32) error
	OnBackgroundScanResults(ctx context.Context, cmdId int32, scanDatas []StaScanData) error
	OnRssiThresholdBreached(ctx context.Context, cmdId int32, currBssid []byte, currRssi int32) error
	OnTwtFailure(ctx context.Context, cmdId int32, error_ IWifiStaIfaceEventCallbackTwtErrorCode) error
	OnTwtSessionCreate(ctx context.Context, cmdId int32, twtSession TwtSession) error
	OnTwtSessionUpdate(ctx context.Context, cmdId int32, twtSession TwtSession) error
	OnTwtSessionTeardown(ctx context.Context, cmdId int32, twtSessionId int32, reasonCode IWifiStaIfaceEventCallbackTwtTeardownReasonCode) error
	OnTwtSessionStats(ctx context.Context, cmdId int32, twtSessionId int32, twtSessionStats TwtSessionStats) error
	OnTwtSessionSuspend(ctx context.Context, cmdId int32, twtSessionId int32) error
	OnTwtSessionResume(ctx context.Context, cmdId int32, twtSessionId int32) error
}

IWifiStaIfaceEventCallbackServer is the server-side interface that user implementations provide to NewWifiStaIfaceEventCallbackStub. It contains only the business methods, without AsBinder (which is provided by the stub itself).

type IWifiStaIfaceEventCallbackTwtErrorCode 

type IWifiStaIfaceEventCallbackTwtErrorCode byte
const (
	IWifiStaIfaceEventCallbackTwtErrorCodeFailureUnknown    IWifiStaIfaceEventCallbackTwtErrorCode = 0
	IWifiStaIfaceEventCallbackTwtErrorCodeAlreadyResumed    IWifiStaIfaceEventCallbackTwtErrorCode = 1
	IWifiStaIfaceEventCallbackTwtErrorCodeAlreadySuspended  IWifiStaIfaceEventCallbackTwtErrorCode = 2
	IWifiStaIfaceEventCallbackTwtErrorCodeInvalidParams     IWifiStaIfaceEventCallbackTwtErrorCode = 3
	IWifiStaIfaceEventCallbackTwtErrorCodeMaxSessionReached IWifiStaIfaceEventCallbackTwtErrorCode = 4
	IWifiStaIfaceEventCallbackTwtErrorCodeNotAvailable      IWifiStaIfaceEventCallbackTwtErrorCode = 5
	IWifiStaIfaceEventCallbackTwtErrorCodeNotSupported      IWifiStaIfaceEventCallbackTwtErrorCode = 6
	IWifiStaIfaceEventCallbackTwtErrorCodePeerNotSupported  IWifiStaIfaceEventCallbackTwtErrorCode = 7
	IWifiStaIfaceEventCallbackTwtErrorCodePeerRejected      IWifiStaIfaceEventCallbackTwtErrorCode = 8
	IWifiStaIfaceEventCallbackTwtErrorCodeTIMEOUT           IWifiStaIfaceEventCallbackTwtErrorCode = 9
)

type IWifiStaIfaceEventCallbackTwtTeardownReasonCode 

type IWifiStaIfaceEventCallbackTwtTeardownReasonCode byte
const (
	IWifiStaIfaceEventCallbackTwtTeardownReasonCodeUNKNOWN             IWifiStaIfaceEventCallbackTwtTeardownReasonCode = 0
	IWifiStaIfaceEventCallbackTwtTeardownReasonCodeLocallyRequested    IWifiStaIfaceEventCallbackTwtTeardownReasonCode = 1
	IWifiStaIfaceEventCallbackTwtTeardownReasonCodeInternallyInitiated IWifiStaIfaceEventCallbackTwtTeardownReasonCode = 2
	IWifiStaIfaceEventCallbackTwtTeardownReasonCodePeerInitiated       IWifiStaIfaceEventCallbackTwtTeardownReasonCode = 3
)

type IWifiStaIfaceFeatureSetMask 

type IWifiStaIfaceFeatureSetMask int32
const (
	IWifiStaIfaceFeatureSetMaskAPF                IWifiStaIfaceFeatureSetMask = (1 << 0)
	IWifiStaIfaceFeatureSetMaskBackgroundScan     IWifiStaIfaceFeatureSetMask = (1 << 1)
	IWifiStaIfaceFeatureSetMaskLinkLayerStats     IWifiStaIfaceFeatureSetMask = (1 << 2)
	IWifiStaIfaceFeatureSetMaskRssiMonitor        IWifiStaIfaceFeatureSetMask = (1 << 3)
	IWifiStaIfaceFeatureSetMaskControlRoaming     IWifiStaIfaceFeatureSetMask = (1 << 4)
	IWifiStaIfaceFeatureSetMaskProbeIeAllowlist   IWifiStaIfaceFeatureSetMask = (1 << 5)
	IWifiStaIfaceFeatureSetMaskScanRand           IWifiStaIfaceFeatureSetMask = (1 << 6)
	IWifiStaIfaceFeatureSetMaskSta5g              IWifiStaIfaceFeatureSetMask = (1 << 7)
	IWifiStaIfaceFeatureSetMaskHOTSPOT            IWifiStaIfaceFeatureSetMask = (1 << 8)
	IWifiStaIfaceFeatureSetMaskPNO                IWifiStaIfaceFeatureSetMask = (1 << 9)
	IWifiStaIfaceFeatureSetMaskTDLS               IWifiStaIfaceFeatureSetMask = (1 << 10)
	IWifiStaIfaceFeatureSetMaskTdlsOffchannel     IWifiStaIfaceFeatureSetMask = (1 << 11)
	IWifiStaIfaceFeatureSetMaskNdOffload          IWifiStaIfaceFeatureSetMask = (1 << 12)
	IWifiStaIfaceFeatureSetMaskKeepAlive          IWifiStaIfaceFeatureSetMask = (1 << 13)
	IWifiStaIfaceFeatureSetMaskRoamingModeControl IWifiStaIfaceFeatureSetMask = (1 << 14)
	IWifiStaIfaceFeatureSetMaskCachedScanData     IWifiStaIfaceFeatureSetMask = (1 << 15)
)

type IWifiStaIfaceServer 

type IWifiStaIfaceServer interface {
	GetName(ctx context.Context) (string, error)
	ConfigureRoaming(ctx context.Context, config StaRoamingConfig) error
	DisableLinkLayerStatsCollection(ctx context.Context) error
	EnableLinkLayerStatsCollection(ctx context.Context, debug bool) error
	EnableNdOffload(ctx context.Context, enable bool) error
	GetApfPacketFilterCapabilities(ctx context.Context) (StaApfPacketFilterCapabilities, error)
	GetBackgroundScanCapabilities(ctx context.Context) (StaBackgroundScanCapabilities, error)
	GetFeatureSet(ctx context.Context) (int32, error)
	GetDebugRxPacketFates(ctx context.Context) ([]WifiDebugRxPacketFateReport, error)
	GetDebugTxPacketFates(ctx context.Context) ([]WifiDebugTxPacketFateReport, error)
	GetFactoryMacAddress(ctx context.Context) ([]byte, error)
	GetLinkLayerStats(ctx context.Context) (StaLinkLayerStats, error)
	GetRoamingCapabilities(ctx context.Context) (StaRoamingCapabilities, error)
	InstallApfPacketFilter(ctx context.Context, program []byte) error
	ReadApfPacketFilterData(ctx context.Context) ([]byte, error)
	RegisterEventCallback(ctx context.Context, callback IWifiStaIfaceEventCallback) error
	SetMacAddress(ctx context.Context, mac []byte) error
	SetRoamingState(ctx context.Context, state StaRoamingState) error
	SetScanMode(ctx context.Context, enable bool) error
	StartBackgroundScan(ctx context.Context, cmdId int32, params StaBackgroundScanParameters) error
	StartDebugPacketFateMonitoring(ctx context.Context) error
	StartRssiMonitoring(ctx context.Context, cmdId int32, maxRssi int32, minRssi int32) error
	StartSendingKeepAlivePackets(ctx context.Context, cmdId int32, ipPacketData []byte, etherType uint16, srcAddress []byte, dstAddress []byte, periodInMs int32) error
	StopBackgroundScan(ctx context.Context, cmdId int32) error
	StopRssiMonitoring(ctx context.Context, cmdId int32) error
	StopSendingKeepAlivePackets(ctx context.Context, cmdId int32) error
	SetDtimMultiplier(ctx context.Context, multiplier int32) error
	GetCachedScanData(ctx context.Context) (CachedScanData, error)
	TwtGetCapabilities(ctx context.Context) (TwtCapabilities, error)
	TwtSessionSetup(ctx context.Context, cmdId int32, twtRequest TwtRequest) error
	TwtSessionUpdate(ctx context.Context, cmdId int32, sessionId int32, twtRequest TwtRequest) error
	TwtSessionSuspend(ctx context.Context, cmdId int32, sessionId int32) error
	TwtSessionResume(ctx context.Context, cmdId int32, sessionId int32) error
	TwtSessionTeardown(ctx context.Context, cmdId int32, sessionId int32) error
	TwtSessionGetStats(ctx context.Context, cmdId int32, sessionId int32) error
}

IWifiStaIfaceServer is the server-side interface that user implementations provide to NewWifiStaIfaceStub. It contains only the business methods, without AsBinder (which is provided by the stub itself).

type IfaceConcurrencyType 

type IfaceConcurrencyType int32
const (
	IfaceConcurrencyTypeSTA       IfaceConcurrencyType = 0
	IfaceConcurrencyTypeAP        IfaceConcurrencyType = 1
	IfaceConcurrencyTypeApBridged IfaceConcurrencyType = 2
	IfaceConcurrencyTypeP2P       IfaceConcurrencyType = 3
	IfaceConcurrencyTypeNanIface  IfaceConcurrencyType = 4
)

type IfaceType 

type IfaceType int32
const (
	IfaceTypeSTA      IfaceType = 0
	IfaceTypeAP       IfaceType = 1
	IfaceTypeP2P      IfaceType = 2
	IfaceTypeNanIface IfaceType = 3
)

type MacAddress 

type MacAddress struct {
	Data []byte
}

func (*MacAddress) MarshalParcel 

func (s *MacAddress) MarshalParcel(
	p *parcel.Parcel,
) error

func (*MacAddress) UnmarshalParcel 

func (s *MacAddress) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanBandIndex 

type NanBandIndex int32
const (
	NanBandIndexNanBand24ghz NanBandIndex = 0
	NanBandIndexNanBand5ghz  NanBandIndex = 1
	NanBandIndexNanBand6ghz  NanBandIndex = 2
)

type NanBandSpecificConfig 

type NanBandSpecificConfig struct {
	RssiClose                       byte
	RssiMiddle                      byte
	RssiCloseProximity              byte
	DwellTimeMs                     uint16
	ScanPeriodSec                   uint16
	ValidDiscoveryWindowIntervalVal bool
	DiscoveryWindowIntervalVal      byte
}

func (*NanBandSpecificConfig) MarshalParcel 

func (s *NanBandSpecificConfig) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanBandSpecificConfig) UnmarshalParcel 

func (s *NanBandSpecificConfig) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanBootstrappingConfirmInd 

type NanBootstrappingConfirmInd struct {
	BootstrappingInstanceId int32
	ResponseCode            NanBootstrappingResponseCode
	ReasonCode              NanStatus
	ComeBackDelay           int32
	Cookie                  []byte
}

func (*NanBootstrappingConfirmInd) MarshalParcel 

func (s *NanBootstrappingConfirmInd) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanBootstrappingConfirmInd) UnmarshalParcel 

func (s *NanBootstrappingConfirmInd) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanBootstrappingMethod 

type NanBootstrappingMethod int32
const (
	NanBootstrappingMethodBootstrappingOpportunisticMask     NanBootstrappingMethod = (1 << 0)
	NanBootstrappingMethodBootstrappingPinCodeDisplayMask    NanBootstrappingMethod = (1 << 1)
	NanBootstrappingMethodBootstrappingPassphraseDisplayMask NanBootstrappingMethod = (1 << 2)
	NanBootstrappingMethodBootstrappingQrDisplayMask         NanBootstrappingMethod = (1 << 3)
	NanBootstrappingMethodBootstrappingNfcTagMask            NanBootstrappingMethod = (1 << 4)
	NanBootstrappingMethodBootstrappingPinCodeKeypadMask     NanBootstrappingMethod = (1 << 5)
	NanBootstrappingMethodBootstrappingPassphraseKeypadMask  NanBootstrappingMethod = (1 << 6)
	NanBootstrappingMethodBootstrappingQrScanMask            NanBootstrappingMethod = (1 << 7)
	NanBootstrappingMethodBootstrappingNfcReaderMask         NanBootstrappingMethod = (1 << 8)
	NanBootstrappingMethodBootstrappingServiceManagedMask    NanBootstrappingMethod = (1 << 14)
	NanBootstrappingMethodBootstrappingHandshakeShipMask     NanBootstrappingMethod = (1 << 15)
)

type NanBootstrappingRequest 

type NanBootstrappingRequest struct {
	PeerId                     int32
	PeerDiscMacAddr            []byte
	RequestBootstrappingMethod NanBootstrappingMethod
	Cookie                     []byte
	IsComeback                 bool
	DiscoverySessionId         byte
}

func (*NanBootstrappingRequest) MarshalParcel 

func (s *NanBootstrappingRequest) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanBootstrappingRequest) UnmarshalParcel 

func (s *NanBootstrappingRequest) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanBootstrappingRequestInd 

type NanBootstrappingRequestInd struct {
	DiscoverySessionId         byte
	PeerId                     int32
	PeerDiscMacAddr            []byte
	BootstrappingInstanceId    int32
	RequestBootstrappingMethod NanBootstrappingMethod
}

func (*NanBootstrappingRequestInd) MarshalParcel 

func (s *NanBootstrappingRequestInd) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanBootstrappingRequestInd) UnmarshalParcel 

func (s *NanBootstrappingRequestInd) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanBootstrappingResponse 

type NanBootstrappingResponse struct {
	BootstrappingInstanceId int32
	AcceptRequest           bool
	DiscoverySessionId      byte
}

func (*NanBootstrappingResponse) MarshalParcel 

func (s *NanBootstrappingResponse) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanBootstrappingResponse) UnmarshalParcel 

func (s *NanBootstrappingResponse) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanBootstrappingResponseCode 

type NanBootstrappingResponseCode int32
const (
	NanBootstrappingResponseCodeNanBootstrappingRequestAccept   NanBootstrappingResponseCode = 0
	NanBootstrappingResponseCodeNanBootstrappingRequestReject   NanBootstrappingResponseCode = 1
	NanBootstrappingResponseCodeNanBootstrappingRequestComeback NanBootstrappingResponseCode = 2
)

type NanCapabilities 

type NanCapabilities struct {
	MaxConcurrentClusters               int32
	MaxPublishes                        int32
	MaxSubscribes                       int32
	MaxServiceNameLen                   int32
	MaxMatchFilterLen                   int32
	MaxTotalMatchFilterLen              int32
	MaxServiceSpecificInfoLen           int32
	MaxExtendedServiceSpecificInfoLen   int32
	MaxNdiInterfaces                    int32
	MaxNdpSessions                      int32
	MaxAppInfoLen                       int32
	MaxQueuedTransmitFollowupMsgs       int32
	MaxSubscribeInterfaceAddresses      int32
	SupportedCipherSuites               int32
	InstantCommunicationModeSupportFlag bool
	Supports6g                          bool
	SupportsHe                          bool
	SupportsPairing                     bool
	SupportsSetClusterId                bool
	SupportsSuspension                  bool
}

func (*NanCapabilities) MarshalParcel 

func (s *NanCapabilities) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanCapabilities) UnmarshalParcel 

func (s *NanCapabilities) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanCipherSuiteType 

type NanCipherSuiteType int32
const (
	NanCipherSuiteTypeNONE                 NanCipherSuiteType = 0
	NanCipherSuiteTypeSharedKey128Mask     NanCipherSuiteType = (1 << 0)
	NanCipherSuiteTypeSharedKey256Mask     NanCipherSuiteType = (1 << 1)
	NanCipherSuiteTypePublicKey2wdh128Mask NanCipherSuiteType = (1 << 2)
	NanCipherSuiteTypePublicKey2wdh256Mask NanCipherSuiteType = (1 << 3)
	NanCipherSuiteTypePublicKeyPasn128Mask NanCipherSuiteType = (1 << 6)
	NanCipherSuiteTypePublicKeyPasn256Mask NanCipherSuiteType = (1 << 7)
)

type NanClusterEventInd 

type NanClusterEventInd struct {
	EventType NanClusterEventType
	Addr      []byte
}

func (*NanClusterEventInd) MarshalParcel 

func (s *NanClusterEventInd) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanClusterEventInd) UnmarshalParcel 

func (s *NanClusterEventInd) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanClusterEventType 

type NanClusterEventType int32
const (
	NanClusterEventTypeDiscoveryMacAddressChanged NanClusterEventType = 0
	NanClusterEventTypeStartedCluster             NanClusterEventType = 1
	NanClusterEventTypeJoinedCluster              NanClusterEventType = 2
)

type NanConfigRequest 

type NanConfigRequest struct {
	MasterPref                              byte
	DisableDiscoveryAddressChangeIndication bool
	DisableStartedClusterIndication         bool
	DisableJoinedClusterIndication          bool
	IncludePublishServiceIdsInBeacon        bool
	NumberOfPublishServiceIdsInBeacon       byte
	IncludeSubscribeServiceIdsInBeacon      bool
	NumberOfSubscribeServiceIdsInBeacon     byte
	RssiWindowSize                          uint16
	MacAddressRandomizationIntervalSec      int32
	BandSpecificConfig                      []NanBandSpecificConfig
	VendorData                              []common.OuiKeyedData
}

func (*NanConfigRequest) MarshalParcel 

func (s *NanConfigRequest) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanConfigRequest) UnmarshalParcel 

func (s *NanConfigRequest) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanConfigRequestSupplemental 

type NanConfigRequestSupplemental struct {
	DiscoveryBeaconIntervalMs             int32
	NumberOfSpatialStreamsInDiscovery     int32
	EnableDiscoveryWindowEarlyTermination bool
	EnableRanging                         bool
	EnableInstantCommunicationMode        bool
	InstantModeChannel                    int32
	ClusterId                             int32
}

func (*NanConfigRequestSupplemental) MarshalParcel 

func (s *NanConfigRequestSupplemental) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanConfigRequestSupplemental) UnmarshalParcel 

func (s *NanConfigRequestSupplemental) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanDataPathChannelCfg 

type NanDataPathChannelCfg int32
const (
	NanDataPathChannelCfgChannelNotRequested NanDataPathChannelCfg = 0
	NanDataPathChannelCfgRequestChannelSetup NanDataPathChannelCfg = 1
	NanDataPathChannelCfgForceChannelSetup   NanDataPathChannelCfg = 2
)

type NanDataPathChannelInfo 

type NanDataPathChannelInfo struct {
	ChannelFreq       int32
	ChannelBandwidth  WifiChannelWidthInMhz
	NumSpatialStreams int32
}

func (*NanDataPathChannelInfo) MarshalParcel 

func (s *NanDataPathChannelInfo) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanDataPathChannelInfo) UnmarshalParcel 

func (s *NanDataPathChannelInfo) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanDataPathConfirmInd 

type NanDataPathConfirmInd struct {
	NdpInstanceId        int32
	DataPathSetupSuccess bool
	PeerNdiMacAddr       []byte
	AppInfo              []byte
	Status               NanStatus
	ChannelInfo          []NanDataPathChannelInfo
}

func (*NanDataPathConfirmInd) MarshalParcel 

func (s *NanDataPathConfirmInd) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanDataPathConfirmInd) UnmarshalParcel 

func (s *NanDataPathConfirmInd) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanDataPathRequestInd 

type NanDataPathRequestInd struct {
	DiscoverySessionId byte
	PeerDiscMacAddr    []byte
	NdpInstanceId      int32
	SecurityRequired   bool
	AppInfo            []byte
}

func (*NanDataPathRequestInd) MarshalParcel 

func (s *NanDataPathRequestInd) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanDataPathRequestInd) UnmarshalParcel 

func (s *NanDataPathRequestInd) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanDataPathScheduleUpdateInd 

type NanDataPathScheduleUpdateInd struct {
	PeerDiscoveryAddress []byte
	ChannelInfo          []NanDataPathChannelInfo
	NdpInstanceIds       []int32
}

func (*NanDataPathScheduleUpdateInd) MarshalParcel 

func (s *NanDataPathScheduleUpdateInd) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanDataPathScheduleUpdateInd) UnmarshalParcel 

func (s *NanDataPathScheduleUpdateInd) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanDataPathSecurityConfig 

type NanDataPathSecurityConfig struct {
	SecurityType                    NanDataPathSecurityType
	CipherType                      NanCipherSuiteType
	Pmk                             []byte
	Passphrase                      []byte
	Scid                            []byte
	Enable16ReplyCountersForTksa    bool
	Enable16ReplyCountersForGtksa   bool
	SupportGtkAndIgtk               bool
	SupportBigtksa                  bool
	EnableNcsBip256                 bool
	RequiresEnhancedFrameProtection bool
}

func (*NanDataPathSecurityConfig) MarshalParcel 

func (s *NanDataPathSecurityConfig) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanDataPathSecurityConfig) UnmarshalParcel 

func (s *NanDataPathSecurityConfig) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanDataPathSecurityType 

type NanDataPathSecurityType int32
const (
	NanDataPathSecurityTypeOPEN       NanDataPathSecurityType = 0
	NanDataPathSecurityTypePMK        NanDataPathSecurityType = 1
	NanDataPathSecurityTypePASSPHRASE NanDataPathSecurityType = 2
)

type NanDebugConfig 

type NanDebugConfig struct {
	ValidClusterIdVals        bool
	ClusterIdBottomRangeVal   uint16
	ClusterIdTopRangeVal      uint16
	ValidIntfAddrVal          bool
	IntfAddrVal               []byte
	ValidOuiVal               bool
	OuiVal                    int32
	ValidRandomFactorForceVal bool
	RandomFactorForceVal      byte
	ValidHopCountForceVal     bool
	HopCountForceVal          byte
	ValidDiscoveryChannelVal  bool
	DiscoveryChannelMhzVal    []int32
	ValidUseBeaconsInBandVal  bool
	UseBeaconsInBandVal       []bool
	ValidUseSdfInBandVal      bool
	UseSdfInBandVal           []bool
}

func (*NanDebugConfig) MarshalParcel 

func (s *NanDebugConfig) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanDebugConfig) UnmarshalParcel 

func (s *NanDebugConfig) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanDiscoveryCommonConfig 

type NanDiscoveryCommonConfig struct {
	SessionId                             byte
	TtlSec                                uint16
	DiscoveryWindowPeriod                 uint16
	DiscoveryCount                        byte
	ServiceName                           []byte
	DiscoveryMatchIndicator               NanMatchAlg
	ServiceSpecificInfo                   []byte
	ExtendedServiceSpecificInfo           []byte
	RxMatchFilter                         []byte
	TxMatchFilter                         []byte
	UseRssiThreshold                      bool
	DisableDiscoveryTerminationIndication bool
	DisableMatchExpirationIndication      bool
	DisableFollowupReceivedIndication     bool
	SecurityConfig                        NanDataPathSecurityConfig
	RangingRequired                       bool
	RangingIntervalMs                     int32
	ConfigRangingIndications              int32
	DistanceIngressCm                     uint16
	DistanceEgressCm                      uint16
	EnableSessionSuspendability           bool
}

func (*NanDiscoveryCommonConfig) MarshalParcel 

func (s *NanDiscoveryCommonConfig) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanDiscoveryCommonConfig) UnmarshalParcel 

func (s *NanDiscoveryCommonConfig) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanEnableRequest 

type NanEnableRequest struct {
	OperateInBand []bool
	HopCountMax   byte
	ConfigParams  NanConfigRequest
	DebugConfigs  NanDebugConfig
}

func (*NanEnableRequest) MarshalParcel 

func (s *NanEnableRequest) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanEnableRequest) UnmarshalParcel 

func (s *NanEnableRequest) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanFollowupReceivedInd 

type NanFollowupReceivedInd struct {
	DiscoverySessionId          byte
	PeerId                      int32
	Addr                        []byte
	ReceivedInFaw               bool
	ServiceSpecificInfo         []byte
	ExtendedServiceSpecificInfo []byte
}

func (*NanFollowupReceivedInd) MarshalParcel 

func (s *NanFollowupReceivedInd) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanFollowupReceivedInd) UnmarshalParcel 

func (s *NanFollowupReceivedInd) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanIdentityResolutionAttribute 

type NanIdentityResolutionAttribute struct {
	Nonce []byte
	Tag   []byte
}

func (*NanIdentityResolutionAttribute) MarshalParcel 

func (s *NanIdentityResolutionAttribute) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanIdentityResolutionAttribute) UnmarshalParcel 

func (s *NanIdentityResolutionAttribute) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanInitiateDataPathRequest 

type NanInitiateDataPathRequest struct {
	PeerId               int32
	PeerDiscMacAddr      []byte
	ChannelRequestType   NanDataPathChannelCfg
	Channel              int32
	IfaceName            string
	SecurityConfig       NanDataPathSecurityConfig
	AppInfo              []byte
	ServiceNameOutOfBand []byte
	DiscoverySessionId   byte
}

func (*NanInitiateDataPathRequest) MarshalParcel 

func (s *NanInitiateDataPathRequest) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanInitiateDataPathRequest) UnmarshalParcel 

func (s *NanInitiateDataPathRequest) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanMatchAlg 

type NanMatchAlg int32
const (
	NanMatchAlgMatchOnce       NanMatchAlg = 0
	NanMatchAlgMatchContinuous NanMatchAlg = 1
	NanMatchAlgMatchNever      NanMatchAlg = 2
)

type NanMatchInd 

type NanMatchInd struct {
	DiscoverySessionId               byte
	PeerId                           int32
	Addr                             []byte
	ServiceSpecificInfo              []byte
	ExtendedServiceSpecificInfo      []byte
	MatchFilter                      []byte
	MatchOccurredInBeaconFlag        bool
	OutOfResourceFlag                bool
	RssiValue                        byte
	PeerCipherType                   NanCipherSuiteType
	PeerRequiresSecurityEnabledInNdp bool
	PeerRequiresRanging              bool
	RangingMeasurementInMm           int32
	RangingIndicationType            int32
	Scid                             []byte
	PeerPairingConfig                NanPairingConfig
	PeerNira                         NanIdentityResolutionAttribute
	VendorData                       []common.OuiKeyedData
}

func (*NanMatchInd) MarshalParcel 

func (s *NanMatchInd) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanMatchInd) UnmarshalParcel 

func (s *NanMatchInd) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanPairingAkm 

type NanPairingAkm int32
const (
	NanPairingAkmSAE  NanPairingAkm = 0
	NanPairingAkmPASN NanPairingAkm = 1
)

type NanPairingConfig 

type NanPairingConfig struct {
	EnablePairingSetup            bool
	EnablePairingCache            bool
	EnablePairingVerification     bool
	SupportedBootstrappingMethods int32
}

func (*NanPairingConfig) MarshalParcel 

func (s *NanPairingConfig) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanPairingConfig) UnmarshalParcel 

func (s *NanPairingConfig) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanPairingConfirmInd 

type NanPairingConfirmInd struct {
	PairingInstanceId  int32
	PairingSuccess     bool
	Status             NanStatus
	RequestType        NanPairingRequestType
	EnablePairingCache bool
	Npksa              NpkSecurityAssociation
	VendorData         []common.OuiKeyedData
}

func (*NanPairingConfirmInd) MarshalParcel 

func (s *NanPairingConfirmInd) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanPairingConfirmInd) UnmarshalParcel 

func (s *NanPairingConfirmInd) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanPairingRequest 

type NanPairingRequest struct {
	PeerId             int32
	PeerDiscMacAddr    []byte
	RequestType        NanPairingRequestType
	EnablePairingCache bool
	PairingIdentityKey []byte
	SecurityConfig     NanPairingSecurityConfig
	VendorData         []common.OuiKeyedData
}

func (*NanPairingRequest) MarshalParcel 

func (s *NanPairingRequest) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanPairingRequest) UnmarshalParcel 

func (s *NanPairingRequest) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanPairingRequestInd 

type NanPairingRequestInd struct {
	DiscoverySessionId byte
	PeerId             int32
	PeerDiscMacAddr    []byte
	PairingInstanceId  int32
	RequestType        NanPairingRequestType
	EnablePairingCache bool
	PeerNira           NanIdentityResolutionAttribute
	VendorData         []common.OuiKeyedData
}

func (*NanPairingRequestInd) MarshalParcel 

func (s *NanPairingRequestInd) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanPairingRequestInd) UnmarshalParcel 

func (s *NanPairingRequestInd) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanPairingRequestType 

type NanPairingRequestType int32
const (
	NanPairingRequestTypeNanPairingSetup        NanPairingRequestType = 0
	NanPairingRequestTypeNanPairingVerification NanPairingRequestType = 1
)

type NanPairingSecurityConfig 

type NanPairingSecurityConfig struct {
	SecurityType NanPairingSecurityType
	Pmk          []byte
	Passphrase   []byte
	Akm          NanPairingAkm
	CipherType   NanCipherSuiteType
}

func (*NanPairingSecurityConfig) MarshalParcel 

func (s *NanPairingSecurityConfig) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanPairingSecurityConfig) UnmarshalParcel 

func (s *NanPairingSecurityConfig) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanPairingSecurityType 

type NanPairingSecurityType int32
const (
	NanPairingSecurityTypeOPPORTUNISTIC NanPairingSecurityType = 0
	NanPairingSecurityTypePMK           NanPairingSecurityType = 1
	NanPairingSecurityTypePASSPHRASE    NanPairingSecurityType = 2
)

type NanPublishRequest 

type NanPublishRequest struct {
	BaseConfigs                NanDiscoveryCommonConfig
	PublishType                NanPublishType
	TxType                     NanTxType
	AutoAcceptDataPathRequests bool
	PairingConfig              NanPairingConfig
	IdentityKey                []byte
	VendorData                 []common.OuiKeyedData
}

func (*NanPublishRequest) MarshalParcel 

func (s *NanPublishRequest) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanPublishRequest) UnmarshalParcel 

func (s *NanPublishRequest) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanPublishType 

type NanPublishType int32
const (
	NanPublishTypeUNSOLICITED          NanPublishType = 0
	NanPublishTypeSOLICITED            NanPublishType = 1
	NanPublishTypeUnsolicitedSolicited NanPublishType = 2
)

type NanRangingIndication 

type NanRangingIndication int32
const (
	NanRangingIndicationContinuousIndicationMask NanRangingIndication = (1 << 0)
	NanRangingIndicationIngressMetMask           NanRangingIndication = (1 << 1)
	NanRangingIndicationEgressMetMask            NanRangingIndication = (1 << 2)
)

type NanRespondToDataPathIndicationRequest 

type NanRespondToDataPathIndicationRequest struct {
	AcceptRequest        bool
	NdpInstanceId        int32
	IfaceName            string
	SecurityConfig       NanDataPathSecurityConfig
	AppInfo              []byte
	ServiceNameOutOfBand []byte
	DiscoverySessionId   byte
}

func (*NanRespondToDataPathIndicationRequest) MarshalParcel 

func (s *NanRespondToDataPathIndicationRequest) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanRespondToDataPathIndicationRequest) UnmarshalParcel 

func (s *NanRespondToDataPathIndicationRequest) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanRespondToPairingIndicationRequest 

type NanRespondToPairingIndicationRequest struct {
	AcceptRequest      bool
	PairingInstanceId  int32
	RequestType        NanPairingRequestType
	EnablePairingCache bool
	PairingIdentityKey []byte
	SecurityConfig     NanPairingSecurityConfig
	VendorData         []common.OuiKeyedData
}

func (*NanRespondToPairingIndicationRequest) MarshalParcel 

func (s *NanRespondToPairingIndicationRequest) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanRespondToPairingIndicationRequest) UnmarshalParcel 

func (s *NanRespondToPairingIndicationRequest) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanSrfType 

type NanSrfType int32
const (
	NanSrfTypeBloomFilter    NanSrfType = 0
	NanSrfTypePartialMacAddr NanSrfType = 1
)

type NanStatus 

type NanStatus struct {
	Status      NanStatusCode
	Description string
}

func (*NanStatus) MarshalParcel 

func (s *NanStatus) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanStatus) UnmarshalParcel 

func (s *NanStatus) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanStatusCode 

type NanStatusCode int32
const (
	NanStatusCodeSUCCESS                           NanStatusCode = 0
	NanStatusCodeInternalFailure                   NanStatusCode = 1
	NanStatusCodeProtocolFailure                   NanStatusCode = 2
	NanStatusCodeInvalidSessionId                  NanStatusCode = 3
	NanStatusCodeNoResourcesAvailable              NanStatusCode = 4
	NanStatusCodeInvalidArgs                       NanStatusCode = 5
	NanStatusCodeInvalidPeerId                     NanStatusCode = 6
	NanStatusCodeInvalidNdpId                      NanStatusCode = 7
	NanStatusCodeNanNotAllowed                     NanStatusCode = 8
	NanStatusCodeNoOtaAck                          NanStatusCode = 9
	NanStatusCodeAlreadyEnabled                    NanStatusCode = 10
	NanStatusCodeFollowupTxQueueFull               NanStatusCode = 11
	NanStatusCodeUnsupportedConcurrencyNanDisabled NanStatusCode = 12
	NanStatusCodeInvalidPairingId                  NanStatusCode = 13
	NanStatusCodeInvalidBootstrappingId            NanStatusCode = 14
	NanStatusCodeRedundantRequest                  NanStatusCode = 15
	NanStatusCodeNotSupported                      NanStatusCode = 16
	NanStatusCodeNoConnection                      NanStatusCode = 17
)

type NanSubscribeRequest 

type NanSubscribeRequest struct {
	BaseConfigs              NanDiscoveryCommonConfig
	SubscribeType            NanSubscribeType
	SrfType                  NanSrfType
	SrfRespondIfInAddressSet bool
	ShouldUseSrf             bool
	IsSsiRequiredForMatch    bool
	IntfAddr                 []MacAddress
	PairingConfig            NanPairingConfig
	IdentityKey              []byte
	VendorData               []common.OuiKeyedData
}

func (*NanSubscribeRequest) MarshalParcel 

func (s *NanSubscribeRequest) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanSubscribeRequest) UnmarshalParcel 

func (s *NanSubscribeRequest) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanSubscribeType 

type NanSubscribeType int32
const (
	NanSubscribeTypePASSIVE NanSubscribeType = 0
	NanSubscribeTypeACTIVE  NanSubscribeType = 1
)

type NanSuspensionModeChangeInd 

type NanSuspensionModeChangeInd struct {
	IsSuspended bool
}

func (*NanSuspensionModeChangeInd) MarshalParcel 

func (s *NanSuspensionModeChangeInd) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanSuspensionModeChangeInd) UnmarshalParcel 

func (s *NanSuspensionModeChangeInd) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanTransmitFollowupRequest 

type NanTransmitFollowupRequest struct {
	DiscoverySessionId              byte
	PeerId                          int32
	Addr                            []byte
	IsHighPriority                  bool
	ShouldUseDiscoveryWindow        bool
	ServiceSpecificInfo             []byte
	ExtendedServiceSpecificInfo     []byte
	DisableFollowupResultIndication bool
}

func (*NanTransmitFollowupRequest) MarshalParcel 

func (s *NanTransmitFollowupRequest) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NanTransmitFollowupRequest) UnmarshalParcel 

func (s *NanTransmitFollowupRequest) UnmarshalParcel(
	p *parcel.Parcel,
) error

type NanTxType 

type NanTxType int32
const (
	NanTxTypeBROADCAST NanTxType = 0
	NanTxTypeUNICAST   NanTxType = 1
)

type NpkSecurityAssociation 

type NpkSecurityAssociation struct {
	PeerNanIdentityKey  []byte
	LocalNanIdentityKey []byte
	Npk                 []byte
	Akm                 NanPairingAkm
	CipherType          NanCipherSuiteType
}

func (*NpkSecurityAssociation) MarshalParcel 

func (s *NpkSecurityAssociation) MarshalParcel(
	p *parcel.Parcel,
) error

func (*NpkSecurityAssociation) UnmarshalParcel 

func (s *NpkSecurityAssociation) UnmarshalParcel(
	p *parcel.Parcel,
) error

type RttBw 

type RttBw int32
const (
	RttBwBwUnspecified RttBw = 0
	RttBwBw5mhz        RttBw = 1
	RttBwBw10mhz       RttBw = 2
	RttBwBw20mhz       RttBw = 4
	RttBwBw40mhz       RttBw = 8
	RttBwBw80mhz       RttBw = 16
	RttBwBw160mhz      RttBw = 32
	RttBwBw320mhz      RttBw = 64
)

type RttCapabilities 

type RttCapabilities struct {
	RttOneSidedSupported  bool
	RttFtmSupported       bool
	LciSupported          bool
	LcrSupported          bool
	ResponderSupported    bool
	PreambleSupport       RttPreamble
	BwSupport             RttBw
	McVersion             byte
	AzPreambleSupport     int32
	AzBwSupport           int32
	NtbInitiatorSupported bool
	NtbResponderSupported bool
	VendorData            []common.OuiKeyedData
}

func (*RttCapabilities) MarshalParcel 

func (s *RttCapabilities) MarshalParcel(
	p *parcel.Parcel,
) error

func (*RttCapabilities) UnmarshalParcel 

func (s *RttCapabilities) UnmarshalParcel(
	p *parcel.Parcel,
) error

type RttConfig 

type RttConfig struct {
	Addr                  []byte
	Type                  RttType
	Peer                  RttPeerType
	Channel               WifiChannelInfo
	BurstPeriod           int32
	NumBurst              int32
	NumFramesPerBurst     int32
	NumRetriesPerRttFrame int32
	NumRetriesPerFtmr     int32
	MustRequestLci        bool
	MustRequestLcr        bool
	BurstDuration         int32
	Preamble              RttPreamble
	Bw                    RttBw
	NtbMinMeasurementTime int64
	NtbMaxMeasurementTime int64
	VendorData            []common.OuiKeyedData
}

func (*RttConfig) MarshalParcel 

func (s *RttConfig) MarshalParcel(
	p *parcel.Parcel,
) error

func (*RttConfig) UnmarshalParcel 

func (s *RttConfig) UnmarshalParcel(
	p *parcel.Parcel,
) error

type RttLciInformation 

type RttLciInformation struct {
	Latitude         int64
	Longitude        int64
	Altitude         int32
	LatitudeUnc      byte
	LongitudeUnc     byte
	AltitudeUnc      byte
	MotionPattern    RttMotionPattern
	Floor            int32
	HeightAboveFloor int32
	HeightUnc        int32
}

func (*RttLciInformation) MarshalParcel 

func (s *RttLciInformation) MarshalParcel(
	p *parcel.Parcel,
) error

func (*RttLciInformation) UnmarshalParcel 

func (s *RttLciInformation) UnmarshalParcel(
	p *parcel.Parcel,
) error

type RttLcrInformation 

type RttLcrInformation struct {
	CountryCode []byte
	CivicInfo   string
}

func (*RttLcrInformation) MarshalParcel 

func (s *RttLcrInformation) MarshalParcel(
	p *parcel.Parcel,
) error

func (*RttLcrInformation) UnmarshalParcel 

func (s *RttLcrInformation) UnmarshalParcel(
	p *parcel.Parcel,
) error

type RttMotionPattern 

type RttMotionPattern int32
const (
	RttMotionPatternNotExpected RttMotionPattern = 0
	RttMotionPatternEXPECTED    RttMotionPattern = 1
	RttMotionPatternUNKNOWN     RttMotionPattern = 2
)

type RttPeerType 

type RttPeerType int32
const (
	RttPeerTypeAP        RttPeerType = 1
	RttPeerTypeSTA       RttPeerType = 2
	RttPeerTypeP2pGo     RttPeerType = 3
	RttPeerTypeP2pClient RttPeerType = 4
	RttPeerTypeNanType   RttPeerType = 5
)

type RttPreamble 

type RttPreamble int32
const (
	RttPreambleINVALID RttPreamble = 0
	RttPreambleLEGACY  RttPreamble = 1
	RttPreambleHT      RttPreamble = 2
	RttPreambleVHT     RttPreamble = 4
	RttPreambleHE      RttPreamble = 8
	RttPreambleEHT     RttPreamble = 16
)

type RttResponder 

type RttResponder struct {
	Channel  WifiChannelInfo
	Preamble RttPreamble
}

func (*RttResponder) MarshalParcel 

func (s *RttResponder) MarshalParcel(
	p *parcel.Parcel,
) error

func (*RttResponder) UnmarshalParcel 

func (s *RttResponder) UnmarshalParcel(
	p *parcel.Parcel,
) error

type RttResult 

type RttResult struct {
	Addr                    []byte
	BurstNum                int32
	MeasurementNumber       int32
	SuccessNumber           int32
	NumberPerBurstPeer      byte
	Status                  RttStatus
	RetryAfterDuration      byte
	Type                    RttType
	Rssi                    int32
	RssiSpread              int32
	TxRate                  WifiRateInfo
	RxRate                  WifiRateInfo
	Rtt                     int64
	RttSd                   int64
	RttSpread               int64
	DistanceInMm            int32
	DistanceSdInMm          int32
	DistanceSpreadInMm      int32
	TimeStampInUs           int64
	BurstDurationInMs       int32
	NegotiatedBurstNum      int32
	Lci                     WifiInformationElement
	Lcr                     WifiInformationElement
	ChannelFreqMHz          int32
	PacketBw                RttBw
	I2rTxLtfRepetitionCount byte
	R2iTxLtfRepetitionCount byte
	NtbMinMeasurementTime   int64
	NtbMaxMeasurementTime   int64
	NumTxSpatialStreams     byte
	NumRxSpatialStreams     byte
	VendorData              []common.OuiKeyedData
}

func (*RttResult) MarshalParcel 

func (s *RttResult) MarshalParcel(
	p *parcel.Parcel,
) error

func (*RttResult) UnmarshalParcel 

func (s *RttResult) UnmarshalParcel(
	p *parcel.Parcel,
) error

type RttStatus 

type RttStatus int32
const (
	RttStatusSUCCESS                           RttStatus = 0
	RttStatusFAILURE                           RttStatus = 1
	RttStatusFailNoRsp                         RttStatus = 2
	RttStatusFailRejected                      RttStatus = 3
	RttStatusFailNotScheduledYet               RttStatus = 4
	RttStatusFailTmTimeout                     RttStatus = 5
	RttStatusFailApOnDiffChannel               RttStatus = 6
	RttStatusFailNoCapability                  RttStatus = 7
	RttStatusABORTED                           RttStatus = 8
	RttStatusFailInvalidTs                     RttStatus = 9
	RttStatusFailProtocol                      RttStatus = 10
	RttStatusFailSchedule                      RttStatus = 11
	RttStatusFailBusyTryLater                  RttStatus = 12
	RttStatusInvalidReq                        RttStatus = 13
	RttStatusNoWifi                            RttStatus = 14
	RttStatusFailFtmParamOverride              RttStatus = 15
	RttStatusNanRangingProtocolFailure         RttStatus = 16
	RttStatusNanRangingConcurrencyNotSupported RttStatus = 17
)

type RttType 

type RttType int32
const (
	RttTypeOneSided        RttType = 1
	RttTypeTwoSided        RttType = 2
	RttTypeTwoSided11mc    RttType = RttTypeTwoSided
	RttTypeTwoSided11azNtb RttType = 3
)

type Ssid 

type Ssid struct {
	Data []byte
}

func (*Ssid) MarshalParcel 

func (s *Ssid) MarshalParcel(
	p *parcel.Parcel,
) error

func (*Ssid) UnmarshalParcel 

func (s *Ssid) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaApfPacketFilterCapabilities 

type StaApfPacketFilterCapabilities struct {
	Version   int32
	MaxLength int32
}

func (*StaApfPacketFilterCapabilities) MarshalParcel 

func (s *StaApfPacketFilterCapabilities) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaApfPacketFilterCapabilities) UnmarshalParcel 

func (s *StaApfPacketFilterCapabilities) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaBackgroundScanBucketEventReportSchemeMask 

type StaBackgroundScanBucketEventReportSchemeMask int32
const (
	StaBackgroundScanBucketEventReportSchemeMaskEachScan    StaBackgroundScanBucketEventReportSchemeMask = (1 << 0)
	StaBackgroundScanBucketEventReportSchemeMaskFullResults StaBackgroundScanBucketEventReportSchemeMask = (1 << 1)
	StaBackgroundScanBucketEventReportSchemeMaskNoBatch     StaBackgroundScanBucketEventReportSchemeMask = (1 << 2)
)

type StaBackgroundScanBucketParameters 

type StaBackgroundScanBucketParameters struct {
	BucketIdx                int32
	Band                     WifiBand
	Frequencies              []int32
	PeriodInMs               int32
	EventReportScheme        int32
	ExponentialMaxPeriodInMs int32
	ExponentialBase          int32
	ExponentialStepCount     int32
}

func (*StaBackgroundScanBucketParameters) MarshalParcel 

func (s *StaBackgroundScanBucketParameters) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaBackgroundScanBucketParameters) UnmarshalParcel 

func (s *StaBackgroundScanBucketParameters) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaBackgroundScanCapabilities 

type StaBackgroundScanCapabilities struct {
	MaxCacheSize          int32
	MaxBuckets            int32
	MaxApCachePerScan     int32
	MaxReportingThreshold int32
}

func (*StaBackgroundScanCapabilities) MarshalParcel 

func (s *StaBackgroundScanCapabilities) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaBackgroundScanCapabilities) UnmarshalParcel 

func (s *StaBackgroundScanCapabilities) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaBackgroundScanLimits 

type StaBackgroundScanLimits int32
const (
	StaBackgroundScanLimitsMaxChannels       StaBackgroundScanLimits = 16
	StaBackgroundScanLimitsMaxBuckets        StaBackgroundScanLimits = 16
	StaBackgroundScanLimitsMaxApCachePerScan StaBackgroundScanLimits = 32
)

type StaBackgroundScanParameters 

type StaBackgroundScanParameters struct {
	BasePeriodInMs          int32
	MaxApPerScan            int32
	ReportThresholdPercent  int32
	ReportThresholdNumScans int32
	Buckets                 []StaBackgroundScanBucketParameters
}

func (*StaBackgroundScanParameters) MarshalParcel 

func (s *StaBackgroundScanParameters) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaBackgroundScanParameters) UnmarshalParcel 

func (s *StaBackgroundScanParameters) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaLinkLayerIfaceContentionTimeStats 

type StaLinkLayerIfaceContentionTimeStats struct {
	ContentionTimeMinInUsec int32
	ContentionTimeMaxInUsec int32
	ContentionTimeAvgInUsec int32
	ContentionNumSamples    int32
}

func (*StaLinkLayerIfaceContentionTimeStats) MarshalParcel 

func (s *StaLinkLayerIfaceContentionTimeStats) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaLinkLayerIfaceContentionTimeStats) UnmarshalParcel 

func (s *StaLinkLayerIfaceContentionTimeStats) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaLinkLayerIfacePacketStats 

type StaLinkLayerIfacePacketStats struct {
	RxMpdu   int64
	TxMpdu   int64
	LostMpdu int64
	Retries  int64
}

func (*StaLinkLayerIfacePacketStats) MarshalParcel 

func (s *StaLinkLayerIfacePacketStats) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaLinkLayerIfacePacketStats) UnmarshalParcel 

func (s *StaLinkLayerIfacePacketStats) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaLinkLayerIfaceStats 

type StaLinkLayerIfaceStats struct {
	Links []StaLinkLayerLinkStats
}

func (*StaLinkLayerIfaceStats) MarshalParcel 

func (s *StaLinkLayerIfaceStats) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaLinkLayerIfaceStats) UnmarshalParcel 

func (s *StaLinkLayerIfaceStats) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaLinkLayerLinkStats 

type StaLinkLayerLinkStats struct {
	LinkId                      int32
	RadioId                     int32
	FrequencyMhz                int32
	BeaconRx                    int32
	AvgRssiMgmt                 int32
	WmeBePktStats               StaLinkLayerIfacePacketStats
	WmeBkPktStats               StaLinkLayerIfacePacketStats
	WmeViPktStats               StaLinkLayerIfacePacketStats
	WmeVoPktStats               StaLinkLayerIfacePacketStats
	TimeSliceDutyCycleInPercent byte
	WmeBeContentionTimeStats    StaLinkLayerIfaceContentionTimeStats
	WmeBkContentionTimeStats    StaLinkLayerIfaceContentionTimeStats
	WmeViContentionTimeStats    StaLinkLayerIfaceContentionTimeStats
	WmeVoContentionTimeStats    StaLinkLayerIfaceContentionTimeStats
	Peers                       []StaPeerInfo
	State                       StaLinkLayerLinkStatsStaLinkState
}

func (*StaLinkLayerLinkStats) MarshalParcel 

func (s *StaLinkLayerLinkStats) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaLinkLayerLinkStats) UnmarshalParcel 

func (s *StaLinkLayerLinkStats) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaLinkLayerLinkStatsStaLinkState 

type StaLinkLayerLinkStatsStaLinkState int32
const (
	StaLinkLayerLinkStatsStaLinkStateUNKNOWN  StaLinkLayerLinkStatsStaLinkState = 0
	StaLinkLayerLinkStatsStaLinkStateNotInUse StaLinkLayerLinkStatsStaLinkState = (1 << 0)
	StaLinkLayerLinkStatsStaLinkStateInUse    StaLinkLayerLinkStatsStaLinkState = (1 << 1)
)

type StaLinkLayerRadioStats 

type StaLinkLayerRadioStats struct {
	OnTimeInMs            int32
	TxTimeInMs            int32
	TxTimeInMsPerLevel    []int32
	RxTimeInMs            int32
	OnTimeInMsForScan     int32
	OnTimeInMsForNanScan  int32
	OnTimeInMsForBgScan   int32
	OnTimeInMsForRoamScan int32
	OnTimeInMsForPnoScan  int32
	OnTimeInMsForHs20Scan int32
	ChannelStats          []WifiChannelStats
	RadioId               int32
}

func (*StaLinkLayerRadioStats) MarshalParcel 

func (s *StaLinkLayerRadioStats) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaLinkLayerRadioStats) UnmarshalParcel 

func (s *StaLinkLayerRadioStats) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaLinkLayerStats 

type StaLinkLayerStats struct {
	Iface         StaLinkLayerIfaceStats
	Radios        []StaLinkLayerRadioStats
	TimeStampInMs int64
}

func (*StaLinkLayerStats) MarshalParcel 

func (s *StaLinkLayerStats) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaLinkLayerStats) UnmarshalParcel 

func (s *StaLinkLayerStats) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaPeerInfo 

type StaPeerInfo struct {
	StaCount  uint16
	ChanUtil  uint16
	RateStats []StaRateStat
}

func (*StaPeerInfo) MarshalParcel 

func (s *StaPeerInfo) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaPeerInfo) UnmarshalParcel 

func (s *StaPeerInfo) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaRateStat 

type StaRateStat struct {
	RateInfo WifiRateInfo
	TxMpdu   int32
	RxMpdu   int32
	MpduLost int32
	Retries  int32
}

func (*StaRateStat) MarshalParcel 

func (s *StaRateStat) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaRateStat) UnmarshalParcel 

func (s *StaRateStat) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaRoamingCapabilities 

type StaRoamingCapabilities struct {
	MaxBlocklistSize int32
	MaxAllowlistSize int32
}

func (*StaRoamingCapabilities) MarshalParcel 

func (s *StaRoamingCapabilities) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaRoamingCapabilities) UnmarshalParcel 

func (s *StaRoamingCapabilities) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaRoamingConfig 

type StaRoamingConfig struct {
	BssidBlocklist []MacAddress
	SsidAllowlist  []Ssid
}

func (*StaRoamingConfig) MarshalParcel 

func (s *StaRoamingConfig) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaRoamingConfig) UnmarshalParcel 

func (s *StaRoamingConfig) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaRoamingState 

type StaRoamingState byte
const (
	StaRoamingStateDISABLED   StaRoamingState = 0
	StaRoamingStateENABLED    StaRoamingState = 1
	StaRoamingStateAGGRESSIVE StaRoamingState = 2
)

type StaScanData 

type StaScanData struct {
	Flags          int32
	BucketsScanned int32
	Results        []StaScanResult
}

func (*StaScanData) MarshalParcel 

func (s *StaScanData) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaScanData) UnmarshalParcel 

func (s *StaScanData) UnmarshalParcel(
	p *parcel.Parcel,
) error

type StaScanDataFlagMask 

type StaScanDataFlagMask int32
const (
	StaScanDataFlagMaskINTERRUPTED StaScanDataFlagMask = (1 << 0)
)

type StaScanResult 

type StaScanResult struct {
	TimeStampInUs       int64
	Ssid                []byte
	Bssid               []byte
	Rssi                int32
	Frequency           int32
	BeaconPeriodInMs    uint16
	Capability          uint16
	InformationElements []WifiInformationElement
}

func (*StaScanResult) MarshalParcel 

func (s *StaScanResult) MarshalParcel(
	p *parcel.Parcel,
) error

func (*StaScanResult) UnmarshalParcel 

func (s *StaScanResult) UnmarshalParcel(
	p *parcel.Parcel,
) error

type TwtCapabilities 

type TwtCapabilities struct {
	IsTwtRequesterSupported        bool
	IsTwtResponderSupported        bool
	IsBroadcastTwtSupported        bool
	IsFlexibleTwtScheduleSupported bool
	MinWakeDurationUs              int32
	MaxWakeDurationUs              int32
	MinWakeIntervalUs              int64
	MaxWakeIntervalUs              int64
}

func (*TwtCapabilities) MarshalParcel 

func (s *TwtCapabilities) MarshalParcel(
	p *parcel.Parcel,
) error

func (*TwtCapabilities) UnmarshalParcel 

func (s *TwtCapabilities) UnmarshalParcel(
	p *parcel.Parcel,
) error

type TwtRequest 

type TwtRequest struct {
	MloLinkId         int32
	MinWakeDurationUs int32
	MaxWakeDurationUs int32
	MinWakeIntervalUs int64
	MaxWakeIntervalUs int64
}

func (*TwtRequest) MarshalParcel 

func (s *TwtRequest) MarshalParcel(
	p *parcel.Parcel,
) error

func (*TwtRequest) UnmarshalParcel 

func (s *TwtRequest) UnmarshalParcel(
	p *parcel.Parcel,
) error

type TwtSession 

type TwtSession struct {
	SessionId                int32
	MloLinkId                int32
	WakeDurationUs           int32
	WakeIntervalUs           int64
	NegotiationType          TwtSessionTwtNegotiationType
	IsTriggerEnabled         bool
	IsAnnounced              bool
	IsImplicit               bool
	IsProtected              bool
	IsUpdatable              bool
	IsSuspendable            bool
	IsResponderPmModeEnabled bool
}

func (*TwtSession) MarshalParcel 

func (s *TwtSession) MarshalParcel(
	p *parcel.Parcel,
) error

func (*TwtSession) UnmarshalParcel 

func (s *TwtSession) UnmarshalParcel(
	p *parcel.Parcel,
) error

type TwtSessionStats 

type TwtSessionStats struct {
	AvgTxPktCount     int32
	AvgRxPktCount     int32
	AvgTxPktSize      int32
	AvgRxPktSize      int32
	AvgEospDurationUs int32
	EospCount         int32
}

func (*TwtSessionStats) MarshalParcel 

func (s *TwtSessionStats) MarshalParcel(
	p *parcel.Parcel,
) error

func (*TwtSessionStats) UnmarshalParcel 

func (s *TwtSessionStats) UnmarshalParcel(
	p *parcel.Parcel,
) error

type TwtSessionTwtNegotiationType 

type TwtSessionTwtNegotiationType byte
const (
	TwtSessionTwtNegotiationTypeINDIVIDUAL TwtSessionTwtNegotiationType = 0
	TwtSessionTwtNegotiationTypeBROADCAST  TwtSessionTwtNegotiationType = 1
)

type WifiAntennaMode 

type WifiAntennaMode int32
const (
	WifiAntennaModeWifiAntennaModeUnspecified WifiAntennaMode = 0
	WifiAntennaModeWifiAntennaMode1x1         WifiAntennaMode = 1
	WifiAntennaModeWifiAntennaMode2x2         WifiAntennaMode = 2
	WifiAntennaModeWifiAntennaMode3x3         WifiAntennaMode = 3
	WifiAntennaModeWifiAntennaMode4x4         WifiAntennaMode = 4
)

type WifiApIfaceProxy 

type WifiApIfaceProxy struct {
	Remote binder.IBinder
}

func NewWifiApIfaceProxy 

func NewWifiApIfaceProxy(
	remote binder.IBinder,
) *WifiApIfaceProxy

func (*WifiApIfaceProxy) AsBinder 

func (p *WifiApIfaceProxy) AsBinder() binder.IBinder

func (*WifiApIfaceProxy) GetBridgedInstances 

func (p *WifiApIfaceProxy) GetBridgedInstances(
	ctx context.Context,
) ([]string, error)

func (*WifiApIfaceProxy) GetFactoryMacAddress 

func (p *WifiApIfaceProxy) GetFactoryMacAddress(
	ctx context.Context,
) ([]byte, error)

func (*WifiApIfaceProxy) GetName 

func (p *WifiApIfaceProxy) GetName(
	ctx context.Context,
) (string, error)

func (*WifiApIfaceProxy) ResetToFactoryMacAddress 

func (p *WifiApIfaceProxy) ResetToFactoryMacAddress(
	ctx context.Context,
) error

func (*WifiApIfaceProxy) SetCountryCode 

func (p *WifiApIfaceProxy) SetCountryCode(
	ctx context.Context,
	code []byte,
) error

func (*WifiApIfaceProxy) SetMacAddress 

func (p *WifiApIfaceProxy) SetMacAddress(
	ctx context.Context,
	mac []byte,
) error

type WifiApIfaceStub 

type WifiApIfaceStub struct {
	Impl      IWifiApIface
	Transport binder.VersionAwareTransport
}

WifiApIfaceStub dispatches incoming binder transactions to a typed IWifiApIface implementation.

func (*WifiApIfaceStub) Descriptor 

func (s *WifiApIfaceStub) Descriptor() string

func (*WifiApIfaceStub) OnTransaction 

func (s *WifiApIfaceStub) OnTransaction(
	ctx context.Context,
	code binder.TransactionCode,
	_data *parcel.Parcel,
) (*parcel.Parcel, error)

type WifiBand 

type WifiBand int32
const (
	WifiBandBandUnspecified               WifiBand = 0
	WifiBandBand24ghz                     WifiBand = 1
	WifiBandBand5ghz                      WifiBand = 2
	WifiBandBand5ghzDfs                   WifiBand = 4
	WifiBandBand5ghzWithDfs               WifiBand = 6
	WifiBandBand24ghz5ghz                 WifiBand = 3
	WifiBandBand24ghz5ghzWithDfs          WifiBand = 7
	WifiBandBand6ghz                      WifiBand = 8
	WifiBandBand5ghz6ghz                  WifiBand = 10
	WifiBandBand24ghz5ghz6ghz             WifiBand = 11
	WifiBandBand24ghz5ghzWithDfs6ghz      WifiBand = 15
	WifiBandBand60ghz                     WifiBand = 16
	WifiBandBand24ghz5ghz6ghz60ghz        WifiBand = 27
	WifiBandBand24ghz5ghzWithDfs6ghz60ghz WifiBand = 31
)

type WifiChannelInfo 

type WifiChannelInfo struct {
	Width       WifiChannelWidthInMhz
	CenterFreq  int32
	CenterFreq0 int32
	CenterFreq1 int32
}

func (*WifiChannelInfo) MarshalParcel 

func (s *WifiChannelInfo) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiChannelInfo) UnmarshalParcel 

func (s *WifiChannelInfo) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiChannelStats 

type WifiChannelStats struct {
	Channel         WifiChannelInfo
	OnTimeInMs      int32
	CcaBusyTimeInMs int32
}

func (*WifiChannelStats) MarshalParcel 

func (s *WifiChannelStats) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiChannelStats) UnmarshalParcel 

func (s *WifiChannelStats) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiChannelWidthInMhz 

type WifiChannelWidthInMhz int32
const (
	WifiChannelWidthInMhzWidthInvalid WifiChannelWidthInMhz = -1
	WifiChannelWidthInMhzWidth20      WifiChannelWidthInMhz = 0
	WifiChannelWidthInMhzWidth40      WifiChannelWidthInMhz = 1
	WifiChannelWidthInMhzWidth80      WifiChannelWidthInMhz = 2
	WifiChannelWidthInMhzWidth160     WifiChannelWidthInMhz = 3
	WifiChannelWidthInMhzWidth80p80   WifiChannelWidthInMhz = 4
	WifiChannelWidthInMhzWidth5       WifiChannelWidthInMhz = 5
	WifiChannelWidthInMhzWidth10      WifiChannelWidthInMhz = 6
	WifiChannelWidthInMhzWidth320     WifiChannelWidthInMhz = 7
)

type WifiChipCapabilities 

type WifiChipCapabilities struct {
	MaxMloAssociationLinkCount    int32
	MaxMloStrLinkCount            int32
	MaxConcurrentTdlsSessionCount int32
}

func (*WifiChipCapabilities) MarshalParcel 

func (s *WifiChipCapabilities) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiChipCapabilities) UnmarshalParcel 

func (s *WifiChipCapabilities) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiChipEventCallbackProxy 

type WifiChipEventCallbackProxy struct {
	Remote binder.IBinder
}

func NewWifiChipEventCallbackProxy 

func NewWifiChipEventCallbackProxy(
	remote binder.IBinder,
) *WifiChipEventCallbackProxy

func (*WifiChipEventCallbackProxy) AsBinder 

func (p *WifiChipEventCallbackProxy) AsBinder() binder.IBinder

func (*WifiChipEventCallbackProxy) OnChipReconfigureFailure 

func (p *WifiChipEventCallbackProxy) OnChipReconfigureFailure(
	ctx context.Context,
	status WifiStatusCode,
) error

func (*WifiChipEventCallbackProxy) OnChipReconfigured 

func (p *WifiChipEventCallbackProxy) OnChipReconfigured(
	ctx context.Context,
	modeId int32,
) error

func (*WifiChipEventCallbackProxy) OnDebugErrorAlert 

func (p *WifiChipEventCallbackProxy) OnDebugErrorAlert(
	ctx context.Context,
	errorCode int32,
	debugData []byte,
) error

func (*WifiChipEventCallbackProxy) OnDebugRingBufferDataAvailable 

func (p *WifiChipEventCallbackProxy) OnDebugRingBufferDataAvailable(
	ctx context.Context,
	status WifiDebugRingBufferStatus,
	data []byte,
) error

func (*WifiChipEventCallbackProxy) OnIfaceAdded 

func (p *WifiChipEventCallbackProxy) OnIfaceAdded(
	ctx context.Context,
	type_ IfaceType,
	name string,
) error

func (*WifiChipEventCallbackProxy) OnIfaceRemoved 

func (p *WifiChipEventCallbackProxy) OnIfaceRemoved(
	ctx context.Context,
	type_ IfaceType,
	name string,
) error

func (*WifiChipEventCallbackProxy) OnRadioModeChange 

func (p *WifiChipEventCallbackProxy) OnRadioModeChange(
	ctx context.Context,
	radioModeInfos []IWifiChipEventCallbackRadioModeInfo,
) error

type WifiChipEventCallbackStub 

type WifiChipEventCallbackStub struct {
	Impl      IWifiChipEventCallback
	Transport binder.VersionAwareTransport
}

WifiChipEventCallbackStub dispatches incoming binder transactions to a typed IWifiChipEventCallback implementation.

func (*WifiChipEventCallbackStub) Descriptor 

func (s *WifiChipEventCallbackStub) Descriptor() string

func (*WifiChipEventCallbackStub) OnTransaction 

func (s *WifiChipEventCallbackStub) OnTransaction(
	ctx context.Context,
	code binder.TransactionCode,
	_data *parcel.Parcel,
) (*parcel.Parcel, error)

type WifiChipProxy 

type WifiChipProxy struct {
	Remote binder.IBinder
}

func NewWifiChipProxy 

func NewWifiChipProxy(
	remote binder.IBinder,
) *WifiChipProxy

func (*WifiChipProxy) AsBinder 

func (p *WifiChipProxy) AsBinder() binder.IBinder

func (*WifiChipProxy) ConfigureChip 

func (p *WifiChipProxy) ConfigureChip(
	ctx context.Context,
	modeId int32,
) error

func (*WifiChipProxy) CreateApIface 

func (p *WifiChipProxy) CreateApIface(
	ctx context.Context,
) (IWifiApIface, error)

func (*WifiChipProxy) CreateApOrBridgedApIface 

func (p *WifiChipProxy) CreateApOrBridgedApIface(
	ctx context.Context,
	iface IfaceConcurrencyType,
	vendorData []common.OuiKeyedData,
) (IWifiApIface, error)

func (*WifiChipProxy) CreateBridgedApIface 

func (p *WifiChipProxy) CreateBridgedApIface(
	ctx context.Context,
) (IWifiApIface, error)

func (*WifiChipProxy) CreateNanIface 

func (p *WifiChipProxy) CreateNanIface(
	ctx context.Context,
) (IWifiNanIface, error)

func (*WifiChipProxy) CreateP2pIface 

func (p *WifiChipProxy) CreateP2pIface(
	ctx context.Context,
) (IWifiP2pIface, error)

func (*WifiChipProxy) CreateRttController 

func (p *WifiChipProxy) CreateRttController(
	ctx context.Context,
	boundIface IWifiStaIface,
) (IWifiRttController, error)

func (*WifiChipProxy) CreateStaIface 

func (p *WifiChipProxy) CreateStaIface(
	ctx context.Context,
) (IWifiStaIface, error)

func (*WifiChipProxy) EnableDebugErrorAlerts 

func (p *WifiChipProxy) EnableDebugErrorAlerts(
	ctx context.Context,
	enable bool,
) error

func (*WifiChipProxy) EnableStaChannelForPeerNetwork 

func (p *WifiChipProxy) EnableStaChannelForPeerNetwork(
	ctx context.Context,
	channelCategoryEnableFlag int32,
) error

func (*WifiChipProxy) FlushRingBufferToFile 

func (p *WifiChipProxy) FlushRingBufferToFile(
	ctx context.Context,
) error

func (*WifiChipProxy) ForceDumpToDebugRingBuffer 

func (p *WifiChipProxy) ForceDumpToDebugRingBuffer(
	ctx context.Context,
	ringName string,
) error

func (*WifiChipProxy) GetApIface 

func (p *WifiChipProxy) GetApIface(
	ctx context.Context,
	ifname string,
) (IWifiApIface, error)

func (*WifiChipProxy) GetApIfaceNames 

func (p *WifiChipProxy) GetApIfaceNames(
	ctx context.Context,
) ([]string, error)

func (*WifiChipProxy) GetAvailableModes 

func (p *WifiChipProxy) GetAvailableModes(
	ctx context.Context,
) ([]IWifiChipChipMode, error)

func (*WifiChipProxy) GetDebugHostWakeReasonStats 

func (p *WifiChipProxy) GetDebugHostWakeReasonStats(
	ctx context.Context,
) (WifiDebugHostWakeReasonStats, error)

func (*WifiChipProxy) GetDebugRingBuffersStatus 

func (p *WifiChipProxy) GetDebugRingBuffersStatus(
	ctx context.Context,
) ([]WifiDebugRingBufferStatus, error)

func (*WifiChipProxy) GetFeatureSet 

func (p *WifiChipProxy) GetFeatureSet(
	ctx context.Context,
) (int32, error)

func (*WifiChipProxy) GetId 

func (p *WifiChipProxy) GetId(
	ctx context.Context,
) (int32, error)

func (*WifiChipProxy) GetMode 

func (p *WifiChipProxy) GetMode(
	ctx context.Context,
) (int32, error)

func (*WifiChipProxy) GetNanIface 

func (p *WifiChipProxy) GetNanIface(
	ctx context.Context,
	ifname string,
) (IWifiNanIface, error)

func (*WifiChipProxy) GetNanIfaceNames 

func (p *WifiChipProxy) GetNanIfaceNames(
	ctx context.Context,
) ([]string, error)

func (*WifiChipProxy) GetP2pIface 

func (p *WifiChipProxy) GetP2pIface(
	ctx context.Context,
	ifname string,
) (IWifiP2pIface, error)

func (*WifiChipProxy) GetP2pIfaceNames 

func (p *WifiChipProxy) GetP2pIfaceNames(
	ctx context.Context,
) ([]string, error)

func (*WifiChipProxy) GetStaIface 

func (p *WifiChipProxy) GetStaIface(
	ctx context.Context,
	ifname string,
) (IWifiStaIface, error)

func (*WifiChipProxy) GetStaIfaceNames 

func (p *WifiChipProxy) GetStaIfaceNames(
	ctx context.Context,
) ([]string, error)

func (*WifiChipProxy) GetSupportedRadioCombinations 

func (p *WifiChipProxy) GetSupportedRadioCombinations(
	ctx context.Context,
) ([]WifiRadioCombination, error)

func (*WifiChipProxy) GetUsableChannels 

func (p *WifiChipProxy) GetUsableChannels(
	ctx context.Context,
	band WifiBand,
	ifaceModeMask int32,
	filterMask int32,
) ([]WifiUsableChannel, error)

func (*WifiChipProxy) GetWifiChipCapabilities 

func (p *WifiChipProxy) GetWifiChipCapabilities(
	ctx context.Context,
) (WifiChipCapabilities, error)

func (*WifiChipProxy) RegisterEventCallback 

func (p *WifiChipProxy) RegisterEventCallback(
	ctx context.Context,
	callback IWifiChipEventCallback,
) error

func (*WifiChipProxy) RemoveApIface 

func (p *WifiChipProxy) RemoveApIface(
	ctx context.Context,
	ifname string,
) error

func (*WifiChipProxy) RemoveIfaceInstanceFromBridgedApIface 

func (p *WifiChipProxy) RemoveIfaceInstanceFromBridgedApIface(
	ctx context.Context,
	brIfaceName string,
	ifaceInstanceName string,
) error

func (*WifiChipProxy) RemoveNanIface 

func (p *WifiChipProxy) RemoveNanIface(
	ctx context.Context,
	ifname string,
) error

func (*WifiChipProxy) RemoveP2pIface 

func (p *WifiChipProxy) RemoveP2pIface(
	ctx context.Context,
	ifname string,
) error

func (*WifiChipProxy) RemoveStaIface 

func (p *WifiChipProxy) RemoveStaIface(
	ctx context.Context,
	ifname string,
) error

func (*WifiChipProxy) RequestChipDebugInfo 

func (p *WifiChipProxy) RequestChipDebugInfo(
	ctx context.Context,
) (IWifiChipChipDebugInfo, error)

func (*WifiChipProxy) RequestDriverDebugDump 

func (p *WifiChipProxy) RequestDriverDebugDump(
	ctx context.Context,
) ([]byte, error)

func (*WifiChipProxy) RequestFirmwareDebugDump 

func (p *WifiChipProxy) RequestFirmwareDebugDump(
	ctx context.Context,
) ([]byte, error)

func (*WifiChipProxy) ResetTxPowerScenario 

func (p *WifiChipProxy) ResetTxPowerScenario(
	ctx context.Context,
) error

func (*WifiChipProxy) SelectTxPowerScenario 

func (p *WifiChipProxy) SelectTxPowerScenario(
	ctx context.Context,
	scenario IWifiChipTxPowerScenario,
) error

func (*WifiChipProxy) SetAfcChannelAllowance 

func (p *WifiChipProxy) SetAfcChannelAllowance(
	ctx context.Context,
	afcChannelAllowance AfcChannelAllowance,
) error

func (*WifiChipProxy) SetCoexUnsafeChannels 

func (p *WifiChipProxy) SetCoexUnsafeChannels(
	ctx context.Context,
	unsafeChannels []IWifiChipCoexUnsafeChannel,
	restrictions int32,
) error

func (*WifiChipProxy) SetCountryCode 

func (p *WifiChipProxy) SetCountryCode(
	ctx context.Context,
	code []byte,
) error

func (*WifiChipProxy) SetLatencyMode 

func (p *WifiChipProxy) SetLatencyMode(
	ctx context.Context,
	mode IWifiChipLatencyMode,
) error

func (*WifiChipProxy) SetMloMode 

func (p *WifiChipProxy) SetMloMode(
	ctx context.Context,
	mode IWifiChipChipMloMode,
) error

func (*WifiChipProxy) SetMultiStaPrimaryConnection 

func (p *WifiChipProxy) SetMultiStaPrimaryConnection(
	ctx context.Context,
	ifName string,
) error

func (*WifiChipProxy) SetMultiStaUseCase 

func (p *WifiChipProxy) SetMultiStaUseCase(
	ctx context.Context,
	useCase IWifiChipMultiStaUseCase,
) error

func (*WifiChipProxy) SetVoipMode 

func (p *WifiChipProxy) SetVoipMode(
	ctx context.Context,
	mode IWifiChipVoipMode,
) error

func (*WifiChipProxy) StartLoggingToDebugRingBuffer 

func (p *WifiChipProxy) StartLoggingToDebugRingBuffer(
	ctx context.Context,
	ringName string,
	verboseLevel WifiDebugRingBufferVerboseLevel,
	maxIntervalInSec int32,
	minDataSizeInBytes int32,
) error

func (*WifiChipProxy) StopLoggingToDebugRingBuffer 

func (p *WifiChipProxy) StopLoggingToDebugRingBuffer(
	ctx context.Context,
) error

func (*WifiChipProxy) TriggerSubsystemRestart 

func (p *WifiChipProxy) TriggerSubsystemRestart(
	ctx context.Context,
) error

type WifiChipStub 

type WifiChipStub struct {
	Impl      IWifiChip
	Transport binder.VersionAwareTransport
}

WifiChipStub dispatches incoming binder transactions to a typed IWifiChip implementation.

func (*WifiChipStub) Descriptor 

func (s *WifiChipStub) Descriptor() string

func (*WifiChipStub) OnTransaction 

func (s *WifiChipStub) OnTransaction(
	ctx context.Context,
	code binder.TransactionCode,
	_data *parcel.Parcel,
) (*parcel.Parcel, error)

type WifiDebugHostWakeReasonRxIcmpPacketDetails 

type WifiDebugHostWakeReasonRxIcmpPacketDetails struct {
	IcmpPkt  int32
	Icmp6Pkt int32
	Icmp6Ra  int32
	Icmp6Na  int32
	Icmp6Ns  int32
}

func (*WifiDebugHostWakeReasonRxIcmpPacketDetails) MarshalParcel 

func (s *WifiDebugHostWakeReasonRxIcmpPacketDetails) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiDebugHostWakeReasonRxIcmpPacketDetails) UnmarshalParcel 

func (s *WifiDebugHostWakeReasonRxIcmpPacketDetails) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiDebugHostWakeReasonRxMulticastPacketDetails 

type WifiDebugHostWakeReasonRxMulticastPacketDetails struct {
	Ipv4RxMulticastAddrCnt  int32
	Ipv6RxMulticastAddrCnt  int32
	OtherRxMulticastAddrCnt int32
}

func (*WifiDebugHostWakeReasonRxMulticastPacketDetails) MarshalParcel 

func (s *WifiDebugHostWakeReasonRxMulticastPacketDetails) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiDebugHostWakeReasonRxMulticastPacketDetails) UnmarshalParcel 

func (s *WifiDebugHostWakeReasonRxMulticastPacketDetails) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiDebugHostWakeReasonRxPacketDetails 

type WifiDebugHostWakeReasonRxPacketDetails struct {
	RxUnicastCnt   int32
	RxMulticastCnt int32
	RxBroadcastCnt int32
}

func (*WifiDebugHostWakeReasonRxPacketDetails) MarshalParcel 

func (s *WifiDebugHostWakeReasonRxPacketDetails) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiDebugHostWakeReasonRxPacketDetails) UnmarshalParcel 

func (s *WifiDebugHostWakeReasonRxPacketDetails) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiDebugHostWakeReasonStats 

type WifiDebugHostWakeReasonStats struct {
	TotalCmdEventWakeCnt        int32
	CmdEventWakeCntPerType      []int32
	TotalDriverFwLocalWakeCnt   int32
	DriverFwLocalWakeCntPerType []int32
	TotalRxPacketWakeCnt        int32
	RxPktWakeDetails            WifiDebugHostWakeReasonRxPacketDetails
	RxMulticastPkWakeDetails    WifiDebugHostWakeReasonRxMulticastPacketDetails
	RxIcmpPkWakeDetails         WifiDebugHostWakeReasonRxIcmpPacketDetails
}

func (*WifiDebugHostWakeReasonStats) MarshalParcel 

func (s *WifiDebugHostWakeReasonStats) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiDebugHostWakeReasonStats) UnmarshalParcel 

func (s *WifiDebugHostWakeReasonStats) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiDebugPacketFateFrameInfo 

type WifiDebugPacketFateFrameInfo struct {
	FrameType             WifiDebugPacketFateFrameType
	FrameLen              int64
	DriverTimestampUsec   int64
	FirmwareTimestampUsec int64
	FrameContent          []byte
}

func (*WifiDebugPacketFateFrameInfo) MarshalParcel 

func (s *WifiDebugPacketFateFrameInfo) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiDebugPacketFateFrameInfo) UnmarshalParcel 

func (s *WifiDebugPacketFateFrameInfo) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiDebugPacketFateFrameType 

type WifiDebugPacketFateFrameType int32
const (
	WifiDebugPacketFateFrameTypeUNKNOWN    WifiDebugPacketFateFrameType = 0
	WifiDebugPacketFateFrameTypeEthernetIi WifiDebugPacketFateFrameType = 1
	WifiDebugPacketFateFrameTypeMgmt80211  WifiDebugPacketFateFrameType = 2
)

type WifiDebugRingBufferFlags 

type WifiDebugRingBufferFlags int32
const (
	WifiDebugRingBufferFlagsHasBinaryEntries    WifiDebugRingBufferFlags = (1 << 0)
	WifiDebugRingBufferFlagsHasAsciiEntries     WifiDebugRingBufferFlags = (1 << 1)
	WifiDebugRingBufferFlagsHasPerPacketEntries WifiDebugRingBufferFlags = (1 << 2)
)

type WifiDebugRingBufferStatus 

type WifiDebugRingBufferStatus struct {
	RingName        string
	Flags           int32
	RingId          int32
	SizeInBytes     int32
	FreeSizeInBytes int32
	VerboseLevel    int32
}

func (*WifiDebugRingBufferStatus) MarshalParcel 

func (s *WifiDebugRingBufferStatus) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiDebugRingBufferStatus) UnmarshalParcel 

func (s *WifiDebugRingBufferStatus) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiDebugRingBufferVerboseLevel 

type WifiDebugRingBufferVerboseLevel int32
const (
	WifiDebugRingBufferVerboseLevelNONE      WifiDebugRingBufferVerboseLevel = 0
	WifiDebugRingBufferVerboseLevelDEFAULT   WifiDebugRingBufferVerboseLevel = 1
	WifiDebugRingBufferVerboseLevelVERBOSE   WifiDebugRingBufferVerboseLevel = 2
	WifiDebugRingBufferVerboseLevelEXCESSIVE WifiDebugRingBufferVerboseLevel = 3
)

type WifiDebugRxPacketFate 

type WifiDebugRxPacketFate int32
const (
	WifiDebugRxPacketFateSUCCESS        WifiDebugRxPacketFate = 0
	WifiDebugRxPacketFateFwQueued       WifiDebugRxPacketFate = 1
	WifiDebugRxPacketFateFwDropFilter   WifiDebugRxPacketFate = 2
	WifiDebugRxPacketFateFwDropInvalid  WifiDebugRxPacketFate = 3
	WifiDebugRxPacketFateFwDropNobufs   WifiDebugRxPacketFate = 4
	WifiDebugRxPacketFateFwDropOther    WifiDebugRxPacketFate = 5
	WifiDebugRxPacketFateDrvQueued      WifiDebugRxPacketFate = 6
	WifiDebugRxPacketFateDrvDropFilter  WifiDebugRxPacketFate = 7
	WifiDebugRxPacketFateDrvDropInvalid WifiDebugRxPacketFate = 8
	WifiDebugRxPacketFateDrvDropNobufs  WifiDebugRxPacketFate = 9
	WifiDebugRxPacketFateDrvDropOther   WifiDebugRxPacketFate = 10
)

type WifiDebugRxPacketFateReport 

type WifiDebugRxPacketFateReport struct {
	Fate      WifiDebugRxPacketFate
	FrameInfo WifiDebugPacketFateFrameInfo
}

func (*WifiDebugRxPacketFateReport) MarshalParcel 

func (s *WifiDebugRxPacketFateReport) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiDebugRxPacketFateReport) UnmarshalParcel 

func (s *WifiDebugRxPacketFateReport) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiDebugTxPacketFate 

type WifiDebugTxPacketFate int32
const (
	WifiDebugTxPacketFateACKED          WifiDebugTxPacketFate = 0
	WifiDebugTxPacketFateSENT           WifiDebugTxPacketFate = 1
	WifiDebugTxPacketFateFwQueued       WifiDebugTxPacketFate = 2
	WifiDebugTxPacketFateFwDropInvalid  WifiDebugTxPacketFate = 3
	WifiDebugTxPacketFateFwDropNobufs   WifiDebugTxPacketFate = 4
	WifiDebugTxPacketFateFwDropOther    WifiDebugTxPacketFate = 5
	WifiDebugTxPacketFateDrvQueued      WifiDebugTxPacketFate = 6
	WifiDebugTxPacketFateDrvDropInvalid WifiDebugTxPacketFate = 7
	WifiDebugTxPacketFateDrvDropNobufs  WifiDebugTxPacketFate = 8
	WifiDebugTxPacketFateDrvDropOther   WifiDebugTxPacketFate = 9
)

type WifiDebugTxPacketFateReport 

type WifiDebugTxPacketFateReport struct {
	Fate      WifiDebugTxPacketFate
	FrameInfo WifiDebugPacketFateFrameInfo
}

func (*WifiDebugTxPacketFateReport) MarshalParcel 

func (s *WifiDebugTxPacketFateReport) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiDebugTxPacketFateReport) UnmarshalParcel 

func (s *WifiDebugTxPacketFateReport) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiEventCallbackProxy 

type WifiEventCallbackProxy struct {
	Remote binder.IBinder
}

func NewWifiEventCallbackProxy 

func NewWifiEventCallbackProxy(
	remote binder.IBinder,
) *WifiEventCallbackProxy

func (*WifiEventCallbackProxy) AsBinder 

func (p *WifiEventCallbackProxy) AsBinder() binder.IBinder

func (*WifiEventCallbackProxy) OnFailure 

func (p *WifiEventCallbackProxy) OnFailure(
	ctx context.Context,
	status WifiStatusCode,
) error

func (*WifiEventCallbackProxy) OnStart 

func (p *WifiEventCallbackProxy) OnStart(
	ctx context.Context,
) error

func (*WifiEventCallbackProxy) OnStop 

func (p *WifiEventCallbackProxy) OnStop(
	ctx context.Context,
) error

func (*WifiEventCallbackProxy) OnSubsystemRestart 

func (p *WifiEventCallbackProxy) OnSubsystemRestart(
	ctx context.Context,
	status WifiStatusCode,
) error

type WifiEventCallbackStub 

type WifiEventCallbackStub struct {
	Impl      IWifiEventCallback
	Transport binder.VersionAwareTransport
}

WifiEventCallbackStub dispatches incoming binder transactions to a typed IWifiEventCallback implementation.

func (*WifiEventCallbackStub) Descriptor 

func (s *WifiEventCallbackStub) Descriptor() string

func (*WifiEventCallbackStub) OnTransaction 

func (s *WifiEventCallbackStub) OnTransaction(
	ctx context.Context,
	code binder.TransactionCode,
	_data *parcel.Parcel,
) (*parcel.Parcel, error)

type WifiIfaceMode 

type WifiIfaceMode int32
const (
	WifiIfaceModeIfaceModeSta       WifiIfaceMode = (1 << 0)
	WifiIfaceModeIfaceModeSoftap    WifiIfaceMode = (1 << 1)
	WifiIfaceModeIfaceModeIbss      WifiIfaceMode = (1 << 2)
	WifiIfaceModeIfaceModeP2pClient WifiIfaceMode = (1 << 3)
	WifiIfaceModeIfaceModeP2pGo     WifiIfaceMode = (1 << 4)
	WifiIfaceModeIfaceModeNan       WifiIfaceMode = (1 << 5)
	WifiIfaceModeIfaceModeMesh      WifiIfaceMode = (1 << 6)
	WifiIfaceModeIfaceModeTdls      WifiIfaceMode = (1 << 7)
)

type WifiInformationElement 

type WifiInformationElement struct {
	Id   byte
	Data []byte
}

func (*WifiInformationElement) MarshalParcel 

func (s *WifiInformationElement) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiInformationElement) UnmarshalParcel 

func (s *WifiInformationElement) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiNanIfaceEventCallbackProxy 

type WifiNanIfaceEventCallbackProxy struct {
	Remote binder.IBinder
}

func NewWifiNanIfaceEventCallbackProxy 

func NewWifiNanIfaceEventCallbackProxy(
	remote binder.IBinder,
) *WifiNanIfaceEventCallbackProxy

func (*WifiNanIfaceEventCallbackProxy) AsBinder 

func (p *WifiNanIfaceEventCallbackProxy) AsBinder() binder.IBinder

func (*WifiNanIfaceEventCallbackProxy) EventBootstrappingConfirm 

func (p *WifiNanIfaceEventCallbackProxy) EventBootstrappingConfirm(
	ctx context.Context,
	event NanBootstrappingConfirmInd,
) error

func (*WifiNanIfaceEventCallbackProxy) EventBootstrappingRequest 

func (p *WifiNanIfaceEventCallbackProxy) EventBootstrappingRequest(
	ctx context.Context,
	event NanBootstrappingRequestInd,
) error

func (*WifiNanIfaceEventCallbackProxy) EventClusterEvent 

func (p *WifiNanIfaceEventCallbackProxy) EventClusterEvent(
	ctx context.Context,
	event NanClusterEventInd,
) error

func (*WifiNanIfaceEventCallbackProxy) EventDataPathConfirm 

func (p *WifiNanIfaceEventCallbackProxy) EventDataPathConfirm(
	ctx context.Context,
	event NanDataPathConfirmInd,
) error

func (*WifiNanIfaceEventCallbackProxy) EventDataPathRequest 

func (p *WifiNanIfaceEventCallbackProxy) EventDataPathRequest(
	ctx context.Context,
	event NanDataPathRequestInd,
) error

func (*WifiNanIfaceEventCallbackProxy) EventDataPathScheduleUpdate 

func (p *WifiNanIfaceEventCallbackProxy) EventDataPathScheduleUpdate(
	ctx context.Context,
	event NanDataPathScheduleUpdateInd,
) error

func (*WifiNanIfaceEventCallbackProxy) EventDataPathTerminated 

func (p *WifiNanIfaceEventCallbackProxy) EventDataPathTerminated(
	ctx context.Context,
	ndpInstanceId int32,
) error

func (*WifiNanIfaceEventCallbackProxy) EventDisabled 

func (p *WifiNanIfaceEventCallbackProxy) EventDisabled(
	ctx context.Context,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) EventFollowupReceived 

func (p *WifiNanIfaceEventCallbackProxy) EventFollowupReceived(
	ctx context.Context,
	event NanFollowupReceivedInd,
) error

func (*WifiNanIfaceEventCallbackProxy) EventMatch 

func (p *WifiNanIfaceEventCallbackProxy) EventMatch(
	ctx context.Context,
	event NanMatchInd,
) error

func (*WifiNanIfaceEventCallbackProxy) EventMatchExpired 

func (p *WifiNanIfaceEventCallbackProxy) EventMatchExpired(
	ctx context.Context,
	discoverySessionId byte,
	peerId int32,
) error

func (*WifiNanIfaceEventCallbackProxy) EventPairingConfirm 

func (p *WifiNanIfaceEventCallbackProxy) EventPairingConfirm(
	ctx context.Context,
	event NanPairingConfirmInd,
) error

func (*WifiNanIfaceEventCallbackProxy) EventPairingRequest 

func (p *WifiNanIfaceEventCallbackProxy) EventPairingRequest(
	ctx context.Context,
	event NanPairingRequestInd,
) error

func (*WifiNanIfaceEventCallbackProxy) EventPublishTerminated 

func (p *WifiNanIfaceEventCallbackProxy) EventPublishTerminated(
	ctx context.Context,
	sessionId byte,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) EventSubscribeTerminated 

func (p *WifiNanIfaceEventCallbackProxy) EventSubscribeTerminated(
	ctx context.Context,
	sessionId byte,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) EventSuspensionModeChanged 

func (p *WifiNanIfaceEventCallbackProxy) EventSuspensionModeChanged(
	ctx context.Context,
	event NanSuspensionModeChangeInd,
) error

func (*WifiNanIfaceEventCallbackProxy) EventTransmitFollowup 

func (p *WifiNanIfaceEventCallbackProxy) EventTransmitFollowup(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyCapabilitiesResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyCapabilitiesResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
	capabilities NanCapabilities,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyConfigResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyConfigResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyCreateDataInterfaceResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyCreateDataInterfaceResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyDeleteDataInterfaceResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyDeleteDataInterfaceResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyDisableResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyDisableResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyEnableResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyEnableResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyInitiateBootstrappingResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyInitiateBootstrappingResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
	bootstrappingInstanceId int32,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyInitiateDataPathResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyInitiateDataPathResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
	ndpInstanceId int32,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyInitiatePairingResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyInitiatePairingResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
	pairingInstanceId int32,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyRespondToBootstrappingIndicationResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyRespondToBootstrappingIndicationResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyRespondToDataPathIndicationResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyRespondToDataPathIndicationResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyRespondToPairingIndicationResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyRespondToPairingIndicationResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyResumeResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyResumeResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyStartPublishResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyStartPublishResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
	sessionId byte,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyStartSubscribeResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyStartSubscribeResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
	sessionId byte,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyStopPublishResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyStopPublishResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyStopSubscribeResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyStopSubscribeResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifySuspendResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifySuspendResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyTerminateDataPathResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyTerminateDataPathResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyTerminatePairingResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyTerminatePairingResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

func (*WifiNanIfaceEventCallbackProxy) NotifyTransmitFollowupResponse 

func (p *WifiNanIfaceEventCallbackProxy) NotifyTransmitFollowupResponse(
	ctx context.Context,
	id uint16,
	status NanStatus,
) error

type WifiNanIfaceEventCallbackStub 

type WifiNanIfaceEventCallbackStub struct {
	Impl      IWifiNanIfaceEventCallback
	Transport binder.VersionAwareTransport
}

WifiNanIfaceEventCallbackStub dispatches incoming binder transactions to a typed IWifiNanIfaceEventCallback implementation.

func (*WifiNanIfaceEventCallbackStub) Descriptor 

func (s *WifiNanIfaceEventCallbackStub) Descriptor() string

func (*WifiNanIfaceEventCallbackStub) OnTransaction 

func (s *WifiNanIfaceEventCallbackStub) OnTransaction(
	ctx context.Context,
	code binder.TransactionCode,
	_data *parcel.Parcel,
) (*parcel.Parcel, error)

type WifiNanIfaceProxy 

type WifiNanIfaceProxy struct {
	Remote binder.IBinder
}

func NewWifiNanIfaceProxy 

func NewWifiNanIfaceProxy(
	remote binder.IBinder,
) *WifiNanIfaceProxy

func (*WifiNanIfaceProxy) AsBinder 

func (p *WifiNanIfaceProxy) AsBinder() binder.IBinder

func (*WifiNanIfaceProxy) ConfigRequest 

func (p *WifiNanIfaceProxy) ConfigRequest(
	ctx context.Context,
	cmdId uint16,
	msg1 NanConfigRequest,
	msg2 NanConfigRequestSupplemental,
) error

func (*WifiNanIfaceProxy) CreateDataInterfaceRequest 

func (p *WifiNanIfaceProxy) CreateDataInterfaceRequest(
	ctx context.Context,
	cmdId uint16,
	ifaceName string,
) error

func (*WifiNanIfaceProxy) DeleteDataInterfaceRequest 

func (p *WifiNanIfaceProxy) DeleteDataInterfaceRequest(
	ctx context.Context,
	cmdId uint16,
	ifaceName string,
) error

func (*WifiNanIfaceProxy) DisableRequest 

func (p *WifiNanIfaceProxy) DisableRequest(
	ctx context.Context,
	cmdId uint16,
) error

func (*WifiNanIfaceProxy) EnableRequest 

func (p *WifiNanIfaceProxy) EnableRequest(
	ctx context.Context,
	cmdId uint16,
	msg1 NanEnableRequest,
	msg2 NanConfigRequestSupplemental,
) error

func (*WifiNanIfaceProxy) GetCapabilitiesRequest 

func (p *WifiNanIfaceProxy) GetCapabilitiesRequest(
	ctx context.Context,
	cmdId uint16,
) error

func (*WifiNanIfaceProxy) GetName 

func (p *WifiNanIfaceProxy) GetName(
	ctx context.Context,
) (string, error)

func (*WifiNanIfaceProxy) InitiateBootstrappingRequest 

func (p *WifiNanIfaceProxy) InitiateBootstrappingRequest(
	ctx context.Context,
	cmdId uint16,
	msg NanBootstrappingRequest,
) error

func (*WifiNanIfaceProxy) InitiateDataPathRequest 

func (p *WifiNanIfaceProxy) InitiateDataPathRequest(
	ctx context.Context,
	cmdId uint16,
	msg NanInitiateDataPathRequest,
) error

func (*WifiNanIfaceProxy) InitiatePairingRequest 

func (p *WifiNanIfaceProxy) InitiatePairingRequest(
	ctx context.Context,
	cmdId uint16,
	msg NanPairingRequest,
) error

func (*WifiNanIfaceProxy) RegisterEventCallback 

func (p *WifiNanIfaceProxy) RegisterEventCallback(
	ctx context.Context,
	callback IWifiNanIfaceEventCallback,
) error

func (*WifiNanIfaceProxy) RespondToBootstrappingIndicationRequest 

func (p *WifiNanIfaceProxy) RespondToBootstrappingIndicationRequest(
	ctx context.Context,
	cmdId uint16,
	msg NanBootstrappingResponse,
) error

func (*WifiNanIfaceProxy) RespondToDataPathIndicationRequest 

func (p *WifiNanIfaceProxy) RespondToDataPathIndicationRequest(
	ctx context.Context,
	cmdId uint16,
	msg NanRespondToDataPathIndicationRequest,
) error

func (*WifiNanIfaceProxy) RespondToPairingIndicationRequest 

func (p *WifiNanIfaceProxy) RespondToPairingIndicationRequest(
	ctx context.Context,
	cmdId uint16,
	msg NanRespondToPairingIndicationRequest,
) error

func (*WifiNanIfaceProxy) ResumeRequest 

func (p *WifiNanIfaceProxy) ResumeRequest(
	ctx context.Context,
	cmdId uint16,
	sessionId byte,
) error

func (*WifiNanIfaceProxy) StartPublishRequest 

func (p *WifiNanIfaceProxy) StartPublishRequest(
	ctx context.Context,
	cmdId uint16,
	msg NanPublishRequest,
) error

func (*WifiNanIfaceProxy) StartSubscribeRequest 

func (p *WifiNanIfaceProxy) StartSubscribeRequest(
	ctx context.Context,
	cmdId uint16,
	msg NanSubscribeRequest,
) error

func (*WifiNanIfaceProxy) StopPublishRequest 

func (p *WifiNanIfaceProxy) StopPublishRequest(
	ctx context.Context,
	cmdId uint16,
	sessionId byte,
) error

func (*WifiNanIfaceProxy) StopSubscribeRequest 

func (p *WifiNanIfaceProxy) StopSubscribeRequest(
	ctx context.Context,
	cmdId uint16,
	sessionId byte,
) error

func (*WifiNanIfaceProxy) SuspendRequest 

func (p *WifiNanIfaceProxy) SuspendRequest(
	ctx context.Context,
	cmdId uint16,
	sessionId byte,
) error

func (*WifiNanIfaceProxy) TerminateDataPathRequest 

func (p *WifiNanIfaceProxy) TerminateDataPathRequest(
	ctx context.Context,
	cmdId uint16,
	ndpInstanceId int32,
) error

func (*WifiNanIfaceProxy) TerminatePairingRequest 

func (p *WifiNanIfaceProxy) TerminatePairingRequest(
	ctx context.Context,
	cmdId uint16,
	pairingInstanceId int32,
) error

func (*WifiNanIfaceProxy) TransmitFollowupRequest 

func (p *WifiNanIfaceProxy) TransmitFollowupRequest(
	ctx context.Context,
	cmdId uint16,
	msg NanTransmitFollowupRequest,
) error

type WifiNanIfaceStub 

type WifiNanIfaceStub struct {
	Impl      IWifiNanIface
	Transport binder.VersionAwareTransport
}

WifiNanIfaceStub dispatches incoming binder transactions to a typed IWifiNanIface implementation.

func (*WifiNanIfaceStub) Descriptor 

func (s *WifiNanIfaceStub) Descriptor() string

func (*WifiNanIfaceStub) OnTransaction 

func (s *WifiNanIfaceStub) OnTransaction(
	ctx context.Context,
	code binder.TransactionCode,
	_data *parcel.Parcel,
) (*parcel.Parcel, error)

type WifiP2pIfaceProxy 

type WifiP2pIfaceProxy struct {
	Remote binder.IBinder
}

func NewWifiP2pIfaceProxy 

func NewWifiP2pIfaceProxy(
	remote binder.IBinder,
) *WifiP2pIfaceProxy

func (*WifiP2pIfaceProxy) AsBinder 

func (p *WifiP2pIfaceProxy) AsBinder() binder.IBinder

func (*WifiP2pIfaceProxy) GetName 

func (p *WifiP2pIfaceProxy) GetName(
	ctx context.Context,
) (string, error)

type WifiP2pIfaceStub 

type WifiP2pIfaceStub struct {
	Impl      IWifiP2pIface
	Transport binder.VersionAwareTransport
}

WifiP2pIfaceStub dispatches incoming binder transactions to a typed IWifiP2pIface implementation.

func (*WifiP2pIfaceStub) Descriptor 

func (s *WifiP2pIfaceStub) Descriptor() string

func (*WifiP2pIfaceStub) OnTransaction 

func (s *WifiP2pIfaceStub) OnTransaction(
	ctx context.Context,
	code binder.TransactionCode,
	_data *parcel.Parcel,
) (*parcel.Parcel, error)

type WifiProxy 

type WifiProxy struct {
	Remote binder.IBinder
}

func NewWifiProxy 

func NewWifiProxy(
	remote binder.IBinder,
) *WifiProxy

func (*WifiProxy) AsBinder 

func (p *WifiProxy) AsBinder() binder.IBinder

func (*WifiProxy) GetChip 

func (p *WifiProxy) GetChip(
	ctx context.Context,
	chipId int32,
) (IWifiChip, error)

func (*WifiProxy) GetChipIds 

func (p *WifiProxy) GetChipIds(
	ctx context.Context,
) ([]int32, error)

func (*WifiProxy) IsStarted 

func (p *WifiProxy) IsStarted(
	ctx context.Context,
) (bool, error)

func (*WifiProxy) RegisterEventCallback 

func (p *WifiProxy) RegisterEventCallback(
	ctx context.Context,
	callback IWifiEventCallback,
) error

func (*WifiProxy) Start 

func (p *WifiProxy) Start(
	ctx context.Context,
) error

func (*WifiProxy) Stop 

func (p *WifiProxy) Stop(
	ctx context.Context,
) error

type WifiRadioCombination 

type WifiRadioCombination struct {
	RadioConfigurations []WifiRadioConfiguration
}

func (*WifiRadioCombination) MarshalParcel 

func (s *WifiRadioCombination) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiRadioCombination) UnmarshalParcel 

func (s *WifiRadioCombination) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiRadioConfiguration 

type WifiRadioConfiguration struct {
	BandInfo    WifiBand
	AntennaMode WifiAntennaMode
}

func (*WifiRadioConfiguration) MarshalParcel 

func (s *WifiRadioConfiguration) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiRadioConfiguration) UnmarshalParcel 

func (s *WifiRadioConfiguration) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiRateInfo 

type WifiRateInfo struct {
	Preamble      WifiRatePreamble
	Nss           WifiRateNss
	Bw            WifiChannelWidthInMhz
	RateMcsIdx    byte
	BitRateInKbps int32
}

func (*WifiRateInfo) MarshalParcel 

func (s *WifiRateInfo) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiRateInfo) UnmarshalParcel 

func (s *WifiRateInfo) UnmarshalParcel(
	p *parcel.Parcel,
) error

type WifiRateNss 

type WifiRateNss int32
const (
	WifiRateNssNSS_1x1 WifiRateNss = 0
	WifiRateNssNSS_2x2 WifiRateNss = 1
	WifiRateNssNSS_3x3 WifiRateNss = 2
	WifiRateNssNSS_4x4 WifiRateNss = 3
)

type WifiRatePreamble 

type WifiRatePreamble int32
const (
	WifiRatePreambleOFDM     WifiRatePreamble = 0
	WifiRatePreambleCCK      WifiRatePreamble = 1
	WifiRatePreambleHT       WifiRatePreamble = 2
	WifiRatePreambleVHT      WifiRatePreamble = 3
	WifiRatePreambleRESERVED WifiRatePreamble = 4
	WifiRatePreambleHE       WifiRatePreamble = 5
	WifiRatePreambleEHT      WifiRatePreamble = 6
)

type WifiRttControllerEventCallbackProxy 

type WifiRttControllerEventCallbackProxy struct {
	Remote binder.IBinder
}

func NewWifiRttControllerEventCallbackProxy 

func NewWifiRttControllerEventCallbackProxy(
	remote binder.IBinder,
) *WifiRttControllerEventCallbackProxy

func (*WifiRttControllerEventCallbackProxy) AsBinder 

func (p *WifiRttControllerEventCallbackProxy) AsBinder() binder.IBinder

func (*WifiRttControllerEventCallbackProxy) OnResults 

func (p *WifiRttControllerEventCallbackProxy) OnResults(
	ctx context.Context,
	cmdId int32,
	results []RttResult,
) error

type WifiRttControllerEventCallbackStub 

type WifiRttControllerEventCallbackStub struct {
	Impl      IWifiRttControllerEventCallback
	Transport binder.VersionAwareTransport
}

WifiRttControllerEventCallbackStub dispatches incoming binder transactions to a typed IWifiRttControllerEventCallback implementation.

func (*WifiRttControllerEventCallbackStub) Descriptor 

func (s *WifiRttControllerEventCallbackStub) Descriptor() string

func (*WifiRttControllerEventCallbackStub) OnTransaction 

func (s *WifiRttControllerEventCallbackStub) OnTransaction(
	ctx context.Context,
	code binder.TransactionCode,
	_data *parcel.Parcel,
) (*parcel.Parcel, error)

type WifiRttControllerProxy 

type WifiRttControllerProxy struct {
	Remote binder.IBinder
}

func NewWifiRttControllerProxy 

func NewWifiRttControllerProxy(
	remote binder.IBinder,
) *WifiRttControllerProxy

func (*WifiRttControllerProxy) AsBinder 

func (p *WifiRttControllerProxy) AsBinder() binder.IBinder

func (*WifiRttControllerProxy) DisableResponder 

func (p *WifiRttControllerProxy) DisableResponder(
	ctx context.Context,
	cmdId int32,
) error

func (*WifiRttControllerProxy) EnableResponder 

func (p *WifiRttControllerProxy) EnableResponder(
	ctx context.Context,
	cmdId int32,
	channelHint WifiChannelInfo,
	maxDurationInSeconds int32,
	info RttResponder,
) error

func (*WifiRttControllerProxy) GetBoundIface 

func (p *WifiRttControllerProxy) GetBoundIface(
	ctx context.Context,
) (IWifiStaIface, error)

func (*WifiRttControllerProxy) GetCapabilities 

func (p *WifiRttControllerProxy) GetCapabilities(
	ctx context.Context,
) (RttCapabilities, error)

func (*WifiRttControllerProxy) GetResponderInfo 

func (p *WifiRttControllerProxy) GetResponderInfo(
	ctx context.Context,
) (RttResponder, error)

func (*WifiRttControllerProxy) RangeCancel 

func (p *WifiRttControllerProxy) RangeCancel(
	ctx context.Context,
	cmdId int32,
	addrs []MacAddress,
) error

func (*WifiRttControllerProxy) RangeRequest 

func (p *WifiRttControllerProxy) RangeRequest(
	ctx context.Context,
	cmdId int32,
	rttConfigs []RttConfig,
) error

func (*WifiRttControllerProxy) RegisterEventCallback 

func (p *WifiRttControllerProxy) RegisterEventCallback(
	ctx context.Context,
	callback IWifiRttControllerEventCallback,
) error

func (*WifiRttControllerProxy) SetLci 

func (p *WifiRttControllerProxy) SetLci(
	ctx context.Context,
	cmdId int32,
	lci RttLciInformation,
) error

func (*WifiRttControllerProxy) SetLcr 

func (p *WifiRttControllerProxy) SetLcr(
	ctx context.Context,
	cmdId int32,
	lcr RttLcrInformation,
) error

type WifiRttControllerStub 

type WifiRttControllerStub struct {
	Impl      IWifiRttController
	Transport binder.VersionAwareTransport
}

WifiRttControllerStub dispatches incoming binder transactions to a typed IWifiRttController implementation.

func (*WifiRttControllerStub) Descriptor 

func (s *WifiRttControllerStub) Descriptor() string

func (*WifiRttControllerStub) OnTransaction 

func (s *WifiRttControllerStub) OnTransaction(
	ctx context.Context,
	code binder.TransactionCode,
	_data *parcel.Parcel,
) (*parcel.Parcel, error)

type WifiStaIfaceEventCallbackProxy 

type WifiStaIfaceEventCallbackProxy struct {
	Remote binder.IBinder
}

func NewWifiStaIfaceEventCallbackProxy 

func NewWifiStaIfaceEventCallbackProxy(
	remote binder.IBinder,
) *WifiStaIfaceEventCallbackProxy

func (*WifiStaIfaceEventCallbackProxy) AsBinder 

func (p *WifiStaIfaceEventCallbackProxy) AsBinder() binder.IBinder

func (*WifiStaIfaceEventCallbackProxy) OnBackgroundFullScanResult 

func (p *WifiStaIfaceEventCallbackProxy) OnBackgroundFullScanResult(
	ctx context.Context,
	cmdId int32,
	bucketsScanned int32,
	result StaScanResult,
) error

func (*WifiStaIfaceEventCallbackProxy) OnBackgroundScanFailure 

func (p *WifiStaIfaceEventCallbackProxy) OnBackgroundScanFailure(
	ctx context.Context,
	cmdId int32,
) error

func (*WifiStaIfaceEventCallbackProxy) OnBackgroundScanResults 

func (p *WifiStaIfaceEventCallbackProxy) OnBackgroundScanResults(
	ctx context.Context,
	cmdId int32,
	scanDatas []StaScanData,
) error

func (*WifiStaIfaceEventCallbackProxy) OnRssiThresholdBreached 

func (p *WifiStaIfaceEventCallbackProxy) OnRssiThresholdBreached(
	ctx context.Context,
	cmdId int32,
	currBssid []byte,
	currRssi int32,
) error

func (*WifiStaIfaceEventCallbackProxy) OnTwtFailure 

func (p *WifiStaIfaceEventCallbackProxy) OnTwtFailure(
	ctx context.Context,
	cmdId int32,
	error_ IWifiStaIfaceEventCallbackTwtErrorCode,
) error

func (*WifiStaIfaceEventCallbackProxy) OnTwtSessionCreate 

func (p *WifiStaIfaceEventCallbackProxy) OnTwtSessionCreate(
	ctx context.Context,
	cmdId int32,
	twtSession TwtSession,
) error

func (*WifiStaIfaceEventCallbackProxy) OnTwtSessionResume 

func (p *WifiStaIfaceEventCallbackProxy) OnTwtSessionResume(
	ctx context.Context,
	cmdId int32,
	twtSessionId int32,
) error

func (*WifiStaIfaceEventCallbackProxy) OnTwtSessionStats 

func (p *WifiStaIfaceEventCallbackProxy) OnTwtSessionStats(
	ctx context.Context,
	cmdId int32,
	twtSessionId int32,
	twtSessionStats TwtSessionStats,
) error

func (*WifiStaIfaceEventCallbackProxy) OnTwtSessionSuspend 

func (p *WifiStaIfaceEventCallbackProxy) OnTwtSessionSuspend(
	ctx context.Context,
	cmdId int32,
	twtSessionId int32,
) error

func (*WifiStaIfaceEventCallbackProxy) OnTwtSessionTeardown 

func (p *WifiStaIfaceEventCallbackProxy) OnTwtSessionTeardown(
	ctx context.Context,
	cmdId int32,
	twtSessionId int32,
	reasonCode IWifiStaIfaceEventCallbackTwtTeardownReasonCode,
) error

func (*WifiStaIfaceEventCallbackProxy) OnTwtSessionUpdate 

func (p *WifiStaIfaceEventCallbackProxy) OnTwtSessionUpdate(
	ctx context.Context,
	cmdId int32,
	twtSession TwtSession,
) error

type WifiStaIfaceEventCallbackStub 

type WifiStaIfaceEventCallbackStub struct {
	Impl      IWifiStaIfaceEventCallback
	Transport binder.VersionAwareTransport
}

WifiStaIfaceEventCallbackStub dispatches incoming binder transactions to a typed IWifiStaIfaceEventCallback implementation.

func (*WifiStaIfaceEventCallbackStub) Descriptor 

func (s *WifiStaIfaceEventCallbackStub) Descriptor() string

func (*WifiStaIfaceEventCallbackStub) OnTransaction 

func (s *WifiStaIfaceEventCallbackStub) OnTransaction(
	ctx context.Context,
	code binder.TransactionCode,
	_data *parcel.Parcel,
) (*parcel.Parcel, error)

type WifiStaIfaceProxy 

type WifiStaIfaceProxy struct {
	Remote binder.IBinder
}

func NewWifiStaIfaceProxy 

func NewWifiStaIfaceProxy(
	remote binder.IBinder,
) *WifiStaIfaceProxy

func (*WifiStaIfaceProxy) AsBinder 

func (p *WifiStaIfaceProxy) AsBinder() binder.IBinder

func (*WifiStaIfaceProxy) ConfigureRoaming 

func (p *WifiStaIfaceProxy) ConfigureRoaming(
	ctx context.Context,
	config StaRoamingConfig,
) error

func (*WifiStaIfaceProxy) DisableLinkLayerStatsCollection 

func (p *WifiStaIfaceProxy) DisableLinkLayerStatsCollection(
	ctx context.Context,
) error

func (*WifiStaIfaceProxy) EnableLinkLayerStatsCollection 

func (p *WifiStaIfaceProxy) EnableLinkLayerStatsCollection(
	ctx context.Context,
	debug bool,
) error

func (*WifiStaIfaceProxy) EnableNdOffload 

func (p *WifiStaIfaceProxy) EnableNdOffload(
	ctx context.Context,
	enable bool,
) error

func (*WifiStaIfaceProxy) GetApfPacketFilterCapabilities 

func (p *WifiStaIfaceProxy) GetApfPacketFilterCapabilities(
	ctx context.Context,
) (StaApfPacketFilterCapabilities, error)

func (*WifiStaIfaceProxy) GetBackgroundScanCapabilities 

func (p *WifiStaIfaceProxy) GetBackgroundScanCapabilities(
	ctx context.Context,
) (StaBackgroundScanCapabilities, error)

func (*WifiStaIfaceProxy) GetCachedScanData 

func (p *WifiStaIfaceProxy) GetCachedScanData(
	ctx context.Context,
) (CachedScanData, error)

func (*WifiStaIfaceProxy) GetDebugRxPacketFates 

func (p *WifiStaIfaceProxy) GetDebugRxPacketFates(
	ctx context.Context,
) ([]WifiDebugRxPacketFateReport, error)

func (*WifiStaIfaceProxy) GetDebugTxPacketFates 

func (p *WifiStaIfaceProxy) GetDebugTxPacketFates(
	ctx context.Context,
) ([]WifiDebugTxPacketFateReport, error)

func (*WifiStaIfaceProxy) GetFactoryMacAddress 

func (p *WifiStaIfaceProxy) GetFactoryMacAddress(
	ctx context.Context,
) ([]byte, error)

func (*WifiStaIfaceProxy) GetFeatureSet 

func (p *WifiStaIfaceProxy) GetFeatureSet(
	ctx context.Context,
) (int32, error)

func (*WifiStaIfaceProxy) GetLinkLayerStats 

func (p *WifiStaIfaceProxy) GetLinkLayerStats(
	ctx context.Context,
) (StaLinkLayerStats, error)

func (*WifiStaIfaceProxy) GetName 

func (p *WifiStaIfaceProxy) GetName(
	ctx context.Context,
) (string, error)

func (*WifiStaIfaceProxy) GetRoamingCapabilities 

func (p *WifiStaIfaceProxy) GetRoamingCapabilities(
	ctx context.Context,
) (StaRoamingCapabilities, error)

func (*WifiStaIfaceProxy) InstallApfPacketFilter 

func (p *WifiStaIfaceProxy) InstallApfPacketFilter(
	ctx context.Context,
	program []byte,
) error

func (*WifiStaIfaceProxy) ReadApfPacketFilterData 

func (p *WifiStaIfaceProxy) ReadApfPacketFilterData(
	ctx context.Context,
) ([]byte, error)

func (*WifiStaIfaceProxy) RegisterEventCallback 

func (p *WifiStaIfaceProxy) RegisterEventCallback(
	ctx context.Context,
	callback IWifiStaIfaceEventCallback,
) error

func (*WifiStaIfaceProxy) SetDtimMultiplier 

func (p *WifiStaIfaceProxy) SetDtimMultiplier(
	ctx context.Context,
	multiplier int32,
) error

func (*WifiStaIfaceProxy) SetMacAddress 

func (p *WifiStaIfaceProxy) SetMacAddress(
	ctx context.Context,
	mac []byte,
) error

func (*WifiStaIfaceProxy) SetRoamingState 

func (p *WifiStaIfaceProxy) SetRoamingState(
	ctx context.Context,
	state StaRoamingState,
) error

func (*WifiStaIfaceProxy) SetScanMode 

func (p *WifiStaIfaceProxy) SetScanMode(
	ctx context.Context,
	enable bool,
) error

func (*WifiStaIfaceProxy) StartBackgroundScan 

func (p *WifiStaIfaceProxy) StartBackgroundScan(
	ctx context.Context,
	cmdId int32,
	params StaBackgroundScanParameters,
) error

func (*WifiStaIfaceProxy) StartDebugPacketFateMonitoring 

func (p *WifiStaIfaceProxy) StartDebugPacketFateMonitoring(
	ctx context.Context,
) error

func (*WifiStaIfaceProxy) StartRssiMonitoring 

func (p *WifiStaIfaceProxy) StartRssiMonitoring(
	ctx context.Context,
	cmdId int32,
	maxRssi int32,
	minRssi int32,
) error

func (*WifiStaIfaceProxy) StartSendingKeepAlivePackets 

func (p *WifiStaIfaceProxy) StartSendingKeepAlivePackets(
	ctx context.Context,
	cmdId int32,
	ipPacketData []byte,
	etherType uint16,
	srcAddress []byte,
	dstAddress []byte,
	periodInMs int32,
) error

func (*WifiStaIfaceProxy) StopBackgroundScan 

func (p *WifiStaIfaceProxy) StopBackgroundScan(
	ctx context.Context,
	cmdId int32,
) error

func (*WifiStaIfaceProxy) StopRssiMonitoring 

func (p *WifiStaIfaceProxy) StopRssiMonitoring(
	ctx context.Context,
	cmdId int32,
) error

func (*WifiStaIfaceProxy) StopSendingKeepAlivePackets 

func (p *WifiStaIfaceProxy) StopSendingKeepAlivePackets(
	ctx context.Context,
	cmdId int32,
) error

func (*WifiStaIfaceProxy) TwtGetCapabilities 

func (p *WifiStaIfaceProxy) TwtGetCapabilities(
	ctx context.Context,
) (TwtCapabilities, error)

func (*WifiStaIfaceProxy) TwtSessionGetStats 

func (p *WifiStaIfaceProxy) TwtSessionGetStats(
	ctx context.Context,
	cmdId int32,
	sessionId int32,
) error

func (*WifiStaIfaceProxy) TwtSessionResume 

func (p *WifiStaIfaceProxy) TwtSessionResume(
	ctx context.Context,
	cmdId int32,
	sessionId int32,
) error

func (*WifiStaIfaceProxy) TwtSessionSetup 

func (p *WifiStaIfaceProxy) TwtSessionSetup(
	ctx context.Context,
	cmdId int32,
	twtRequest TwtRequest,
) error

func (*WifiStaIfaceProxy) TwtSessionSuspend 

func (p *WifiStaIfaceProxy) TwtSessionSuspend(
	ctx context.Context,
	cmdId int32,
	sessionId int32,
) error

func (*WifiStaIfaceProxy) TwtSessionTeardown 

func (p *WifiStaIfaceProxy) TwtSessionTeardown(
	ctx context.Context,
	cmdId int32,
	sessionId int32,
) error

func (*WifiStaIfaceProxy) TwtSessionUpdate 

func (p *WifiStaIfaceProxy) TwtSessionUpdate(
	ctx context.Context,
	cmdId int32,
	sessionId int32,
	twtRequest TwtRequest,
) error

type WifiStaIfaceStub 

type WifiStaIfaceStub struct {
	Impl      IWifiStaIface
	Transport binder.VersionAwareTransport
}

WifiStaIfaceStub dispatches incoming binder transactions to a typed IWifiStaIface implementation.

func (*WifiStaIfaceStub) Descriptor 

func (s *WifiStaIfaceStub) Descriptor() string

func (*WifiStaIfaceStub) OnTransaction 

func (s *WifiStaIfaceStub) OnTransaction(
	ctx context.Context,
	code binder.TransactionCode,
	_data *parcel.Parcel,
) (*parcel.Parcel, error)

type WifiStatusCode 

type WifiStatusCode int32
const (
	WifiStatusCodeSUCCESS                       WifiStatusCode = 0
	WifiStatusCodeErrorWifiChipInvalid          WifiStatusCode = 1
	WifiStatusCodeErrorWifiIfaceInvalid         WifiStatusCode = 2
	WifiStatusCodeErrorWifiRttControllerInvalid WifiStatusCode = 3
	WifiStatusCodeErrorNotSupported             WifiStatusCode = 4
	WifiStatusCodeErrorNotAvailable             WifiStatusCode = 5
	WifiStatusCodeErrorNotStarted               WifiStatusCode = 6
	WifiStatusCodeErrorInvalidArgs              WifiStatusCode = 7
	WifiStatusCodeErrorBusy                     WifiStatusCode = 8
	WifiStatusCodeErrorUnknown                  WifiStatusCode = 9
)

type WifiStub 

type WifiStub struct {
	Impl      IWifi
	Transport binder.VersionAwareTransport
}

WifiStub dispatches incoming binder transactions to a typed IWifi implementation.

func (*WifiStub) Descriptor 

func (s *WifiStub) Descriptor() string

func (*WifiStub) OnTransaction 

func (s *WifiStub) OnTransaction(
	ctx context.Context,
	code binder.TransactionCode,
	_data *parcel.Parcel,
) (*parcel.Parcel, error)

type WifiUsableChannel 

type WifiUsableChannel struct {
	Channel          int32
	ChannelBandwidth WifiChannelWidthInMhz
	IfaceModeMask    int32
}

func (*WifiUsableChannel) MarshalParcel 

func (s *WifiUsableChannel) MarshalParcel(
	p *parcel.Parcel,
) error

func (*WifiUsableChannel) UnmarshalParcel 

func (s *WifiUsableChannel) UnmarshalParcel(
	p *parcel.Parcel,
) error

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.