AlbumSetPage.java revision 9c21268fa8d394cca6cab78dd023a52e0b147a6e 
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;
58
59public class AlbumSetPage extends ActivityState implements
60        SelectionManager.SelectionListener, GalleryActionBar.ClusterRunner,
61        EyePosition.EyePositionListener, MediaSet.SyncListener {
62    @SuppressWarnings("unused")
63    private static final String TAG = "AlbumSetPage";
64
65    public static final String KEY_MEDIA_PATH = "media-path";
66    public static final String KEY_SET_TITLE = "set-title";
67    public static final String KEY_SET_SUBTITLE = "set-subtitle";
68    public static final String KEY_SELECTED_CLUSTER_TYPE = "selected-cluster";
69
70    private static final int DATA_CACHE_SIZE = 256;
71    private static final int REQUEST_DO_ANIMATION = 1;
72
73    private boolean mIsActive = false;
74    private StaticBackground mStaticBackground;
75    private AlbumSetView mAlbumSetView;
76
77    private MediaSet mMediaSet;
78    private String mTitle;
79    private String mSubtitle;
80    private boolean mShowClusterMenu;
81    private int mSelectedAction;
82    private Vibrator mVibrator;
83
84    protected SelectionManager mSelectionManager;
85    private AlbumSetDataAdapter mAlbumSetDataAdapter;
86    private GridDrawer mGridDrawer;
87    private HighlightDrawer mHighlightDrawer;
88
89    private boolean mGetContent;
90    private boolean mGetAlbum;
91    private ActionMode mActionMode;
92    private ActionModeHandler mActionModeHandler;
93    private DetailsHelper mDetailsHelper;
94    private MyDetailsSource mDetailsSource;
95    private boolean mShowDetails;
96    private EyePosition mEyePosition;
97
98    // The eyes' position of the user, the origin is at the center of the
99    // device and the unit is in pixels.
100    private float mX;
101    private float mY;
102    private float mZ;
103
104    private Future<Integer> mSyncTask = null;
105
106    private final GLView mRootPane = new GLView() {
107        private final float mMatrix[] = new float[16];
108
109        @Override
110        protected void onLayout(
111                boolean changed, int left, int top, int right, int bottom) {
112            mStaticBackground.layout(0, 0, right - left, bottom - top);
113            mEyePosition.resetPosition();
114
115            int slotViewTop = GalleryActionBar.getHeight((Activity) mActivity);
116            int slotViewBottom = bottom - top;
117            int slotViewRight = right - left;
118
119            if (mShowDetails) {
120                mDetailsHelper.layout(left, slotViewTop, right, bottom);
121            } else {
122                mAlbumSetView.setSelectionDrawer(mGridDrawer);
123            }
124
125            mAlbumSetView.layout(0, slotViewTop, slotViewRight, slotViewBottom);
126            PositionRepository.getInstance(mActivity).setOffset(
127                    0, slotViewTop);
128        }
129
130        @Override
131        protected void render(GLCanvas canvas) {
132            canvas.save(GLCanvas.SAVE_FLAG_MATRIX);
133            GalleryUtils.setViewPointMatrix(mMatrix,
134                    getWidth() / 2 + mX, getHeight() / 2 + mY, mZ);
135            canvas.multiplyMatrix(mMatrix, 0);
136            super.render(canvas);
137            canvas.restore();
138        }
139    };
140
141    @Override
142    public void onEyePositionChanged(float x, float y, float z) {
143        mRootPane.lockRendering();
144        mX = x;
145        mY = y;
146        mZ = z;
147        mRootPane.unlockRendering();
148        mRootPane.invalidate();
149    }
150
151    @Override
152    public void onBackPressed() {
153        if (mShowDetails) {
154            hideDetails();
155        } else if (mSelectionManager.inSelectionMode()) {
156            mSelectionManager.leaveSelectionMode();
157        } else {
158            mAlbumSetView.savePositions(
159                    PositionRepository.getInstance(mActivity));
160            super.onBackPressed();
161        }
162    }
163
164    private void savePositions(int slotIndex, int center[]) {
165        Rect offset = new Rect();
166        mRootPane.getBoundsOf(mAlbumSetView, offset);
167        mAlbumSetView.savePositions(PositionRepository.getInstance(mActivity));
168        Rect r = mAlbumSetView.getSlotRect(slotIndex);
169        int scrollX = mAlbumSetView.getScrollX();
170        int scrollY = mAlbumSetView.getScrollY();
171        center[0] = offset.left + (r.left + r.right) / 2 - scrollX;
172        center[1] = offset.top + (r.top + r.bottom) / 2 - scrollY;
173    }
174
175    public void onSingleTapUp(int slotIndex) {
176        MediaSet targetSet = mAlbumSetDataAdapter.getMediaSet(slotIndex);
177        if (targetSet == null) return; // Content is dirty, we shall reload soon
178
179        if (mShowDetails) {
180            Path path = targetSet.getPath();
181            mHighlightDrawer.setHighlightItem(path);
182            mDetailsHelper.reloadDetails(slotIndex);
183        } else if (!mSelectionManager.inSelectionMode()) {
184            Bundle data = new Bundle(getData());
185            String mediaPath = targetSet.getPath().toString();
186            int[] center = new int[2];
187            savePositions(slotIndex, center);
188            data.putIntArray(AlbumPage.KEY_SET_CENTER, center);
189            if (mGetAlbum && targetSet.isLeafAlbum()) {
190                Activity activity = (Activity) mActivity;
191                Intent result = new Intent()
192                        .putExtra(AlbumPicker.KEY_ALBUM_PATH, targetSet.getPath().toString());
193                activity.setResult(Activity.RESULT_OK, result);
194                activity.finish();
195            } else if (targetSet.getSubMediaSetCount() > 0) {
196                data.putString(AlbumSetPage.KEY_MEDIA_PATH, mediaPath);
197                mActivity.getStateManager().startStateForResult(
198                        AlbumSetPage.class, REQUEST_DO_ANIMATION, data);
199            } else {
200                if (!mGetContent && (targetSet.getSupportedOperations()
201                        & MediaObject.SUPPORT_IMPORT) != 0) {
202                    data.putBoolean(AlbumPage.KEY_AUTO_SELECT_ALL, true);
203                }
204                data.putString(AlbumPage.KEY_MEDIA_PATH, mediaPath);
205                boolean inAlbum = mActivity.getStateManager().hasStateClass(AlbumPage.class);
206                // We only show cluster menu in the first AlbumPage in stack
207                data.putBoolean(AlbumPage.KEY_SHOW_CLUSTER_MENU, !inAlbum);
208                mActivity.getStateManager().startStateForResult(
209                        AlbumPage.class, REQUEST_DO_ANIMATION, data);
210            }
211        } else {
212            mSelectionManager.toggle(targetSet.getPath());
213            mAlbumSetView.invalidate();
214        }
215    }
216
217    private void onDown(int index) {
218        MediaSet set = mAlbumSetDataAdapter.getMediaSet(index);
219        Path path = (set == null) ? null : set.getPath();
220        mSelectionManager.setPressedPath(path);
221        mAlbumSetView.invalidate();
222    }
223
224    private void onUp() {
225        mSelectionManager.setPressedPath(null);
226        mAlbumSetView.invalidate();
227    }
228
229    public void onLongTap(int slotIndex) {
230        if (mGetContent || mGetAlbum) return;
231        if (mShowDetails) {
232            onSingleTapUp(slotIndex);
233        } else {
234            MediaSet set = mAlbumSetDataAdapter.getMediaSet(slotIndex);
235            if (set == null) return;
236            mSelectionManager.setAutoLeaveSelectionMode(true);
237            mSelectionManager.toggle(set.getPath());
238            mDetailsSource.findIndex(slotIndex);
239            mAlbumSetView.invalidate();
240        }
241    }
242
243    public void doCluster(int clusterType) {
244        String basePath = mMediaSet.getPath().toString();
245        String newPath = FilterUtils.switchClusterPath(basePath, clusterType);
246        Bundle data = new Bundle(getData());
247        data.putString(AlbumSetPage.KEY_MEDIA_PATH, newPath);
248        data.putInt(KEY_SELECTED_CLUSTER_TYPE, clusterType);
249        mAlbumSetView.savePositions(PositionRepository.getInstance(mActivity));
250        mActivity.getStateManager().switchState(this, AlbumSetPage.class, data);
251    }
252
253    public void doFilter(int filterType) {
254        String basePath = mMediaSet.getPath().toString();
255        String newPath = FilterUtils.switchFilterPath(basePath, filterType);
256        Bundle data = new Bundle(getData());
257        data.putString(AlbumSetPage.KEY_MEDIA_PATH, newPath);
258        mAlbumSetView.savePositions(PositionRepository.getInstance(mActivity));
259        mActivity.getStateManager().switchState(this, AlbumSetPage.class, data);
260    }
261
262    public void onOperationComplete() {
263        mAlbumSetView.invalidate();
264        // TODO: enable animation
265    }
266
267    @Override
268    public void onCreate(Bundle data, Bundle restoreState) {
269        initializeViews();
270        initializeData(data);
271        Context context = mActivity.getAndroidContext();
272        mGetContent = data.getBoolean(Gallery.KEY_GET_CONTENT, false);
273        mGetAlbum = data.getBoolean(Gallery.KEY_GET_ALBUM, false);
274        mTitle = data.getString(AlbumSetPage.KEY_SET_TITLE);
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            MenuItem selectItem = menu.findItem(R.id.action_select);
400
401            if (selectItem != null) {
402                boolean selectAlbums = !inAlbum &&
403                        actionBar.getClusterTypeAction() == FilterUtils.CLUSTER_BY_ALBUM;
404                if (selectAlbums) {
405                    selectItem.setTitle(R.string.select_album);
406                } else {
407                    selectItem.setTitle(R.string.select_group);
408                }
409            }
410
411            MenuItem switchCamera = menu.findItem(R.id.action_camera);
412            if (switchCamera != null) {
413                switchCamera.setVisible(GalleryUtils.isCameraAvailable(activity));
414            }
415
416            actionBar.setTitle(mTitle);
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                if (mShowClusterMenu) {
523                    mActivity.getGalleryActionBar().showClusterMenu(mSelectedAction, this);
524                }
525                mRootPane.invalidate();
526                break;
527            }
528            case SelectionManager.SELECT_ALL_MODE: {
529                mActionModeHandler.setTitle(getSelectedString());
530                mRootPane.invalidate();
531                break;
532            }
533        }
534    }
535
536    public void onSelectionChange(Path path, boolean selected) {
537        Utils.assertTrue(mActionMode != null);
538        mActionModeHandler.setTitle(getSelectedString());
539        mActionModeHandler.updateSupportedOperation(path, selected);
540    }
541
542    private void hideDetails() {
543        mShowDetails = false;
544        mDetailsHelper.hide();
545        mAlbumSetView.setSelectionDrawer(mGridDrawer);
546        mAlbumSetView.invalidate();
547    }
548
549    private void showDetails() {
550        mShowDetails = true;
551        if (mDetailsHelper == null) {
552            mHighlightDrawer = new HighlightDrawer(mActivity.getAndroidContext(),
553                    mSelectionManager);
554            mDetailsHelper = new DetailsHelper(mActivity, mRootPane, mDetailsSource);
555            mDetailsHelper.setCloseListener(new CloseListener() {
556                public void onClose() {
557                    hideDetails();
558                }
559            });
560        }
561        mAlbumSetView.setSelectionDrawer(mHighlightDrawer);
562        mDetailsHelper.show();
563    }
564
565    @Override
566    public void onSyncDone(final MediaSet mediaSet, final int resultCode) {
567        if (resultCode == MediaSet.SYNC_RESULT_ERROR) {
568            Log.d(TAG, "onSyncDone: " + Utils.maskDebugInfo(mediaSet.getName()) + " result="
569                    + resultCode);
570        }
571        ((Activity) mActivity).runOnUiThread(new Runnable() {
572            @Override
573            public void run() {
574                if (!mIsActive) return;
575                mediaSet.notifyContentChanged(); // force reload to handle spinner
576
577                if (resultCode == MediaSet.SYNC_RESULT_ERROR) {
578                    Toast.makeText((Context) mActivity, R.string.sync_album_set_error,
579                            Toast.LENGTH_LONG).show();
580                }
581            }
582        });
583    }
584
585    private class MyLoadingListener implements LoadingListener {
586        public void onLoadingStarted() {
587            GalleryUtils.setSpinnerVisibility((Activity) mActivity, true);
588        }
589
590        public void onLoadingFinished() {
591            if (!mIsActive) return;
592
593            if (mSyncTask == null) {
594                // Request sync in case the mediaSet hasn't been sync'ed before.
595                mSyncTask = mMediaSet.requestSync(AlbumSetPage.this);
596            }
597            if (mSyncTask.isDone()){
598                // The mediaSet is in sync. Turn off the loading indicator.
599                GalleryUtils.setSpinnerVisibility((Activity) mActivity, false);
600
601                // Only show toast when there's no album and we are going to finish
602                // the page. Toast is redundant if we are going to stay on this page.
603                if ((mAlbumSetDataAdapter.size() == 0)
604                        && (mActivity.getStateManager().getStateCount() > 1)) {
605                    Toast.makeText((Context) mActivity,
606                            R.string.empty_album, Toast.LENGTH_LONG).show();
607                    mActivity.getStateManager().finishState(AlbumSetPage.this);
608                }
609            }
610        }
611    }
612
613    private class MyDetailsSource implements DetailsHelper.DetailsSource {
614        private int mIndex;
615        public int size() {
616            return mAlbumSetDataAdapter.size();
617        }
618
619        public int getIndex() {
620            return mIndex;
621        }
622
623        // If requested index is out of active window, suggest a valid index.
624        // If there is no valid index available, return -1.
625        public int findIndex(int indexHint) {
626            if (mAlbumSetDataAdapter.isActive(indexHint)) {
627                mIndex = indexHint;
628            } else {
629                mIndex = mAlbumSetDataAdapter.getActiveStart();
630                if (!mAlbumSetDataAdapter.isActive(mIndex)) {
631                    return -1;
632                }
633            }
634            return mIndex;
635        }
636
637        public MediaDetails getDetails() {
638            MediaObject item = mAlbumSetDataAdapter.getMediaSet(mIndex);
639            if (item != null) {
640                mHighlightDrawer.setHighlightItem(item.getPath());
641                return item.getDetails();
642            } else {
643                return null;
644            }
645        }
646    }
647}
648