3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.github.play.widget;
17 |
18 | import static android.graphics.Bitmap.CompressFormat.PNG;
19 | import static android.graphics.Bitmap.Config.ARGB_8888;
20 | import static com.github.kevinsawicki.http.HttpRequest.CHARSET_UTF8;
21 | import android.app.Activity;
22 | import android.content.Context;
23 | import android.content.res.Resources;
24 | import android.graphics.Bitmap;
25 | import android.graphics.BitmapFactory;
26 | import android.graphics.BitmapFactory.Options;
27 | import android.graphics.Point;
28 | import android.graphics.drawable.BitmapDrawable;
29 | import android.graphics.drawable.Drawable;
30 | import android.graphics.drawable.LayerDrawable;
31 | import android.util.Log;
32 | import android.util.SparseArray;
33 | import android.widget.ImageView;
34 |
35 | import com.github.play.R.id;
36 | import com.github.play.core.PlayService;
37 | import com.github.play.core.Song;
38 |
39 | import java.io.File;
40 | import java.io.FileNotFoundException;
41 | import java.io.FileOutputStream;
42 | import java.io.IOException;
43 | import java.io.UnsupportedEncodingException;
44 | import java.math.BigInteger;
45 | import java.security.MessageDigest;
46 | import java.security.NoSuchAlgorithmException;
47 | import java.util.Arrays;
48 | import java.util.LinkedHashMap;
49 | import java.util.Map;
50 | import java.util.concurrent.Executor;
51 | import java.util.concurrent.Executors;
52 | import java.util.concurrent.atomic.AtomicReference;
53 |
54 | /**
55 | * View wrapper to load and display art for a {@link Song}
56 | */
57 | public class SongArtWrapper {
58 |
59 | /**
60 | * Get cached art for song
61 | *
62 | * @param context
63 | * @param song
64 | * @return art or null if not available locally
65 | */
66 | public static Bitmap getCachedArt(final Context context, final Song song) {
67 | File file = getArtFile(getArtDirectory(context), song);
68 | if (!isValid(file))
69 | return null;
70 |
71 | Options options = new Options();
72 | options.inDither = false;
73 | options.inPreferredConfig = ARGB_8888;
74 | Bitmap decoded = BitmapFactory.decodeFile(file.getAbsolutePath(),
75 | options);
76 | if (decoded == null)
77 | Log.d(TAG, "Decoding " + file.getName() + " failed");
78 | return decoded;
79 | }
80 |
81 | private static final String TAG = "SongArtWrapper";
82 |
83 | private static final int DIGEST_LENGTH = 40;
84 |
85 | private static final Executor EXECUTORS = Executors.newFixedThreadPool(1);
86 |
87 | private static final int MAX_RECENT = 50;
88 |
89 | private static final int MAX_SIZE_DP = 80;
90 |
91 | private static final MessageDigest SHA1_DIGEST;
92 |
93 | private static final String ART_FOLDER = "art";
94 |
95 | /**
96 | * Version of art to display
97 | *
98 | * This counter should be incremented when {@link #MAX_SIZE_DP} changes or
99 | * if old art should be cleared and re-downloaded
100 | */
101 | private static final int ART_VERSION = 1;
102 |
103 | static {
104 | MessageDigest digest;
105 | try {
106 | digest = MessageDigest.getInstance("SHA-1");
107 | } catch (NoSuchAlgorithmException e) {
108 | digest = null;
109 | }
110 | SHA1_DIGEST = digest;
111 | }
112 |
113 | private static final SparseArray> RECENT_ART = new SparseArray>(
114 | 2);
115 |
116 | private static final SparseArray EMPTY_ART = new SparseArray(
117 | 2);
118 |
119 | private static String digest(Song song) {
120 | if (SHA1_DIGEST == null)
121 | return null;
122 |
123 | byte[] value;
124 | try {
125 | value = song.getAlbumId().getBytes(CHARSET_UTF8);
126 | } catch (UnsupportedEncodingException e) {
127 | return null;
128 | }
129 |
130 | byte[] digested;
131 | synchronized (SHA1_DIGEST) {
132 | SHA1_DIGEST.reset();
133 | digested = SHA1_DIGEST.digest(value);
134 | }
135 | String hashed = new BigInteger(1, digested).toString(16);
136 | int padding = DIGEST_LENGTH - hashed.length();
137 | if (padding > 0) {
138 | char[] zeros = new char[padding];
139 | Arrays.fill(zeros, '0');
140 | hashed = new String(zeros) + hashed;
141 | }
142 | return hashed;
143 | }
144 |
145 | private static Map createCacheMap() {
146 | return new LinkedHashMap(MAX_RECENT, 1.0F) {
147 |
148 | private static final long serialVersionUID = -3434208982358063608L;
149 |
150 | @Override
151 | protected boolean removeEldestEntry(
152 | Map.Entry eldest) {
153 | return size() >= MAX_RECENT;
154 | }
155 | };
156 | }
157 |
158 | private static Drawable getCachedArt(final int drawable, final Song song) {
159 | final String digest = digest(song);
160 | if (digest != null)
161 | synchronized (RECENT_ART) {
162 | Map cache = RECENT_ART.get(drawable);
163 | return cache != null ? cache.get(digest) : null;
164 | }
165 | else
166 | return null;
167 | }
168 |
169 | private static Drawable getEmptyArt(final int drawable,
170 | final Context context) {
171 | Drawable cached = EMPTY_ART.get(drawable);
172 | if (cached == null) {
173 | cached = context.getResources().getDrawable(drawable);
174 | EMPTY_ART.put(drawable, cached);
175 | }
176 | return cached;
177 | }
178 |
179 | private static void putCachedArt(final int drawable, final Song song,
180 | final Drawable bitmap) {
181 | if (bitmap == null)
182 | return;
183 |
184 | final String digest = digest(song);
185 | if (digest != null)
186 | synchronized (RECENT_ART) {
187 | Map cache = RECENT_ART.get(drawable);
188 | if (cache == null) {
189 | cache = createCacheMap();
190 | RECENT_ART.put(drawable, cache);
191 | }
192 | cache.put(digest, bitmap);
193 | }
194 | }
195 |
196 | private static Point getSize(final File file) {
197 | final Options options = new Options();
198 | options.inJustDecodeBounds = true;
199 |
200 | BitmapFactory.decodeFile(file.getAbsolutePath(), options);
201 | if (options.outWidth <= 0 || options.outHeight <= 0)
202 | Log.d(TAG, "Decoding bounds of " + file.getName() + " failed");
203 | return new Point(options.outWidth, options.outHeight);
204 | }
205 |
206 | /**
207 | * Get art file for song
208 | *
209 | * @param parent
210 | * @param song
211 | * @return file
212 | */
213 | protected static File getArtFile(final File parent, final Song song) {
214 | return new File(parent, digest(song) + ".png");
215 | }
216 |
217 | /**
218 | * Get art directory
219 | *
220 | * @param context
221 | * @return directory for storing song art
222 | */
223 | protected static File getArtDirectory(Context context) {
224 | File artFolder = new File(context.getCacheDir(), ART_FOLDER
225 | + ART_VERSION);
226 | if (!artFolder.exists())
227 | artFolder.mkdirs();
228 | return artFolder;
229 | }
230 |
231 | /**
232 | * Is file non-null, existent and non-empty?
233 | *
234 | * @param file
235 | * @return true if valid, false otherwise
236 | */
237 | protected static boolean isValid(final File file) {
238 | return file != null && file.exists() && file.length() > 0;
239 | }
240 |
241 | private final File artFolder;
242 |
243 | private final AtomicReference service;
244 |
245 | private final int maxSize;
246 |
247 | private final Activity activity;
248 |
249 | private boolean oldArtDeleted;
250 |
251 | /**
252 | * Create view wrapper to display art for a {@link Song}
253 | *
254 | * @param activity
255 | * @param service
256 | */
257 | public SongArtWrapper(Activity activity,
258 | final AtomicReference service) {
259 | this.activity = activity;
260 | artFolder = getArtDirectory(activity);
261 | this.service = service;
262 | Resources resources = activity.getResources();
263 | maxSize = Math.round(resources.getDisplayMetrics().density
264 | * MAX_SIZE_DP + 0.5F);
265 | }
266 |
267 | /**
268 | * Decode {@link Bitmap} from given {@link File}
269 | *
270 | * @param file
271 | * @return bitmap
272 | */
273 | protected Bitmap decode(final File file) {
274 | Point size = getSize(file);
275 | int currWidth = size.x;
276 | int currHeight = size.y;
277 |
278 | int scale = 1;
279 | while (currWidth >= maxSize || currHeight >= maxSize) {
280 | currWidth /= 2;
281 | currHeight /= 2;
282 | scale *= 2;
283 | }
284 |
285 | Options options = new Options();
286 | options.inDither = false;
287 | options.inSampleSize = scale;
288 | options.inPreferredConfig = ARGB_8888;
289 | Bitmap decoded = BitmapFactory.decodeFile(file.getAbsolutePath(),
290 | options);
291 | if (decoded == null)
292 | Log.d(TAG, "Decoding " + file.getName() + " failed");
293 | return decoded;
294 | }
295 |
296 | /**
297 | * Write {@link Bitmap} to given {@link File}
298 | *
299 | * @param bitmap
300 | * @param file
301 | * @return bitmap
302 | */
303 | protected Bitmap write(final Bitmap bitmap, final File file) {
304 | FileOutputStream stream = null;
305 | try {
306 | stream = new FileOutputStream(file);
307 | if (!bitmap.compress(PNG, 100, stream))
308 | Log.d(TAG, "Compressing " + file.getName() + " failed");
309 | return bitmap;
310 | } catch (FileNotFoundException e) {
311 | return bitmap;
312 | } finally {
313 | if (stream != null)
314 | try {
315 | stream.close();
316 | } catch (IOException ignored) {
317 | // Ignored
318 | }
319 | }
320 | }
321 |
322 | private void updateDrawable(final ImageView view, final Drawable art) {
323 | view.setTag(null);
324 | view.setImageDrawable(art);
325 | }
326 |
327 | /**
328 | * Delete file or directory include child files
329 | *
330 | * @param file
331 | */
332 | private void delete(final File file) {
333 | if (!file.exists())
334 | return;
335 |
336 | if (file.isDirectory()) {
337 | Log.d(TAG, "Deleting art directory: " + file.getName());
338 | File[] children = file.listFiles();
339 | if (children != null)
340 | for (File child : children)
341 | delete(child);
342 | }
343 | file.delete();
344 | }
345 |
346 | /**
347 | * Delete art in old folders
348 | */
349 | private void deleteOldArt() {
350 | if (oldArtDeleted)
351 | return;
352 |
353 | File root = artFolder.getParentFile();
354 | delete(new File(root, ART_FOLDER));
355 | for (int i = 0; i < ART_VERSION; i++)
356 | delete(new File(root, ART_FOLDER + i));
357 | oldArtDeleted = true;
358 | }
359 |
360 | /**
361 | * Update view with art for song album
362 | *
363 | * @param artView
364 | * @param drawable
365 | * a layer drawable with an album art layer
366 | * @param song
367 | */
368 | public void update(final ImageView artView, final int drawable,
369 | final Song song) {
370 | update(artView, drawable, song, song);
371 | }
372 |
373 | /**
374 | * Update view with art for song album
375 | *
376 | * @param artView
377 | * @param drawable
378 | * a layer drawable with an album art layer
379 | * @param song
380 | * @param tag
381 | */
382 | public void update(final ImageView artView, final int drawable,
383 | final Song song, final Object tag) {
384 | if (song == null) {
385 | updateDrawable(artView, getEmptyArt(drawable, activity));
386 | return;
387 | }
388 |
389 | Drawable cachedBitmap = getCachedArt(drawable, song);
390 | if (cachedBitmap != null) {
391 | updateDrawable(artView, cachedBitmap);
392 | return;
393 | }
394 |
395 | updateDrawable(artView, getEmptyArt(drawable, activity));
396 | artView.setTag(tag);
397 |
398 | EXECUTORS.execute(new Runnable() {
399 |
400 | public void run() {
401 | deleteOldArt();
402 |
403 | Drawable image = getCachedArt(drawable, song);
404 |
405 | if (image == null) {
406 | File artFile = getArtFile(artFolder, song);
407 | Bitmap bitmap = null;
408 | if (isValid(artFile))
409 | bitmap = decode(artFile);
410 | else if (service.get().getArt(song, artFile)) {
411 | bitmap = decode(artFile);
412 | if (bitmap != null)
413 | write(bitmap, artFile);
414 | }
415 |
416 | if (bitmap != null) {
417 | image = new BitmapDrawable(artView.getResources(),
418 | bitmap);
419 | LayerDrawable layers = (LayerDrawable) activity
420 | .getResources().getDrawable(drawable);
421 | layers.setDrawableByLayerId(id.i_album_art, image);
422 | putCachedArt(drawable, song, layers);
423 | image = layers;
424 | }
425 | }
426 |
427 | final Drawable imageDrawable = image;
428 | activity.runOnUiThread(new Runnable() {
429 |
430 | public void run() {
431 | if (tag.equals(artView.getTag()))
432 | if (imageDrawable != null)
433 | updateDrawable(artView, imageDrawable);
434 | else
435 | updateDrawable(artView,
436 | getEmptyArt(drawable, activity));
437 | }
438 | });
439 | }
440 | });
441 | }
442 | }
443 |
--------------------------------------------------------------------------------
/app/src/main/java/com/github/play/app/PlayActivity.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 Kevin Sawicki
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.github.play.app;
17 |
18 | import static com.github.play.app.MusicStreamService.EXTRA_STREAMING;
19 | import static com.github.play.app.StatusService.EXTRA_UPDATE;
20 | import android.content.BroadcastReceiver;
21 | import android.content.Context;
22 | import android.content.Intent;
23 | import android.content.IntentFilter;
24 | import android.graphics.drawable.AnimationDrawable;
25 | import android.os.Bundle;
26 | import android.text.TextUtils;
27 | import android.util.Log;
28 | import android.view.View;
29 | import android.view.View.OnClickListener;
30 | import android.widget.AdapterView;
31 | import android.widget.AdapterView.OnItemClickListener;
32 | import android.widget.ListView;
33 |
34 | import com.actionbarsherlock.app.SherlockActivity;
35 | import com.actionbarsherlock.view.Menu;
36 | import com.actionbarsherlock.view.MenuItem;
37 | import com.github.kevinsawicki.wishlist.LightDialog;
38 | import com.github.kevinsawicki.wishlist.Toaster;
39 | import com.github.kevinsawicki.wishlist.ViewFinder;
40 | import com.github.kevinsawicki.wishlist.ViewUtils;
41 | import com.github.play.R.drawable;
42 | import com.github.play.R.id;
43 | import com.github.play.R.layout;
44 | import com.github.play.R.menu;
45 | import com.github.play.R.string;
46 | import com.github.play.core.DequeueSongTask;
47 | import com.github.play.core.FetchSettingsTask;
48 | import com.github.play.core.FetchStatusTask;
49 | import com.github.play.core.PlayPreferences;
50 | import com.github.play.core.PlayService;
51 | import com.github.play.core.QueueStarsTask;
52 | import com.github.play.core.Song;
53 | import com.github.play.core.SongCallback;
54 | import com.github.play.core.SongResult;
55 | import com.github.play.core.StarSongTask;
56 | import com.github.play.core.StatusUpdate;
57 | import com.github.play.core.StreamingInfo;
58 | import com.github.play.core.UnstarSongTask;
59 | import com.github.play.widget.PlayListAdapter;
60 | import com.github.play.widget.SongArtWrapper;
61 |
62 | import java.io.IOException;
63 | import java.text.MessageFormat;
64 | import java.util.concurrent.atomic.AtomicReference;
65 |
66 | /**
67 | * Activity to view what is playing and listen to music
68 | */
69 | public class PlayActivity extends SherlockActivity implements SongCallback,
70 | OnItemClickListener {
71 |
72 | /**
73 | * Action for broadcasting that the queue has been updated
74 | */
75 | public static final String ACTION_QUEUE = "com.github.play.action.QUEUE_UPDATE";
76 |
77 | private static final String TAG = "PlayActivity";
78 |
79 | private static final String STREAMING_INFO = "streamingInfo";
80 |
81 | private static final int REQUEST_SETTINGS = 1;
82 |
83 | private ListView listView;
84 |
85 | private View loadingView;
86 |
87 | private final AtomicReference playService = new AtomicReference();
88 |
89 | private View nowPlayingView;
90 |
91 | private PlayListAdapter playListAdapter;
92 |
93 | private boolean streaming;
94 |
95 | private boolean queueEmpty = true;
96 |
97 | private MenuItem playItem;
98 |
99 | private MenuItem refreshItem;
100 |
101 | private MenuItem searchItem;
102 |
103 | private MenuItem playStarsItem;
104 |
105 | private PlayPreferences settings;
106 |
107 | private StreamingInfo streamingInfo;
108 |
109 | private Song nowPlaying;
110 |
111 | private final BroadcastReceiver updateReceiver = new BroadcastReceiver() {
112 |
113 | public void onReceive(Context context, Intent intent) {
114 | StatusUpdate update = (StatusUpdate) intent
115 | .getSerializableExtra(EXTRA_UPDATE);
116 | onUpdate(update.playing, update.queued);
117 | }
118 | };
119 |
120 | private final BroadcastReceiver queueReceiver = new BroadcastReceiver() {
121 |
122 | public void onReceive(Context context, Intent intent) {
123 | runOnUiThread(new Runnable() {
124 |
125 | public void run() {
126 | refreshSongs();
127 | }
128 | });
129 | }
130 | };
131 |
132 | private final BroadcastReceiver streamReceiver = new BroadcastReceiver() {
133 |
134 | public void onReceive(Context context, Intent intent) {
135 | final boolean streaming = intent.getBooleanExtra(EXTRA_STREAMING,
136 | false);
137 | runOnUiThread(new Runnable() {
138 |
139 | public void run() {
140 | setStreaming(streaming);
141 | }
142 | });
143 | }
144 | };
145 |
146 | @Override
147 | protected void onDestroy() {
148 | super.onDestroy();
149 |
150 | if (!streaming)
151 | StatusService.stop(getApplicationContext());
152 |
153 | unregisterReceiver(updateReceiver);
154 | unregisterReceiver(streamReceiver);
155 | unregisterReceiver(queueReceiver);
156 | }
157 |
158 | @Override
159 | protected void onSaveInstanceState(Bundle outState) {
160 | super.onSaveInstanceState(outState);
161 |
162 | if (hasStreamingInfo())
163 | outState.putSerializable(STREAMING_INFO, streamingInfo);
164 | }
165 |
166 | @Override
167 | public void onCreate(Bundle savedInstanceState) {
168 | super.onCreate(savedInstanceState);
169 |
170 | setContentView(layout.main);
171 |
172 | final ViewFinder finder = new ViewFinder(this);
173 |
174 | loadingView = finder.find(id.ll_loading);
175 | loadingView.post(new Runnable() {
176 |
177 | public void run() {
178 | ((AnimationDrawable) finder.find(id.v_loading).getBackground())
179 | .start();
180 | }
181 | });
182 |
183 | playListAdapter = new PlayListAdapter(this, layout.queued, playService);
184 |
185 | listView = finder.find(android.R.id.list);
186 | listView.setOnItemClickListener(this);
187 |
188 | nowPlayingView = finder.find(id.ll_now_playing);
189 | ViewUtils.setGone(nowPlayingView, true);
190 | nowPlayingView.setOnClickListener(new OnClickListener() {
191 |
192 | public void onClick(View v) {
193 | showSongDialog(nowPlaying, 0);
194 | }
195 | });
196 | playListAdapter.initialize(nowPlayingView);
197 | listView.setAdapter(playListAdapter);
198 |
199 | if (savedInstanceState != null)
200 | streamingInfo = (StreamingInfo) savedInstanceState
201 | .getSerializable(STREAMING_INFO);
202 |
203 | settings = new PlayPreferences(this);
204 |
205 | if (hasSettings()) {
206 | playService.set(new PlayService(settings.getUrl(), settings
207 | .getToken()));
208 | load();
209 | } else
210 | startActivityForResult(new Intent(this, SettingsActivity.class),
211 | REQUEST_SETTINGS);
212 |
213 | registerReceiver(updateReceiver, new IntentFilter(StatusService.UPDATE));
214 | registerReceiver(streamReceiver, new IntentFilter(
215 | MusicStreamService.UPDATE));
216 | registerReceiver(queueReceiver, new IntentFilter(ACTION_QUEUE));
217 | }
218 |
219 | private void setStreaming(final boolean streaming) {
220 | this.streaming = streaming;
221 | updatePlayMenuItem();
222 | }
223 |
224 | private void updatePlayMenuItem() {
225 | if (playItem == null)
226 | return;
227 |
228 | if (streaming)
229 | playItem.setIcon(drawable.action_pause).setTitle(string.pause);
230 | else
231 | playItem.setIcon(drawable.action_play).setTitle(string.play);
232 | }
233 |
234 | private void startStream() {
235 | if (!hasSettings() || !hasStreamingInfo())
236 | return;
237 |
238 | Log.d(TAG, "Starting stream");
239 |
240 | setStreaming(true);
241 |
242 | Context context = getApplicationContext();
243 | MusicStreamService.start(context, streamingInfo.streamUrl);
244 | StatusService.start(context, streamingInfo.pusherKey, true, nowPlaying);
245 |
246 | refreshSongs();
247 | }
248 |
249 | private void load() {
250 | if (!hasSettings())
251 | return;
252 |
253 | if (!hasStreamingInfo())
254 | new FetchSettingsTask(playService) {
255 |
256 | protected void onPostExecute(PlaySettings result) {
257 | if (result.streamingInfo != null) {
258 | streamingInfo = result.streamingInfo;
259 | load();
260 | } else
261 | onError(result.exception);
262 | }
263 |
264 | }.execute();
265 | else if (isReady()) {
266 | setMenuItemsEnabled(true);
267 | Context context = getApplicationContext();
268 | MusicStreamService.start(context);
269 | StatusService.start(context, streamingInfo.pusherKey, nowPlaying);
270 | refreshSongs();
271 | }
272 | }
273 |
274 | private void setMenuItemsEnabled(final boolean enabled) {
275 | if (playItem != null)
276 | playItem.setEnabled(enabled && hasStreamingInfo());
277 | if (refreshItem != null)
278 | refreshItem.setEnabled(enabled);
279 | if (searchItem != null)
280 | searchItem.setEnabled(enabled);
281 | if (playStarsItem != null)
282 | playStarsItem.setEnabled(enabled);
283 | }
284 |
285 | private void stopStream() {
286 | if (!hasSettings())
287 | return;
288 |
289 | Log.d(TAG, "Stopping stream");
290 |
291 | setStreaming(false);
292 |
293 | Context context = getApplicationContext();
294 | MusicStreamService.stop(context);
295 | if (hasStreamingInfo())
296 | StatusService.start(context, streamingInfo.pusherKey, false,
297 | nowPlaying);
298 | }
299 |
300 | public void onUpdate(final Song playing, final Song[] queued) {
301 | runOnUiThread(new Runnable() {
302 |
303 | public void run() {
304 | nowPlaying = playing;
305 | updateSongs(playing, queued);
306 | }
307 | });
308 | }
309 |
310 | private void showLoading(final boolean loading) {
311 | ViewUtils.setGone(loadingView, !loading);
312 | ViewUtils.setGone(nowPlayingView, loading);
313 | ViewUtils.setGone(listView, loading);
314 | }
315 |
316 | private void updateSongs(final Song playing, final Song[] queued) {
317 | queueEmpty = playing == null && (queued == null || queued.length == 0);
318 |
319 | playListAdapter.updatePlaying(nowPlayingView, playing);
320 | playListAdapter.setItems(queued);
321 |
322 | showLoading(false);
323 | }
324 |
325 | private void refreshSongs() {
326 | if (!isReady())
327 | return;
328 |
329 | if (queueEmpty)
330 | showLoading(true);
331 |
332 | new FetchStatusTask(playService, this).execute();
333 | }
334 |
335 | private boolean hasSettings() {
336 | final PlayPreferences settings = this.settings;
337 | return settings != null && settings.getUrl() != null
338 | && settings.getToken() != null;
339 | }
340 |
341 | private boolean hasStreamingInfo() {
342 | final StreamingInfo info = streamingInfo;
343 | return info != null && !TextUtils.isEmpty(info.pusherKey)
344 | && !TextUtils.isEmpty(info.streamUrl);
345 | }
346 |
347 | private boolean isReady() {
348 | return hasSettings() && playService.get() != null;
349 | }
350 |
351 | @Override
352 | public boolean onOptionsItemSelected(MenuItem item) {
353 | switch (item.getItemId()) {
354 | case id.m_pause:
355 | if (streaming)
356 | stopStream();
357 | else
358 | startStream();
359 | return true;
360 | case id.m_refresh:
361 | refreshSongs();
362 | return true;
363 | case id.m_settings:
364 | startActivityForResult(new Intent(this, SettingsActivity.class),
365 | REQUEST_SETTINGS);
366 | return true;
367 | case id.m_search:
368 | onSearchRequested();
369 | return true;
370 | case id.m_play_stars:
371 | playStars();
372 | return true;
373 | default:
374 | return super.onOptionsItemSelected(item);
375 | }
376 |
377 | }
378 |
379 | @Override
380 | public boolean onCreateOptionsMenu(Menu optionsMenu) {
381 | getSupportMenuInflater().inflate(menu.main, optionsMenu);
382 |
383 | playItem = optionsMenu.findItem(id.m_pause);
384 | updatePlayMenuItem();
385 |
386 | refreshItem = optionsMenu.findItem(id.m_refresh);
387 | searchItem = optionsMenu.findItem(id.m_search);
388 | playStarsItem = optionsMenu.findItem(id.m_play_stars);
389 |
390 | if (isReady())
391 | setMenuItemsEnabled(true);
392 |
393 | return true;
394 | }
395 |
396 | public void onError(IOException e) {
397 | Log.d(TAG, "Play server exception", e);
398 |
399 | ViewUtils.setGone(loadingView, true);
400 |
401 | Toaster.showLong(this, string.error_contacting_play_server,
402 | e.getMessage());
403 | }
404 |
405 | @Override
406 | protected void onActivityResult(int requestCode, int resultCode, Intent data) {
407 | if (requestCode == REQUEST_SETTINGS && resultCode == RESULT_OK) {
408 | stopStream();
409 | if (hasSettings()) {
410 | playService.set(new PlayService(settings.getUrl(), settings
411 | .getToken()));
412 | streamingInfo = null;
413 | load();
414 | }
415 | return;
416 | }
417 |
418 | super.onActivityResult(requestCode, resultCode, data);
419 | }
420 |
421 | private void starSong(final Song song) {
422 | if (!isReady())
423 | return;
424 |
425 | Toaster.showShort(this, string.starring_song, song.name);
426 |
427 | new StarSongTask(playService) {
428 |
429 | @Override
430 | protected void onPostExecute(IOException result) {
431 | super.onPostExecute(result);
432 |
433 | if (result != null)
434 | Toaster.showLong(PlayActivity.this, string.starring_failed,
435 | song.name);
436 | else
437 | refreshSongs();
438 | }
439 | }.execute(song);
440 | }
441 |
442 | private void unstarSong(final Song song) {
443 | if (!isReady())
444 | return;
445 |
446 | Toaster.showShort(this, string.unstarring_song, song.name);
447 |
448 | new UnstarSongTask(playService) {
449 |
450 | @Override
451 | protected void onPostExecute(IOException result) {
452 | super.onPostExecute(result);
453 |
454 | if (result != null)
455 | Toaster.showShort(PlayActivity.this,
456 | string.unstarring_failed, song.name);
457 | else
458 | refreshSongs();
459 | }
460 | }.execute(song);
461 | }
462 |
463 | private void dequeueSong(final Song song) {
464 | if (!isReady())
465 | return;
466 |
467 | Toaster.showShort(PlayActivity.this, string.removing_song, song.name);
468 | new DequeueSongTask(playService) {
469 |
470 | @Override
471 | protected void onPostExecute(IOException result) {
472 | super.onPostExecute(result);
473 |
474 | if (result != null)
475 | Toaster.showShort(PlayActivity.this,
476 | string.removing_song_failed, song.name);
477 | else
478 | refreshSongs();
479 | }
480 | }.execute(song);
481 | }
482 |
483 | private void playStars() {
484 | if (!isReady())
485 | return;
486 |
487 | new QueueStarsTask(playService) {
488 |
489 | @Override
490 | protected void onPostExecute(SongResult result) {
491 | super.onPostExecute(result);
492 |
493 | String message;
494 | if (result.exception != null)
495 | message = getString(string.queueing_stars_failed);
496 | else if (result.songs.length > 1)
497 | message = MessageFormat.format(
498 | getString(string.multiple_songs_queued),
499 | result.songs.length);
500 | else if (result.songs.length == 1)
501 | message = getString(string.single_song_queued);
502 | else
503 | message = getString(string.no_songs_found);
504 |
505 | Toaster.showShort(PlayActivity.this, message);
506 |
507 | refreshSongs();
508 | }
509 | }.execute();
510 | }
511 |
512 | private void showSongDialog(final Song song, final double previousTime) {
513 | if (song == null)
514 | return;
515 |
516 | final LightDialog dialog = LightDialog.create(this);
517 | dialog.setCancelable(true);
518 | dialog.setCanceledOnTouchOutside(true);
519 | View dialogView = getLayoutInflater().inflate(layout.song_dialog, null);
520 | ViewFinder finder = new ViewFinder(dialogView);
521 | finder.setText(id.tv_album, song.album);
522 | finder.setText(id.tv_artist, song.artist);
523 | finder.setText(id.tv_song, song.name);
524 |
525 | long minutes = Math.round(song.duration / 60);
526 | long seconds = Math.round(song.duration / 60);
527 | if (seconds > 10)
528 | finder.setText(id.tv_duration, "Time: " + minutes + ':' + seconds);
529 | else if (seconds > 1)
530 | finder.setText(id.tv_duration, "Time: " + minutes + ":0" + seconds);
531 | else
532 | finder.setText(id.tv_duration, "Time: " + minutes + ":00");
533 |
534 | long backlog = Math.round(previousTime / 60);
535 | if (backlog > 60) {
536 | backlog = Math.round((float) backlog / 60);
537 | if (backlog > 1)
538 | finder.setText(id.tv_soon, new StringBuilder(
539 | "This song will be playing in about ").append(backlog)
540 | .append(" hours"));
541 | else
542 | finder.setText(id.tv_soon, new StringBuilder(
543 | "This song will be playing in about 1 hour"));
544 | } else if (backlog > 1)
545 | finder.setText(id.tv_soon, new StringBuilder(
546 | "This song will be playing in about ").append(backlog)
547 | .append(" minutes"));
548 | else if (backlog == 1)
549 | finder.setText(id.tv_soon, "This song will be playing in about ");
550 | else
551 | ViewUtils.setGone(finder.find(id.tv_soon), true);
552 |
553 | if (song.starred) {
554 | finder.setText(id.tv_star, string.unstar_this_song);
555 | finder.setDrawable(id.iv_star_icon, drawable.action_unstar);
556 | } else {
557 | finder.setText(id.tv_star, string.star_this_song);
558 | finder.setDrawable(id.iv_star_icon, drawable.action_star);
559 | }
560 | finder.onClick(id.rl_star_area, new Runnable() {
561 |
562 | public void run() {
563 | dialog.dismiss();
564 | if (song.starred)
565 | unstarSong(song);
566 | else
567 | starSong(song);
568 | }
569 | });
570 | finder.onClick(id.rl_remove_area, new Runnable() {
571 |
572 | public void run() {
573 | dialog.dismiss();
574 | dequeueSong(song);
575 | }
576 | });
577 | finder.onClick(id.rl_search_album_area, new Runnable() {
578 |
579 | public void run() {
580 | dialog.dismiss();
581 | startActivity(ViewAlbumActivity.createIntent(
582 | getApplicationContext(), song));
583 | }
584 | });
585 | finder.onClick(id.rl_search_artist_area, new Runnable() {
586 |
587 | public void run() {
588 | dialog.dismiss();
589 | startActivity(ViewArtistActivity.createIntent(
590 | getApplicationContext(), song));
591 | }
592 | });
593 | new SongArtWrapper(this, playService).update(
594 | finder.imageView(id.iv_art), drawable.queued_cd, song);
595 | dialog.setView(dialogView, 0, 0, 0, 0);
596 | dialog.show();
597 | }
598 |
599 | public void onItemClick(AdapterView listView, View view, int position,
600 | long itemId) {
601 | double previousTime = 0;
602 | for (int i = 0; i < position; i++)
603 | previousTime += ((Song) listView.getItemAtPosition(i)).duration;
604 | showSongDialog((Song) listView.getItemAtPosition(position),
605 | previousTime);
606 | }
607 | }
--------------------------------------------------------------------------------