content

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: 10 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	TransactionIClipboardSetPrimaryClip                                = binder.FirstCallTransaction + 0
	TransactionIClipboardSetPrimaryClipAsPackage                       = binder.FirstCallTransaction + 1
	TransactionIClipboardClearPrimaryClip                              = binder.FirstCallTransaction + 2
	TransactionIClipboardGetPrimaryClip                                = binder.FirstCallTransaction + 3
	TransactionIClipboardGetPrimaryClipDescription                     = binder.FirstCallTransaction + 4
	TransactionIClipboardHasPrimaryClip                                = binder.FirstCallTransaction + 5
	TransactionIClipboardAddPrimaryClipChangedListener                 = binder.FirstCallTransaction + 6
	TransactionIClipboardRemovePrimaryClipChangedListener              = binder.FirstCallTransaction + 7
	TransactionIClipboardHasClipboardText                              = binder.FirstCallTransaction + 8
	TransactionIClipboardGetPrimaryClipSource                          = binder.FirstCallTransaction + 9
	TransactionIClipboardAreClipboardAccessNotificationsEnabledForUser = binder.FirstCallTransaction + 10
	TransactionIClipboardSetClipboardAccessNotificationsEnabledForUser = binder.FirstCallTransaction + 11
)
View Source 
const (
	MethodIClipboardSetPrimaryClip                                = "setPrimaryClip"
	MethodIClipboardSetPrimaryClipAsPackage                       = "setPrimaryClipAsPackage"
	MethodIClipboardClearPrimaryClip                              = "clearPrimaryClip"
	MethodIClipboardGetPrimaryClip                                = "getPrimaryClip"
	MethodIClipboardGetPrimaryClipDescription                     = "getPrimaryClipDescription"
	MethodIClipboardHasPrimaryClip                                = "hasPrimaryClip"
	MethodIClipboardAddPrimaryClipChangedListener                 = "addPrimaryClipChangedListener"
	MethodIClipboardRemovePrimaryClipChangedListener              = "removePrimaryClipChangedListener"
	MethodIClipboardHasClipboardText                              = "hasClipboardText"
	MethodIClipboardGetPrimaryClipSource                          = "getPrimaryClipSource"
	MethodIClipboardAreClipboardAccessNotificationsEnabledForUser = "areClipboardAccessNotificationsEnabledForUser"
	MethodIClipboardSetClipboardAccessNotificationsEnabledForUser = "setClipboardAccessNotificationsEnabledForUser"
)
View Source 
const (
	TransactionIContentServiceUnregisterContentObserver                = binder.FirstCallTransaction + 0
	TransactionIContentServiceRegisterContentObserver                  = binder.FirstCallTransaction + 1
	TransactionIContentServiceNotifyChange                             = binder.FirstCallTransaction + 2
	TransactionIContentServiceRequestSync                              = binder.FirstCallTransaction + 3
	TransactionIContentServiceSync                                     = binder.FirstCallTransaction + 4
	TransactionIContentServiceSyncAsUser                               = binder.FirstCallTransaction + 5
	TransactionIContentServiceCancelSync                               = binder.FirstCallTransaction + 6
	TransactionIContentServiceCancelSyncAsUser                         = binder.FirstCallTransaction + 7
	TransactionIContentServiceCancelRequest                            = binder.FirstCallTransaction + 8
	TransactionIContentServiceGetSyncAutomatically                     = binder.FirstCallTransaction + 9
	TransactionIContentServiceGetSyncAutomaticallyAsUser               = binder.FirstCallTransaction + 10
	TransactionIContentServiceSetSyncAutomatically                     = binder.FirstCallTransaction + 11
	TransactionIContentServiceSetSyncAutomaticallyAsUser               = binder.FirstCallTransaction + 12
	TransactionIContentServiceGetPeriodicSyncs                         = binder.FirstCallTransaction + 13
	TransactionIContentServiceAddPeriodicSync                          = binder.FirstCallTransaction + 14
	TransactionIContentServiceRemovePeriodicSync                       = binder.FirstCallTransaction + 15
	TransactionIContentServiceGetIsSyncable                            = binder.FirstCallTransaction + 16
	TransactionIContentServiceGetIsSyncableAsUser                      = binder.FirstCallTransaction + 17
	TransactionIContentServiceSetIsSyncable                            = binder.FirstCallTransaction + 18
	TransactionIContentServiceSetIsSyncableAsUser                      = binder.FirstCallTransaction + 19
	TransactionIContentServiceSetMasterSyncAutomatically               = binder.FirstCallTransaction + 20
	TransactionIContentServiceSetMasterSyncAutomaticallyAsUser         = binder.FirstCallTransaction + 21
	TransactionIContentServiceGetMasterSyncAutomatically               = binder.FirstCallTransaction + 22
	TransactionIContentServiceGetMasterSyncAutomaticallyAsUser         = binder.FirstCallTransaction + 23
	TransactionIContentServiceGetCurrentSyncs                          = binder.FirstCallTransaction + 24
	TransactionIContentServiceGetCurrentSyncsAsUser                    = binder.FirstCallTransaction + 25
	TransactionIContentServiceGetSyncAdapterTypes                      = binder.FirstCallTransaction + 26
	TransactionIContentServiceGetSyncAdapterTypesAsUser                = binder.FirstCallTransaction + 27
	TransactionIContentServiceGetSyncAdapterPackagesForAuthorityAsUser = binder.FirstCallTransaction + 28
	TransactionIContentServiceGetSyncAdapterPackageAsUser              = binder.FirstCallTransaction + 29
	TransactionIContentServiceIsSyncActive                             = binder.FirstCallTransaction + 30
	TransactionIContentServiceGetSyncStatus                            = binder.FirstCallTransaction + 31
	TransactionIContentServiceGetSyncStatusAsUser                      = binder.FirstCallTransaction + 32
	TransactionIContentServiceIsSyncPending                            = binder.FirstCallTransaction + 33
	TransactionIContentServiceIsSyncPendingAsUser                      = binder.FirstCallTransaction + 34
	TransactionIContentServiceAddStatusChangeListener                  = binder.FirstCallTransaction + 35
	TransactionIContentServiceRemoveStatusChangeListener               = binder.FirstCallTransaction + 36
	TransactionIContentServicePutCache                                 = binder.FirstCallTransaction + 37
	TransactionIContentServiceGetCache                                 = binder.FirstCallTransaction + 38
	TransactionIContentServiceResetTodayStats                          = binder.FirstCallTransaction + 39
	TransactionIContentServiceOnDbCorruption                           = binder.FirstCallTransaction + 40
)
View Source 
const (
	MethodIContentServiceUnregisterContentObserver                = "unregisterContentObserver"
	MethodIContentServiceRegisterContentObserver                  = "registerContentObserver"
	MethodIContentServiceNotifyChange                             = "notifyChange"
	MethodIContentServiceRequestSync                              = "requestSync"
	MethodIContentServiceSync                                     = "sync"
	MethodIContentServiceSyncAsUser                               = "syncAsUser"
	MethodIContentServiceCancelSync                               = "cancelSync"
	MethodIContentServiceCancelSyncAsUser                         = "cancelSyncAsUser"
	MethodIContentServiceCancelRequest                            = "cancelRequest"
	MethodIContentServiceGetSyncAutomatically                     = "getSyncAutomatically"
	MethodIContentServiceGetSyncAutomaticallyAsUser               = "getSyncAutomaticallyAsUser"
	MethodIContentServiceSetSyncAutomatically                     = "setSyncAutomatically"
	MethodIContentServiceSetSyncAutomaticallyAsUser               = "setSyncAutomaticallyAsUser"
	MethodIContentServiceGetPeriodicSyncs                         = "getPeriodicSyncs"
	MethodIContentServiceAddPeriodicSync                          = "addPeriodicSync"
	MethodIContentServiceRemovePeriodicSync                       = "removePeriodicSync"
	MethodIContentServiceGetIsSyncable                            = "getIsSyncable"
	MethodIContentServiceGetIsSyncableAsUser                      = "getIsSyncableAsUser"
	MethodIContentServiceSetIsSyncable                            = "setIsSyncable"
	MethodIContentServiceSetIsSyncableAsUser                      = "setIsSyncableAsUser"
	MethodIContentServiceSetMasterSyncAutomatically               = "setMasterSyncAutomatically"
	MethodIContentServiceSetMasterSyncAutomaticallyAsUser         = "setMasterSyncAutomaticallyAsUser"
	MethodIContentServiceGetMasterSyncAutomatically               = "getMasterSyncAutomatically"
	MethodIContentServiceGetMasterSyncAutomaticallyAsUser         = "getMasterSyncAutomaticallyAsUser"
	MethodIContentServiceGetCurrentSyncs                          = "getCurrentSyncs"
	MethodIContentServiceGetCurrentSyncsAsUser                    = "getCurrentSyncsAsUser"
	MethodIContentServiceGetSyncAdapterTypes                      = "getSyncAdapterTypes"
	MethodIContentServiceGetSyncAdapterTypesAsUser                = "getSyncAdapterTypesAsUser"
	MethodIContentServiceGetSyncAdapterPackagesForAuthorityAsUser = "getSyncAdapterPackagesForAuthorityAsUser"
	MethodIContentServiceGetSyncAdapterPackageAsUser              = "getSyncAdapterPackageAsUser"
	MethodIContentServiceIsSyncActive                             = "isSyncActive"
	MethodIContentServiceGetSyncStatus                            = "getSyncStatus"
	MethodIContentServiceGetSyncStatusAsUser                      = "getSyncStatusAsUser"
	MethodIContentServiceIsSyncPending                            = "isSyncPending"
	MethodIContentServiceIsSyncPendingAsUser                      = "isSyncPendingAsUser"
	MethodIContentServiceAddStatusChangeListener                  = "addStatusChangeListener"
	MethodIContentServiceRemoveStatusChangeListener               = "removeStatusChangeListener"
	MethodIContentServicePutCache                                 = "putCache"
	MethodIContentServiceGetCache                                 = "getCache"
	MethodIContentServiceResetTodayStats                          = "resetTodayStats"
	MethodIContentServiceOnDbCorruption                           = "onDbCorruption"
)
View Source 
const (
	TransactionICrossUserContentServiceUpdateContent      = binder.FirstCallTransaction + 0
	TransactionICrossUserContentServiceNotifyForUriAsUser = binder.FirstCallTransaction + 1
)
View Source 
const (
	MethodICrossUserContentServiceUpdateContent      = "updateContent"
	MethodICrossUserContentServiceNotifyForUriAsUser = "notifyForUriAsUser"
)
View Source 
const (
	TransactionIRestrictionsManagerGetApplicationRestrictions                = binder.FirstCallTransaction + 0
	TransactionIRestrictionsManagerGetApplicationRestrictionsPerAdminForUser = binder.FirstCallTransaction + 1
	TransactionIRestrictionsManagerHasRestrictionsProvider                   = binder.FirstCallTransaction + 2
	TransactionIRestrictionsManagerRequestPermission                         = binder.FirstCallTransaction + 3
	TransactionIRestrictionsManagerNotifyPermissionResponse                  = binder.FirstCallTransaction + 4
	TransactionIRestrictionsManagerCreateLocalApprovalIntent                 = binder.FirstCallTransaction + 5
)
View Source 
const (
	MethodIRestrictionsManagerGetApplicationRestrictions                = "getApplicationRestrictions"
	MethodIRestrictionsManagerGetApplicationRestrictionsPerAdminForUser = "getApplicationRestrictionsPerAdminForUser"
	MethodIRestrictionsManagerHasRestrictionsProvider                   = "hasRestrictionsProvider"
	MethodIRestrictionsManagerRequestPermission                         = "requestPermission"
	MethodIRestrictionsManagerNotifyPermissionResponse                  = "notifyPermissionResponse"
	MethodIRestrictionsManagerCreateLocalApprovalIntent                 = "createLocalApprovalIntent"
)
View Source 
const (
	TransactionISyncAdapterOnUnsyncableAccount = binder.FirstCallTransaction + 0
	TransactionISyncAdapterStartSync           = binder.FirstCallTransaction + 1
	TransactionISyncAdapterCancelSync          = binder.FirstCallTransaction + 2
)
View Source 
const (
	MethodISyncAdapterOnUnsyncableAccount = "onUnsyncableAccount"
	MethodISyncAdapterStartSync           = "startSync"
	MethodISyncAdapterCancelSync          = "cancelSync"
)
View Source 
const (
	TransactionISyncContextSendHeartbeat = binder.FirstCallTransaction + 0
	TransactionISyncContextOnFinished    = binder.FirstCallTransaction + 1
)
View Source 
const (
	MethodISyncContextSendHeartbeat = "sendHeartbeat"
	MethodISyncContextOnFinished    = "onFinished"
)
View Source 
const (
	TransactionISyncServiceAdapterStartSync  = binder.FirstCallTransaction + 0
	TransactionISyncServiceAdapterCancelSync = binder.FirstCallTransaction + 1
)
View Source 
const (
	MethodISyncServiceAdapterStartSync  = "startSync"
	MethodISyncServiceAdapterCancelSync = "cancelSync"
)
View Source 
const DescriptorIClipboard = "android.content.IClipboard"
View Source 
const DescriptorIContentService = "android.content.IContentService"
View Source 
const DescriptorICrossUserContentService = "android.content.ICrossUserContentService"
View Source 
const DescriptorIIntentReceiver = "android.content.IIntentReceiver"
View Source 
const DescriptorIIntentSender = "android.content.IIntentSender"
View Source 
const DescriptorIOnPrimaryClipChangedListener = "android.content.IOnPrimaryClipChangedListener"
View Source 
const DescriptorIRestrictionsManager = "android.content.IRestrictionsManager"
View Source 
const DescriptorISyncAdapter = "android.content.ISyncAdapter"
View Source 
const DescriptorISyncAdapterUnsyncableAccountCallback = "android.content.ISyncAdapterUnsyncableAccountCallback"
View Source 
const DescriptorISyncContext = "android.content.ISyncContext"
View Source 
const DescriptorISyncServiceAdapter = "android.content.ISyncServiceAdapter"
View Source 
const DescriptorISyncStatusObserver = "android.content.ISyncStatusObserver"
View Source 
const (
	MethodIIntentReceiverPerformReceive = "performReceive"
)
View Source 
const (
	MethodIIntentSenderSend = "send"
)
View Source 
const (
	MethodIOnPrimaryClipChangedListenerDispatchPrimaryClipChanged = "dispatchPrimaryClipChanged"
)
View Source 
const (
	MethodISyncAdapterUnsyncableAccountCallbackOnUnsyncableAccountDone = "onUnsyncableAccountDone"
)
View Source 
const (
	MethodISyncStatusObserverOnStatusChanged = "onStatusChanged"
)
View Source 
const (
	TransactionIIntentReceiverPerformReceive = binder.FirstCallTransaction + 0
)
View Source 
const (
	TransactionIIntentSenderSend = binder.FirstCallTransaction + 0
)
View Source 
const (
	TransactionIOnPrimaryClipChangedListenerDispatchPrimaryClipChanged = binder.FirstCallTransaction + 0
)
View Source 
const (
	TransactionISyncAdapterUnsyncableAccountCallbackOnUnsyncableAccountDone = binder.FirstCallTransaction + 0
)
View Source 
const (
	TransactionISyncStatusObserverOnStatusChanged = binder.FirstCallTransaction + 0
)

