AI 143890: Fixes #1749387. Improve the pooling of the VelocityTracker class.... (d928d683) · Commits · e / os / android_frameworks_base

core/java/android/util/FinitePool.java

0 → 100644

+86 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 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 android.util;

		/**
		* @hide
		*/
		class FinitePool<T extends Poolable<T>> implements Pool<T> {
		/**
		* Factory used to create new pool objects
		*/
		private final PoolableManager<T> mManager;
		/**
		* Maximum number of objects in the pool
		*/
		private final int mLimit;
		/**
		* If true, mLimit is ignored
		*/
		private final boolean mInfinite;

		/**
		* Next object to acquire
		*/
		private T mRoot;
		/**
		* Number of objects in the pool
		*/
		private int mPoolCount;

		FinitePool(PoolableManager<T> manager) {
		mManager = manager;
		mLimit = 0;
		mInfinite = true;
		}

		FinitePool(PoolableManager<T> manager, int limit) {
		if (limit <= 0) throw new IllegalArgumentException("The pool limit must be > 0");

		mManager = manager;
		mLimit = limit;
		mInfinite = false;
		}

		public T acquire() {
		T element;

		if (mRoot != null) {
		element = mRoot;
		mRoot = element.getNextPoolable();
		mPoolCount--;
		} else {
		element = mManager.newInstance();
		}

		if (element != null) {
		element.setNextPoolable(null);
		mManager.onAcquired(element);
		}

		return element;
		}

		public void release(T element) {
		if (mInfinite \|\| mPoolCount < mLimit) {
		mPoolCount++;
		element.setNextPoolable(mRoot);
		mRoot = element;
		}
		mManager.onReleased(element);
		}
		}

core/java/android/util/Pool.java

0 → 100644

+25 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 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 android.util;

		/**
		* @hide
		*/
		public interface Pool<T extends Poolable<T>> {
		public abstract T acquire();
		public abstract void release(T element);
		}

core/java/android/util/PoolFactory.java

0 → 100644

+41 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 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 android.util;

		/**
		* @hide
		*/
		public class PoolFactory {
		private PoolFactory() {
		}

		public static <T extends Poolable<T>> Pool<T> simplePool(PoolableManager<T> manager) {
		return new FinitePool<T>(manager);
		}

		public static <T extends Poolable<T>> Pool<T> finitePool(PoolableManager<T> manager, int limit) {
		return new FinitePool<T>(manager, limit);
		}

		public static <T extends Poolable<T>> Pool<T> synchronizedPool(Pool<T> pool) {
		return new SynchronizedPool<T>(pool);
		}

		public static <T extends Poolable<T>> Pool<T> synchronizedPool(Pool<T> pool, Object lock) {
		return new SynchronizedPool<T>(pool, lock);
		}
		}

core/java/android/util/Poolable.java

0 → 100644

+25 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 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 android.util;

		/**
		* @hide
		*/
		public interface Poolable<T> {
		void setNextPoolable(T element);
		T getNextPoolable();
		}

core/java/android/util/PoolableManager.java

0 → 100644

+27 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 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 android.util;

		/**
		* @hide
		*/
		public interface PoolableManager<T extends Poolable<T>> {
		T newInstance();

		void onAcquired(T element);
		void onReleased(T element);
		}