1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
/*
* Copyright (C) 2013 Square, Inc.
*
* 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.squareup.picasso;
import android.graphics.Bitmap;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import static android.os.Process.THREAD_PRIORITY_BACKGROUND;
class Stats {
private static final int CACHE_HIT = 0;
private static final int CACHE_MISS = 1;
private static final int BITMAP_DECODE_FINISHED = 2;
private static final int BITMAP_TRANSFORMED_FINISHED = 3;
private static final String STATS_THREAD_NAME = Utils.THREAD_PREFIX + "Stats";
final HandlerThread statsThread;
final Cache cache;
final Handler handler;
long cacheHits;
long cacheMisses;
long totalOriginalBitmapSize;
long totalTransformedBitmapSize;
long averageOriginalBitmapSize;
long averageTransformedBitmapSize;
int originalBitmapCount;
int transformedBitmapCount;
Stats(Cache cache) {
this.cache = cache;
this.statsThread = new HandlerThread(STATS_THREAD_NAME, THREAD_PRIORITY_BACKGROUND);
this.statsThread.start();
this.handler = new StatsHandler(statsThread.getLooper(), this);
}
void dispatchBitmapDecoded(Bitmap bitmap) {
processBitmap(bitmap, BITMAP_DECODE_FINISHED);
}
void dispatchBitmapTransformed(Bitmap bitmap) {
processBitmap(bitmap, BITMAP_TRANSFORMED_FINISHED);
}
void dispatchCacheHit() {
handler.sendEmptyMessage(CACHE_HIT);
}
void dispatchCacheMiss() {
handler.sendEmptyMessage(CACHE_MISS);
}
void shutdown() {
statsThread.quit();
}
void performCacheHit() {
cacheHits++;
}
void performCacheMiss() {
cacheMisses++;
}
void performBitmapDecoded(long size) {
originalBitmapCount++;
totalOriginalBitmapSize += size;
averageOriginalBitmapSize = getAverage(originalBitmapCount, totalOriginalBitmapSize);
}
void performBitmapTransformed(long size) {
transformedBitmapCount++;
totalTransformedBitmapSize += size;
averageTransformedBitmapSize = getAverage(originalBitmapCount, totalTransformedBitmapSize);
}
synchronized StatsSnapshot createSnapshot() {
return new StatsSnapshot(cache.maxSize(), cache.size(), cacheHits, cacheMisses,
totalOriginalBitmapSize, totalTransformedBitmapSize, averageOriginalBitmapSize,
averageTransformedBitmapSize, originalBitmapCount, transformedBitmapCount,
System.currentTimeMillis());
}
private void processBitmap(Bitmap bitmap, int what) {
// Never send bitmaps to the handler as they could be recycled before we process them.
int bitmapSize = Utils.getBitmapBytes(bitmap);
handler.sendMessage(handler.obtainMessage(what, bitmapSize, 0));
}
private static long getAverage(int count, long totalSize) {
return totalSize / count;
}
private static class StatsHandler extends Handler {
private final Stats stats;
public StatsHandler(Looper looper, Stats stats) {
super(looper);
this.stats = stats;
}
@Override public void handleMessage(final Message msg) {
switch (msg.what) {
case CACHE_HIT:
stats.performCacheHit();
break;
case CACHE_MISS:
stats.performCacheMiss();
break;
case BITMAP_DECODE_FINISHED:
stats.performBitmapDecoded(msg.arg1);
break;
case BITMAP_TRANSFORMED_FINISHED:
stats.performBitmapTransformed(msg.arg1);
break;
default:
Picasso.HANDLER.post(new Runnable() {
@Override public void run() {
throw new AssertionError("Unhandled stats message." + msg.what);
}
});
}
}
}
}
|
