textservice

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

Documentation

Index

Constants

View Source 
const (
	TransactionISpellCheckerSessionOnGetSuggestionsMultiple         = binder.FirstCallTransaction + 0
	TransactionISpellCheckerSessionOnGetSentenceSuggestionsMultiple = binder.FirstCallTransaction + 1
	TransactionISpellCheckerSessionOnCancel                         = binder.FirstCallTransaction + 2
	TransactionISpellCheckerSessionOnClose                          = binder.FirstCallTransaction + 3
)
View Source 
const (
	MethodISpellCheckerSessionOnGetSuggestionsMultiple         = "onGetSuggestionsMultiple"
	MethodISpellCheckerSessionOnGetSentenceSuggestionsMultiple = "onGetSentenceSuggestionsMultiple"
	MethodISpellCheckerSessionOnCancel                         = "onCancel"
	MethodISpellCheckerSessionOnClose                          = "onClose"
)
View Source 
const (
	TransactionISpellCheckerSessionListenerOnGetSuggestions         = binder.FirstCallTransaction + 0
	TransactionISpellCheckerSessionListenerOnGetSentenceSuggestions = binder.FirstCallTransaction + 1
)
View Source 
const (
	MethodISpellCheckerSessionListenerOnGetSuggestions         = "onGetSuggestions"
	MethodISpellCheckerSessionListenerOnGetSentenceSuggestions = "onGetSentenceSuggestions"
)
View Source 
const (
	TransactionITextServicesManagerGetCurrentSpellChecker        = binder.FirstCallTransaction + 0
	TransactionITextServicesManagerGetCurrentSpellCheckerSubtype = binder.FirstCallTransaction + 1
	TransactionITextServicesManagerGetSpellCheckerService        = binder.FirstCallTransaction + 2
	TransactionITextServicesManagerFinishSpellCheckerService     = binder.FirstCallTransaction + 3
	TransactionITextServicesManagerIsSpellCheckerEnabled         = binder.FirstCallTransaction + 4
	TransactionITextServicesManagerGetEnabledSpellCheckers       = binder.FirstCallTransaction + 5
)
View Source 
const (
	MethodITextServicesManagerGetCurrentSpellChecker        = "getCurrentSpellChecker"
	MethodITextServicesManagerGetCurrentSpellCheckerSubtype = "getCurrentSpellCheckerSubtype"
	MethodITextServicesManagerGetSpellCheckerService        = "getSpellCheckerService"
	MethodITextServicesManagerFinishSpellCheckerService     = "finishSpellCheckerService"
	MethodITextServicesManagerIsSpellCheckerEnabled         = "isSpellCheckerEnabled"
	MethodITextServicesManagerGetEnabledSpellCheckers       = "getEnabledSpellCheckers"
)
View Source 
const DescriptorISpellCheckerService = "com.android.internal.textservice.ISpellCheckerService"
View Source 
const DescriptorISpellCheckerServiceCallback = "com.android.internal.textservice.ISpellCheckerServiceCallback"
View Source 
const DescriptorISpellCheckerSession = "com.android.internal.textservice.ISpellCheckerSession"
View Source 
const DescriptorISpellCheckerSessionListener = "com.android.internal.textservice.ISpellCheckerSessionListener"
View Source 
const DescriptorITextServicesManager = "com.android.internal.textservice.ITextServicesManager"
View Source 
const DescriptorITextServicesSessionListener = "com.android.internal.textservice.ITextServicesSessionListener"
View Source 
const (
	MethodISpellCheckerServiceCallbackOnSessionCreated = "onSessionCreated"
)
View Source 
const (
	MethodISpellCheckerServiceGetISpellCheckerSession = "getISpellCheckerSession"
)
View Source 
const (
	MethodITextServicesSessionListenerOnServiceConnected = "onServiceConnected"
)
View Source 
const (
	TransactionISpellCheckerServiceCallbackOnSessionCreated = binder.FirstCallTransaction + 0
)
View Source 
const (
	TransactionISpellCheckerServiceGetISpellCheckerSession = binder.FirstCallTransaction + 0
)
View Source 
const (
	TransactionITextServicesSessionListenerOnServiceConnected = binder.FirstCallTransaction + 0
)

