/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package androidx.textclassifier;
import android.annotation.SuppressLint;
import android.content.Context;
import android.os.Bundle;
import androidx.annotation.IntDef;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import androidx.annotation.RestrictTo;
import androidx.core.util.ObjectsCompat;
import androidx.core.util.Preconditions;
import androidx.textclassifier.TextClassifier.EntityType;
import androidx.textclassifier.TextClassifier.WidgetType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Locale;
/**
* A selection event.
* Specify index parameters as word token indices.
* @hide
*/
@RestrictTo(RestrictTo.Scope.LIBRARY)
public final class SelectionEvent {
private static final String EXTRA_ABSOLUTE_START = "extra_absolute_start";
private static final String EXTRA_ABSOLUTE_END = "extra_absolute_end";
private static final String EXTRA_ENTITY_TYPE = "extra_entity_type";
private static final String EXTRA_EVENT_TYPE = "extra_event_type";
private static final String EXTRA_PACKAGE_NAME = "extra_package_name";
private static final String EXTRA_WIDGET_TYPE = "extra_widget_type";
private static final String EXTRA_INVOCATION_METHOD = "extra_invocation_method";
private static final String EXTRA_WIDGET_VERSION = "extra_widget_version";
private static final String EXTRA_RESULT_ID = "extra_result_id";
private static final String EXTRA_EVENT_TIME = "extra_event_time";
private static final String EXTRA_DURATION_SINCE_SESSION_START =
"extra_duration_since_session_start";
private static final String EXTRA_DURATION_SINCE_PREVIOUS_EVENT =
"extra_duration_since_previous_event";
private static final String EXTRA_EVENT_INDEX = "extra_event_index";
private static final String EXTRA_SESSION_ID = "extra_session_id";
private static final String EXTRA_START = "extra_start";
private static final String EXTRA_END = "extra_end";
private static final String EXTRA_SMART_START = "extra_smart_start";
private static final String EXTRA_SMART_END = "extra_smart_end";
/** User typed over the selection. */
public static final int ACTION_OVERTYPE =
android.view.textclassifier.SelectionEvent.ACTION_OVERTYPE;
/** User copied the selection. */
public static final int ACTION_COPY = android.view.textclassifier.SelectionEvent.ACTION_COPY;
/** User pasted over the selection. */
public static final int ACTION_PASTE = android.view.textclassifier.SelectionEvent.ACTION_PASTE;
/** User cut the selection. */
public static final int ACTION_CUT = android.view.textclassifier.SelectionEvent.ACTION_CUT;
/** User shared the selection. */
public static final int ACTION_SHARE = android.view.textclassifier.SelectionEvent.ACTION_SHARE;
/** User clicked the textAssist menu item. */
public static final int ACTION_SMART_SHARE =
android.view.textclassifier.SelectionEvent.ACTION_SMART_SHARE;
/** User dragged+dropped the selection. */
public static final int ACTION_DRAG = android.view.textclassifier.SelectionEvent.ACTION_DRAG;
/** User abandoned the selection. */
public static final int ACTION_ABANDON =
android.view.textclassifier.SelectionEvent.ACTION_ABANDON;
/** User performed an action on the selection. */
public static final int ACTION_OTHER = android.view.textclassifier.SelectionEvent.ACTION_OTHER;
// Non-terminal actions.
/** User activated Select All */
public static final int ACTION_SELECT_ALL =
android.view.textclassifier.SelectionEvent.ACTION_SELECT_ALL;
/** User reset the smart selection. */
public static final int ACTION_RESET = android.view.textclassifier.SelectionEvent.ACTION_RESET;
/** @hide */
@RestrictTo(RestrictTo.Scope.LIBRARY)
@Retention(RetentionPolicy.SOURCE)
@IntDef({ACTION_OVERTYPE, ACTION_COPY, ACTION_PASTE, ACTION_CUT,
ACTION_SHARE, ACTION_SMART_SHARE, ACTION_DRAG, ACTION_ABANDON,
ACTION_OTHER, ACTION_SELECT_ALL, ACTION_RESET,
EVENT_SELECTION_STARTED, EVENT_SELECTION_MODIFIED,
EVENT_SMART_SELECTION_SINGLE, EVENT_SMART_SELECTION_MULTI,
EVENT_AUTO_SELECTION})
// NOTE: EventTypes declared here must be less than 100 to avoid colliding with the
// ActionTypes declared above.
public @interface EventType {
/*
* Range: 1 -> 99.
*/
}
/** @hide */
@RestrictTo(RestrictTo.Scope.LIBRARY)
@Retention(RetentionPolicy.SOURCE)
@IntDef({ACTION_OVERTYPE, ACTION_COPY, ACTION_PASTE, ACTION_CUT,
ACTION_SHARE, ACTION_SMART_SHARE, ACTION_DRAG, ACTION_ABANDON,
ACTION_OTHER, ACTION_SELECT_ALL, ACTION_RESET})
// NOTE: ActionType values should not be lower than 100 to avoid colliding with the other
// EventTypes declared below.
public @interface ActionType {
/*
* Terminal event types range: [100,200).
* Non-terminal event types range: [200,300).
*/
}
/** User started a new selection. */
public static final int EVENT_SELECTION_STARTED =
android.view.textclassifier.SelectionEvent.EVENT_SELECTION_STARTED;
/** User modified an existing selection. */
public static final int EVENT_SELECTION_MODIFIED =
android.view.textclassifier.SelectionEvent.EVENT_SELECTION_MODIFIED;
/** Smart selection triggered for a single token (word). */
public static final int EVENT_SMART_SELECTION_SINGLE =
android.view.textclassifier.SelectionEvent.EVENT_SMART_SELECTION_SINGLE;
/** Smart selection triggered spanning multiple tokens (words). */
public static final int EVENT_SMART_SELECTION_MULTI =
android.view.textclassifier.SelectionEvent.EVENT_SMART_SELECTION_MULTI;
/** Something else other than User or the default TextClassifier triggered a selection. */
public static final int EVENT_AUTO_SELECTION =
android.view.textclassifier.SelectionEvent.EVENT_AUTO_SELECTION;
/** @hide */
@RestrictTo(RestrictTo.Scope.LIBRARY)
@Retention(RetentionPolicy.SOURCE)
@IntDef({INVOCATION_MANUAL, INVOCATION_LINK, INVOCATION_UNKNOWN})
public @interface InvocationMethod {}
/** Selection was invoked by the user long pressing, double tapping, or dragging to select. */
public static final int INVOCATION_MANUAL =
android.view.textclassifier.SelectionEvent.INVOCATION_MANUAL;
/** Selection was invoked by the user tapping on a link. */
public static final int INVOCATION_LINK =
android.view.textclassifier.SelectionEvent.INVOCATION_LINK;
/** Unknown invocation method */
public static final int INVOCATION_UNKNOWN =
android.view.textclassifier.SelectionEvent.INVOCATION_UNKNOWN;
private static final String NO_SIGNATURE = "";
private final int mAbsoluteStart;
private final int mAbsoluteEnd;
private final @EntityType String mEntityType;
private @EventType int mEventType;
private String mPackageName = "";
private String mWidgetType = TextClassifier.WIDGET_TYPE_UNKNOWN;
private @InvocationMethod int mInvocationMethod;
@Nullable private String mWidgetVersion;
@Nullable private String mResultId;
private long mEventTime;
private long mDurationSinceSessionStart;
private long mDurationSincePreviousEvent;
private int mEventIndex;
@Nullable private TextClassificationSessionId mSessionId;
private int mStart;
private int mEnd;
private int mSmartStart;
private int mSmartEnd;
// For SL -> Platform conversion.
@Nullable
private TextClassification mTextClassification;
@Nullable
private TextSelection mTextSelection;
/* package */ SelectionEvent(
int start, int end,
@EventType int eventType, @EntityType String entityType,
@InvocationMethod int invocationMethod, @Nullable String resultId) {
Preconditions.checkArgument(end >= start, "end cannot be less than start");
mAbsoluteStart = start;
mAbsoluteEnd = end;
mEventType = eventType;
mEntityType = Preconditions.checkNotNull(entityType);
mResultId = resultId;
mInvocationMethod = invocationMethod;
}
private SelectionEvent(int absoluteStart, int absoluteEnd, @EntityType String entityType,
@EventType int eventType, String packageName, String widgetType,
@InvocationMethod int invocationMethod, String widgetVersion, String resultId,
long eventTime, long durationSinceSessionStart, long durationSincePreviousEvent,
int eventIndex, TextClassificationSessionId sessionId, int start, int end,
int smartStart, int smartEnd) {
mAbsoluteStart = absoluteStart;
mAbsoluteEnd = absoluteEnd;
mEntityType = entityType;
mEventType = eventType;
mPackageName = packageName;
mWidgetType = widgetType;
mInvocationMethod = invocationMethod;
mWidgetVersion = widgetVersion;
mResultId = resultId;
mEventTime = eventTime;
mDurationSinceSessionStart = durationSinceSessionStart;
mDurationSincePreviousEvent = durationSincePreviousEvent;
mEventIndex = eventIndex;
mSessionId = sessionId;
mStart = start;
mEnd = end;
mSmartStart = smartStart;
mSmartEnd = smartEnd;
}
/**
* Adds this Icon to a Bundle that can be read back with the same parameters
* to {@link #createFromBundle(Bundle)}.
*/
@NonNull
public Bundle toBundle() {
Bundle bundle = new Bundle();
bundle.putInt(EXTRA_ABSOLUTE_START, mAbsoluteStart);
bundle.putInt(EXTRA_ABSOLUTE_END, mAbsoluteEnd);
bundle.putString(EXTRA_ENTITY_TYPE, mEntityType);
bundle.putInt(EXTRA_EVENT_TYPE, mEventType);
bundle.putString(EXTRA_PACKAGE_NAME, mPackageName);
bundle.putString(EXTRA_WIDGET_TYPE, mWidgetType);
bundle.putInt(EXTRA_INVOCATION_METHOD, mInvocationMethod);
bundle.putString(EXTRA_WIDGET_VERSION, mWidgetVersion);
bundle.putString(EXTRA_RESULT_ID, mResultId);
bundle.putLong(EXTRA_EVENT_TIME, mEventTime);
bundle.putLong(EXTRA_DURATION_SINCE_SESSION_START, mDurationSinceSessionStart);
bundle.putLong(EXTRA_DURATION_SINCE_PREVIOUS_EVENT, mDurationSincePreviousEvent);
bundle.putInt(EXTRA_EVENT_INDEX, mEventIndex);
if (mSessionId != null) {
bundle.putBundle(EXTRA_SESSION_ID, mSessionId.toBundle());
}
bundle.putInt(EXTRA_START, mStart);
bundle.putInt(EXTRA_END, mEnd);
bundle.putInt(EXTRA_SMART_START, mSmartStart);
bundle.putInt(EXTRA_SMART_END, mSmartEnd);
return bundle;
}
/**
* Extracts a {@link SelectionEvent} from a bundle that was added using {@link #toBundle()}.
*/
@NonNull
public static SelectionEvent createFromBundle(@NonNull Bundle bundle) {
final int absoluteStart = bundle.getInt(EXTRA_ABSOLUTE_START);
final int absoluteEnd = bundle.getInt(EXTRA_ABSOLUTE_END);
final String entityType = bundle.getString(EXTRA_ENTITY_TYPE);
final int eventType = bundle.getInt(EXTRA_EVENT_TYPE);
final String packageName = bundle.getString(EXTRA_PACKAGE_NAME);
final String widgetType = bundle.getString(EXTRA_WIDGET_TYPE);
final int invocationMethod = bundle.getInt(EXTRA_INVOCATION_METHOD);
final String widgetVersion = bundle.getString(EXTRA_WIDGET_VERSION);
final String resultId = bundle.getString(EXTRA_RESULT_ID);
final long eventTime = bundle.getLong(EXTRA_EVENT_TIME);
final long durationSinceSessionStart = bundle.getLong(EXTRA_DURATION_SINCE_SESSION_START);
final long durationSincePreviousEvent = bundle.getLong(EXTRA_DURATION_SINCE_PREVIOUS_EVENT);
final int eventIndex = bundle.getInt(EXTRA_EVENT_INDEX);
final TextClassificationSessionId sessionId = bundle.getBundle(EXTRA_SESSION_ID) == null
? null
: TextClassificationSessionId.createFromBundle(bundle.getBundle(EXTRA_SESSION_ID));
final int start = bundle.getInt(EXTRA_START);
final int end = bundle.getInt(EXTRA_END);
final int smartStart = bundle.getInt(EXTRA_SMART_START);
final int smartEnd = bundle.getInt(EXTRA_SMART_END);
return new SelectionEvent(absoluteStart, absoluteEnd, entityType, eventType, packageName,
widgetType, invocationMethod, widgetVersion, resultId, eventTime,
durationSinceSessionStart, durationSincePreviousEvent, eventIndex,
sessionId, start, end, smartStart, smartEnd);
}
/**
* Creates a "selection started" event.
*
* @param invocationMethod the way the selection was triggered
* @param start the index of the selected text
*/
@NonNull
public static SelectionEvent createSelectionStartedEvent(
@SelectionEvent.InvocationMethod int invocationMethod, int start) {
return new SelectionEvent(
start, start + 1, SelectionEvent.EVENT_SELECTION_STARTED,
TextClassifier.TYPE_UNKNOWN, invocationMethod, NO_SIGNATURE);
}
/**
* Creates a "selection modified" event.
* Use when the user modifies the selection.
*
* @param start the start (inclusive) index of the selection
* @param end the end (exclusive) index of the selection
*
* @throws IllegalArgumentException if end is less than start
*/
@NonNull
public static SelectionEvent createSelectionModifiedEvent(int start, int end) {
Preconditions.checkArgument(end >= start, "end cannot be less than start");
return new SelectionEvent(
start, end, SelectionEvent.EVENT_SELECTION_MODIFIED,
TextClassifier.TYPE_UNKNOWN, INVOCATION_UNKNOWN, NO_SIGNATURE);
}
/**
* Creates a "selection modified" event.
* Use when the user modifies the selection and the selection's entity type is known.
*
* @param start the start (inclusive) index of the selection
* @param end the end (exclusive) index of the selection
* @param classification the TextClassification object returned by the text classifier that
* classified the selected text
*
* @throws IllegalArgumentException if end is less than start
*/
@NonNull
public static SelectionEvent createSelectionModifiedEvent(
int start, int end, @NonNull TextClassification classification) {
Preconditions.checkArgument(end >= start, "end cannot be less than start");
Preconditions.checkNotNull(classification);
final String entityType = classification.getEntityTypeCount() > 0
? classification.getEntityType(0)
: TextClassifier.TYPE_UNKNOWN;
SelectionEvent selectionEvent = new SelectionEvent(
start, end, SelectionEvent.EVENT_SELECTION_MODIFIED,
entityType, INVOCATION_UNKNOWN, classification.getId());
selectionEvent.mTextClassification = classification;
return selectionEvent;
}
/**
* Creates a "selection modified" event.
* Use when a TextClassifier modifies the selection.
*
* @param start the start (inclusive) index of the selection
* @param end the end (exclusive) index of the selection
* @param selection the TextSelection object returned by the text classifier for the
* specified selection
*
* @throws IllegalArgumentException if end is less than start
*/
@NonNull
public static SelectionEvent createSelectionModifiedEvent(
int start, int end, @NonNull TextSelection selection) {
Preconditions.checkArgument(end >= start, "end cannot be less than start");
Preconditions.checkNotNull(selection);
final String entityType = selection.getEntityTypeCount() > 0
? selection.getEntityType(0)
: TextClassifier.TYPE_UNKNOWN;
SelectionEvent selectionEvent = new SelectionEvent(
start, end, SelectionEvent.EVENT_AUTO_SELECTION,
entityType, INVOCATION_UNKNOWN, selection.getId());
selectionEvent.mTextSelection = selection;
return selectionEvent;
}
/**
* Creates an event specifying an action taken on a selection.
* Use when the user clicks on an action to act on the selected text.
*
* @param start the start (inclusive) index of the selection
* @param end the end (exclusive) index of the selection
* @param actionType the action that was performed on the selection
*
* @throws IllegalArgumentException if end is less than start
*/
@NonNull
public static SelectionEvent createSelectionActionEvent(
int start, int end, @SelectionEvent.ActionType int actionType) {
Preconditions.checkArgument(end >= start, "end cannot be less than start");
checkActionType(actionType);
return new SelectionEvent(
start, end, actionType, TextClassifier.TYPE_UNKNOWN, INVOCATION_UNKNOWN,
NO_SIGNATURE);
}
/**
* Creates an event specifying an action taken on a selection.
* Use when the user clicks on an action to act on the selected text and the selection's
* entity type is known.
*
* @param start the start (inclusive) index of the selection
* @param end the end (exclusive) index of the selection
* @param actionType the action that was performed on the selection
* @param classification the TextClassification object returned by the text classifier that
* classified the selected text
*
* @throws IllegalArgumentException if end is less than start
* @throws IllegalArgumentException If actionType is not a valid SelectionEvent actionType
*/
@NonNull
public static SelectionEvent createSelectionActionEvent(
int start, int end, @SelectionEvent.ActionType int actionType,
@NonNull TextClassification classification) {
Preconditions.checkArgument(end >= start, "end cannot be less than start");
Preconditions.checkNotNull(classification);
checkActionType(actionType);
final String entityType = classification.getEntityTypeCount() > 0
? classification.getEntityType(0)
: TextClassifier.TYPE_UNKNOWN;
SelectionEvent selectionEvent =
new SelectionEvent(start, end, actionType, entityType, INVOCATION_UNKNOWN,
classification.getId());
selectionEvent.mTextClassification = classification;
return selectionEvent;
}
/**
* @throws IllegalArgumentException If eventType is not an {@link SelectionEvent.ActionType}
*/
private static void checkActionType(@SelectionEvent.EventType int eventType)
throws IllegalArgumentException {
switch (eventType) {
case SelectionEvent.ACTION_OVERTYPE: // fall through
case SelectionEvent.ACTION_COPY: // fall through
case SelectionEvent.ACTION_PASTE: // fall through
case SelectionEvent.ACTION_CUT: // fall through
case SelectionEvent.ACTION_SHARE: // fall through
case SelectionEvent.ACTION_SMART_SHARE: // fall through
case SelectionEvent.ACTION_DRAG: // fall through
case SelectionEvent.ACTION_ABANDON: // fall through
case SelectionEvent.ACTION_SELECT_ALL: // fall through
case SelectionEvent.ACTION_RESET: // fall through
case SelectionEvent.ACTION_OTHER: // fall through
return;
default:
throw new IllegalArgumentException(
String.format(Locale.US, "%d is not an eventType", eventType));
}
}
int getAbsoluteStart() {
return mAbsoluteStart;
}
int getAbsoluteEnd() {
return mAbsoluteEnd;
}
/**
* Returns the type of event that was triggered. e.g. {@link #ACTION_COPY}.
*/
@EventType
public int getEventType() {
return mEventType;
}
/**
* Sets the event type.
*/
void setEventType(@EventType int eventType) {
mEventType = eventType;
}
/**
* Returns the type of entity that is associated with this event. e.g.
* {@link android.view.textclassifier.TextClassifier#TYPE_EMAIL}.
*/
@EntityType
@NonNull
public String getEntityType() {
return mEntityType;
}
/**
* Returns the package name of the app that this event originated in.
*/
@NonNull
public String getPackageName() {
return mPackageName;
}
/**
* Returns the type of widget that was involved in triggering this event.
*/
@WidgetType
@NonNull
public String getWidgetType() {
return mWidgetType;
}
/**
* Returns a string version info for the widget this event was triggered in.
*/
@Nullable
public String getWidgetVersion() {
return mWidgetVersion;
}
/**
* Sets the {@link TextClassificationContext} for this event.
*/
void setTextClassificationSessionContext(TextClassificationContext context) {
mPackageName = context.getPackageName();
mWidgetType = context.getWidgetType();
mWidgetVersion = context.getWidgetVersion();
}
/**
* Returns the way the selection mode was invoked.
*/
public @InvocationMethod int getInvocationMethod() {
return mInvocationMethod;
}
/**
* Sets the invocationMethod for this event.
*/
void setInvocationMethod(@InvocationMethod int invocationMethod) {
mInvocationMethod = invocationMethod;
}
/**
* Returns the id of the text classifier result associated with this event.
*/
@Nullable
public String getResultId() {
return mResultId;
}
SelectionEvent setResultId(@Nullable String resultId) {
mResultId = resultId;
return this;
}
/**
* Returns the time this event was triggered.
*/
public long getEventTime() {
return mEventTime;
}
SelectionEvent setEventTime(long timeMs) {
mEventTime = timeMs;
return this;
}
/**
* Returns the duration in ms between when this event was triggered and when the first event in
* the selection session was triggered.
*/
public long getDurationSinceSessionStart() {
return mDurationSinceSessionStart;
}
SelectionEvent setDurationSinceSessionStart(long durationMs) {
mDurationSinceSessionStart = durationMs;
return this;
}
/**
* Returns the duration in ms between when this event was triggered and when the previous event
* in the selection session was triggered.
*/
public long getDurationSincePreviousEvent() {
return mDurationSincePreviousEvent;
}
SelectionEvent setDurationSincePreviousEvent(long durationMs) {
this.mDurationSincePreviousEvent = durationMs;
return this;
}
/**
* Returns the index (e.g. 1st event, 2nd event, etc.) of this event in the selection session.
*/
public int getEventIndex() {
return mEventIndex;
}
SelectionEvent setEventIndex(int index) {
mEventIndex = index;
return this;
}
/**
* Returns the selection session id.
*/
@Nullable
public TextClassificationSessionId getSessionId() {
return mSessionId;
}
SelectionEvent setSessionId(TextClassificationSessionId id) {
mSessionId = id;
return this;
}
/**
* Returns the start index of this events relative to the index of the start selection
* event in the selection session.
*/
public int getStart() {
return mStart;
}
SelectionEvent setStart(int start) {
mStart = start;
return this;
}
/**
* Returns the end index of this events relative to the index of the start selection
* event in the selection session.
*/
public int getEnd() {
return mEnd;
}
SelectionEvent setEnd(int end) {
mEnd = end;
return this;
}
/**
* Returns the start index of this events relative to the index of the smart selection
* event in the selection session.
*/
public int getSmartStart() {
return mSmartStart;
}
SelectionEvent setSmartStart(int start) {
this.mSmartStart = start;
return this;
}
/**
* Returns the end index of this events relative to the index of the smart selection
* event in the selection session.
*/
public int getSmartEnd() {
return mSmartEnd;
}
SelectionEvent setSmartEnd(int end) {
mSmartEnd = end;
return this;
}
boolean isTerminal() {
return isTerminal(mEventType);
}
/**
* Returns true if the eventType is a terminal event type. Otherwise returns false.
* A terminal event is an event that ends a selection interaction.
*/
public static boolean isTerminal(@EventType int eventType) {
switch (eventType) {
case ACTION_OVERTYPE: // fall through
case ACTION_COPY: // fall through
case ACTION_PASTE: // fall through
case ACTION_CUT: // fall through
case ACTION_SHARE: // fall through
case ACTION_SMART_SHARE: // fall through
case ACTION_DRAG: // fall through
case ACTION_ABANDON: // fall through
case ACTION_OTHER: // fall through
return true;
default:
return false;
}
}
@Override
public int hashCode() {
return ObjectsCompat.hash(mAbsoluteStart, mAbsoluteEnd, mEventType, mEntityType,
mWidgetVersion, mPackageName, mWidgetType, mInvocationMethod, mResultId,
mEventTime, mDurationSinceSessionStart, mDurationSincePreviousEvent,
mEventIndex, mSessionId, mStart, mEnd, mSmartStart, mSmartEnd);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof SelectionEvent)) {
return false;
}
final SelectionEvent other = (SelectionEvent) obj;
return mAbsoluteStart == other.mAbsoluteStart
&& mAbsoluteEnd == other.mAbsoluteEnd
&& mEventType == other.mEventType
&& ObjectsCompat.equals(mEntityType, other.mEntityType)
&& ObjectsCompat.equals(mWidgetVersion, other.mWidgetVersion)
&& ObjectsCompat.equals(mPackageName, other.mPackageName)
&& ObjectsCompat.equals(mWidgetType, other.mWidgetType)
&& mInvocationMethod == other.mInvocationMethod
&& ObjectsCompat.equals(mResultId, other.mResultId)
&& mEventTime == other.mEventTime
&& mDurationSinceSessionStart == other.mDurationSinceSessionStart
&& mDurationSincePreviousEvent == other.mDurationSincePreviousEvent
&& mEventIndex == other.mEventIndex
&& ObjectsCompat.equals(mSessionId, other.mSessionId)
&& mStart == other.mStart
&& mEnd == other.mEnd
&& mSmartStart == other.mSmartStart
&& mSmartEnd == other.mSmartEnd;
}
@Override
public String toString() {
return String.format(Locale.US,
"SelectionEvent {absoluteStart=%d, absoluteEnd=%d, eventType=%d, entityType=%s, "
+ "widgetVersion=%s, packageName=%s, widgetType=%s, invocationMethod=%s, "
+ "resultId=%s, eventTime=%d, durationSinceSessionStart=%d, "
+ "durationSincePreviousEvent=%d, eventIndex=%d,"
+ "sessionId=%s, start=%d, end=%d, smartStart=%d, smartEnd=%d}",
mAbsoluteStart, mAbsoluteEnd, mEventType, mEntityType,
mWidgetVersion, mPackageName, mWidgetType, mInvocationMethod,
mResultId, mEventTime, mDurationSinceSessionStart,
mDurationSincePreviousEvent, mEventIndex,
mSessionId, mStart, mEnd, mSmartStart, mSmartEnd);
}
/**
* Converts {@link android.view.textclassifier.TextSelection} to
* {@link android.view.textclassifier.TextSelection}. It can only convert text selection
* objects created by those factory methods and without further modification.
*/
@SuppressLint("WrongConstant")
@RequiresApi(28)
@NonNull
// Lint does not know the constants in platform and here are same
Object toPlatform(@NonNull Context context) {
Preconditions.checkNotNull(context);
if (getEventType() == EVENT_SELECTION_STARTED) {
return android.view.textclassifier.SelectionEvent.createSelectionStartedEvent(
getInvocationMethod(),
getAbsoluteStart()
);
}
if (getEventType() == EVENT_AUTO_SELECTION && mTextSelection != null) {
return android.view.textclassifier.SelectionEvent.createSelectionModifiedEvent(
getAbsoluteStart(),
getAbsoluteEnd(),
(android.view.textclassifier.TextSelection) mTextSelection.toPlatform());
}
if (getEventType() == EVENT_SELECTION_MODIFIED) {
return toPlatformSelectionModifiedEvent(context);
}
return toPlatformSelectionActionEvent(context);
}
@NonNull
@RequiresApi(28)
private android.view.textclassifier.SelectionEvent toPlatformSelectionModifiedEvent(
@NonNull Context context) {
Preconditions.checkNotNull(context);
if (mTextClassification != null) {
return android.view.textclassifier.SelectionEvent.createSelectionModifiedEvent(
getAbsoluteStart(),
getAbsoluteEnd(),
(android.view.textclassifier.TextClassification)
mTextClassification.toPlatform(context)
);
}
return android.view.textclassifier.SelectionEvent.createSelectionModifiedEvent(
getAbsoluteStart(),
getAbsoluteEnd()
);
}
@NonNull
@RequiresApi(28)
@SuppressLint("WrongConstant")
// Lint does not know the constants in platform and here are same
private android.view.textclassifier.SelectionEvent toPlatformSelectionActionEvent(
@NonNull Context context) {
Preconditions.checkNotNull(context);
if (mTextClassification != null) {
return android.view.textclassifier.SelectionEvent.createSelectionActionEvent(
getAbsoluteStart(),
getAbsoluteEnd(),
getEventType(),
(android.view.textclassifier.TextClassification)
mTextClassification.toPlatform(context)
);
}
return android.view.textclassifier.SelectionEvent.createSelectionActionEvent(
getAbsoluteStart(),
getAbsoluteEnd(),
getEventType()
);
}
}