Variables

This section is empty.

Functions

This section is empty.

Types

type AttributionSource 

type AttributionSource struct {
}

func (*AttributionSource) MarshalParcel 

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

func (*AttributionSource) UnmarshalParcel 

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

type AttributionSourceState 

type AttributionSourceState struct {
	Pid                  int32
	Uid                  int32
	DeviceId             int32
	PackageName          string
	AttributionTag       string
	Token                binder.IBinder
	RenouncedPermissions []string
	Next                 []AttributionSourceState
}

func (*AttributionSourceState) MarshalParcel 

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

func (*AttributionSourceState) UnmarshalParcel 

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

type AutofillOptions 

type AutofillOptions struct {
	LoggingLevel             int32
	CompatModeEnabled        bool
	AugmentedAutofillEnabled bool
	AppDisabledExpiration    int64
	Size                     int32
}

func (*AutofillOptions) MarshalParcel 

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

func (*AutofillOptions) UnmarshalParcel 

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

type ClipData 

type ClipData struct {
	N int32
}

func (*ClipData) MarshalParcel 

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

func (*ClipData) UnmarshalParcel 

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

type ClipDescription 

type ClipDescription struct {
	TimeStamp            int64
	IsStyledText         bool
	ClassificationStatus int32
}

func (*ClipDescription) MarshalParcel 

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