Variables

This section is empty.

Functions

This section is empty.

Types

type ISpellCheckerService 

type ISpellCheckerService interface {
	AsBinder() binder.IBinder
	GetISpellCheckerSession(ctx context.Context, locale string, listener ISpellCheckerSessionListener, bundle os.Bundle, supportedAttributes int32, callback ISpellCheckerServiceCallback) error
}

func NewSpellCheckerServiceStub 

func NewSpellCheckerServiceStub(
	impl ISpellCheckerServiceServer,
) ISpellCheckerService

NewSpellCheckerServiceStub creates a server-side ISpellCheckerService wrapping the given server implementation. The returned value satisfies ISpellCheckerService 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 ISpellCheckerServiceCallback 

type ISpellCheckerServiceCallback interface {
	AsBinder() binder.IBinder
	OnSessionCreated(ctx context.Context, newSession ISpellCheckerSession) error
}

func NewSpellCheckerServiceCallbackStub 

func NewSpellCheckerServiceCallbackStub(
	impl ISpellCheckerServiceCallbackServer,
) ISpellCheckerServiceCallback

NewSpellCheckerServiceCallbackStub creates a server-side ISpellCheckerServiceCallback wrapping the given server implementation. The returned value satisfies ISpellCheckerServiceCallback 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 ISpellCheckerServiceCallbackServer 

type ISpellCheckerServiceCallbackServer interface {
	OnSessionCreated(ctx context.Context, newSession ISpellCheckerSession) error
}

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

type ISpellCheckerServiceServer 

type ISpellCheckerServiceServer interface {
	GetISpellCheckerSession(ctx context.Context, locale string, listener ISpellCheckerSessionListener, bundle os.Bundle, supportedAttributes int32, callback ISpellCheckerServiceCallback) error
}

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

type ISpellCheckerSession 

type ISpellCheckerSession interface {
	AsBinder() binder.IBinder
	OnGetSuggestionsMultiple(ctx context.Context, textInfos []viewTextservice.TextInfo, suggestionsLimit int32, multipleWords bool) error
	OnGetSentenceSuggestionsMultiple(ctx context.Context, textInfos []viewTextservice.TextInfo, suggestionsLimit int32) error
	OnCancel(ctx context.Context) error
	OnClose(ctx context.Context) error
}

func NewSpellCheckerSessionStub 

func NewSpellCheckerSessionStub(
	impl ISpellCheckerSessionServer,
) ISpellCheckerSession

NewSpellCheckerSessionStub creates a server-side ISpellCheckerSession wrapping the given server implementation. The returned value satisfies ISpellCheckerSession 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 ISpellCheckerSessionListener 

type ISpellCheckerSessionListener interface {
	AsBinder() binder.IBinder
	OnGetSuggestions(ctx context.Context, results []viewTextservice.SuggestionsInfo) error
	OnGetSentenceSuggestions(ctx context.Context, result []viewTextservice.SentenceSuggestionsInfo) error
}

func NewSpellCheckerSessionListenerStub 

func NewSpellCheckerSessionListenerStub(
	impl ISpellCheckerSessionListenerServer,
) ISpellCheckerSessionListener

NewSpellCheckerSessionListenerStub creates a server-side ISpellCheckerSessionListener wrapping the given server implementation. The returned value satisfies ISpellCheckerSessionListener 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 ISpellCheckerSessionListenerServer 

type ISpellCheckerSessionListenerServer interface {
	OnGetSuggestions(ctx context.Context, results []viewTextservice.SuggestionsInfo) error
	OnGetSentenceSuggestions(ctx context.Context, result []viewTextservice.SentenceSuggestionsInfo) error
}

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

type ISpellCheckerSessionServer 

