java/src/com/android/inputmethod/compat/CursorAnchorInfoCompatWrapper.java


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

/*
 * Copyright (C) 2014 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 com.android.inputmethod.compat;

import android.annotation.TargetApi;
import android.graphics.Matrix;
import android.graphics.RectF;
import android.os.Build;
import android.view.inputmethod.CursorAnchorInfo;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

/**
 * A wrapper for {@link CursorAnchorInfo}, which has been introduced in API Level 21. You can use
 * this wrapper to avoid direct dependency on newly introduced types.
 */
public class CursorAnchorInfoCompatWrapper {

    /**
     * The insertion marker or character bounds have at least one visible region.
     */
    public static final int FLAG_HAS_VISIBLE_REGION = 0x01;

    /**
     * The insertion marker or character bounds have at least one invisible (clipped) region.
     */
    public static final int FLAG_HAS_INVISIBLE_REGION = 0x02;

    /**
     * The insertion marker or character bounds is placed at right-to-left (RTL) character.
     */
    public static final int FLAG_IS_RTL = 0x04;

    CursorAnchorInfoCompatWrapper() {
        // This class is not publicly instantiable.
    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    @Nullable
    public static CursorAnchorInfoCompatWrapper wrap(@Nullable final CursorAnchorInfo instance) {
        if (BuildCompatUtils.EFFECTIVE_SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            return null;
        }
        if (instance == null) {
            return null;
        }
        return new RealWrapper(instance);
    }

    public int getSelectionStart() {
        throw new UnsupportedOperationException("not supported.");
    }

    public int getSelectionEnd() {
        throw new UnsupportedOperationException("not supported.");
    }

    public CharSequence getComposingText() {
        throw new UnsupportedOperationException("not supported.");
    }

    public int getComposingTextStart() {
        throw new UnsupportedOperationException("not supported.");
    }

    public Matrix getMatrix() {
        throw new UnsupportedOperationException("not supported.");
    }

    public RectF getCharacterBounds(final int index) {
        throw new UnsupportedOperationException("not supported.");
    }

    public int getCharacterBoundsFlags(final int index) {
        throw new UnsupportedOperationException("not supported.");
    }

    public float getInsertionMarkerBaseline() {
        throw new UnsupportedOperationException("not supported.");
    }

    public float getInsertionMarkerBottom() {
        throw new UnsupportedOperationException("not supported.");
    }

    public float getInsertionMarkerHorizontal() {
        throw new UnsupportedOperationException("not supported.");
    }

    public float getInsertionMarkerTop() {
        throw new UnsupportedOperationException("not supported.");
    }

    public int getInsertionMarkerFlags() {
        throw new UnsupportedOperationException("not supported.");
    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    private static final class RealWrapper extends CursorAnchorInfoCompatWrapper {

        @Nonnull
        private final CursorAnchorInfo mInstance;

        public RealWrapper(@Nonnull final CursorAnchorInfo info) {
            mInstance = info;
        }

        @Override
        public int getSelectionStart() {
            return mInstance.getSelectionStart();
        }

        @Override
        public int getSelectionEnd() {
            return mInstance.getSelectionEnd();
        }

        @Override
        public CharSequence getComposingText() {
            return mInstance.getComposingText();
        }

        @Override
        public int getComposingTextStart() {
            return mInstance.getComposingTextStart();
        }

        @Override
        public Matrix getMatrix() {
            return mInstance.getMatrix();
        }

        @Override
        public RectF getCharacterBounds(final int index) {
            return mInstance.getCharacterBounds(index);
        }

        @Override
        public int getCharacterBoundsFlags(final int index) {
            return mInstance.getCharacterBoundsFlags(index);
        }

        @Override
        public float getInsertionMarkerBaseline() {
            return mInstance.getInsertionMarkerBaseline();
        }

        @Override
        public float getInsertionMarkerBottom() {
            return mInstance.getInsertionMarkerBottom();
        }

        @Override
        public float getInsertionMarkerHorizontal() {
            return mInstance.getInsertionMarkerHorizontal();
        }

        @Override
        public float getInsertionMarkerTop() {
            return mInstance.getInsertionMarkerTop();
        }

        @Override
        public int getInsertionMarkerFlags() {
            return mInstance.getInsertionMarkerFlags();
        }
    }
}