func (*ClipDescription) UnmarshalParcel 

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

type ClipboardProxy 

type ClipboardProxy struct {
	Remote binder.IBinder
}

func NewClipboardProxy 

func NewClipboardProxy(
	remote binder.IBinder,
) *ClipboardProxy

func (*ClipboardProxy) AddPrimaryClipChangedListener 

func (p *ClipboardProxy) AddPrimaryClipChangedListener(
	ctx context.Context,
	listener IOnPrimaryClipChangedListener,
	deviceId int32,
) error

func (*ClipboardProxy) AreClipboardAccessNotificationsEnabledForUser 

func (p *ClipboardProxy) AreClipboardAccessNotificationsEnabledForUser(
	ctx context.Context,
) (bool, error)

func (*ClipboardProxy) AsBinder 

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

func (*ClipboardProxy) ClearPrimaryClip 

func (p *ClipboardProxy) ClearPrimaryClip(
	ctx context.Context,
	deviceId int32,
) error

func (*ClipboardProxy) GetPrimaryClip 

func (p *ClipboardProxy) GetPrimaryClip(
	ctx context.Context,
	pkg string,
	deviceId int32,
) (ClipData, error)

func (*ClipboardProxy) GetPrimaryClipDescription 

func (p *ClipboardProxy) GetPrimaryClipDescription(
	ctx context.Context,
	deviceId int32,
) (ClipDescription, error)

func (*ClipboardProxy) GetPrimaryClipSource 

func (p *ClipboardProxy) GetPrimaryClipSource(
	ctx context.Context,
	deviceId int32,
) (string, error)

func (*ClipboardProxy) HasClipboardText 

func (p *ClipboardProxy) HasClipboardText(
	ctx context.Context,
	deviceId int32,
) (bool, error)

func (*ClipboardProxy) HasPrimaryClip 

func (p *ClipboardProxy) HasPrimaryClip(
	ctx context.Context,
	deviceId int32,
) (bool, error)

func (*ClipboardProxy) RemovePrimaryClipChangedListener 

func (p *ClipboardProxy) RemovePrimaryClipChangedListener(
	ctx context.Context,
	listener IOnPrimaryClipChangedListener,
	deviceId int32,
) error

func (*ClipboardProxy) SetClipboardAccessNotificationsEnabledForUser 

func (p *ClipboardProxy) SetClipboardAccessNotificationsEnabledForUser(
	ctx context.Context,
	enable bool,
) error

func (*ClipboardProxy) SetPrimaryClip 

func (p *ClipboardProxy) SetPrimaryClip(
	ctx context.Context,
	clip ClipData,
	deviceId int32,
) error

func (*ClipboardProxy) SetPrimaryClipAsPackage 

func (p *ClipboardProxy) SetPrimaryClipAsPackage(
	ctx context.Context,
	clip ClipData,
	deviceId int32,
	sourcePackage string,
) error

type ClipboardStub 

type ClipboardStub struct {
	Impl      IClipboard
	Transport binder.VersionAwareTransport
}

ClipboardStub dispatches incoming binder transactions to a typed IClipboard implementation.

func (*ClipboardStub) Descriptor 

func (s *ClipboardStub) Descriptor() string

func (*ClipboardStub) OnTransaction 

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

type ComponentName 

type ComponentName struct {
}

func (*ComponentName) MarshalParcel 

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

func (*ComponentName) UnmarshalParcel 

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

type ContentCaptureOptions 

type ContentCaptureOptions struct {
	Lite                             bool
	LoggingLevel                     int32
	MaxBufferSize                    int32
	IdleFlushingFrequencyMs          int32
	TextChangeFlushingFrequencyMs    int32
	LogHistorySize                   int32
	DisableFlushForViewTreeAppearing bool
	EnableReceiver                   bool
}

func (*ContentCaptureOptions) MarshalParcel 

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

func (*ContentCaptureOptions) UnmarshalParcel 

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

type ContentServiceProxy 

type ContentServiceProxy struct {
	Remote binder.IBinder
}

func NewContentServiceProxy 

func NewContentServiceProxy(
	remote binder.IBinder,
) *ContentServiceProxy

func (*ContentServiceProxy) AddPeriodicSync 

func (p *ContentServiceProxy) AddPeriodicSync(
	ctx context.Context,
	account accounts.Account,
	providerName string,
	extras os.Bundle,
	pollFrequency int64,
) error

func (*ContentServiceProxy) AddStatusChangeListener 

func (p *ContentServiceProxy) AddStatusChangeListener(
	ctx context.Context,
	mask int32,
	callback ISyncStatusObserver,
) error

func (*ContentServiceProxy) AsBinder 

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

func (*ContentServiceProxy) CancelRequest 

func (p *ContentServiceProxy) CancelRequest(
	ctx context.Context,
	request SyncRequest,
) error

func (*ContentServiceProxy) CancelSync 

func (p *ContentServiceProxy) CancelSync(
	ctx context.Context,
	account accounts.Account,
	authority string,
	cname ComponentName,
) error

func (*ContentServiceProxy) CancelSyncAsUser 

func (p *ContentServiceProxy) CancelSyncAsUser(
	ctx context.Context,
	account accounts.Account,
	authority string,
	cname ComponentName,
) error

func (*ContentServiceProxy) GetCache 

func (p *ContentServiceProxy) GetCache(
	ctx context.Context,
	packageName string,
	key net.Uri,
) (os.Bundle, error)

func (*ContentServiceProxy) GetCurrentSyncs 

func (p *ContentServiceProxy) GetCurrentSyncs(
	ctx context.Context,
) ([]SyncInfo, error)

func (*ContentServiceProxy) GetCurrentSyncsAsUser 

func (p *ContentServiceProxy) GetCurrentSyncsAsUser(
	ctx context.Context,
) ([]SyncInfo, error)

func (*ContentServiceProxy) GetIsSyncable 

func (p *ContentServiceProxy) GetIsSyncable(
	ctx context.Context,
	account accounts.Account,
	providerName string,
) (int32, error)

func (*ContentServiceProxy) GetIsSyncableAsUser 

func (p *ContentServiceProxy) GetIsSyncableAsUser(
	ctx context.Context,
	account accounts.Account,
	providerName string,
) (int32, error)

func (*ContentServiceProxy) GetMasterSyncAutomatically 

func (p *ContentServiceProxy) GetMasterSyncAutomatically(
	ctx context.Context,
) (bool, error)

func (*ContentServiceProxy) GetMasterSyncAutomaticallyAsUser 

func (p *ContentServiceProxy) GetMasterSyncAutomaticallyAsUser(
	ctx context.Context,
) (bool, error)

func (*ContentServiceProxy) GetPeriodicSyncs 

func (p *ContentServiceProxy) GetPeriodicSyncs(
	ctx context.Context,
	account accounts.Account,
	providerName string,
	cname ComponentName,
) ([]PeriodicSync, error)

func (*ContentServiceProxy) GetSyncAdapterPackageAsUser 

func (p *ContentServiceProxy) GetSyncAdapterPackageAsUser(
	ctx context.Context,
	accountType string,
	authority string,
) (string, error)

func (*ContentServiceProxy) GetSyncAdapterPackagesForAuthorityAsUser 

func (p *ContentServiceProxy) GetSyncAdapterPackagesForAuthorityAsUser(
	ctx context.Context,
	authority string,
) ([]string, error)

func (*ContentServiceProxy) GetSyncAdapterTypes 

func (p *ContentServiceProxy) GetSyncAdapterTypes(
	ctx context.Context,
) ([]SyncAdapterType, error)

func (*ContentServiceProxy) GetSyncAdapterTypesAsUser 

func (p *ContentServiceProxy) GetSyncAdapterTypesAsUser(
	ctx context.Context,
) ([]SyncAdapterType, error)

func (*ContentServiceProxy) GetSyncAutomatically 

func (p *ContentServiceProxy) GetSyncAutomatically(
	ctx context.Context,
	account accounts.Account,
	providerName string,
) (bool, error)

func (*ContentServiceProxy) GetSyncAutomaticallyAsUser 

func (p *ContentServiceProxy) GetSyncAutomaticallyAsUser(
	ctx context.Context,
	account accounts.Account,
	providerName string,
) (bool, error)

func (*ContentServiceProxy) GetSyncStatus 