type ISpellCheckerSessionServer interface {
	OnGetSuggestionsMultiple(ctx context.Context, textInfos []viewTextservice.TextInfo, suggestionsLimit int32, multipleWords bool) error
	OnGetSentenceSuggestionsMultiple(ctx context.Context, textInfos []viewTextservice.TextInfo, suggestionsLimit int32) error
	OnCancel(ctx context.Context) error
	OnClose(ctx context.Context) error
}

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

type ITextServicesManager 

type ITextServicesManager interface {
	AsBinder() binder.IBinder
	GetCurrentSpellChecker(ctx context.Context, locale string) (viewTextservice.SpellCheckerInfo, error)
	GetCurrentSpellCheckerSubtype(ctx context.Context, allowImplicitlySelectedSubtype bool) (viewTextservice.SpellCheckerSubtype, error)
	GetSpellCheckerService(ctx context.Context, sciId string, locale string, tsListener ITextServicesSessionListener, scListener ISpellCheckerSessionListener, bundle os.Bundle, supportedAttributes int32) error
	FinishSpellCheckerService(ctx context.Context, listener ISpellCheckerSessionListener) error
	IsSpellCheckerEnabled(ctx context.Context) (bool, error)
	GetEnabledSpellCheckers(ctx context.Context) ([]viewTextservice.SpellCheckerInfo, error)
}

func NewTextServicesManagerStub 

func NewTextServicesManagerStub(
	impl ITextServicesManagerServer,
) ITextServicesManager

NewTextServicesManagerStub creates a server-side ITextServicesManager wrapping the given server implementation. The returned value satisfies ITextServicesManager 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 ITextServicesManagerServer 

type ITextServicesManagerServer interface {
	GetCurrentSpellChecker(ctx context.Context, locale string) (viewTextservice.SpellCheckerInfo, error)
	GetCurrentSpellCheckerSubtype(ctx context.Context, allowImplicitlySelectedSubtype bool) (viewTextservice.SpellCheckerSubtype, error)
	GetSpellCheckerService(ctx context.Context, sciId string, locale string, tsListener ITextServicesSessionListener, scListener ISpellCheckerSessionListener, bundle os.Bundle, supportedAttributes int32) error
	FinishSpellCheckerService(ctx context.Context, listener ISpellCheckerSessionListener) error
	IsSpellCheckerEnabled(ctx context.Context) (bool, error)
	GetEnabledSpellCheckers(ctx context.Context) ([]viewTextservice.SpellCheckerInfo, error)
}

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

type ITextServicesSessionListener 

type ITextServicesSessionListener interface {
	AsBinder() binder.IBinder
	OnServiceConnected(ctx context.Context, spellCheckerSession ISpellCheckerSession) error
}

func NewTextServicesSessionListenerStub 

func NewTextServicesSessionListenerStub(
	impl ITextServicesSessionListenerServer,
) ITextServicesSessionListener

NewTextServicesSessionListenerStub creates a server-side ITextServicesSessionListener wrapping the given server implementation. The returned value satisfies ITextServicesSessionListener 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 ITextServicesSessionListenerServer 

type ITextServicesSessionListenerServer interface {
	OnServiceConnected(ctx context.Context, spellCheckerSession ISpellCheckerSession) error
}

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

type SpellCheckerServiceCallbackProxy 

type SpellCheckerServiceCallbackProxy struct {
	Remote binder.IBinder
}

func NewSpellCheckerServiceCallbackProxy 

func NewSpellCheckerServiceCallbackProxy(
	remote binder.IBinder,
) *SpellCheckerServiceCallbackProxy

func (*SpellCheckerServiceCallbackProxy) AsBinder 

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

func (*SpellCheckerServiceCallbackProxy) OnSessionCreated 

func (p *SpellCheckerServiceCallbackProxy) OnSessionCreated(
	ctx context.Context,
	newSession ISpellCheckerSession,
) error

type SpellCheckerServiceCallbackStub 

type SpellCheckerServiceCallbackStub struct {
	Impl      ISpellCheckerServiceCallback
	Transport binder.VersionAwareTransport
}

