Skip to content

Most visited

Recently visited

navigation
CommitContentSampleApp / src / com.example.android.commitcontent.app /

MainActivity.java

1
/*
2
 * Copyright (C) 2016 The Android Open Source Project
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of 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,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License
15
 */
16
 
17
package com.example.android.commitcontent.app;
18
 
19
import android.support.v13.view.inputmethod.EditorInfoCompat;
20
import android.support.v13.view.inputmethod.InputConnectionCompat;
21
import android.support.v13.view.inputmethod.InputContentInfoCompat;
22
 
23
import android.app.Activity;
24
import android.graphics.Color;
25
import android.net.Uri;
26
import android.os.Bundle;
27
import android.os.Parcelable;
28
import android.text.TextUtils;
29
import android.util.Log;
30
import android.view.inputmethod.EditorInfo;
31
import android.view.inputmethod.InputConnection;
32
import android.webkit.WebView;
33
import android.widget.EditText;
34
import android.widget.LinearLayout;
35
import android.widget.TextView;
36
 
37
import java.util.ArrayList;
38
import java.util.Arrays;
39
 
40
public class MainActivity extends Activity {
41
    private static final String INPUT_CONTENT_INFO_KEY = "COMMIT_CONTENT_INPUT_CONTENT_INFO";
42
    private static final String COMMIT_CONTENT_FLAGS_KEY = "COMMIT_CONTENT_FLAGS";
43
 
44
    private static String TAG = "CommitContentSupport";
45
 
46
    private WebView mWebView;
47
    private TextView mLabel;
48
    private TextView mContentUri;
49
    private TextView mLinkUri;
50
    private TextView mMimeTypes;
51
    private TextView mFlags;
52
 
53
    private InputContentInfoCompat mCurrentInputContentInfo;
54
    private int mCurrentFlags;
55
 
56
    @Override
57
    public void onCreate(Bundle savedInstanceState) {
58
        super.onCreate(savedInstanceState);
59
 
60
        setContentView(R.layout.commit_content);
61
 
62
        final LinearLayout layout =
63
                (LinearLayout) findViewById(R.id.commit_content_sample_edit_boxes);
64
 
65
        // This declares that the IME cannot commit any content with
66
        // InputConnectionCompat#commitContent().
67
        layout.addView(createEditTextWithContentMimeTypes(null));
68
 
69
        // This declares that the IME can commit contents with
70
        // InputConnectionCompat#commitContent() if they match "image/gif".
71
        layout.addView(createEditTextWithContentMimeTypes(new String[]{"image/gif"}));
72
 
73
        // This declares that the IME can commit contents with
74
        // InputConnectionCompat#commitContent() if they match "image/png".
75
        layout.addView(createEditTextWithContentMimeTypes(new String[]{"image/png"}));
76
 
77
        // This declares that the IME can commit contents with
78
        // InputConnectionCompat#commitContent() if they match "image/jpeg".
79
        layout.addView(createEditTextWithContentMimeTypes(new String[]{"image/jpeg"}));
80
 
81
        // This declares that the IME can commit contents with
82
        // InputConnectionCompat#commitContent() if they match "image/webp".
83
        layout.addView(createEditTextWithContentMimeTypes(new String[]{"image/webp"}));
84
 
85
        // This declares that the IME can commit contents with
86
        // InputConnectionCompat#commitContent() if they match "image/png", "image/gif",
87
        // "image/jpeg", or "image/webp".
88
        layout.addView(createEditTextWithContentMimeTypes(
89
                new String[]{"image/png", "image/gif", "image/jpeg", "image/webp"}));
90
 
91
        mWebView = (WebView) findViewById(R.id.commit_content_webview);
92
        mMimeTypes = (TextView) findViewById(R.id.text_commit_content_mime_types);
93
        mLabel = (TextView) findViewById(R.id.text_commit_content_label);
94
        mContentUri = (TextView) findViewById(R.id.text_commit_content_content_uri);
95
        mLinkUri = (TextView) findViewById(R.id.text_commit_content_link_uri);
96
        mFlags = (TextView) findViewById(R.id.text_commit_content_link_flags);
97
 
98
        if (savedInstanceState != null) {
99
            final InputContentInfoCompat previousInputContentInfo = InputContentInfoCompat.wrap(
100
                    savedInstanceState.getParcelable(INPUT_CONTENT_INFO_KEY));
101
            final int previousFlags = savedInstanceState.getInt(COMMIT_CONTENT_FLAGS_KEY);
102
            if (previousInputContentInfo != null) {
103
                onCommitContentInternal(previousInputContentInfo, previousFlags);
104
            }
105
        }
106
    }
107
 
108
    private boolean onCommitContent(InputContentInfoCompat inputContentInfo, int flags,
109
            Bundle opts, String[] contentMimeTypes) {
110
        // Clear the temporary permission (if any).  See below about why we do this here.
111
        try {
112
            if (mCurrentInputContentInfo != null) {
113
                mCurrentInputContentInfo.releasePermission();
114
            }
115
        } catch (Exception e) {
116
            Log.e(TAG, "InputContentInfoCompat#releasePermission() failed.", e);
117
        } finally {
118
            mCurrentInputContentInfo = null;
119
        }
120
 
121
        mWebView.loadUrl("about:blank");
122
        mMimeTypes.setText("");
123
        mContentUri.setText("");
124
        mLabel.setText("");
125
        mLinkUri.setText("");
126
        mFlags.setText("");
127
 
128
        boolean supported = false;
129
        for (final String mimeType : contentMimeTypes) {
130
            if (inputContentInfo.getDescription().hasMimeType(mimeType)) {
131
                supported = true;
132
                break;
133
            }
134
        }
135
        if (!supported) {
136
            return false;
137
        }
138
 
139
        return onCommitContentInternal(inputContentInfo, flags);
140
    }
141
 
142
    private boolean onCommitContentInternal(InputContentInfoCompat inputContentInfo, int flags) {
143
        if ((flags & InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION) != 0) {
144
            try {
145
                inputContentInfo.requestPermission();
146
            } catch (Exception e) {
147
                Log.e(TAG, "InputContentInfoCompat#requestPermission() failed.", e);
148
                return false;
149
            }
150
        }
151
 
152
        mMimeTypes.setText(
153
                Arrays.toString(inputContentInfo.getDescription().filterMimeTypes("*/*")));
154
        mContentUri.setText(inputContentInfo.getContentUri().toString());
155
        mLabel.setText(inputContentInfo.getDescription().getLabel());
156
        Uri linkUri = inputContentInfo.getLinkUri();
157
        mLinkUri.setText(linkUri != null ? linkUri.toString() : "null");
158
        mFlags.setText(flagsToString(flags));
159
        mWebView.loadUrl(inputContentInfo.getContentUri().toString());
160
        mWebView.setBackgroundColor(Color.TRANSPARENT);
161
 
162
        // Due to the asynchronous nature of WebView, it is a bit too early to call
163
        // inputContentInfo.releasePermission() here. Hence we call IC#releasePermission() when this
164
        // method is called next time.  Note that calling IC#releasePermission() is just to be a
165
        // good citizen. Even if we failed to call that method, the system would eventually revoke
166
        // the permission sometime after inputContentInfo object gets garbage-collected.
167
        mCurrentInputContentInfo = inputContentInfo;
168
        mCurrentFlags = flags;
169
 
170
        return true;
171
    }
172
 
173
    @Override
174
    public void onSaveInstanceState(Bundle savedInstanceState) {
175
        if (mCurrentInputContentInfo != null) {
176
            savedInstanceState.putParcelable(INPUT_CONTENT_INFO_KEY,
177
                    (Parcelable) mCurrentInputContentInfo.unwrap());
178
            savedInstanceState.putInt(COMMIT_CONTENT_FLAGS_KEY, mCurrentFlags);
179
        }
180
        mCurrentInputContentInfo = null;
181
        mCurrentFlags = 0;
182
        super.onSaveInstanceState(savedInstanceState);
183
    }
184
 
185
    /**
186
     * Creates a new instance of {@link EditText} that is configured to specify the given content
187
     * MIME types to EditorInfo#contentMimeTypes so that developers can locally test how the current
188
     * input method behaves for such content MIME types.
189
     *
190
     * @param contentMimeTypes A {@link String} array that indicates the supported content MIME
191
     *                         types
192
     * @return a new instance of {@link EditText}, which specifies EditorInfo#contentMimeTypes with
193
     * the given content MIME types
194
     */
195
    private EditText createEditTextWithContentMimeTypes(String[] contentMimeTypes) {
196
        final CharSequence hintText;
197
        final String[] mimeTypes;  // our own copy of contentMimeTypes.
198
        if (contentMimeTypes == null || contentMimeTypes.length == 0) {
199
            hintText = "MIME: []";
200
            mimeTypes = new String[0];
201
        } else {
202
            hintText = "MIME: " + Arrays.toString(contentMimeTypes);
203
            mimeTypes = Arrays.copyOf(contentMimeTypes, contentMimeTypes.length);
204
        }
205
        EditText exitText = new EditText(this) {
206
            @Override
207
            public InputConnection onCreateInputConnection(EditorInfo editorInfo) {
208
                final InputConnection ic = super.onCreateInputConnection(editorInfo);
209
                EditorInfoCompat.setContentMimeTypes(editorInfo, mimeTypes);
210
                final InputConnectionCompat.OnCommitContentListener callback =
211
                        new InputConnectionCompat.OnCommitContentListener() {
212
                            @Override
213
                            public boolean onCommitContent(InputContentInfoCompat inputContentInfo,
214
                                    int flags, Bundle opts) {
215
                                return MainActivity.this.onCommitContent(
216
                                        inputContentInfo, flags, opts, mimeTypes);
217
                            }
218
                        };
219
                return InputConnectionCompat.createWrapper(ic, editorInfo, callback);
220
            }
221
        };
222
        exitText.setHint(hintText);
223
        exitText.setTextColor(Color.WHITE);
224
        exitText.setHintTextColor(Color.WHITE);
225
        return exitText;
226
    }
227
 
228
    /**
229
     * Converts {@code flags} specified in {@link InputConnectionCompat#commitContent(
230
     * InputConnection, EditorInfo, InputContentInfoCompat, int, Bundle)} to a human readable
231
     * string.
232
     *
233
     * @param flags the 2nd parameter of
234
     *              {@link InputConnectionCompat#commitContent(InputConnection, EditorInfo,
235
     *              InputContentInfoCompat, int, Bundle)}
236
     * @return a human readable string that corresponds to the given {@code flags}
237
     */
238
    private static String flagsToString(int flags) {
239
        final ArrayList<String> tokens = new ArrayList<>();
240
        if ((flags & InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION) != 0) {
241
            tokens.add("INPUT_CONTENT_GRANT_READ_URI_PERMISSION");
242
            flags &= ~InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION;
243
        }
244
        if (flags != 0) {
245
            tokens.add("0x" + Integer.toHexString(flags));
246
        }
247
        return TextUtils.join(" | ", tokens);
248
    }
249
 
250
}
This site uses cookies to store your preferences