Add authentication/http request related code to LatinIme (05274d5a) · Commits · e / os / android_packages_inputmethods_LatinIME

java/src/com/android/inputmethod/latin/accounts/AuthUtils.java

0 → 100644

+67 −0

Original line number	Diff line number	Diff line
		/*
		* 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.latin.accounts;

		import android.accounts.Account;
		import android.accounts.AccountManager;
		import android.accounts.AccountManagerCallback;
		import android.accounts.AccountManagerFuture;
		import android.accounts.AuthenticatorException;
		import android.accounts.OperationCanceledException;
		import android.content.Context;
		import android.os.Bundle;
		import android.os.Handler;

		import java.io.IOException;

		/**
		* Utility class that handles generation/invalidation of auth tokens in the app.
		*/
		public class AuthUtils {
		private final AccountManager mAccountManager;

		public AuthUtils(Context context) {
		mAccountManager = AccountManager.get(context);
		}

		/**
		* @see AccountManager#invalidateAuthToken(String, String)
		*/
		public void invalidateAuthToken(final String accountType, final String authToken) {
		mAccountManager.invalidateAuthToken(accountType, authToken);
		}

		/**
		* @see AccountManager#getAuthToken(
		* Account, String, Bundle, boolean, AccountManagerCallback, Handler)
		*/
		public AccountManagerFuture<Bundle> getAuthToken(final Account account,
		final String authTokenType, final Bundle options, final boolean notifyAuthFailure,
		final AccountManagerCallback<Bundle> callback, final Handler handler) {
		return mAccountManager.getAuthToken(account, authTokenType, options, notifyAuthFailure,
		callback, handler);
		}

		/**
		* @see AccountManager#blockingGetAuthToken(Account, String, boolean)
		*/
		public String blockingGetAuthToken(final Account account, final String authTokenType,
		final boolean notifyAuthFailure) throws OperationCanceledException,
		AuthenticatorException, IOException {
		return mAccountManager.blockingGetAuthToken(account, authTokenType, notifyAuthFailure);
		}
		}

java/src/com/android/inputmethod/latin/network/BlockingHttpClient.java

0 → 100644

+99 −0

Original line number	Diff line number	Diff line
		/*
		* 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.latin.network;

		import com.android.inputmethod.annotations.UsedForTesting;

		import java.io.BufferedOutputStream;
		import java.io.IOException;
		import java.io.InputStream;
		import java.io.OutputStream;
		import java.net.HttpURLConnection;

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

		/**
		* A client for executing HTTP requests synchronously.
		* This must never be called from the main thread.
		*
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public class BlockingHttpClient {
		private final HttpURLConnection mConnection;

		/**
		* Interface that handles processing the response for a request.
		*/
		public interface ResponseProcessor {
		/**
		* Called when the HTTP request fails with an error.
		*
		* @param httpStatusCode The status code of the HTTP response.
		* @param message The HTTP response message, if any, or null.
		*/
		void onError(int httpStatusCode, @Nullable String message);

		/**
		* Called when the HTTP request finishes successfully.
		* The {@link InputStream} is closed by the client after the method finishes,
		* so any processing must be done in this method itself.
		*
		* @param response An input stream that can be used to read the HTTP response.
		*/
		void onSuccess(InputStream response);
		}

		/**
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public BlockingHttpClient(HttpURLConnection connection) {
		mConnection = connection;
		}

		/**
		* Executes the request on the underlying {@link HttpURLConnection}.
		*
		* TODO: Remove @UsedForTesting after this is actually used.
		*
		* @param request The request payload, if any, or null.
		* @param responeProcessor A processor for the HTTP response.
		*/
		@UsedForTesting
		public void execute(@Nullable byte[] request, @Nonnull ResponseProcessor responseProcessor)
		throws IOException {
		try {
		if (request != null) {
		OutputStream out = new BufferedOutputStream(mConnection.getOutputStream());
		out.write(request);
		out.flush();
		out.close();
		}

		final int responseCode = mConnection.getResponseCode();
		if (responseCode != HttpURLConnection.HTTP_OK) {
		responseProcessor.onError(responseCode, mConnection.getResponseMessage());
		} else {
		responseProcessor.onSuccess(mConnection.getInputStream());
		}
		} finally {
		mConnection.disconnect();
		}
		}
		}

