AlbumSetPage.java revision 57cbaa1ef40d2215c6400f5ae4af3a09e67abb2d 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
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
17package com.android.gallery3d.app;
18
19import android.app.Activity;
20import android.content.Context;
21import android.content.Intent;
22import android.graphics.Rect;
23import android.os.Bundle;
24import android.os.Vibrator;
25import android.provider.MediaStore;
26import android.view.ActionMode;
27import android.view.Menu;
28import android.view.MenuInflater;
29import android.view.MenuItem;
30import android.widget.Toast;
31
32import com.android.gallery3d.R;
33import com.android.gallery3d.common.Utils;
34import com.android.gallery3d.data.DataManager;
35import com.android.gallery3d.data.MediaDetails;
36import com.android.gallery3d.data.MediaObject;
37import com.android.gallery3d.data.MediaSet;
38import com.android.gallery3d.data.Path;
39import com.android.gallery3d.picasasource.PicasaSource;
40import com.android.gallery3d.settings.GallerySettings;
41import com.android.gallery3d.ui.ActionModeHandler;
42import com.android.gallery3d.ui.ActionModeHandler.ActionModeListener;
43import com.android.gallery3d.ui.AlbumSetView;
44import com.android.gallery3d.ui.DetailsHelper;
45import com.android.gallery3d.ui.DetailsHelper.CloseListener;
46import com.android.gallery3d.util.GalleryUtils;
47import com.android.gallery3d.ui.GLCanvas;
48import com.android.gallery3d.ui.GLView;
49import com.android.gallery3d.ui.GridDrawer;
50import com.android.gallery3d.ui.HighlightDrawer;
51import com.android.gallery3d.ui.PositionProvider;
52import com.android.gallery3d.ui.PositionRepository;
53import com.android.gallery3d.ui.PositionRepository.Position;
54import com.android.gallery3d.ui.SelectionManager;
55import com.android.gallery3d.ui.SlotView;
56import com.android.gallery3d.ui.StaticBackground;
57import com.android.gallery3d.util.Future;
58import com.android.gallery3d.util.GalleryUtils;
59
60public class AlbumSetPage extends ActivityState implements
61        SelectionManager.SelectionListener, GalleryActionBar.ClusterRunner,
62        EyePosition.EyePositionListener, MediaSet.SyncListener {
63    @SuppressWarnings("unused")
64    private static final String TAG = "AlbumSetPage";
65
66    public static final String KEY_MEDIA_PATH = "media-path";
67    public static final String KEY_SET_TITLE = "set-title";
68    public static final String KEY_SET_SUBTITLE = "set-subtitle";
69    public static final String KEY_SELECTED_CLUSTER_TYPE = "selected-cluster";
70
71    private static final int DATA_CACHE_SIZE = 256;
72    private static final int REQUEST_DO_ANIMATION = 1;
73    private static final int MSG_GOTO_MANAGE_CACHE_PAGE = 1;
74
75    private boolean mIsActive = false;
76    private StaticBackground mStaticBackground;
77    private AlbumSetView mAlbumSetView;
78
79    private MediaSet mMediaSet;
80    private String mSubtitle;
81    private boolean mShowClusterMenu;
82    private int mSelectedAction;
83    private Vibrator mVibrator;
84
85    protected SelectionManager mSelectionManager;
86    private AlbumSetDataAdapter mAlbumSetDataAdapter;
87    private GridDrawer mGridDrawer;
88    private HighlightDrawer mHighlightDrawer;
89
90    private boolean mGetContent;
91    private boolean mGetAlbum;
92    private ActionMode mActionMode;
93    private ActionModeHandler mActionModeHandler;
94    private DetailsHelper mDetailsHelper;
95    private MyDetailsSource mDetailsSource;
96    private boolean mShowDetails;
97    private EyePosition mEyePosition;
98
99    // The eyes' position of the user, the origin is at the center of the
100    // device and the unit is in pixels.
101    private float mX;
102    private float mY;
103    private float mZ;
104
105    private Future<Integer> mSyncTask = null;
106
107    private final GLView mRootPane = new GLView() {
108        private final float mMatrix[] = new float[16];
109
110        @Override
111        protected void onLayout(
112                boolean changed, int left, int top, int right, int bottom) {
113            mStaticBackground.layout(0, 0, right - left, bottom - top);
114            mEyePosition.resetPosition();
115
116            int slotViewTop = GalleryActionBar.getHeight((Activity) mActivity);
117            int slotViewBottom = bottom - top;
118            int slotViewRight = right - left;
119
120            if (mShowDetails) {
121                mDetailsHelper.layout(left, slotViewTop, right, bottom);
122            } else {
123                mAlbumSetView.setSelectionDrawer(mGridDrawer);
124            }
125
126            mAlbumSetView.layout(0, slotViewTop, slotViewRight, slotViewBottom);
127            PositionRepository.getInstance(mActivity).setOffset(
128                    0, slotViewTop);
129        }
130
131        @Override
132        protected void render(GLCanvas canvas) {
133            canvas.save(GLCanvas.SAVE_FLAG_MATRIX);
134            GalleryUtils.setViewPointMatrix(mMatrix,
135                    getWidth() / 2 + mX, getHeight() / 2 + mY, mZ);
136            canvas.multiplyMatrix(mMatrix, 0);
137            super.render(canvas);
138            canvas.restore();
139        }
140    };
141
142    @Override
143    public void onEyePositionChanged(float x, float y, float z) {
144        mRootPane.lockRendering();
145        mX = x;
146        mY = y;
147        mZ = z;
148        mRootPane.unlockRendering();
149        mRootPane.invalidate();
150    }
151
152    @Override
153    public void onBackPressed() {
154        if (mShowDetails) {
155            hideDetails();
156        } else if (mSelectionManager.inSelectionMode()) {
157            mSelectionManager.leaveSelectionMode();
158        } else {
159            mAlbumSetView.savePositions(
160                    PositionRepository.getInstance(mActivity));
161            super.onBackPressed();
162        }
163    }
164
165    private void savePositions(int slotIndex, int center[]) {
166        Rect offset = new Rect();
167        mRootPane.getBoundsOf(mAlbumSetView, offset);
168        mAlbumSetView.savePositions(PositionRepository.getInstance(mActivity));
169        Rect r = mAlbumSetView.getSlotRect(slotIndex);
170        int scrollX = mAlbumSetView.getScrollX();
171        int scrollY = mAlbumSetView.getScrollY();
172        center[0] = offset.left + (r.left + r.right) / 2 - scrollX;
173        center[1] = offset.top + (r.top + r.bottom) / 2 - scrollY;
174    }
175
176    public void onSingleTapUp(int slotIndex) {
177        MediaSet targetSet = mAlbumSetDataAdapter.getMediaSet(slotIndex);
178        if (targetSet == null) return; // Content is dirty, we shall reload soon
179
180        if (mShowDetails) {
181            Path path = targetSet.getPath();
182            mHighlightDrawer.setHighlightItem(path);
183            mDetailsHelper.reloadDetails(slotIndex);
184        } else if (!mSelectionManager.inSelectionMode()) {
185            Bundle data = new Bundle(getData());
186            String mediaPath = targetSet.getPath().toString();
187            int[] center = new int[2];
188            savePositions(slotIndex, center);
189            data.putIntArray(AlbumPage.KEY_SET_CENTER, center);
190            if (mGetAlbum && targetSet.isLeafAlbum()) {
191                Activity activity = (Activity) mActivity;
192                Intent result = new Intent()
193                        .putExtra(AlbumPicker.KEY_ALBUM_PATH, targetSet.getPath().toString());
194                activity.setResult(Activity.RESULT_OK, result);
195                activity.finish();
196            } else if (targetSet.getSubMediaSetCount() > 0) {
197                data.putString(AlbumSetPage.KEY_MEDIA_PATH, mediaPath);
198                mActivity.getStateManager().startStateForResult(
199                        AlbumSetPage.class, REQUEST_DO_ANIMATION, data);
200            } else {
201                if (!mGetContent && (targetSet.getSupportedOperations()
202                        & MediaObject.SUPPORT_IMPORT) != 0) {
203                    data.putBoolean(AlbumPage.KEY_AUTO_SELECT_ALL, true);
204                }
205                data.putString(AlbumPage.KEY_MEDIA_PATH, mediaPath);
206                boolean inAlbum = mActivity.getStateManager().hasStateClass(AlbumPage.class);
207                // We only show cluster menu in the first AlbumPage in stack
208                data.putBoolean(AlbumPage.KEY_SHOW_CLUSTER_MENU, !inAlbum);
209                mActivity.getStateManager().startStateForResult(
210                        AlbumPage.class, REQUEST_DO_ANIMATION, data);
211            }
212        } else {
213            mSelectionManager.toggle(targetSet.getPath());
214            mAlbumSetView.invalidate();
215        }
216    }
217
218    private void onDown(int index) {
219        MediaSet set = mAlbumSetDataAdapter.getMediaSet(index);
220        Path path = (set == null) ? null : set.getPath();
221        mSelectionManager.setPressedPath(path);
222        mAlbumSetView.invalidate();
223    }
224
225    private void onUp() {
226        mSelectionManager.setPressedPath(null);
227        mAlbumSetView.invalidate();
228    }
229
230    public void onLongTap(int slotIndex) {
231        if (mGetContent || mGetAlbum) return;
232        if (mShowDetails) {
233            onSingleTapUp(slotIndex);
234        } else {
235            MediaSet set = mAlbumSetDataAdapter.getMediaSet(slotIndex);
236            if (set == null) return;
237            mSelectionManager.setAutoLeaveSelectionMode(true);
238            mSelectionManager.toggle(set.getPath());
239            mDetailsSource.findIndex(slotIndex);
240            mAlbumSetView.invalidate();
241        }
242    }
243
244    public void doCluster(int clusterType) {
245        String basePath = mMediaSet.getPath().toString();
246        String newPath = FilterUtils.switchClusterPath(basePath, clusterType);
247        Bundle data = new Bundle(getData());
248        data.putString(AlbumSetPage.KEY_MEDIA_PATH, newPath);
249        data.putInt(KEY_SELECTED_CLUSTER_TYPE, clusterType);
250        mAlbumSetView.savePositions(PositionRepository.getInstance(mActivity));
251        mActivity.getStateManager().switchState(this, AlbumSetPage.class, data);
252    }
253
254    public void doFilter(int filterType) {
255        String basePath = mMediaSet.getPath().toString();
256        String newPath = FilterUtils.switchFilterPath(basePath, filterType);
257        Bundle data = new Bundle(getData());
258        data.putString(AlbumSetPage.KEY_MEDIA_PATH, newPath);
259        mAlbumSetView.savePositions(PositionRepository.getInstance(mActivity));
260        mActivity.getStateManager().switchState(this, AlbumSetPage.class, data);
261    }
262
263    public void onOperationComplete() {
264        mAlbumSetView.invalidate();
265        // TODO: enable animation
266    }
267
268    @Override
269    public void onCreate(Bundle data, Bundle restoreState) {
270        initializeViews();
271        initializeData(data);
272        Context context = mActivity.getAndroidContext();
273        mGetContent = data.getBoolean(Gallery.KEY_GET_CONTENT, false);
274        mGetAlbum = data.getBoolean(Gallery.KEY_GET_ALBUM, false);
275        mSubtitle = data.getString(AlbumSetPage.KEY_SET_SUBTITLE);
276        mEyePosition = new EyePosition(context, this);
277        mDetailsSource = new MyDetailsSource();
278        mVibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
279        GalleryActionBar actionBar = mActivity.getGalleryActionBar();
280        if (actionBar != null) {
281            mSelectedAction = data.getInt(
282                    AlbumSetPage.KEY_SELECTED_CLUSTER_TYPE, FilterUtils.CLUSTER_BY_ALBUM);
283        }
284        startTransition();
285    }
286
287    @Override
288    public void onPause() {
289        super.onPause();
290        mIsActive = false;
291        mActionModeHandler.pause();
292        mAlbumSetDataAdapter.pause();
293        mAlbumSetView.pause();
294        mEyePosition.pause();
295        DetailsHelper.pause();
296        GalleryActionBar actionBar = mActivity.getGalleryActionBar();
297        if (actionBar != null) actionBar.hideClusterMenu();
298        if (mSyncTask != null) {
299            mSyncTask.cancel();
300            mSyncTask = null;
301        }
302    }
303
304    @Override
305    public void onResume() {
306        super.onResume();
307        mIsActive = true;
308        setContentPane(mRootPane);
309        mAlbumSetDataAdapter.resume();
310        mAlbumSetView.resume();
311        mEyePosition.resume();
312        mActionModeHandler.resume();
313        GalleryActionBar actionBar = mActivity.getGalleryActionBar();
314        if (mShowClusterMenu && actionBar != null) {
315            actionBar.showClusterMenu(mSelectedAction, this);
316        }
317    }
318
319    private void initializeData(Bundle data) {
320        String mediaPath = data.getString(AlbumSetPage.KEY_MEDIA_PATH);
321        mMediaSet = mActivity.getDataManager().getMediaSet(mediaPath);
322        mSelectionManager.setSourceMediaSet(mMediaSet);
323        mAlbumSetDataAdapter = new AlbumSetDataAdapter(
324                mActivity, mMediaSet, DATA_CACHE_SIZE);
325        mAlbumSetDataAdapter.setLoadingListener(new MyLoadingListener());
326        mAlbumSetView.setModel(mAlbumSetDataAdapter);
327    }
328
329    private void initializeViews() {
330        mSelectionManager = new SelectionManager(mActivity, true);
331        mSelectionManager.setSelectionListener(this);
332        mStaticBackground = new StaticBackground(mActivity.getAndroidContext());
333        mRootPane.addComponent(mStaticBackground);
334
335        mGridDrawer = new GridDrawer((Context) mActivity, mSelectionManager);
336        Config.AlbumSetPage config = Config.AlbumSetPage.get((Context) mActivity);
337        mAlbumSetView = new AlbumSetView(mActivity, mGridDrawer,
338                config.slotViewSpec, config.labelSpec);
339        mAlbumSetView.setListener(new SlotView.SimpleListener() {
340            @Override
341            public void onDown(int index) {
342                AlbumSetPage.this.onDown(index);
343            }
344
345            @Override
346            public void onUp() {
347                AlbumSetPage.this.onUp();
348            }
349
350            @Override
351            public void onSingleTapUp(int slotIndex) {
352                AlbumSetPage.this.onSingleTapUp(slotIndex);
353            }
354
355            @Override
356            public void onLongTap(int slotIndex) {
357                AlbumSetPage.this.onLongTap(slotIndex);
358            }
359        });
360
361        mActionModeHandler = new ActionModeHandler(mActivity, mSelectionManager);
362        mActionModeHandler.setActionModeListener(new ActionModeListener() {
363            public boolean onActionItemClicked(MenuItem item) {
364                return onItemSelected(item);
365            }
366        });
367        mRootPane.addComponent(mAlbumSetView);
368
369        mStaticBackground.setImage(R.drawable.background,
370                R.drawable.background_portrait);
371    }
372
373    @Override
374    protected boolean onCreateActionBar(Menu menu) {
375        Activity activity = (Activity) mActivity;
376        GalleryActionBar actionBar = mActivity.getGalleryActionBar();
377        MenuInflater inflater = activity.getMenuInflater();
378
379        final boolean inAlbum = mActivity.getStateManager().hasStateClass(
380                AlbumPage.class);
381
382        if (mGetContent) {
383            inflater.inflate(R.menu.pickup, menu);
384            int typeBits = mData.getInt(
385                    Gallery.KEY_TYPE_BITS, DataManager.INCLUDE_IMAGE);
386            int id = R.string.select_image;
387            if ((typeBits & DataManager.INCLUDE_VIDEO) != 0) {
388                id = (typeBits & DataManager.INCLUDE_IMAGE) == 0
389                        ? R.string.select_video
390                        : R.string.select_item;
391            }
392            actionBar.setTitle(id);
393        } else  if (mGetAlbum) {
394            inflater.inflate(R.menu.pickup, menu);
395            actionBar.setTitle(R.string.select_album);
396        } else {
397            mShowClusterMenu = !inAlbum;
398            inflater.inflate(R.menu.albumset, menu);
399            actionBar.setTitle(null);
400            MenuItem selectItem = menu.findItem(R.id.action_select);
401
402            if (selectItem != null) {
403                boolean selectAlbums = !inAlbum &&
404                        actionBar.getClusterTypeAction() == FilterUtils.CLUSTER_BY_ALBUM;
405                if (selectAlbums) {
406                    selectItem.setTitle(R.string.select_album);
407                } else {
408                    selectItem.setTitle(R.string.select_group);
409                }
410            }
411
412            MenuItem switchCamera = menu.findItem(R.id.action_camera);
413            if (switchCamera != null) {
414                switchCamera.setVisible(GalleryUtils.isCameraAvailable(activity));
415            }
416
417            actionBar.setSubtitle(mSubtitle);
418        }
419        return true;
420    }
421
422    @Override
423    protected boolean onItemSelected(MenuItem item) {
424        Activity activity = (Activity) mActivity;
425        switch (item.getItemId()) {
426            case R.id.action_cancel:
427                activity.setResult(Activity.RESULT_CANCELED);
428                activity.finish();
429                return true;
430            case R.id.action_select:
431                mSelectionManager.setAutoLeaveSelectionMode(false);
432                mSelectionManager.enterSelectionMode();
433                return true;
434            case R.id.action_details:
435                if (mAlbumSetDataAdapter.size() != 0) {
436                    if (mShowDetails) {
437                        hideDetails();
438                    } else {
439                        showDetails();
440                    }
441                } else {
442                    Toast.makeText(activity,
443                            activity.getText(R.string.no_albums_alert),
444                            Toast.LENGTH_SHORT).show();
445                }
446                return true;
447            case R.id.action_camera: {
448                Intent intent = new Intent(MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA)
449                        .setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP
450                        | Intent.FLAG_ACTIVITY_NEW_TASK);
451                activity.startActivity(intent);
452                return true;
453            }
454            case R.id.action_manage_offline: {
455                Bundle data = new Bundle();
456                String mediaPath = mActivity.getDataManager().getTopSetPath(
457                    DataManager.INCLUDE_ALL);
458                data.putString(AlbumSetPage.KEY_MEDIA_PATH, mediaPath);
459                mActivity.getStateManager().startState(ManageCachePage.class, data);
460                return true;
461            }
462            case R.id.action_sync_picasa_albums: {
463                PicasaSource.requestSync(activity);
464                return true;
465            }
466            case R.id.action_settings: {
467                activity.startActivity(new Intent(activity, GallerySettings.class));
468                return true;
469            }
470            default:
471                return false;
472        }
473    }
474
475    @Override
476    protected void onStateResult(int requestCode, int resultCode, Intent data) {
477        switch (requestCode) {
478            case REQUEST_DO_ANIMATION: {
479                startTransition();
480            }
481        }
482    }
483
484    private void startTransition() {
485        final PositionRepository repository =
486                PositionRepository.getInstance(mActivity);
487        mAlbumSetView.startTransition(new PositionProvider() {
488            private final Position mTempPosition = new Position();
489            public Position getPosition(long identity, Position target) {
490                Position p = repository.get(identity);
491                if (p == null) {
492                    p = mTempPosition;
493                    p.set(target.x, target.y, 128, target.theta, 1);
494                }
495                return p;
496            }
497        });
498    }
499
500    private String getSelectedString() {
501        GalleryActionBar actionBar = mActivity.getGalleryActionBar();
502        int count = mSelectionManager.getSelectedCount();
503        int action = actionBar.getClusterTypeAction();
504        int string = action == FilterUtils.CLUSTER_BY_ALBUM
505                ? R.plurals.number_of_albums_selected
506                : R.plurals.number_of_groups_selected;
507        String format = mActivity.getResources().getQuantityString(string, count);
508        return String.format(format, count);
509    }
510
511    public void onSelectionModeChange(int mode) {
512
513        switch (mode) {
514            case SelectionManager.ENTER_SELECTION_MODE: {
515                mActivity.getGalleryActionBar().hideClusterMenu();
516                mActionMode = mActionModeHandler.startActionMode();
517                mVibrator.vibrate(100);
518                break;
519            }
520            case SelectionManager.LEAVE_SELECTION_MODE: {
521                mActionMode.finish();
522                mActivity.getGalleryActionBar().showClusterMenu(mSelectedAction, this);
523                mRootPane.invalidate();
524                break;
525            }
526            case SelectionManager.SELECT_ALL_MODE: {
527                mActionModeHandler.setTitle(getSelectedString());
528                mRootPane.invalidate();
529                break;
530            }
531        }
532    }
533
534    public void onSelectionChange(Path path, boolean selected) {
535        Utils.assertTrue(mActionMode != null);
536        mActionModeHandler.setTitle(getSelectedString());
537        mActionModeHandler.updateSupportedOperation(path, selected);
538    }
539
540    private void hideDetails() {
541        mShowDetails = false;
542        mDetailsHelper.hide();
543        mAlbumSetView.setSelectionDrawer(mGridDrawer);
544        mAlbumSetView.invalidate();
545    }
546
547    private void showDetails() {
548        mShowDetails = true;
549        if (mDetailsHelper == null) {
550            mHighlightDrawer = new HighlightDrawer(mActivity.getAndroidContext(),
551                    mSelectionManager);
552            mDetailsHelper = new DetailsHelper(mActivity, mRootPane, mDetailsSource);
553            mDetailsHelper.setCloseListener(new CloseListener() {
554                public void onClose() {
555                    hideDetails();
556                }
557            });
558        }
559        mAlbumSetView.setSelectionDrawer(mHighlightDrawer);
560        mDetailsHelper.show();
561    }
562
563    @Override
564    public void onSyncDone(final MediaSet mediaSet, final int resultCode) {
565        if (resultCode == MediaSet.SYNC_RESULT_ERROR) {
566            Log.d(TAG, "onSyncDone: " + Utils.maskDebugInfo(mediaSet.getName()) + " result="
567                    + resultCode);
568        }
569        ((Activity) mActivity).runOnUiThread(new Runnable() {
570            @Override
571            public void run() {
572                if (!mIsActive) return;
573                mediaSet.notifyContentChanged(); // force reload to handle spinner
574
575                if (resultCode == MediaSet.SYNC_RESULT_ERROR) {
576                    Toast.makeText((Context) mActivity, R.string.sync_album_set_error,
577                            Toast.LENGTH_LONG).show();
578                }
579            }
580        });
581    }
582
583    private class MyLoadingListener implements LoadingListener {
584        public void onLoadingStarted() {
585            GalleryUtils.setSpinnerVisibility((Activity) mActivity, true);
586        }
587
588        public void onLoadingFinished() {
589            if (!mIsActive) return;
590
591            if (mSyncTask == null) {
592                // Request sync in case the mediaSet hasn't been sync'ed before.
593                mSyncTask = mMediaSet.requestSync(AlbumSetPage.this);
594            }
595            if (mSyncTask.isDone()){
596                // The mediaSet is in sync. Turn off the loading indicator.
597                GalleryUtils.setSpinnerVisibility((Activity) mActivity, false);
598
599                // Only show toast when there's no album and we are going to finish
600                // the page. Toast is redundant if we are going to stay on this page.
601                if ((mAlbumSetDataAdapter.size() == 0)
602                        && (mActivity.getStateManager().getStateCount() > 1)) {
603                    Toast.makeText((Context) mActivity,
604                            R.string.empty_album, Toast.LENGTH_LONG).show();
605                    mActivity.getStateManager().finishState(AlbumSetPage.this);
606                }
607            }
608        }
609    }
610
611    private class MyDetailsSource implements DetailsHelper.DetailsSource {
612        private int mIndex;
613        public int size() {
614            return mAlbumSetDataAdapter.size();
615        }
616
617        public int getIndex() {
618            return mIndex;
619        }
620
621        // If requested index is out of active window, suggest a valid index.
622        // If there is no valid index available, return -1.
623        public int findIndex(int indexHint) {
624            if (mAlbumSetDataAdapter.isActive(indexHint)) {
625                mIndex = indexHint;
626            } else {
627                mIndex = mAlbumSetDataAdapter.getActiveStart();
628                if (!mAlbumSetDataAdapter.isActive(mIndex)) {
629                    return -1;
630                }
631            }
632            return mIndex;
633        }
634
635        public MediaDetails getDetails() {
636            MediaObject item = mAlbumSetDataAdapter.getMediaSet(mIndex);
637            if (item != null) {
638                mHighlightDrawer.setHighlightItem(item.getPath());
639                return item.getDetails();
640            } else {
641                return null;
642            }
643        }
644    }
645}
646