func (p *ContentServiceProxy) GetSyncStatus(
	ctx context.Context,
	account accounts.Account,
	authority string,
	cname ComponentName,
) (SyncStatusInfo, error)

func (*ContentServiceProxy) GetSyncStatusAsUser 

func (p *ContentServiceProxy) GetSyncStatusAsUser(
	ctx context.Context,
	account accounts.Account,
	authority string,
	cname ComponentName,
) (SyncStatusInfo, error)

func (*ContentServiceProxy) IsSyncActive 

func (p *ContentServiceProxy) IsSyncActive(
	ctx context.Context,
	account accounts.Account,
	authority string,
	cname ComponentName,
) (bool, error)

func (*ContentServiceProxy) IsSyncPending 

func (p *ContentServiceProxy) IsSyncPending(
	ctx context.Context,
	account accounts.Account,
	authority string,
	cname ComponentName,
) (bool, error)

func (*ContentServiceProxy) IsSyncPendingAsUser 

func (p *ContentServiceProxy) IsSyncPendingAsUser(
	ctx context.Context,
	account accounts.Account,
	authority string,
	cname ComponentName,
) (bool, error)

func (*ContentServiceProxy) NotifyChange 

func (p *ContentServiceProxy) NotifyChange(
	ctx context.Context,
	uris []net.Uri,
	observer database.IContentObserver,
	observerWantsSelfNotifications bool,
	flags int32,
	targetSdkVersion int32,
) error

func (*ContentServiceProxy) OnDbCorruption 

func (p *ContentServiceProxy) OnDbCorruption(
	ctx context.Context,
	tag string,
	message string,
	stacktrace string,
) error

func (*ContentServiceProxy) PutCache 

func (p *ContentServiceProxy) PutCache(
	ctx context.Context,
	packageName string,
	key net.Uri,
	value os.Bundle,
) error

func (*ContentServiceProxy) RegisterContentObserver 

func (p *ContentServiceProxy) RegisterContentObserver(
	ctx context.Context,
	uri net.Uri,
	notifyForDescendants bool,
	observer database.IContentObserver,
	targetSdkVersion int32,
) error

func (*ContentServiceProxy) RemovePeriodicSync 

func (p *ContentServiceProxy) RemovePeriodicSync(
	ctx context.Context,
	account accounts.Account,
	providerName string,
	extras os.Bundle,
) error

func (*ContentServiceProxy) RemoveStatusChangeListener 

func (p *ContentServiceProxy) RemoveStatusChangeListener(
	ctx context.Context,
	callback ISyncStatusObserver,
) error

func (*ContentServiceProxy) RequestSync 

func (p *ContentServiceProxy) RequestSync(
	ctx context.Context,
	account accounts.Account,
	authority string,
	extras os.Bundle,
) error

func (*ContentServiceProxy) ResetTodayStats 

func (p *ContentServiceProxy) ResetTodayStats(
	ctx context.Context,
) error

func (*ContentServiceProxy) SetIsSyncable 

func (p *ContentServiceProxy) SetIsSyncable(
	ctx context.Context,
	account accounts.Account,
	providerName string,
	syncable int32,
) error

func (*ContentServiceProxy) SetIsSyncableAsUser 

func (p *ContentServiceProxy) SetIsSyncableAsUser(
	ctx context.Context,
	account accounts.Account,
	providerName string,
	syncable int32,
) error

func (*ContentServiceProxy) SetMasterSyncAutomatically 

func (p *ContentServiceProxy) SetMasterSyncAutomatically(
	ctx context.Context,
	flag bool,
) error

func (*ContentServiceProxy) SetMasterSyncAutomaticallyAsUser 

func (p *ContentServiceProxy) SetMasterSyncAutomaticallyAsUser(
	ctx context.Context,
	flag bool,
) error

func (*ContentServiceProxy) SetSyncAutomatically 

func (p *ContentServiceProxy) SetSyncAutomatically(
	ctx context.Context,
	account accounts.Account,
	providerName string,
	sync bool,
) error

func (*ContentServiceProxy) SetSyncAutomaticallyAsUser 

func (p *ContentServiceProxy) SetSyncAutomaticallyAsUser(
	ctx context.Context,
	account accounts.Account,
	providerName string,
	sync bool,
) error

func (*ContentServiceProxy) Sync 

func (p *ContentServiceProxy) Sync(
	ctx context.Context,
	request SyncRequest,
) error

func (*ContentServiceProxy) SyncAsUser 

func (p *ContentServiceProxy) SyncAsUser(
	ctx context.Context,
	request SyncRequest,
) error

func (*ContentServiceProxy) UnregisterContentObserver 

func (p *ContentServiceProxy) UnregisterContentObserver(
	ctx context.Context,
	observer database.IContentObserver,
) error

type ContentServiceStub 

type ContentServiceStub struct {
	Impl      IContentService
	Transport binder.VersionAwareTransport
}

ContentServiceStub dispatches incoming binder transactions to a typed IContentService implementation.

func (*ContentServiceStub) Descriptor 

func (s *ContentServiceStub) Descriptor() string

func (*ContentServiceStub) OnTransaction 

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

type ContentValues 

type ContentValues struct {
}

func (*ContentValues) MarshalParcel 

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

func (*ContentValues) UnmarshalParcel 

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

type CrossUserContentServiceProxy 

type CrossUserContentServiceProxy struct {
	Remote binder.IBinder
}

func NewCrossUserContentServiceProxy 

func NewCrossUserContentServiceProxy(
	remote binder.IBinder,
) *CrossUserContentServiceProxy

func (*CrossUserContentServiceProxy) AsBinder 

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

func (*CrossUserContentServiceProxy) NotifyForUriAsUser 

func (p *CrossUserContentServiceProxy) NotifyForUriAsUser(
	ctx context.Context,
	uri net.Uri,
) error

func (*CrossUserContentServiceProxy) UpdateContent 

func (p *CrossUserContentServiceProxy) UpdateContent(
	ctx context.Context,
	uri net.Uri,
	key string,
	value int32,
) error

type CrossUserContentServiceStub 

type CrossUserContentServiceStub struct {
	Impl      ICrossUserContentService
	Transport binder.VersionAwareTransport
}

CrossUserContentServiceStub dispatches incoming binder transactions to a typed ICrossUserContentService implementation.

func (*CrossUserContentServiceStub) Descriptor 

func (s *CrossUserContentServiceStub) Descriptor() string

func (*CrossUserContentServiceStub) OnTransaction 

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

type IClipboard 

type IClipboard interface {
	AsBinder() binder.IBinder
	SetPrimaryClip(ctx context.Context, clip ClipData, deviceId int32) error
	SetPrimaryClipAsPackage(ctx context.Context, clip ClipData, deviceId int32, sourcePackage string) error
	ClearPrimaryClip(ctx context.Context, deviceId int32) error
	GetPrimaryClip(ctx context.Context, pkg string, deviceId int32) (ClipData, error)
	GetPrimaryClipDescription(ctx context.Context, deviceId int32) (ClipDescription, error)
	HasPrimaryClip(ctx context.Context, deviceId int32) (bool, error)
	AddPrimaryClipChangedListener(ctx context.Context, listener IOnPrimaryClipChangedListener, deviceId int32) error
	RemovePrimaryClipChangedListener(ctx context.Context, listener IOnPrimaryClipChangedListener, deviceId int32) error
	HasClipboardText(ctx context.Context, deviceId int32) (bool, error)
	GetPrimaryClipSource(ctx context.Context, deviceId int32) (string, error)
	AreClipboardAccessNotificationsEnabledForUser(ctx context.Context) (bool, error)
	SetClipboardAccessNotificationsEnabledForUser(ctx context.Context, enable bool) error
}

func NewClipboardStub 

func NewClipboardStub(
	impl IClipboardServer,
) IClipboard

NewClipboardStub creates a server-side IClipboard wrapping the given server implementation. The returned value satisfies IClipboard 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 IClipboardServer 

