input/keyboard/CommitContentSampleApp/app/src/main/java/com/example/android/commitcontent/app/MainActivity.java - platform/developers/samples/android - Git at Google

 /*
  * Copyright (C) 2016 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.example.android.commitcontent.app;

 import android.support.v13.view.inputmethod.EditorInfoCompat;
 import android.support.v13.view.inputmethod.InputConnectionCompat;
 import android.support.v13.view.inputmethod.InputContentInfoCompat;

 import android.app.Activity;
 import android.graphics.Color;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.Parcelable;
 import android.text.TextUtils;
 import android.util.Log;
 import android.view.inputmethod.EditorInfo;
 import android.view.inputmethod.InputConnection;
 import android.webkit.WebView;
 import android.widget.EditText;
 import android.widget.LinearLayout;
 import android.widget.TextView;

 import java.util.ArrayList;
 import java.util.Arrays;

 public class MainActivity extends Activity {
     private static final String INPUT_CONTENT_INFO_KEY = "COMMIT_CONTENT_INPUT_CONTENT_INFO";
     private static final String COMMIT_CONTENT_FLAGS_KEY = "COMMIT_CONTENT_FLAGS";

     private static String TAG = "CommitContentSupport";

     private WebView mWebView;
     private TextView mLabel;
     private TextView mContentUri;
     private TextView mLinkUri;
     private TextView mMimeTypes;
     private TextView mFlags;

     private InputContentInfoCompat mCurrentInputContentInfo;
     private int mCurrentFlags;

     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);

         setContentView(R.layout.commit_content);

         final LinearLayout layout =
                 (LinearLayout) findViewById(R.id.commit_content_sample_edit_boxes);

         // This declares that the IME cannot commit any content with
         // InputConnectionCompat#commitContent().
         layout.addView(createEditTextWithContentMimeTypes(null));

         // This declares that the IME can commit contents with
         // InputConnectionCompat#commitContent() if they match "image/gif".
         layout.addView(createEditTextWithContentMimeTypes(new String[]{"image/gif"}));

         // This declares that the IME can commit contents with
         // InputConnectionCompat#commitContent() if they match "image/png".
         layout.addView(createEditTextWithContentMimeTypes(new String[]{"image/png"}));

         // This declares that the IME can commit contents with
         // InputConnectionCompat#commitContent() if they match "image/jpeg".
         layout.addView(createEditTextWithContentMimeTypes(new String[]{"image/jpeg"}));

         // This declares that the IME can commit contents with
         // InputConnectionCompat#commitContent() if they match "image/webp".
         layout.addView(createEditTextWithContentMimeTypes(new String[]{"image/webp"}));

         // This declares that the IME can commit contents with
         // InputConnectionCompat#commitContent() if they match "image/png", "image/gif",
         // "image/jpeg", or "image/webp".
         layout.addView(createEditTextWithContentMimeTypes(
                 new String[]{"image/png", "image/gif", "image/jpeg", "image/webp"}));

         mWebView = (WebView) findViewById(R.id.commit_content_webview);
         mMimeTypes = (TextView) findViewById(R.id.text_commit_content_mime_types);
         mLabel = (TextView) findViewById(R.id.text_commit_content_label);
         mContentUri = (TextView) findViewById(R.id.text_commit_content_content_uri);
         mLinkUri = (TextView) findViewById(R.id.text_commit_content_link_uri);
         mFlags = (TextView) findViewById(R.id.text_commit_content_link_flags);

         if (savedInstanceState != null) {
             final InputContentInfoCompat previousInputContentInfo = InputContentInfoCompat.wrap(
                     savedInstanceState.getParcelable(INPUT_CONTENT_INFO_KEY));
             final int previousFlags = savedInstanceState.getInt(COMMIT_CONTENT_FLAGS_KEY);
             if (previousInputContentInfo != null) {
                 onCommitContentInternal(previousInputContentInfo, previousFlags);
             }
         }
     }

     private boolean onCommitContent(InputContentInfoCompat inputContentInfo, int flags,
             Bundle opts, String[] contentMimeTypes) {
         // Clear the temporary permission (if any).  See below about why we do this here.
         try {
             if (mCurrentInputContentInfo != null) {
                 mCurrentInputContentInfo.releasePermission();
             }
         } catch (Exception e) {
             Log.e(TAG, "InputContentInfoCompat#releasePermission() failed.", e);
         } finally {
             mCurrentInputContentInfo = null;
         }

         mWebView.loadUrl("about:blank");
         mMimeTypes.setText("");
         mContentUri.setText("");
         mLabel.setText("");
         mLinkUri.setText("");
         mFlags.setText("");

         boolean supported = false;
         for (final String mimeType : contentMimeTypes) {
             if (inputContentInfo.getDescription().hasMimeType(mimeType)) {
                 supported = true;
                 break;
             }
         }
         if (!supported) {
             return false;
         }

         return onCommitContentInternal(inputContentInfo, flags);
     }

     private boolean onCommitContentInternal(InputContentInfoCompat inputContentInfo, int flags) {
         if ((flags & InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION) != 0) {
             try {
                 inputContentInfo.requestPermission();
             } catch (Exception e) {
                 Log.e(TAG, "InputContentInfoCompat#requestPermission() failed.", e);
                 return false;
             }
         }

         mMimeTypes.setText(
                 Arrays.toString(inputContentInfo.getDescription().filterMimeTypes("*/*")));
         mContentUri.setText(inputContentInfo.getContentUri().toString());
         mLabel.setText(inputContentInfo.getDescription().getLabel());
         Uri linkUri = inputContentInfo.getLinkUri();
         mLinkUri.setText(linkUri != null ? linkUri.toString() : "null");
         mFlags.setText(flagsToString(flags));
         mWebView.loadUrl(inputContentInfo.getContentUri().toString());
         mWebView.setBackgroundColor(Color.TRANSPARENT);

         // Due to the asynchronous nature of WebView, it is a bit too early to call
         // inputContentInfo.releasePermission() here. Hence we call IC#releasePermission() when this
         // method is called next time.  Note that calling IC#releasePermission() is just to be a
         // good citizen. Even if we failed to call that method, the system would eventually revoke
         // the permission sometime after inputContentInfo object gets garbage-collected.
         mCurrentInputContentInfo = inputContentInfo;
         mCurrentFlags = flags;

         return true;
     }

     @Override
     public void onSaveInstanceState(Bundle savedInstanceState) {
         if (mCurrentInputContentInfo != null) {
             savedInstanceState.putParcelable(INPUT_CONTENT_INFO_KEY,
                     (Parcelable) mCurrentInputContentInfo.unwrap());
             savedInstanceState.putInt(COMMIT_CONTENT_FLAGS_KEY, mCurrentFlags);
         }
         mCurrentInputContentInfo = null;
         mCurrentFlags = 0;
         super.onSaveInstanceState(savedInstanceState);
     }

     /**
      * Creates a new instance of {@link EditText} that is configured to specify the given content
      * MIME types to EditorInfo#contentMimeTypes so that developers can locally test how the current
      * input method behaves for such content MIME types.
      *
      * @param contentMimeTypes A {@link String} array that indicates the supported content MIME
      *                         types
      * @return a new instance of {@link EditText}, which specifies EditorInfo#contentMimeTypes with
      * the given content MIME types
      */
     private EditText createEditTextWithContentMimeTypes(String[] contentMimeTypes) {
         final CharSequence hintText;
         final String[] mimeTypes;  // our own copy of contentMimeTypes.
         if (contentMimeTypes == null || contentMimeTypes.length == 0) {
             hintText = "MIME: []";
             mimeTypes = new String[0];
         } else {
             hintText = "MIME: " + Arrays.toString(contentMimeTypes);
             mimeTypes = Arrays.copyOf(contentMimeTypes, contentMimeTypes.length);
         }
         EditText exitText = new EditText(this) {
             @Override
             public InputConnection onCreateInputConnection(EditorInfo editorInfo) {
                 final InputConnection ic = super.onCreateInputConnection(editorInfo);
                 EditorInfoCompat.setContentMimeTypes(editorInfo, mimeTypes);
                 final InputConnectionCompat.OnCommitContentListener callback =
                         new InputConnectionCompat.OnCommitContentListener() {
                             @Override
                             public boolean onCommitContent(InputContentInfoCompat inputContentInfo,
                                     int flags, Bundle opts) {
                                 return MainActivity.this.onCommitContent(
                                         inputContentInfo, flags, opts, mimeTypes);
                             }
                         };
                 return InputConnectionCompat.createWrapper(ic, editorInfo, callback);
             }
         };
         exitText.setHint(hintText);
         exitText.setTextColor(Color.WHITE);
         exitText.setHintTextColor(Color.WHITE);
         return exitText;
     }

     /**
      * Converts {@code flags} specified in {@link InputConnectionCompat#commitContent(
      * InputConnection, EditorInfo, InputContentInfoCompat, int, Bundle)} to a human readable
      * string.
      *
      * @param flags the 2nd parameter of
      *              {@link InputConnectionCompat#commitContent(InputConnection, EditorInfo,
      *              InputContentInfoCompat, int, Bundle)}
      * @return a human readable string that corresponds to the given {@code flags}
      */
     private static String flagsToString(int flags) {
         final ArrayList<String> tokens = new ArrayList<>();
         if ((flags & InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION) != 0) {
             tokens.add("INPUT_CONTENT_GRANT_READ_URI_PERMISSION");
             flags &= ~InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION;
         }
         if (flags != 0) {
             tokens.add("0x" + Integer.toHexString(flags));
         }
         return TextUtils.join(" | ", tokens);
     }

 }
	/*
	* Copyright (C) 2016 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.example.android.commitcontent.app;

	import android.support.v13.view.inputmethod.EditorInfoCompat;
	import android.support.v13.view.inputmethod.InputConnectionCompat;
	import android.support.v13.view.inputmethod.InputContentInfoCompat;

	import android.app.Activity;
	import android.graphics.Color;
	import android.net.Uri;
	import android.os.Bundle;
	import android.os.Parcelable;
	import android.text.TextUtils;
	import android.util.Log;
	import android.view.inputmethod.EditorInfo;
	import android.view.inputmethod.InputConnection;
	import android.webkit.WebView;
	import android.widget.EditText;
	import android.widget.LinearLayout;
	import android.widget.TextView;

	import java.util.ArrayList;
	import java.util.Arrays;

	public class MainActivity extends Activity {
	private static final String INPUT_CONTENT_INFO_KEY = "COMMIT_CONTENT_INPUT_CONTENT_INFO";
	private static final String COMMIT_CONTENT_FLAGS_KEY = "COMMIT_CONTENT_FLAGS";

	private static String TAG = "CommitContentSupport";

	private WebView mWebView;
	private TextView mLabel;
	private TextView mContentUri;
	private TextView mLinkUri;
	private TextView mMimeTypes;
	private TextView mFlags;

	private InputContentInfoCompat mCurrentInputContentInfo;
	private int mCurrentFlags;

	@Override
	public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	setContentView(R.layout.commit_content);

	final LinearLayout layout =
	(LinearLayout) findViewById(R.id.commit_content_sample_edit_boxes);

	// This declares that the IME cannot commit any content with
	// InputConnectionCompat#commitContent().
	layout.addView(createEditTextWithContentMimeTypes(null));

	// This declares that the IME can commit contents with
	// InputConnectionCompat#commitContent() if they match "image/gif".
	layout.addView(createEditTextWithContentMimeTypes(new String[]{"image/gif"}));

	// This declares that the IME can commit contents with
	// InputConnectionCompat#commitContent() if they match "image/png".
	layout.addView(createEditTextWithContentMimeTypes(new String[]{"image/png"}));

	// This declares that the IME can commit contents with
	// InputConnectionCompat#commitContent() if they match "image/jpeg".
	layout.addView(createEditTextWithContentMimeTypes(new String[]{"image/jpeg"}));

	// This declares that the IME can commit contents with
	// InputConnectionCompat#commitContent() if they match "image/webp".
	layout.addView(createEditTextWithContentMimeTypes(new String[]{"image/webp"}));

	// This declares that the IME can commit contents with
	// InputConnectionCompat#commitContent() if they match "image/png", "image/gif",
	// "image/jpeg", or "image/webp".
	layout.addView(createEditTextWithContentMimeTypes(
	new String[]{"image/png", "image/gif", "image/jpeg", "image/webp"}));

	mWebView = (WebView) findViewById(R.id.commit_content_webview);
	mMimeTypes = (TextView) findViewById(R.id.text_commit_content_mime_types);
	mLabel = (TextView) findViewById(R.id.text_commit_content_label);
	mContentUri = (TextView) findViewById(R.id.text_commit_content_content_uri);
	mLinkUri = (TextView) findViewById(R.id.text_commit_content_link_uri);
	mFlags = (TextView) findViewById(R.id.text_commit_content_link_flags);

	if (savedInstanceState != null) {
	final InputContentInfoCompat previousInputContentInfo = InputContentInfoCompat.wrap(
	savedInstanceState.getParcelable(INPUT_CONTENT_INFO_KEY));
	final int previousFlags = savedInstanceState.getInt(COMMIT_CONTENT_FLAGS_KEY);
	if (previousInputContentInfo != null) {
	onCommitContentInternal(previousInputContentInfo, previousFlags);
	}
	}
	}

	private boolean onCommitContent(InputContentInfoCompat inputContentInfo, int flags,
	Bundle opts, String[] contentMimeTypes) {
	// Clear the temporary permission (if any). See below about why we do this here.
	try {
	if (mCurrentInputContentInfo != null) {
	mCurrentInputContentInfo.releasePermission();
	}
	} catch (Exception e) {
	Log.e(TAG, "InputContentInfoCompat#releasePermission() failed.", e);
	} finally {
	mCurrentInputContentInfo = null;
	}

	mWebView.loadUrl("about:blank");
	mMimeTypes.setText("");
	mContentUri.setText("");
	mLabel.setText("");
	mLinkUri.setText("");
	mFlags.setText("");

	boolean supported = false;
	for (final String mimeType : contentMimeTypes) {
	if (inputContentInfo.getDescription().hasMimeType(mimeType)) {
	supported = true;
	break;
	}
	}
	if (!supported) {
	return false;
	}

	return onCommitContentInternal(inputContentInfo, flags);
	}

	private boolean onCommitContentInternal(InputContentInfoCompat inputContentInfo, int flags) {
	if ((flags & InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION) != 0) {
	try {
	inputContentInfo.requestPermission();
	} catch (Exception e) {
	Log.e(TAG, "InputContentInfoCompat#requestPermission() failed.", e);
	return false;
	}
	}

	mMimeTypes.setText(
	Arrays.toString(inputContentInfo.getDescription().filterMimeTypes("/")));
	mContentUri.setText(inputContentInfo.getContentUri().toString());
	mLabel.setText(inputContentInfo.getDescription().getLabel());
	Uri linkUri = inputContentInfo.getLinkUri();
	mLinkUri.setText(linkUri != null ? linkUri.toString() : "null");
	mFlags.setText(flagsToString(flags));
	mWebView.loadUrl(inputContentInfo.getContentUri().toString());
	mWebView.setBackgroundColor(Color.TRANSPARENT);

	// Due to the asynchronous nature of WebView, it is a bit too early to call
	// inputContentInfo.releasePermission() here. Hence we call IC#releasePermission() when this
	// method is called next time. Note that calling IC#releasePermission() is just to be a
	// good citizen. Even if we failed to call that method, the system would eventually revoke
	// the permission sometime after inputContentInfo object gets garbage-collected.
	mCurrentInputContentInfo = inputContentInfo;
	mCurrentFlags = flags;

	return true;
	}

	@Override
	public void onSaveInstanceState(Bundle savedInstanceState) {
	if (mCurrentInputContentInfo != null) {
	savedInstanceState.putParcelable(INPUT_CONTENT_INFO_KEY,
	(Parcelable) mCurrentInputContentInfo.unwrap());
	savedInstanceState.putInt(COMMIT_CONTENT_FLAGS_KEY, mCurrentFlags);
	}
	mCurrentInputContentInfo = null;
	mCurrentFlags = 0;
	super.onSaveInstanceState(savedInstanceState);
	}

	/**
	* Creates a new instance of {@link EditText} that is configured to specify the given content
	* MIME types to EditorInfo#contentMimeTypes so that developers can locally test how the current
	* input method behaves for such content MIME types.
	*
	* @param contentMimeTypes A {@link String} array that indicates the supported content MIME
	* types
	* @return a new instance of {@link EditText}, which specifies EditorInfo#contentMimeTypes with
	* the given content MIME types
	*/
	private EditText createEditTextWithContentMimeTypes(String[] contentMimeTypes) {
	final CharSequence hintText;
	final String[] mimeTypes; // our own copy of contentMimeTypes.
	if (contentMimeTypes == null \|\| contentMimeTypes.length == 0) {
	hintText = "MIME: []";
	mimeTypes = new String[0];
	} else {
	hintText = "MIME: " + Arrays.toString(contentMimeTypes);
	mimeTypes = Arrays.copyOf(contentMimeTypes, contentMimeTypes.length);
	}
	EditText exitText = new EditText(this) {
	@Override
	public InputConnection onCreateInputConnection(EditorInfo editorInfo) {
	final InputConnection ic = super.onCreateInputConnection(editorInfo);
	EditorInfoCompat.setContentMimeTypes(editorInfo, mimeTypes);
	final InputConnectionCompat.OnCommitContentListener callback =
	new InputConnectionCompat.OnCommitContentListener() {
	@Override
	public boolean onCommitContent(InputContentInfoCompat inputContentInfo,
	int flags, Bundle opts) {
	return MainActivity.this.onCommitContent(
	inputContentInfo, flags, opts, mimeTypes);
	}
	};
	return InputConnectionCompat.createWrapper(ic, editorInfo, callback);
	}
	};
	exitText.setHint(hintText);
	exitText.setTextColor(Color.WHITE);
	exitText.setHintTextColor(Color.WHITE);
	return exitText;
	}

	/**
	* Converts {@code flags} specified in {@link InputConnectionCompat#commitContent(
	* InputConnection, EditorInfo, InputContentInfoCompat, int, Bundle)} to a human readable
	* string.
	*
	* @param flags the 2nd parameter of
	* {@link InputConnectionCompat#commitContent(InputConnection, EditorInfo,
	* InputContentInfoCompat, int, Bundle)}
	* @return a human readable string that corresponds to the given {@code flags}
	*/
	private static String flagsToString(int flags) {
	final ArrayList<String> tokens = new ArrayList<>();
	if ((flags & InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION) != 0) {
	tokens.add("INPUT_CONTENT_GRANT_READ_URI_PERMISSION");
	flags &= ~InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION;
	}
	if (flags != 0) {
	tokens.add("0x" + Integer.toHexString(flags));
	}
	return TextUtils.join(" \| ", tokens);
	}

	}