SpellCheckerServiceCallbackStub dispatches incoming binder transactions to a typed ISpellCheckerServiceCallback implementation.

func (*SpellCheckerServiceCallbackStub) Descriptor 

func (s *SpellCheckerServiceCallbackStub) Descriptor() string

func (*SpellCheckerServiceCallbackStub) OnTransaction 

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

type SpellCheckerServiceProxy 

type SpellCheckerServiceProxy struct {
	Remote binder.IBinder
}

func NewSpellCheckerServiceProxy 

func NewSpellCheckerServiceProxy(
	remote binder.IBinder,
) *SpellCheckerServiceProxy

func (*SpellCheckerServiceProxy) AsBinder 

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

func (*SpellCheckerServiceProxy) GetISpellCheckerSession 

func (p *SpellCheckerServiceProxy) GetISpellCheckerSession(
	ctx context.Context,
	locale string,
	listener ISpellCheckerSessionListener,
	bundle os.Bundle,
	supportedAttributes int32,
	callback ISpellCheckerServiceCallback,
) error

type SpellCheckerServiceStub 

type SpellCheckerServiceStub struct {
	Impl      ISpellCheckerService
	Transport binder.VersionAwareTransport
}

SpellCheckerServiceStub dispatches incoming binder transactions to a typed ISpellCheckerService implementation.

func (*SpellCheckerServiceStub) Descriptor 

func (s *SpellCheckerServiceStub) Descriptor() string

func (*SpellCheckerServiceStub) OnTransaction 

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

type SpellCheckerSessionListenerProxy 

type SpellCheckerSessionListenerProxy struct {
	Remote binder.IBinder
}

func NewSpellCheckerSessionListenerProxy 

func NewSpellCheckerSessionListenerProxy(
	remote binder.IBinder,
) *SpellCheckerSessionListenerProxy

func (*SpellCheckerSessionListenerProxy) AsBinder 

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

func (*SpellCheckerSessionListenerProxy) OnGetSentenceSuggestions 

func (p *SpellCheckerSessionListenerProxy) OnGetSentenceSuggestions(
	ctx context.Context,
	result []viewTextservice.SentenceSuggestionsInfo,
) error

func (*SpellCheckerSessionListenerProxy) OnGetSuggestions 

func (p *SpellCheckerSessionListenerProxy) OnGetSuggestions(
	ctx context.Context,
	results []viewTextservice.SuggestionsInfo,
) error

type SpellCheckerSessionListenerStub 

type SpellCheckerSessionListenerStub struct {
	Impl      ISpellCheckerSessionListener
	Transport binder.VersionAwareTransport
}

SpellCheckerSessionListenerStub dispatches incoming binder transactions to a typed ISpellCheckerSessionListener implementation.

func (*SpellCheckerSessionListenerStub) Descriptor 

func (s *SpellCheckerSessionListenerStub) Descriptor() string

func (*SpellCheckerSessionListenerStub) OnTransaction 

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

type SpellCheckerSessionProxy 

type SpellCheckerSessionProxy struct {
	Remote binder.IBinder
}

func NewSpellCheckerSessionProxy 

func NewSpellCheckerSessionProxy(
	remote binder.IBinder,
) *SpellCheckerSessionProxy

func (*SpellCheckerSessionProxy) AsBinder 

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

func (*SpellCheckerSessionProxy) OnCancel 

func (p *SpellCheckerSessionProxy) OnCancel(
	ctx context.Context,
) error

func (*SpellCheckerSessionProxy) OnClose 

func (p *SpellCheckerSessionProxy) OnClose(
	ctx context.Context,
) error

func (*SpellCheckerSessionProxy) OnGetSentenceSuggestionsMultiple 

func (p *SpellCheckerSessionProxy) OnGetSentenceSuggestionsMultiple(
	ctx context.Context,
	textInfos []viewTextservice.TextInfo,
	suggestionsLimit int32,
) error

func (*SpellCheckerSessionProxy) OnGetSuggestionsMultiple 