type IClipboardServer interface {
	SetPrimaryClip(ctx context.Context, clip ClipData, deviceId int32) error
	SetPrimaryClipAsPackage(ctx context.Context, clip ClipData, deviceId int32, sourcePackage string) error
	ClearPrimaryClip(ctx context.Context, deviceId int32) error
	GetPrimaryClip(ctx context.Context, pkg string, deviceId int32) (ClipData, error)
	GetPrimaryClipDescription(ctx context.Context, deviceId int32) (ClipDescription, error)
	HasPrimaryClip(ctx context.Context, deviceId int32) (bool, error)
	AddPrimaryClipChangedListener(ctx context.Context, listener IOnPrimaryClipChangedListener, deviceId int32) error
	RemovePrimaryClipChangedListener(ctx context.Context, listener IOnPrimaryClipChangedListener, deviceId int32) error
	HasClipboardText(ctx context.Context, deviceId int32) (bool, error)
	GetPrimaryClipSource(ctx context.Context, deviceId int32) (string, error)
	AreClipboardAccessNotificationsEnabledForUser(ctx context.Context) (bool, error)
	SetClipboardAccessNotificationsEnabledForUser(ctx context.Context, enable bool) error
}

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

type IContentService 

type IContentService interface {
	AsBinder() binder.IBinder
	UnregisterContentObserver(ctx context.Context, observer database.IContentObserver) error
	RegisterContentObserver(ctx context.Context, uri net.Uri, notifyForDescendants bool, observer database.IContentObserver, targetSdkVersion int32) error
	NotifyChange(ctx context.Context, uris []net.Uri, observer database.IContentObserver, observerWantsSelfNotifications bool, flags int32, targetSdkVersion int32) error
	RequestSync(ctx context.Context, account accounts.Account, authority string, extras os.Bundle) error
	Sync(ctx context.Context, request SyncRequest) error
	SyncAsUser(ctx context.Context, request SyncRequest) error
	CancelSync(ctx context.Context, account accounts.Account, authority string, cname ComponentName) error
	CancelSyncAsUser(ctx context.Context, account accounts.Account, authority string, cname ComponentName) error
	CancelRequest(ctx context.Context, request SyncRequest) error
	GetSyncAutomatically(ctx context.Context, account accounts.Account, providerName string) (bool, error)
	GetSyncAutomaticallyAsUser(ctx context.Context, account accounts.Account, providerName string) (bool, error)
	SetSyncAutomatically(ctx context.Context, account accounts.Account, providerName string, sync bool) error
	SetSyncAutomaticallyAsUser(ctx context.Context, account accounts.Account, providerName string, sync bool) error
	GetPeriodicSyncs(ctx context.Context, account accounts.Account, providerName string, cname ComponentName) ([]PeriodicSync, error)
	AddPeriodicSync(ctx context.Context, account accounts.Account, providerName string, extras os.Bundle, pollFrequency int64) error
	RemovePeriodicSync(ctx context.Context, account accounts.Account, providerName string, extras os.Bundle) error
	GetIsSyncable(ctx context.Context, account accounts.Account, providerName string) (int32, error)
	GetIsSyncableAsUser(ctx context.Context, account accounts.Account, providerName string) (int32, error)
	SetIsSyncable(ctx context.Context, account accounts.Account, providerName string, syncable int32) error
	SetIsSyncableAsUser(ctx context.Context, account accounts.Account, providerName string, syncable int32) error
	SetMasterSyncAutomatically(ctx context.Context, flag bool) error
	SetMasterSyncAutomaticallyAsUser(ctx context.Context, flag bool) error
	GetMasterSyncAutomatically(ctx context.Context) (bool, error)
	GetMasterSyncAutomaticallyAsUser(ctx context.Context) (bool, error)
	GetCurrentSyncs(ctx context.Context) ([]SyncInfo, error)
	GetCurrentSyncsAsUser(ctx context.Context) ([]SyncInfo, error)
	GetSyncAdapterTypes(ctx context.Context) ([]SyncAdapterType, error)
	GetSyncAdapterTypesAsUser(ctx context.Context) ([]SyncAdapterType, error)
	GetSyncAdapterPackagesForAuthorityAsUser(ctx context.Context, authority string) ([]string, error)
	GetSyncAdapterPackageAsUser(ctx context.Context, accountType string, authority string) (string, error)
	IsSyncActive(ctx context.Context, account accounts.Account, authority string, cname ComponentName) (bool, error)
	GetSyncStatus(ctx context.Context, account accounts.Account, authority string, cname ComponentName) (SyncStatusInfo, error)
	GetSyncStatusAsUser(ctx context.Context, account accounts.Account, authority string, cname ComponentName) (SyncStatusInfo, error)
	IsSyncPending(ctx context.Context, account accounts.Account, authority string, cname ComponentName) (bool, error)
	IsSyncPendingAsUser(ctx context.Context, account accounts.Account, authority string, cname ComponentName) (bool, error)
	AddStatusChangeListener(ctx context.Context, mask int32, callback ISyncStatusObserver) error
	RemoveStatusChangeListener(ctx context.Context, callback ISyncStatusObserver) error
	PutCache(ctx context.Context, packageName string, key net.Uri, value os.Bundle) error
	GetCache(ctx context.Context, packageName string, key net.Uri) (os.Bundle, error)
	ResetTodayStats(ctx context.Context) error
	OnDbCorruption(ctx context.Context, tag string, message string, stacktrace string) error
}

func NewContentServiceStub 

func NewContentServiceStub(
	impl IContentServiceServer,
) IContentService

NewContentServiceStub creates a server-side IContentService wrapping the given server implementation. The returned value satisfies IContentService 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 IContentServiceServer 

type IContentServiceServer interface {
	UnregisterContentObserver(ctx context.Context, observer database.IContentObserver) error
	RegisterContentObserver(ctx context.Context, uri net.Uri, notifyForDescendants bool, observer database.IContentObserver, targetSdkVersion int32) error
	NotifyChange(ctx context.Context, uris []net.Uri, observer database.IContentObserver, observerWantsSelfNotifications bool, flags int32, targetSdkVersion int32) error
	RequestSync(ctx context.Context, account accounts.Account, authority string, extras os.Bundle) error
	Sync(ctx context.Context, request SyncRequest) error
	SyncAsUser(ctx context.Context, request SyncRequest) error
	CancelSync(ctx context.Context, account accounts.Account, authority string, cname ComponentName) error
	CancelSyncAsUser(ctx context.Context, account accounts.Account, authority string, cname ComponentName) error
	CancelRequest(ctx context.Context, request SyncRequest) error
	GetSyncAutomatically(ctx context.Context, account accounts.Account, providerName string) (bool, error)
	GetSyncAutomaticallyAsUser(ctx context.Context, account accounts.Account, providerName string) (bool, error)
	SetSyncAutomatically(ctx context.Context, account accounts.Account, providerName string, sync bool) error
	SetSyncAutomaticallyAsUser(ctx context.Context, account accounts.Account, providerName string, sync bool) error
	GetPeriodicSyncs(ctx context.Context, account accounts.Account, providerName string, cname ComponentName) ([]PeriodicSync, error)
	AddPeriodicSync(ctx context.Context, account accounts.Account, providerName string, extras os.Bundle, pollFrequency int64) error
	RemovePeriodicSync(ctx context.Context, account accounts.Account, providerName string, extras os.Bundle) error
	GetIsSyncable(ctx context.Context, account accounts.Account, providerName string) (int32, error)
	GetIsSyncableAsUser(ctx context.Context, account accounts.Account, providerName string) (int32, error)
	SetIsSyncable(ctx context.Context, account accounts.Account, providerName string, syncable int32) error
	SetIsSyncableAsUser(ctx context.Context, account accounts.Account, providerName string, syncable int32) error
	SetMasterSyncAutomatically(ctx context.Context, flag bool) error
	SetMasterSyncAutomaticallyAsUser(ctx context.Context, flag bool) error
	GetMasterSyncAutomatically(ctx context.Context) (bool, error)
	GetMasterSyncAutomaticallyAsUser(ctx context.Context) (bool, error)
	GetCurrentSyncs(ctx context.Context) ([]SyncInfo, error)
	GetCurrentSyncsAsUser(ctx context.Context) ([]SyncInfo, error)
	GetSyncAdapterTypes(ctx context.Context) ([]SyncAdapterType, error)
	GetSyncAdapterTypesAsUser(ctx context.Context) ([]SyncAdapterType, error)
	GetSyncAdapterPackagesForAuthorityAsUser(ctx context.Context, authority string) ([]string, error)
	GetSyncAdapterPackageAsUser(ctx context.Context, accountType string, authority string) (string, error)
	IsSyncActive(ctx context.Context, account accounts.Account, authority string, cname ComponentName) (bool, error)
	GetSyncStatus(ctx context.Context, account accounts.Account, authority string, cname ComponentName) (SyncStatusInfo, error)
	GetSyncStatusAsUser(ctx context.Context, account accounts.Account, authority string, cname ComponentName) (SyncStatusInfo, error)
	IsSyncPending(ctx context.Context, account accounts.Account, authority string, cname ComponentName) (bool, error)
	IsSyncPendingAsUser(ctx context.Context, account accounts.Account, authority string, cname ComponentName) (bool, error)
	AddStatusChangeListener(ctx context.Context, mask int32, callback ISyncStatusObserver) error
	RemoveStatusChangeListener(ctx context.Context, callback ISyncStatusObserver) error
	PutCache(ctx context.Context, packageName string, key net.Uri, value os.Bundle) error
	GetCache(ctx context.Context, packageName string, key net.Uri) (os.Bundle, error)
	ResetTodayStats(ctx context.Context) error
	OnDbCorruption(ctx context.Context, tag string, message string, stacktrace string) error
}

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