java/src/com/android/inputmethod/latin/network/HttpUrlConnectionBuilder.java

0 → 100644

+213 −0

Original line number	Diff line number	Diff line
		/*
		* 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.latin.network;

		import android.text.TextUtils;

		import com.android.inputmethod.annotations.UsedForTesting;

		import java.io.IOException;
		import java.net.HttpURLConnection;
		import java.net.MalformedURLException;
		import java.net.URL;
		import java.util.HashMap;
		import java.util.Map.Entry;

		/**
		* Builder for {@link HttpURLConnection}s.
		*
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public class HttpUrlConnectionBuilder {
		private static final int DEFAULT_TIMEOUT_MILLIS = 5 * 1000;

		/**
		* Request header key for cache control.
		*/
		public static final String KEY_CACHE_CONTROL = "Cache-Control";
		/**
		* Request header value for cache control indicating no caching.
		* @see #KEY_CACHE_CONTROL
		*/
		public static final String VALUE_NO_CACHE = "no-cache";

		/**
		* Indicates that the request is unidirectional - upload-only.
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public static final int MODE_UPLOAD_ONLY = 1;
		/**
		* Indicates that the request is unidirectional - download only.
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public static final int MODE_DOWNLOAD_ONLY = 2;
		/**
		* Indicates that the request is bi-directional.
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public static final int MODE_BI_DIRECTIONAL = 3;

		private final HashMap<String, String> mHeaderMap = new HashMap<>();

		private URL mUrl;
		private int mConnectTimeoutMillis = DEFAULT_TIMEOUT_MILLIS;
		private int mReadTimeoutMillis = DEFAULT_TIMEOUT_MILLIS;
		private int mContentLength = -1;
		private boolean mUseCache;
		private int mMode;

		/**
		* Sets the URL that'll be used for the request.
		* This must be set before calling {@link #build()}
		*
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public HttpUrlConnectionBuilder setUrl(String url) throws MalformedURLException {
		if (TextUtils.isEmpty(url)) {
		throw new IllegalArgumentException("URL must not be empty");
		}
		mUrl = new URL(url);
		return this;
		}

		/**
		* Sets the connect timeout. Defaults to {@value #DEFAULT_TIMEOUT} milliseconds.
		*
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public HttpUrlConnectionBuilder setConnectTimeout(int timeoutMillis) {
		if (timeoutMillis < 0) {
		throw new IllegalArgumentException("connect-timeout must be >= 0, but was "
		+ timeoutMillis);
		}
		mConnectTimeoutMillis = timeoutMillis;
		return this;
		}

		/**
		* Sets the read timeout. Defaults to {@value #DEFAULT_TIMEOUT} milliseconds.
		*
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public HttpUrlConnectionBuilder setReadTimeout(int timeoutMillis) {
		if (timeoutMillis < 0) {
		throw new IllegalArgumentException("read-timeout must be >= 0, but was "
		+ timeoutMillis);
		}
		mReadTimeoutMillis = timeoutMillis;
		return this;
		}

		/**
		* Adds an entry to the request header.
		*
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public HttpUrlConnectionBuilder addHeader(String key, String value) {
		mHeaderMap.put(key, value);
		return this;
		}

		/**
		* Sets the request to be executed such that the input is not buffered.
		* This may be set when the request size is known beforehand.
		*
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public HttpUrlConnectionBuilder setFixedLengthForStreaming(int length) {
		mContentLength = length;
		return this;
		}

		/**
		* Indicates if the request can use cached responses or not.
		*
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public HttpUrlConnectionBuilder setUseCache(boolean useCache) {
		mUseCache = useCache;
		return this;
		}

		/**
		* The request mode.
		* Sets the request mode to be one of: upload-only, download-only or bidirectional.
		*
		* @see #MODE_UPLOAD_ONLY
		* @see #MODE_DOWNLOAD_ONLY
		* @see #MODE_BI_DIRECTIONAL
		*
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public HttpUrlConnectionBuilder setMode(int mode) {
		if (mode != MODE_UPLOAD_ONLY
		&& mode != MODE_DOWNLOAD_ONLY
		&& mode != MODE_BI_DIRECTIONAL) {
		throw new IllegalArgumentException("Invalid mode specified:" + mode);
		}
		mMode = mode;
		return this;
		}

		/**
		* Builds the {@link HttpURLConnection} instance that can be used to execute the request.
		*
		* TODO: Remove @UsedForTesting after this is actually used.
		*/
		@UsedForTesting
		public HttpURLConnection build() throws IOException {
		if (mUrl == null) {
		throw new IllegalArgumentException("A URL must be specified!");
		}
		final HttpURLConnection connection = (HttpURLConnection) mUrl.openConnection();
		connection.setConnectTimeout(mConnectTimeoutMillis);
		connection.setReadTimeout(mReadTimeoutMillis);
		connection.setUseCaches(mUseCache);
		switch (mMode) {
		case MODE_UPLOAD_ONLY:
		connection.setDoInput(true);
		connection.setDoOutput(false);
		break;
		case MODE_DOWNLOAD_ONLY:
		connection.setDoInput(false);
		connection.setDoOutput(true);
		break;
		case MODE_BI_DIRECTIONAL:
		connection.setDoInput(true);
		connection.setDoOutput(true);
		break;
		}
		for (final Entry<String, String> entry : mHeaderMap.entrySet()) {
		connection.addRequestProperty(entry.getKey(), entry.getValue());
		}
		if (mContentLength >= 0) {
		connection.setFixedLengthStreamingMode(mContentLength);
		}
		return connection;
		}
		}