func (p *SpellCheckerSessionProxy) OnGetSuggestionsMultiple(
	ctx context.Context,
	textInfos []viewTextservice.TextInfo,
	suggestionsLimit int32,
	multipleWords bool,
) error

type SpellCheckerSessionStub 

type SpellCheckerSessionStub struct {
	Impl      ISpellCheckerSession
	Transport binder.VersionAwareTransport
}

SpellCheckerSessionStub dispatches incoming binder transactions to a typed ISpellCheckerSession implementation.

func (*SpellCheckerSessionStub) Descriptor 

func (s *SpellCheckerSessionStub) Descriptor() string

func (*SpellCheckerSessionStub) OnTransaction 

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

type TextServicesManagerProxy 

type TextServicesManagerProxy struct {
	Remote binder.IBinder
}

func NewTextServicesManagerProxy 

func NewTextServicesManagerProxy(
	remote binder.IBinder,
) *TextServicesManagerProxy

func (*TextServicesManagerProxy) AsBinder 

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

func (*TextServicesManagerProxy) FinishSpellCheckerService 

func (p *TextServicesManagerProxy) FinishSpellCheckerService(
	ctx context.Context,
	listener ISpellCheckerSessionListener,
) error

func (*TextServicesManagerProxy) GetCurrentSpellChecker 

func (p *TextServicesManagerProxy) GetCurrentSpellChecker(
	ctx context.Context,
	locale string,
) (viewTextservice.SpellCheckerInfo, error)

func (*TextServicesManagerProxy) GetCurrentSpellCheckerSubtype 

func (p *TextServicesManagerProxy) GetCurrentSpellCheckerSubtype(
	ctx context.Context,
	allowImplicitlySelectedSubtype bool,
) (viewTextservice.SpellCheckerSubtype, error)

func (*TextServicesManagerProxy) GetEnabledSpellCheckers 

func (p *TextServicesManagerProxy) GetEnabledSpellCheckers(
	ctx context.Context,
) ([]viewTextservice.SpellCheckerInfo, error)

func (*TextServicesManagerProxy) GetSpellCheckerService 

func (p *TextServicesManagerProxy) GetSpellCheckerService(
	ctx context.Context,
	sciId string,
	locale string,
	tsListener ITextServicesSessionListener,
	scListener ISpellCheckerSessionListener,
	bundle os.Bundle,
	supportedAttributes int32,
) error

func (*TextServicesManagerProxy) IsSpellCheckerEnabled 

func (p *TextServicesManagerProxy) IsSpellCheckerEnabled(
	ctx context.Context,
) (bool, error)

type TextServicesManagerStub 

type TextServicesManagerStub struct {
	Impl      ITextServicesManager
	Transport binder.VersionAwareTransport
}

TextServicesManagerStub dispatches incoming binder transactions to a typed ITextServicesManager implementation.

func (*TextServicesManagerStub) Descriptor 

func (s *TextServicesManagerStub) Descriptor() string

func (*TextServicesManagerStub) OnTransaction 

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

type TextServicesSessionListenerProxy 

type TextServicesSessionListenerProxy struct {
	Remote binder.IBinder
}

func NewTextServicesSessionListenerProxy 

func NewTextServicesSessionListenerProxy(
	remote binder.IBinder,
) *TextServicesSessionListenerProxy

func (*TextServicesSessionListenerProxy) AsBinder 

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

func (*TextServicesSessionListenerProxy) OnServiceConnected 

func (p *TextServicesSessionListenerProxy) OnServiceConnected(
	ctx context.Context,
	spellCheckerSession ISpellCheckerSession,
) error

type TextServicesSessionListenerStub 

type TextServicesSessionListenerStub struct {
	Impl      ITextServicesSessionListener
	Transport binder.VersionAwareTransport
}

TextServicesSessionListenerStub dispatches incoming binder transactions to a typed ITextServicesSessionListener implementation.

func (*TextServicesSessionListenerStub) Descriptor 

func (s *TextServicesSessionListenerStub) Descriptor() string

func (*TextServicesSessionListenerStub) OnTransaction 

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

Source Files

View all Source files

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.