type ICrossUserContentService 

type ICrossUserContentService interface {
	AsBinder() binder.IBinder
	UpdateContent(ctx context.Context, uri net.Uri, key string, value int32) error
	NotifyForUriAsUser(ctx context.Context, uri net.Uri) error
}

func NewCrossUserContentServiceStub 

func NewCrossUserContentServiceStub(
	impl ICrossUserContentServiceServer,
) ICrossUserContentService

NewCrossUserContentServiceStub creates a server-side ICrossUserContentService wrapping the given server implementation. The returned value satisfies ICrossUserContentService 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 ICrossUserContentServiceServer 

type ICrossUserContentServiceServer interface {
	UpdateContent(ctx context.Context, uri net.Uri, key string, value int32) error
	NotifyForUriAsUser(ctx context.Context, uri net.Uri) error
}

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

type IIntentReceiver 

type IIntentReceiver interface {
	AsBinder() binder.IBinder
	PerformReceive(ctx context.Context, intent Intent, resultCode int32, data string, extras os.Bundle, ordered bool, sticky bool, sendingUser int32) error
}

func NewIntentReceiverStub 

func NewIntentReceiverStub(
	impl IIntentReceiverServer,
) IIntentReceiver

NewIntentReceiverStub creates a server-side IIntentReceiver wrapping the given server implementation. The returned value satisfies IIntentReceiver 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 IIntentReceiverServer 

type IIntentReceiverServer interface {
	PerformReceive(ctx context.Context, intent Intent, resultCode int32, data string, extras os.Bundle, ordered bool, sticky bool, sendingUser int32) error
}

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

type IIntentSender 

type IIntentSender interface {
	AsBinder() binder.IBinder
	Send(ctx context.Context, code int32, intent Intent, resolvedType string, whitelistToken binder.IBinder, finishedReceiver IIntentReceiver, requiredPermission string, options os.Bundle) error
}

func NewIntentSenderStub 

func NewIntentSenderStub(
	impl IIntentSenderServer,
) IIntentSender

NewIntentSenderStub creates a server-side IIntentSender wrapping the given server implementation. The returned value satisfies IIntentSender 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 IIntentSenderServer 

type IIntentSenderServer interface {
	Send(ctx context.Context, code int32, intent Intent, resolvedType string, whitelistToken binder.IBinder, finishedReceiver IIntentReceiver, requiredPermission string, options os.Bundle) error
}

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

type IOnPrimaryClipChangedListener 

type IOnPrimaryClipChangedListener interface {
	AsBinder() binder.IBinder
	DispatchPrimaryClipChanged(ctx context.Context) error
}

func NewOnPrimaryClipChangedListenerStub 

func NewOnPrimaryClipChangedListenerStub(
	impl IOnPrimaryClipChangedListenerServer,
) IOnPrimaryClipChangedListener

NewOnPrimaryClipChangedListenerStub creates a server-side IOnPrimaryClipChangedListener wrapping the given server implementation. The returned value satisfies IOnPrimaryClipChangedListener 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 IOnPrimaryClipChangedListenerServer 

type IOnPrimaryClipChangedListenerServer interface {
	DispatchPrimaryClipChanged(ctx context.Context) error
}

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

type IRestrictionsManager 

type IRestrictionsManager interface {
	AsBinder() binder.IBinder
	GetApplicationRestrictions(ctx context.Context, packageName string) (os.Bundle, error)
	GetApplicationRestrictionsPerAdminForUser(ctx context.Context, packageName string) ([]os.Bundle, error)
	HasRestrictionsProvider(ctx context.Context) (bool, error)
	RequestPermission(ctx context.Context, packageName string, requestType string, requestId string, requestData os.PersistableBundle) error
	NotifyPermissionResponse(ctx context.Context, packageName string, response os.PersistableBundle) error
	CreateLocalApprovalIntent(ctx context.Context) (Intent, error)
}

func NewRestrictionsManagerStub 

func NewRestrictionsManagerStub(
	impl IRestrictionsManagerServer,
) IRestrictionsManager

NewRestrictionsManagerStub creates a server-side IRestrictionsManager wrapping the given server implementation. The returned value satisfies IRestrictionsManager 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 IRestrictionsManagerServer 

type IRestrictionsManagerServer interface {
	GetApplicationRestrictions(ctx context.Context, packageName string) (os.Bundle, error)
	GetApplicationRestrictionsPerAdminForUser(ctx context.Context, packageName string) ([]os.Bundle, error)
	HasRestrictionsProvider(ctx context.Context) (bool, error)
	RequestPermission(ctx context.Context, packageName string, requestType string, requestId string, requestData os.PersistableBundle) error
	NotifyPermissionResponse(ctx context.Context, packageName string, response os.PersistableBundle) error
	CreateLocalApprovalIntent(ctx context.Context) (Intent, error)
}

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

type ISyncAdapter 

type ISyncAdapter interface {
	AsBinder() binder.IBinder
	OnUnsyncableAccount(ctx context.Context, cb ISyncAdapterUnsyncableAccountCallback) error
	StartSync(ctx context.Context, syncContext ISyncContext, authority string, account accounts.Account, extras os.Bundle) error
	CancelSync(ctx context.Context, syncContext ISyncContext) error
}

func NewSyncAdapterStub 

func NewSyncAdapterStub(
	impl ISyncAdapterServer,
) ISyncAdapter

NewSyncAdapterStub creates a server-side ISyncAdapter wrapping the given server implementation. The returned value satisfies ISyncAdapter 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 ISyncAdapterServer 

type ISyncAdapterServer interface {
	OnUnsyncableAccount(ctx context.Context, cb ISyncAdapterUnsyncableAccountCallback) error
	StartSync(ctx context.Context, syncContext ISyncContext, authority string, account accounts.Account, extras os.Bundle) error
	CancelSync(ctx context.Context, syncContext ISyncContext) error
}

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

type ISyncAdapterUnsyncableAccountCallback 

type ISyncAdapterUnsyncableAccountCallback interface {
	AsBinder() binder.IBinder
	OnUnsyncableAccountDone(ctx context.Context, isReady bool) error
}

func NewSyncAdapterUnsyncableAccountCallbackStub 

func NewSyncAdapterUnsyncableAccountCallbackStub(
	impl ISyncAdapterUnsyncableAccountCallbackServer,
) ISyncAdapterUnsyncableAccountCallback

NewSyncAdapterUnsyncableAccountCallbackStub creates a server-side ISyncAdapterUnsyncableAccountCallback wrapping the given server implementation. The returned value satisfies ISyncAdapterUnsyncableAccountCallback 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 ISyncAdapterUnsyncableAccountCallbackServer 

type ISyncAdapterUnsyncableAccountCallbackServer interface {
	OnUnsyncableAccountDone(ctx context.Context, isReady bool) error
}

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

type ISyncContext 

type ISyncContext interface {
	AsBinder() binder.IBinder
	SendHeartbeat(ctx context.Context) error
	OnFinished(ctx context.Context, result SyncResult) error
}

func NewSyncContextStub 

func NewSyncContextStub(
	impl ISyncContextServer,
) ISyncContext

NewSyncContextStub creates a server-side ISyncContext wrapping the given server implementation. The returned value satisfies ISyncContext 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 ISyncContextServer 

type ISyncContextServer interface {
	SendHeartbeat(ctx context.Context) error
	OnFinished(ctx context.Context, result SyncResult) error
}

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

type ISyncServiceAdapter 

type ISyncServiceAdapter interface {
	AsBinder() binder.IBinder
	StartSync(ctx context.Context, syncContext ISyncContext, extras os.Bundle) error
	CancelSync(ctx context.Context, syncContext ISyncContext) error
}