tests/src/com/android/inputmethod/latin/network/BlockingHttpClientTests.java

0 → 100644

+174 −0

Original line number	Diff line number	Diff line
		/*
		* 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.latin.network;

		import static org.mockito.Mockito.any;
		import static org.mockito.Mockito.eq;
		import static org.mockito.Mockito.verify;
		import static org.mockito.Mockito.when;

		import android.test.AndroidTestCase;
		import android.test.suitebuilder.annotation.SmallTest;

		import com.android.inputmethod.latin.network.BlockingHttpClient.ResponseProcessor;

		import org.mockito.Mock;
		import org.mockito.Mockito;
		import org.mockito.MockitoAnnotations;

		import java.io.BufferedInputStream;
		import java.io.ByteArrayInputStream;
		import java.io.ByteArrayOutputStream;
		import java.io.IOException;
		import java.io.InputStream;
		import java.io.OutputStream;
		import java.net.HttpURLConnection;
		import java.util.Arrays;
		import java.util.Random;

		/**
		* Tests for {@link BlockingHttpClient}.
		*/
		@SmallTest
		public class BlockingHttpClientTests extends AndroidTestCase {
		@Mock HttpURLConnection mMockHttpConnection;

		@Override
		protected void setUp() throws Exception {
		super.setUp();
		MockitoAnnotations.initMocks(this);
		}

		public void testError_badGateway() throws IOException {
		when(mMockHttpConnection.getResponseCode()).thenReturn(HttpURLConnection.HTTP_BAD_GATEWAY);
		final BlockingHttpClient client = new BlockingHttpClient(mMockHttpConnection);
		final FakeErrorResponseProcessor processor =
		new FakeErrorResponseProcessor(HttpURLConnection.HTTP_BAD_GATEWAY);

		client.execute(null /* empty request */, processor);
		assertTrue("ResponseProcessor was not invoked", processor.mInvoked);
		}

		public void testError_clientTimeout() throws IOException {
		when(mMockHttpConnection.getResponseCode()).thenReturn(
		HttpURLConnection.HTTP_CLIENT_TIMEOUT);
		final BlockingHttpClient client = new BlockingHttpClient(mMockHttpConnection);
		final FakeErrorResponseProcessor processor =
		new FakeErrorResponseProcessor(HttpURLConnection.HTTP_CLIENT_TIMEOUT);

		client.execute(null /* empty request */, processor);
		assertTrue("ResponseProcessor was not invoked", processor.mInvoked);
		}

		public void testError_forbiddenWithRequest() throws IOException {
		final OutputStream mockOutputStream = Mockito.mock(OutputStream.class);
		when(mMockHttpConnection.getResponseCode()).thenReturn(HttpURLConnection.HTTP_FORBIDDEN);
		when(mMockHttpConnection.getOutputStream()).thenReturn(mockOutputStream);
		final BlockingHttpClient client = new BlockingHttpClient(mMockHttpConnection);
		final FakeErrorResponseProcessor processor =
		new FakeErrorResponseProcessor(HttpURLConnection.HTTP_FORBIDDEN);

		client.execute(new byte[100], processor);
		verify(mockOutputStream).write(any(byte[].class), eq(0), eq(100));
		assertTrue("ResponseProcessor was not invoked", processor.mInvoked);
		}

		public void testSuccess_emptyRequest() throws IOException {
		final Random rand = new Random();
		byte[] response = new byte[100];
		rand.nextBytes(response);
		when(mMockHttpConnection.getResponseCode()).thenReturn(HttpURLConnection.HTTP_OK);
		when(mMockHttpConnection.getInputStream()).thenReturn(new ByteArrayInputStream(response));
		final BlockingHttpClient client = new BlockingHttpClient(mMockHttpConnection);
		final FakeSuccessResponseProcessor processor =
		new FakeSuccessResponseProcessor(response);

		client.execute(null /* empty request */, processor);
		assertTrue("ResponseProcessor was not invoked", processor.mInvoked);
		}

		public void testSuccess() throws IOException {
		final OutputStream mockOutputStream = Mockito.mock(OutputStream.class);
		final Random rand = new Random();
		byte[] response = new byte[100];
		rand.nextBytes(response);
		when(mMockHttpConnection.getOutputStream()).thenReturn(mockOutputStream);
		when(mMockHttpConnection.getResponseCode()).thenReturn(HttpURLConnection.HTTP_OK);
		when(mMockHttpConnection.getInputStream()).thenReturn(new ByteArrayInputStream(response));
		final BlockingHttpClient client = new BlockingHttpClient(mMockHttpConnection);
		final FakeSuccessResponseProcessor processor =
		new FakeSuccessResponseProcessor(response);

		client.execute(new byte[100], processor);
		assertTrue("ResponseProcessor was not invoked", processor.mInvoked);
		}

		private static class FakeErrorResponseProcessor implements ResponseProcessor {
		private final int mExpectedStatusCode;

		boolean mInvoked;

		FakeErrorResponseProcessor(int expectedStatusCode) {
		mExpectedStatusCode = expectedStatusCode;
		}

		@Override
		public void onError(int httpStatusCode, String message) {
		mInvoked = true;
		assertEquals("onError:", mExpectedStatusCode, httpStatusCode);
		}

		@Override
		public void onSuccess(InputStream response) {
		fail("Expected an error but received success");
		}
		}

		private static class FakeSuccessResponseProcessor implements ResponseProcessor {
		private final byte[] mExpectedResponse;

		boolean mInvoked;

		FakeSuccessResponseProcessor(byte[] expectedResponse) {
		mExpectedResponse = expectedResponse;
		}

		@Override
		public void onError(int httpStatusCode, String message) {
		fail("Expected a response but received an error");
		}

		@Override
		public void onSuccess(InputStream response) {
		try {
		mInvoked = true;
		BufferedInputStream in = new BufferedInputStream(response);
		ByteArrayOutputStream buffer = new ByteArrayOutputStream();
		int read = 0;
		while ((read = in.read()) != -1) {
		buffer.write(read);
		}
		byte[] actualResponse = buffer.toByteArray();
		in.close();
		assertTrue("Response doesn't match",
		Arrays.equals(mExpectedResponse, actualResponse));
		} catch (IOException ex) {
		fail("IOException in onSuccess");
		}
		}
		}
		}

tests/src/com/android/inputmethod/latin/network/HttpUrlConnectionBuilderTests.java

0 → 100644

+145 −0

File added.

Preview size limit exceeded, changes collapsed.