InputConnectionWrapper.java revision 45700fa135e83ed44e4b69ca60cf12960a5898d7
1/* 2 * Copyright (C) 2007-2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not 5 * use this file except in compliance with the License. You may obtain a copy of 6 * the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 13 * License for the specific language governing permissions and limitations under 14 * the License. 15 */ 16 17package android.view.inputmethod; 18 19import android.os.Bundle; 20import android.os.Handler; 21import android.view.KeyEvent; 22 23/** 24 * <p>Wrapper class for proxying calls to another InputConnection. Subclass and have fun! 25 */ 26public class InputConnectionWrapper implements InputConnection { 27 private InputConnection mTarget; 28 final boolean mMutable; 29 @InputConnectionInspector.MissingMethodFlags 30 private int mMissingMethodFlags; 31 32 /** 33 * Initializes a wrapper. 34 * 35 * <p><b>Caveat:</b> Although the system can accept {@code (InputConnection) null} in some 36 * places, you cannot emulate such a behavior by non-null {@link InputConnectionWrapper} that 37 * has {@code null} in {@code target}.</p> 38 * @param target the {@link InputConnection} to be proxied. 39 * @param mutable set {@code true} to protect this object from being reconfigured to target 40 * another {@link InputConnection}. Note that this is ignored while the target is {@code null}. 41 */ 42 public InputConnectionWrapper(InputConnection target, boolean mutable) { 43 mMutable = mutable; 44 mTarget = target; 45 mMissingMethodFlags = InputConnectionInspector.getMissingMethodFlags(target); 46 } 47 48 /** 49 * Change the target of the input connection. 50 * 51 * <p><b>Caveat:</b> Although the system can accept {@code (InputConnection) null} in some 52 * places, you cannot emulate such a behavior by non-null {@link InputConnectionWrapper} that 53 * has {@code null} in {@code target}.</p> 54 * @param target the {@link InputConnection} to be proxied. 55 * @throws SecurityException when this wrapper has non-null target and is immutable. 56 */ 57 public void setTarget(InputConnection target) { 58 if (mTarget != null && !mMutable) { 59 throw new SecurityException("not mutable"); 60 } 61 mTarget = target; 62 mMissingMethodFlags = InputConnectionInspector.getMissingMethodFlags(target); 63 } 64 65 /** 66 * @hide 67 */ 68 @InputConnectionInspector.MissingMethodFlags 69 public int getMissingMethodFlags() { 70 return mMissingMethodFlags; 71 } 72 73 /** 74 * {@inheritDoc} 75 * @throws NullPointerException if the target is {@code null}. 76 */ 77 public CharSequence getTextBeforeCursor(int n, int flags) { 78 return mTarget.getTextBeforeCursor(n, flags); 79 } 80 81 /** 82 * {@inheritDoc} 83 * @throws NullPointerException if the target is {@code null}. 84 */ 85 public CharSequence getTextAfterCursor(int n, int flags) { 86 return mTarget.getTextAfterCursor(n, flags); 87 } 88 89 /** 90 * {@inheritDoc} 91 * @throws NullPointerException if the target is {@code null}. 92 */ 93 public CharSequence getSelectedText(int flags) { 94 return mTarget.getSelectedText(flags); 95 } 96 97 /** 98 * {@inheritDoc} 99 * @throws NullPointerException if the target is {@code null}. 100 */ 101 public int getCursorCapsMode(int reqModes) { 102 return mTarget.getCursorCapsMode(reqModes); 103 } 104 105 /** 106 * {@inheritDoc} 107 * @throws NullPointerException if the target is {@code null}. 108 */ 109 public ExtractedText getExtractedText(ExtractedTextRequest request, int flags) { 110 return mTarget.getExtractedText(request, flags); 111 } 112 113 /** 114 * {@inheritDoc} 115 * @throws NullPointerException if the target is {@code null}. 116 */ 117 public boolean deleteSurroundingTextInCodePoints(int beforeLength, int afterLength) { 118 return mTarget.deleteSurroundingTextInCodePoints(beforeLength, afterLength); 119 } 120 121 /** 122 * {@inheritDoc} 123 * @throws NullPointerException if the target is {@code null}. 124 */ 125 public boolean deleteSurroundingText(int beforeLength, int afterLength) { 126 return mTarget.deleteSurroundingText(beforeLength, afterLength); 127 } 128 129 /** 130 * {@inheritDoc} 131 * @throws NullPointerException if the target is {@code null}. 132 */ 133 public boolean setComposingText(CharSequence text, int newCursorPosition) { 134 return mTarget.setComposingText(text, newCursorPosition); 135 } 136 137 /** 138 * {@inheritDoc} 139 * @throws NullPointerException if the target is {@code null}. 140 */ 141 public boolean setComposingRegion(int start, int end) { 142 return mTarget.setComposingRegion(start, end); 143 } 144 145 /** 146 * {@inheritDoc} 147 * @throws NullPointerException if the target is {@code null}. 148 */ 149 public boolean finishComposingText() { 150 return mTarget.finishComposingText(); 151 } 152 153 /** 154 * {@inheritDoc} 155 * @throws NullPointerException if the target is {@code null}. 156 */ 157 public boolean commitText(CharSequence text, int newCursorPosition) { 158 return mTarget.commitText(text, newCursorPosition); 159 } 160 161 /** 162 * {@inheritDoc} 163 * @throws NullPointerException if the target is {@code null}. 164 */ 165 public boolean commitCompletion(CompletionInfo text) { 166 return mTarget.commitCompletion(text); 167 } 168 169 /** 170 * {@inheritDoc} 171 * @throws NullPointerException if the target is {@code null}. 172 */ 173 public boolean commitCorrection(CorrectionInfo correctionInfo) { 174 return mTarget.commitCorrection(correctionInfo); 175 } 176 177 /** 178 * {@inheritDoc} 179 * @throws NullPointerException if the target is {@code null}. 180 */ 181 public boolean setSelection(int start, int end) { 182 return mTarget.setSelection(start, end); 183 } 184 185 /** 186 * {@inheritDoc} 187 * @throws NullPointerException if the target is {@code null}. 188 */ 189 public boolean performEditorAction(int editorAction) { 190 return mTarget.performEditorAction(editorAction); 191 } 192 193 /** 194 * {@inheritDoc} 195 * @throws NullPointerException if the target is {@code null}. 196 */ 197 public boolean performContextMenuAction(int id) { 198 return mTarget.performContextMenuAction(id); 199 } 200 201 /** 202 * {@inheritDoc} 203 * @throws NullPointerException if the target is {@code null}. 204 */ 205 public boolean beginBatchEdit() { 206 return mTarget.beginBatchEdit(); 207 } 208 209 /** 210 * {@inheritDoc} 211 * @throws NullPointerException if the target is {@code null}. 212 */ 213 public boolean endBatchEdit() { 214 return mTarget.endBatchEdit(); 215 } 216 217 /** 218 * {@inheritDoc} 219 * @throws NullPointerException if the target is {@code null}. 220 */ 221 public boolean sendKeyEvent(KeyEvent event) { 222 return mTarget.sendKeyEvent(event); 223 } 224 225 /** 226 * {@inheritDoc} 227 * @throws NullPointerException if the target is {@code null}. 228 */ 229 public boolean clearMetaKeyStates(int states) { 230 return mTarget.clearMetaKeyStates(states); 231 } 232 233 /** 234 * {@inheritDoc} 235 * @throws NullPointerException if the target is {@code null}. 236 */ 237 public boolean reportFullscreenMode(boolean enabled) { 238 return mTarget.reportFullscreenMode(enabled); 239 } 240 241 /** 242 * {@inheritDoc} 243 * @throws NullPointerException if the target is {@code null}. 244 */ 245 public boolean performPrivateCommand(String action, Bundle data) { 246 return mTarget.performPrivateCommand(action, data); 247 } 248 249 /** 250 * {@inheritDoc} 251 * @throws NullPointerException if the target is {@code null}. 252 */ 253 public boolean requestCursorUpdates(int cursorUpdateMode) { 254 return mTarget.requestCursorUpdates(cursorUpdateMode); 255 } 256 257 /** 258 * {@inheritDoc} 259 * @throws NullPointerException if the target is {@code null}. 260 */ 261 public Handler getHandler() { 262 return mTarget.getHandler(); 263 } 264 265 /** 266 * {@inheritDoc} 267 * @throws NullPointerException if the target is {@code null}. 268 */ 269 public void closeConnection() { 270 mTarget.closeConnection(); 271 } 272 273 /** 274 * {@inheritDoc} 275 * @throws NullPointerException if the target is {@code null}. 276 */ 277 public boolean commitContent(InputContentInfo inputContentInfo, int flags, Bundle opts) { 278 return mTarget.commitContent(inputContentInfo, flags, opts); 279 } 280} 281