From 9b321a54769e69606f625f1bd092112bd07ad7bc Mon Sep 17 00:00:00 2001 From: Vincent Brison Date: Sun, 28 Jun 2015 12:03:03 +0200 Subject: [PATCH 01/12] Remove android.support dependency. --- lib/build.gradle | 1 - .../android/dualcache/lib/DualCache.java | 2 - .../android/dualcache/lib/LruCache.java | 388 ++++++++++++++++++ .../dualcache/lib/ReferenceLRUCache.java | 2 - .../android/dualcache/lib/StringLRUCache.java | 2 - 5 files changed, 388 insertions(+), 7 deletions(-) create mode 100644 lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/LruCache.java diff --git a/lib/build.gradle b/lib/build.gradle index f4a565c..f6b9fdd 100644 --- a/lib/build.gradle +++ b/lib/build.gradle @@ -26,7 +26,6 @@ android { dependencies { compile fileTree(dir: 'libs', include: ['*.jar']) - compile 'com.android.support:support-v4:22.2.0' compile 'com.jakewharton:disklrucache:2.0.2' compile 'com.fasterxml.jackson.core:jackson-databind:2.4.2' diff --git a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/DualCache.java b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/DualCache.java index dd26a35..78d5448 100755 --- a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/DualCache.java +++ b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/DualCache.java @@ -16,8 +16,6 @@ package com.vincentbrison.openlibraries.android.dualcache.lib; -import android.support.v4.util.LruCache; - import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.core.JsonProcessingException; diff --git a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/LruCache.java b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/LruCache.java new file mode 100644 index 0000000..dca3e7e --- /dev/null +++ b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/LruCache.java @@ -0,0 +1,388 @@ +/* + * Copyright (C) 2011 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.vincentbrison.openlibraries.android.dualcache.lib; + +import java.lang.reflect.InvocationTargetException; +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * A cache that holds strong references to a limited number of values. Each time + * a value is accessed, it is moved to the head of a queue. When a value is + * added to a full cache, the value at the end of that queue is evicted and may + * become eligible for garbage collection. + * + *

If your cached values hold resources that need to be explicitly released, + * override {@link #entryRemoved}. + * + *

If a cache miss should be computed on demand for the corresponding keys, + * override {@link #create}. This simplifies the calling code, allowing it to + * assume a value will always be returned, even when there's a cache miss. + * + *

By default, the cache size is measured in the number of entries. Override + * {@link #sizeOf} to size the cache in different units. For example, this cache + * is limited to 4MiB of bitmaps: + * 

   {@code
+ *   int cacheSize = 4 * 1024 * 1024; // 4MiB
+ *   LruCache bitmapCache = new LruCache(cacheSize) {
+ *       protected int sizeOf(String key, Bitmap value) {
+ *           return value.getByteCount();
+ *       }
+ *   }}
+ * + *

This class is thread-safe. Perform multiple cache operations atomically by + * synchronizing on the cache: 

   {@code
+ *   synchronized (cache) {
+ *     if (cache.get(key) == null) {
+ *         cache.put(key, value);
+ *     }
+ *   }}
+ * + *

This class does not allow null to be used as a key or value. A return + * value of null from {@link #get}, {@link #put} or {@link #remove} is + * unambiguous: the key was not in the cache. + * + *

This class appeared in Android 3.1 (Honeycomb MR1); it's available as part + * of Android's + * Support Package for earlier releases. + */ +public class LruCache { + private final LinkedHashMap map; + + /** Size of this cache in units. Not necessarily the number of elements. */ + private int size; + private int maxSize; + + private int putCount; + private int createCount; + private int evictionCount; + private int hitCount; + private int missCount; + + /** + * @param maxSize for caches that do not override {@link #sizeOf}, this is + * the maximum number of entries in the cache. For all other caches, + * this is the maximum sum of the sizes of the entries in this cache. + */ + public LruCache(int maxSize) { + if (maxSize <= 0) { + throw new IllegalArgumentException("maxSize <= 0"); + } + this.maxSize = maxSize; + this.map = new LinkedHashMap(0, 0.75f, true); + } + + /** + * Sets the size of the cache. + * + * @param maxSize The new maximum size. + */ + public void resize(int maxSize) { + if (maxSize <= 0) { + throw new IllegalArgumentException("maxSize <= 0"); + } + + synchronized (this) { + this.maxSize = maxSize; + } + trimToSize(maxSize); + } + + /** + * Returns the value for {@code key} if it exists in the cache or can be + * created by {@code #create}. If a value was returned, it is moved to the + * head of the queue. This returns null if a value is not cached and cannot + * be created. + */ + public final V get(K key) { + if (key == null) { + throw new NullPointerException("key == null"); + } + + V mapValue; + synchronized (this) { + mapValue = map.get(key); + if (mapValue != null) { + hitCount++; + return mapValue; + } + missCount++; + } + + /* + * Attempt to create a value. This may take a long time, and the map + * may be different when create() returns. If a conflicting value was + * added to the map while create() was working, we leave that value in + * the map and release the created value. + */ + + V createdValue = create(key); + if (createdValue == null) { + return null; + } + + synchronized (this) { + createCount++; + mapValue = map.put(key, createdValue); + + if (mapValue != null) { + // There was a conflict so undo that last put + map.put(key, mapValue); + } else { + size += safeSizeOf(key, createdValue); + } + } + + if (mapValue != null) { + entryRemoved(false, key, createdValue, mapValue); + return mapValue; + } else { + trimToSize(maxSize); + return createdValue; + } + } + + /** + * Caches {@code value} for {@code key}. The value is moved to the head of + * the queue. + * + * @return the previous value mapped by {@code key}. + */ + public final V put(K key, V value) { + if (key == null || value == null) { + throw new NullPointerException("key == null || value == null"); + } + + V previous; + synchronized (this) { + putCount++; + size += safeSizeOf(key, value); + previous = map.put(key, value); + if (previous != null) { + size -= safeSizeOf(key, previous); + } + } + + if (previous != null) { + entryRemoved(false, key, previous, value); + } + + trimToSize(maxSize); + return previous; + } + + /** + * Remove the eldest entries until the total of remaining entries is at or + * below the requested size. + * + * @param maxSize the maximum size of the cache before returning. May be -1 + * to evict even 0-sized elements. + */ + public void trimToSize(int maxSize) { + while (true) { + K key; + V value; + synchronized (this) { + if (size < 0 || (map.isEmpty() && size != 0)) { + throw new IllegalStateException(getClass().getName() + + ".sizeOf() is reporting inconsistent results!"); + } + + if (size <= maxSize) { + break; + } + Map.Entry toEvict = null; + try { + toEvict = (Map.Entry) map.getClass().getMethod("eldest").invoke(map); + + } catch (NoSuchMethodException e) { + e.printStackTrace(); + } catch (InvocationTargetException e) { + e.printStackTrace(); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + if (toEvict == null) { + break; + } + key = toEvict.getKey(); + value = toEvict.getValue(); + map.remove(key); + size -= safeSizeOf(key, value); + evictionCount++; + } + entryRemoved(true, key, value, null); + } + } + + /** + * Removes the entry for {@code key} if it exists. + * + * @return the previous value mapped by {@code key}. + */ + public final V remove(K key) { + if (key == null) { + throw new NullPointerException("key == null"); + } + + V previous; + synchronized (this) { + previous = map.remove(key); + if (previous != null) { + size -= safeSizeOf(key, previous); + } + } + + if (previous != null) { + entryRemoved(false, key, previous, null); + } + + return previous; + } + + /** + * Called for entries that have been evicted or removed. This method is + * invoked when a value is evicted to make space, removed by a call to + * {@link #remove}, or replaced by a call to {@link #put}. The default + * implementation does nothing. + * + *

The method is called without synchronization: other threads may + * access the cache while this method is executing. + * + * @param evicted true if the entry is being removed to make space, false + * if the removal was caused by a {@link #put} or {@link #remove}. + * @param newValue the new value for {@code key}, if it exists. If non-null, + * this removal was caused by a {@link #put}. Otherwise it was caused by + * an eviction or a {@link #remove}. + */ + protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {} + + /** + * Called after a cache miss to compute a value for the corresponding key. + * Returns the computed value or null if no value can be computed. The + * default implementation returns null. + * + *

The method is called without synchronization: other threads may + * access the cache while this method is executing. + * + *

If a value for {@code key} exists in the cache when this method + * returns, the created value will be released with {@link #entryRemoved} + * and discarded. This can occur when multiple threads request the same key + * at the same time (causing multiple values to be created), or when one + * thread calls {@link #put} while another is creating a value for the same + * key. + */ + protected V create(K key) { + return null; + } + + private int safeSizeOf(K key, V value) { + int result = sizeOf(key, value); + if (result < 0) { + throw new IllegalStateException("Negative size: " + key + "=" + value); + } + return result; + } + + /** + * Returns the size of the entry for {@code key} and {@code value} in + * user-defined units. The default implementation returns 1 so that size + * is the number of entries and max size is the maximum number of entries. + * + *

An entry's size must not change while it is in the cache. + */ + protected int sizeOf(K key, V value) { + return 1; + } + + /** + * Clear the cache, calling {@link #entryRemoved} on each removed entry. + */ + public final void evictAll() { + trimToSize(-1); // -1 will evict 0-sized elements + } + + /** + * For caches that do not override {@link #sizeOf}, this returns the number + * of entries in the cache. For all other caches, this returns the sum of + * the sizes of the entries in this cache. + */ + public synchronized final int size() { + return size; + } + + /** + * For caches that do not override {@link #sizeOf}, this returns the maximum + * number of entries in the cache. For all other caches, this returns the + * maximum sum of the sizes of the entries in this cache. + */ + public synchronized final int maxSize() { + return maxSize; + } + + /** + * Returns the number of times {@link #get} returned a value that was + * already present in the cache. + */ + public synchronized final int hitCount() { + return hitCount; + } + + /** + * Returns the number of times {@link #get} returned null or required a new + * value to be created. + */ + public synchronized final int missCount() { + return missCount; + } + + /** + * Returns the number of times {@link #create(Object)} returned a value. + */ + public synchronized final int createCount() { + return createCount; + } + + /** + * Returns the number of times {@link #put} was called. + */ + public synchronized final int putCount() { + return putCount; + } + + /** + * Returns the number of values that have been evicted. + */ + public synchronized final int evictionCount() { + return evictionCount; + } + + /** + * Returns a copy of the current contents of the cache, ordered from least + * recently accessed to most recently accessed. + */ + public synchronized final Map snapshot() { + return new LinkedHashMap(map); + } + + @Override public synchronized final String toString() { + int accesses = hitCount + missCount; + int hitPercent = accesses != 0 ? (100 * hitCount / accesses) : 0; + return String.format("LruCache[maxSize=%d,hits=%d,misses=%d,hitRate=%d%%]", + maxSize, hitCount, missCount, hitPercent); + } +} \ No newline at end of file diff --git a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/ReferenceLRUCache.java b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/ReferenceLRUCache.java index 8111d8a..1396748 100644 --- a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/ReferenceLRUCache.java +++ b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/ReferenceLRUCache.java @@ -1,7 +1,5 @@ package com.vincentbrison.openlibraries.android.dualcache.lib; -import android.support.v4.util.LruCache; - /** * This is the LRU cache used for the RAM layer when configured to used references. * @param is the class of object stored in the cache. diff --git a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/StringLRUCache.java b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/StringLRUCache.java index 49b17a3..e5fd110 100644 --- a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/StringLRUCache.java +++ b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/StringLRUCache.java @@ -16,8 +16,6 @@ package com.vincentbrison.openlibraries.android.dualcache.lib; -import android.support.v4.util.LruCache; - import java.nio.charset.Charset; From 3425d12a7e7ef6e1c1761e08d0666a2652cb3b40 Mon Sep 17 00:00:00 2001 From: Vincent Brison Date: Sun, 28 Jun 2015 13:32:12 +0200 Subject: [PATCH 02/12] Rename LruCache class import. --- .../dualcache/lib/{LruCache.java => CustomLruCache.java} | 4 ++-- .../openlibraries/android/dualcache/lib/DualCache.java | 4 ++-- .../android/dualcache/lib/ReferenceLRUCache.java | 2 +- .../openlibraries/android/dualcache/lib/StringLRUCache.java | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) rename lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/{LruCache.java => CustomLruCache.java} (99%) diff --git a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/LruCache.java b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/CustomLruCache.java similarity index 99% rename from lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/LruCache.java rename to lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/CustomLruCache.java index dca3e7e..58b9d26 100644 --- a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/LruCache.java +++ b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/CustomLruCache.java @@ -60,7 +60,7 @@ * of Android's * Support Package for earlier releases. */ -public class LruCache { +public class CustomLruCache { private final LinkedHashMap map; /** Size of this cache in units. Not necessarily the number of elements. */ @@ -78,7 +78,7 @@ public class LruCache { * the maximum number of entries in the cache. For all other caches, * this is the maximum sum of the sizes of the entries in this cache. */ - public LruCache(int maxSize) { + public CustomLruCache(int maxSize) { if (maxSize <= 0) { throw new IllegalArgumentException("maxSize <= 0"); } diff --git a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/DualCache.java b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/DualCache.java index 78d5448..0567984 100755 --- a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/DualCache.java +++ b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/DualCache.java @@ -103,7 +103,7 @@ public enum DualCacheDiskMode { /** * RAM cache. */ - private LruCache mRamCacheLru; + private CustomLruCache mRamCacheLru; /** * Disk cache. @@ -191,7 +191,7 @@ protected void setDiskSerializer(Serializer diskSerializer) { mDiskSerializer = diskSerializer; } - protected void setRamCacheLru(LruCache ramLruCache) { + protected void setRamCacheLru(CustomLruCache ramLruCache) { mRamCacheLru = ramLruCache; } diff --git a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/ReferenceLRUCache.java b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/ReferenceLRUCache.java index 1396748..2f8ec3a 100644 --- a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/ReferenceLRUCache.java +++ b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/ReferenceLRUCache.java @@ -4,7 +4,7 @@ * This is the LRU cache used for the RAM layer when configured to used references. * @param is the class of object stored in the cache. */ -public class ReferenceLRUCache extends LruCache { +public class ReferenceLRUCache extends CustomLruCache { private SizeOf mHandlerSizeOf; diff --git a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/StringLRUCache.java b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/StringLRUCache.java index e5fd110..f1d40b4 100644 --- a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/StringLRUCache.java +++ b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/StringLRUCache.java @@ -22,7 +22,7 @@ /** * LRU cache used by the RAM cache layer when storing serialized object. */ -public class StringLRUCache extends LruCache { +public class StringLRUCache extends CustomLruCache { /** * @param maxSize for caches that do not override {@link #sizeOf}, this is From ded4a7e38e037da906ad53483d78d3a5c80873ac Mon Sep 17 00:00:00 2001 From: Vincent Brison Date: Mon, 7 Sep 2015 21:10:52 +0200 Subject: [PATCH 03/12] Prepare 2.2.0 release. --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index f9f3893..fe09183 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,4 +1,4 @@ -VERSION_NAME=2.1.0 +VERSION_NAME=2.2.0 VERSION_CODE=1 GROUP=com.vincentbrison.openlibraries.android From d5101dcf69659838ad12e7c1518f6a0d19704994 Mon Sep 17 00:00:00 2001 From: Vincent Brison Date: Mon, 7 Sep 2015 21:11:58 +0200 Subject: [PATCH 04/12] Fix #9 --- .travis.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 9c0daec..41f73dc 100644 --- a/.travis.yml +++ b/.travis.yml @@ -28,4 +28,6 @@ before_script: - adb wait-for-device && sleep 300 - adb shell input keyevent 82 & -script: ./gradlew lib:connectedAndroidTest -Ptravis --stacktrace \ No newline at end of file +script: + - ./gradlew lib:connectedAndroidTest -Ptravis --stacktrace + - ./gradlew lib:check \ No newline at end of file From 81b842a256d18cb683839cc83ee96f744d6defb8 Mon Sep 17 00:00:00 2001 From: Vincent Brison Date: Tue, 8 Sep 2015 00:43:37 +0200 Subject: [PATCH 05/12] Fix Travis conf. --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 41f73dc..20e2c4e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -30,4 +30,4 @@ before_script: script: - ./gradlew lib:connectedAndroidTest -Ptravis --stacktrace - - ./gradlew lib:check \ No newline at end of file + - ./gradlew lib:check -Ptravis --stacktrace \ No newline at end of file From 54ba2ff3c1a81392a92f0facc524360645c9c706 Mon Sep 17 00:00:00 2001 From: Vincent Brison Date: Tue, 8 Sep 2015 01:01:55 +0200 Subject: [PATCH 06/12] Fix Checkstyle. --- config/quality/checkstyle/suppressions.xml | 2 +- .../android/dualcache/lib/DualCacheDiskBuilder.java | 11 ++++++----- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/config/quality/checkstyle/suppressions.xml b/config/quality/checkstyle/suppressions.xml index 6fd5ec9..372f57a 100644 --- a/config/quality/checkstyle/suppressions.xml +++ b/config/quality/checkstyle/suppressions.xml @@ -8,5 +8,5 @@ - + \ No newline at end of file diff --git a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/DualCacheDiskBuilder.java b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/DualCacheDiskBuilder.java index 2180bff..14b43ee 100755 --- a/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/DualCacheDiskBuilder.java +++ b/lib/src/main/java/com/vincentbrison/openlibraries/android/dualcache/lib/DualCacheDiskBuilder.java @@ -78,22 +78,23 @@ private File getDefaultDiskCacheFolder(boolean usePrivateFiles) { } private DualCache useCustomSerializerInDiskIfProvided(int maxDiskSize, File diskCacheFolder, Serializer serializer) { + File crtDiskCacheFolder = diskCacheFolder; mDualCache.setDiskCacheSizeInBytes(maxDiskSize); - if(serializer == null) { + if (serializer == null) { mDualCache.setDiskMode(DualCache.DualCacheDiskMode.ENABLE_WITH_DEFAULT_SERIALIZER); } else { mDualCache.setDiskMode(DualCache.DualCacheDiskMode.ENABLE_WITH_CUSTOM_SERIALIZER); mDualCache.setDiskSerializer(serializer); } - if(diskCacheFolder == null) { - diskCacheFolder = getDefaultDiskCacheFolder(false); + if (crtDiskCacheFolder == null) { + crtDiskCacheFolder = getDefaultDiskCacheFolder(false); } try { - mDualCache.setDiskLruCache(DiskLruCache.open(diskCacheFolder, mDualCache.getAppVersion(), 1, maxDiskSize)); - mDualCache.setDiskCacheFolder(diskCacheFolder); + mDualCache.setDiskLruCache(DiskLruCache.open(crtDiskCacheFolder, mDualCache.getAppVersion(), 1, maxDiskSize)); + mDualCache.setDiskCacheFolder(crtDiskCacheFolder); } catch (IOException e) { DualCacheLogUtils.logError(e); } From 69aa370e376164247226b18fa64460a55e533e9f Mon Sep 17 00:00:00 2001 From: Vincent Brison Date: Tue, 8 Sep 2015 01:02:15 +0200 Subject: [PATCH 07/12] Let myself upload from Windows or OSX. --- lib/maven_push.gradle | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/maven_push.gradle b/lib/maven_push.gradle index 8d7fefc..da9096d 100644 --- a/lib/maven_push.gradle +++ b/lib/maven_push.gradle @@ -74,7 +74,8 @@ afterEvaluate { project -> allprojects { ext."signing.password" = ask("Please provide your key password") ext."signing.keyId" = "D376F8F6" - ext."signing.secretKeyRingFile" = "/Users/vincentbrison/.gnupg/secring.gpg" + ext."signing.secretKeyRingFile" = "C:/Users/Brize/AppData/Roaming/gnupg/secring.gpg" + //ext."signing.secretKeyRingFile" = "/Users/vincentbrison/.gnupg/secring.gpg" } required { isReleaseBuild() && gradle.taskGraph.hasTask("uploadArchives") } sign configurations.archives From a726d56f79e82c109f97725a0566ea8566379d91 Mon Sep 17 00:00:00 2001 From: Vincent Brison Date: Tue, 8 Sep 2015 01:16:08 +0200 Subject: [PATCH 08/12] Fix Findbugs task dependency. --- config/quality.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config/quality.gradle b/config/quality.gradle index 8765648..8f6d6a1 100644 --- a/config/quality.gradle +++ b/config/quality.gradle @@ -16,7 +16,7 @@ task checkstyle(type: Checkstyle) { } -task findbugs(type: FindBugs) { +task findbugs(type: FindBugs, dependsOn: assembleDebug) { ignoreFailures = false effort = "max" reportLevel = "high" From 265b4a37dc3a1099e1e580ea711b561adc92ff88 Mon Sep 17 00:00:00 2001 From: Vincent Brison Date: Tue, 8 Sep 2015 01:30:53 +0200 Subject: [PATCH 09/12] Update .travis.yml Debug Travis. --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 20e2c4e..b1346bc 100644 --- a/.travis.yml +++ b/.travis.yml @@ -30,4 +30,4 @@ before_script: script: - ./gradlew lib:connectedAndroidTest -Ptravis --stacktrace - - ./gradlew lib:check -Ptravis --stacktrace \ No newline at end of file + - ./gradlew lib:check -Ptravis --debug --stacktrace From 804785a3fcf29cde25459bef2b55b966aeec1136 Mon Sep 17 00:00:00 2001 From: Vincent Brison Date: Tue, 8 Sep 2015 10:39:47 +0200 Subject: [PATCH 10/12] Update quality.gradle Remove app findbugs. --- config/quality.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config/quality.gradle b/config/quality.gradle index 8f6d6a1..ff8218d 100644 --- a/config/quality.gradle +++ b/config/quality.gradle @@ -21,7 +21,7 @@ task findbugs(type: FindBugs, dependsOn: assembleDebug) { effort = "max" reportLevel = "high" excludeFilter = new File("${project.rootDir}/config/quality/findbugs/findbugs-filter.xml") - classes = files("${project.rootDir}/app/build/intermediates/classes") + files("${project.rootDir}/lib/build/intermediates/classes") + classes = files("${project.rootDir}/lib/build/intermediates/classes") source 'src/main/java' include '**/*.java' From f1c487a0cf2672d68b61f8986333577925fd070f Mon Sep 17 00:00:00 2001 From: Vincent Brison Date: Tue, 8 Sep 2015 11:18:31 +0200 Subject: [PATCH 11/12] Update pmd-ruleset.xml Update PMD conf --- config/quality/pmd/pmd-ruleset.xml | 39 ++++++++++++++++++++++-------- 1 file changed, 29 insertions(+), 10 deletions(-) diff --git a/config/quality/pmd/pmd-ruleset.xml b/config/quality/pmd/pmd-ruleset.xml index 4e007f7..0485668 100644 --- a/config/quality/pmd/pmd-ruleset.xml +++ b/config/quality/pmd/pmd-ruleset.xml @@ -1,4 +1,20 @@ + + .*/R.java .*/gen/.* - + - - - - - - - - + + + + + + + + + + + @@ -30,4 +49,4 @@ - \ No newline at end of file + From 3d4dfeb8e3ec943e7c5b547bda6de8aad4b78a2a Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 8 Sep 2015 13:27:20 +0200 Subject: [PATCH 12/12] Fix PMD. --- .travis.yml | 2 +- config/quality/pmd/pmd-ruleset.xml | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index b1346bc..5e33e9b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -30,4 +30,4 @@ before_script: script: - ./gradlew lib:connectedAndroidTest -Ptravis --stacktrace - - ./gradlew lib:check -Ptravis --debug --stacktrace + - ./gradlew lib:check -Ptravis --stacktrace diff --git a/config/quality/pmd/pmd-ruleset.xml b/config/quality/pmd/pmd-ruleset.xml index 0485668..35a5492 100644 --- a/config/quality/pmd/pmd-ruleset.xml +++ b/config/quality/pmd/pmd-ruleset.xml @@ -24,6 +24,7 @@ .*/R.java .*/gen/.* + .*/CustomLruCache.java