func NewSyncServiceAdapterStub 

func NewSyncServiceAdapterStub(
	impl ISyncServiceAdapterServer,
) ISyncServiceAdapter

NewSyncServiceAdapterStub creates a server-side ISyncServiceAdapter wrapping the given server implementation. The returned value satisfies ISyncServiceAdapter 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 ISyncServiceAdapterServer 

type ISyncServiceAdapterServer interface {
	StartSync(ctx context.Context, syncContext ISyncContext, extras os.Bundle) error
	CancelSync(ctx context.Context, syncContext ISyncContext) error
}

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

type ISyncStatusObserver 

type ISyncStatusObserver interface {
	AsBinder() binder.IBinder
	OnStatusChanged(ctx context.Context, which int32) error
}

func NewSyncStatusObserverStub 

func NewSyncStatusObserverStub(
	impl ISyncStatusObserverServer,
) ISyncStatusObserver

NewSyncStatusObserverStub creates a server-side ISyncStatusObserver wrapping the given server implementation. The returned value satisfies ISyncStatusObserver 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 ISyncStatusObserverServer 

type ISyncStatusObserverServer interface {
	OnStatusChanged(ctx context.Context, which int32) error
}

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

type Intent 

type Intent struct {
	Action          string
	Type            string
	Identifier      string
	Flags           int32
	ExtendedFlags   int32
	Package         string
	ContentUserHint int32
}

func (*Intent) MarshalParcel 

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

func (*Intent) UnmarshalParcel 

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

type IntentFilter 

type IntentFilter struct {
	Priority             int32
	InstantAppVisibility int32
	Order                int32
}

func (*IntentFilter) MarshalParcel 

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

func (*IntentFilter) UnmarshalParcel 

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

type IntentReceiverProxy 

type IntentReceiverProxy struct {
	Remote binder.IBinder
}

func NewIntentReceiverProxy 

func NewIntentReceiverProxy(
	remote binder.IBinder,
) *IntentReceiverProxy

func (*IntentReceiverProxy) AsBinder 

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

func (*IntentReceiverProxy) PerformReceive 

func (p *IntentReceiverProxy) PerformReceive(
	ctx context.Context,
	intent Intent,
	resultCode int32,
	data string,
	extras os.Bundle,
	ordered bool,
	sticky bool,
	sendingUser int32,
) error

type IntentReceiverStub 

type IntentReceiverStub struct {
	Impl      IIntentReceiver
	Transport binder.VersionAwareTransport
}

IntentReceiverStub dispatches incoming binder transactions to a typed IIntentReceiver implementation.

func (*IntentReceiverStub) Descriptor 

func (s *IntentReceiverStub) Descriptor() string

func (*IntentReceiverStub) OnTransaction 

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

type IntentSender 

type IntentSender struct {
}

func (*IntentSender) MarshalParcel 

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

func (*IntentSender) UnmarshalParcel 

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

type IntentSenderProxy 

type IntentSenderProxy struct {
	Remote binder.IBinder
}

func NewIntentSenderProxy 

func NewIntentSenderProxy(
	remote binder.IBinder,
) *IntentSenderProxy

func (*IntentSenderProxy) AsBinder 

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

func (*IntentSenderProxy) Send 

func (p *IntentSenderProxy) Send(
	ctx context.Context,
	code int32,
	intent Intent,
	resolvedType string,
	whitelistToken binder.IBinder,
	finishedReceiver IIntentReceiver,
	requiredPermission string,
	options os.Bundle,
) error

type IntentSenderStub 

type IntentSenderStub struct {
	Impl      IIntentSender
	Transport binder.VersionAwareTransport
}

IntentSenderStub dispatches incoming binder transactions to a typed IIntentSender implementation.

func (*IntentSenderStub) Descriptor 

func (s *IntentSenderStub) Descriptor() string

func (*IntentSenderStub) OnTransaction 

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

type LocusId 

type LocusId struct {
	Id string
}

func (*LocusId) MarshalParcel 

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

func (*LocusId) UnmarshalParcel 

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

type OnPrimaryClipChangedListenerProxy 

type OnPrimaryClipChangedListenerProxy struct {
	Remote binder.IBinder
}

func NewOnPrimaryClipChangedListenerProxy 

func NewOnPrimaryClipChangedListenerProxy(
	remote binder.IBinder,
) *OnPrimaryClipChangedListenerProxy

func (*OnPrimaryClipChangedListenerProxy) AsBinder 

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

func (*OnPrimaryClipChangedListenerProxy) DispatchPrimaryClipChanged 

func (p *OnPrimaryClipChangedListenerProxy) DispatchPrimaryClipChanged(
	ctx context.Context,
) error

type OnPrimaryClipChangedListenerStub 

type OnPrimaryClipChangedListenerStub struct {
	Impl      IOnPrimaryClipChangedListener
	Transport binder.VersionAwareTransport
}

OnPrimaryClipChangedListenerStub dispatches incoming binder transactions to a typed IOnPrimaryClipChangedListener implementation.

func (*OnPrimaryClipChangedListenerStub) Descriptor 

func (s *OnPrimaryClipChangedListenerStub) Descriptor() string

func (*OnPrimaryClipChangedListenerStub) OnTransaction 

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

type PeriodicSync 

type PeriodicSync struct {
	Authority string
	Period    int64
	FlexTime  int64
	Account   *types.Account
}

func (*PeriodicSync) MarshalParcel 

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

func (*PeriodicSync) UnmarshalParcel 

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

type RestrictionEntry 

type RestrictionEntry struct {
	Type         int32
	Key          string
	Title        string
	Description  string
	CurrentValue string
}

func (*RestrictionEntry) MarshalParcel 

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

func (*RestrictionEntry) UnmarshalParcel 

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

type RestrictionsManagerProxy 

type RestrictionsManagerProxy struct {
	Remote binder.IBinder
}

func GetRestrictionsManager 

func GetRestrictionsManager(
	ctx context.Context,
	sm *servicemanager.ServiceManager,
) (*RestrictionsManagerProxy, error)

GetRestrictionsManager retrieves the RestrictionsService service and returns a typed proxy.

func NewRestrictionsManagerProxy 

func NewRestrictionsManagerProxy(
	remote binder.IBinder,
) *RestrictionsManagerProxy

func (*RestrictionsManagerProxy) AsBinder 

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

func (*RestrictionsManagerProxy) CreateLocalApprovalIntent 

func (p *RestrictionsManagerProxy) CreateLocalApprovalIntent(
	ctx context.Context,
) (Intent, error)

func (*RestrictionsManagerProxy) GetApplicationRestrictions 

func (p *RestrictionsManagerProxy) GetApplicationRestrictions(
	ctx context.Context,
	packageName string,
) (os.Bundle, error)

func (*RestrictionsManagerProxy) GetApplicationRestrictionsPerAdminForUser 

func (p *RestrictionsManagerProxy) GetApplicationRestrictionsPerAdminForUser(
	ctx context.Context,
	packageName string,
) ([]os.Bundle, error)

func (*RestrictionsManagerProxy) HasRestrictionsProvider 

func (p *RestrictionsManagerProxy) HasRestrictionsProvider(
	ctx context.Context,
) (bool, error)

func (*RestrictionsManagerProxy) NotifyPermissionResponse 

func (p *RestrictionsManagerProxy) NotifyPermissionResponse(
	ctx context.Context,
	packageName string,
	response os.PersistableBundle,
) error

func (*RestrictionsManagerProxy) RequestPermission 

func (p *RestrictionsManagerProxy) RequestPermission(
	ctx context.Context,
	packageName string,
	requestType string,
	requestId string,
	requestData os.PersistableBundle,
) error

type RestrictionsManagerStub 

type RestrictionsManagerStub struct {
	Impl      IRestrictionsManager
	Transport binder.VersionAwareTransport
}

RestrictionsManagerStub dispatches incoming binder transactions to a typed IRestrictionsManager implementation.

func (*RestrictionsManagerStub) Descriptor 

func (s *RestrictionsManagerStub) Descriptor() string

func (*RestrictionsManagerStub) OnTransaction 

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

type SyncAdapterProxy 

type SyncAdapterProxy struct {
	Remote binder.IBinder
}

func NewSyncAdapterProxy 

func NewSyncAdapterProxy(
	remote binder.IBinder,
) *SyncAdapterProxy

func (*SyncAdapterProxy) AsBinder 

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

func (*SyncAdapterProxy) CancelSync 

func (p *SyncAdapterProxy) CancelSync(
	ctx context.Context,
	syncContext ISyncContext,
) error

func (*SyncAdapterProxy) OnUnsyncableAccount 

func (p *SyncAdapterProxy) OnUnsyncableAccount(
	ctx context.Context,
	cb ISyncAdapterUnsyncableAccountCallback,
) error

func (*SyncAdapterProxy) StartSync 

func (p *SyncAdapterProxy) StartSync(
	ctx context.Context,
	syncContext ISyncContext,
	authority string,
	account accounts.Account,
	extras os.Bundle,
) error

type SyncAdapterStub 

type SyncAdapterStub struct {
	Impl      ISyncAdapter
	Transport binder.VersionAwareTransport
}

SyncAdapterStub dispatches incoming binder transactions to a typed ISyncAdapter implementation.

func (*SyncAdapterStub) Descriptor 

func (s *SyncAdapterStub) Descriptor() string

func (*SyncAdapterStub) OnTransaction 

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

type SyncAdapterType 

type SyncAdapterType struct {
	Authority        string
	AccountType      string
	SettingsActivity string
	PackageName      string
}

func (*SyncAdapterType) MarshalParcel 

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

func (*SyncAdapterType) UnmarshalParcel 

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

type SyncAdapterUnsyncableAccountCallbackProxy 

type SyncAdapterUnsyncableAccountCallbackProxy struct {
	Remote binder.IBinder
}

func NewSyncAdapterUnsyncableAccountCallbackProxy 

func NewSyncAdapterUnsyncableAccountCallbackProxy(
	remote binder.IBinder,
) *SyncAdapterUnsyncableAccountCallbackProxy

func (*SyncAdapterUnsyncableAccountCallbackProxy) AsBinder 

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

func (*SyncAdapterUnsyncableAccountCallbackProxy) OnUnsyncableAccountDone 

func (p *SyncAdapterUnsyncableAccountCallbackProxy) OnUnsyncableAccountDone(
	ctx context.Context,
	isReady bool,
) error

type SyncAdapterUnsyncableAccountCallbackStub 

type SyncAdapterUnsyncableAccountCallbackStub struct {
	Impl      ISyncAdapterUnsyncableAccountCallback
	Transport binder.VersionAwareTransport
}

SyncAdapterUnsyncableAccountCallbackStub dispatches incoming binder transactions to a typed ISyncAdapterUnsyncableAccountCallback implementation.

func (*SyncAdapterUnsyncableAccountCallbackStub) Descriptor 

func (s *SyncAdapterUnsyncableAccountCallbackStub) Descriptor() string

func (*SyncAdapterUnsyncableAccountCallbackStub) OnTransaction 

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

type SyncContextProxy 

type SyncContextProxy struct {
	Remote binder.IBinder
}

func NewSyncContextProxy 

func NewSyncContextProxy(
	remote binder.IBinder,
) *SyncContextProxy

func (*SyncContextProxy) AsBinder 

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

func (*SyncContextProxy) OnFinished 

func (p *SyncContextProxy) OnFinished(
	ctx context.Context,
	result SyncResult,
) error

func (*SyncContextProxy) SendHeartbeat 

func (p *SyncContextProxy) SendHeartbeat(
	ctx context.Context,
) error

type SyncContextStub 

type SyncContextStub struct {
	Impl      ISyncContext
	Transport binder.VersionAwareTransport
}

SyncContextStub dispatches incoming binder transactions to a typed ISyncContext implementation.

func (*SyncContextStub) Descriptor 

func (s *SyncContextStub) Descriptor() string

func (*SyncContextStub) OnTransaction 

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

type SyncInfo 

type SyncInfo struct {
	AuthorityId int32
	Authority   string
	StartTime   int64
	Account     *types.Account
}

func (*SyncInfo) MarshalParcel 

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

func (*SyncInfo) UnmarshalParcel 

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

type SyncRequest 

type SyncRequest struct {
	SyncFlexTimeSecs int64
	SyncRunTimeSecs  int64
	Authority        string
}

func (*SyncRequest) MarshalParcel 

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

func (*SyncRequest) UnmarshalParcel 

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

type SyncResult 

type SyncResult struct {
	DelayUntil int64
}

func (*SyncResult) MarshalParcel 

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

func (*SyncResult) UnmarshalParcel 

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

type SyncServiceAdapterProxy 

type SyncServiceAdapterProxy struct {
	Remote binder.IBinder
}

func NewSyncServiceAdapterProxy 

func NewSyncServiceAdapterProxy(
	remote binder.IBinder,
) *SyncServiceAdapterProxy

func (*SyncServiceAdapterProxy) AsBinder 

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

func (*SyncServiceAdapterProxy) CancelSync 

func (p *SyncServiceAdapterProxy) CancelSync(
	ctx context.Context,
	syncContext ISyncContext,
) error

func (*SyncServiceAdapterProxy) StartSync 

func (p *SyncServiceAdapterProxy) StartSync(
	ctx context.Context,
	syncContext ISyncContext,
	extras os.Bundle,
) error

type SyncServiceAdapterStub 

type SyncServiceAdapterStub struct {
	Impl      ISyncServiceAdapter
	Transport binder.VersionAwareTransport
}

SyncServiceAdapterStub dispatches incoming binder transactions to a typed ISyncServiceAdapter implementation.

func (*SyncServiceAdapterStub) Descriptor 

func (s *SyncServiceAdapterStub) Descriptor() string

func (*SyncServiceAdapterStub) OnTransaction 

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

type SyncStats 

type SyncStats struct {
	NumAuthExceptions             int64
	NumIoExceptions               int64
	NumParseExceptions            int64
	NumConflictDetectedExceptions int64
	NumInserts                    int64
	NumUpdates                    int64
	NumDeletes                    int64
	NumEntries                    int64
	NumSkippedEntries             int64
}

func (*SyncStats) MarshalParcel 

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

func (*SyncStats) UnmarshalParcel 

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

type SyncStatusInfo 

type SyncStatusInfo struct {
	VERSION            int32
	AuthorityId        int32
	LastSuccessTime    int64
	LastSuccessSource  int32
	LastFailureTime    int64
	LastFailureSource  int32
	LastFailureMesg    string
	InitialFailureTime int64
	LastTodayResetTime int64
}

func (*SyncStatusInfo) MarshalParcel 

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

func (*SyncStatusInfo) UnmarshalParcel 

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

type SyncStatusObserverProxy 

type SyncStatusObserverProxy struct {
	Remote binder.IBinder
}

func NewSyncStatusObserverProxy 

func NewSyncStatusObserverProxy(
	remote binder.IBinder,
) *SyncStatusObserverProxy

func (*SyncStatusObserverProxy) AsBinder 

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

func (*SyncStatusObserverProxy) OnStatusChanged 

func (p *SyncStatusObserverProxy) OnStatusChanged(
	ctx context.Context,
	which int32,
) error

type SyncStatusObserverStub 

type SyncStatusObserverStub struct {
	Impl      ISyncStatusObserver
	Transport binder.VersionAwareTransport
}

SyncStatusObserverStub dispatches incoming binder transactions to a typed ISyncStatusObserver implementation.

func (*SyncStatusObserverStub) Descriptor 

func (s *SyncStatusObserverStub) Descriptor() string

func (*SyncStatusObserverStub) OnTransaction 

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

type UriRelativeFilterGroup 

type UriRelativeFilterGroup struct {
	Action int32
}

func (*UriRelativeFilterGroup) MarshalParcel 

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

func (*UriRelativeFilterGroup) UnmarshalParcel 

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

type UriRelativeFilterGroupParcel 

type UriRelativeFilterGroupParcel struct {
	Action  int32
	Filters []UriRelativeFilterParcel
}

func (*UriRelativeFilterGroupParcel) MarshalParcel 

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

func (*UriRelativeFilterGroupParcel) UnmarshalParcel 

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

type UriRelativeFilterParcel 

type UriRelativeFilterParcel struct {
	UriPart     int32
	PatternType int32
	Filter      string
}

func (*UriRelativeFilterParcel) MarshalParcel 

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

func (*UriRelativeFilterParcel) UnmarshalParcel 

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

Source Files

View all Source files

Directories

Path Synopsis
pm
dex
permission
types
verify/domain
res
types

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.