Esempio n. 1
0
 private boolean needContentReload() {
   for (int i = mContentStart, n = mContentEnd; i < n; ++i) {
     if (mData[i % DATA_CACHE_SIZE] == null) return true;
   }
   MediaItem current = mData[mCurrentIndex % DATA_CACHE_SIZE];
   return current == null || current.getPath() != mItemPath;
 }
Esempio n. 2
0
  private void updateImageCache() {
    HashSet<Long> toBeRemoved = new HashSet<Long>(mImageCache.keySet());
    for (int i = mActiveStart; i < mActiveEnd; ++i) {
      MediaItem item = mData[i % DATA_CACHE_SIZE];
      long version = item == null ? MediaObject.INVALID_DATA_VERSION : item.getDataVersion();
      if (version == MediaObject.INVALID_DATA_VERSION) continue;
      ImageEntry entry = mImageCache.get(version);
      toBeRemoved.remove(version);
      if (entry != null) {
        if (Math.abs(i - mCurrentIndex) > 1) {
          if (entry.fullImageTask != null) {
            entry.fullImageTask.cancel();
            entry.fullImageTask = null;
          }
          entry.fullImage = null;
          entry.requestedBits &= ~BIT_FULL_IMAGE;
        }
      } else {
        entry = new ImageEntry();
        entry.rotation = item.getFullImageRotation();
        mImageCache.put(version, entry);
      }
    }

    // Clear the data and requests for ImageEntries outside the new window.
    for (Long version : toBeRemoved) {
      ImageEntry entry = mImageCache.remove(version);
      if (entry.fullImageTask != null) entry.fullImageTask.cancel();
      if (entry.screenNailTask != null) entry.screenNailTask.cancel();
    }
  }
Esempio n. 3
0
 @Override
 public void run() {
   while (mActive) {
     synchronized (this) {
       if (!mDirty && mActive) {
         updateLoading(false);
         Utils.waitWithoutInterrupt(this);
         continue;
       }
     }
     mDirty = false;
     UpdateInfo info = executeAndWait(new GetUpdateInfo());
     synchronized (DataManager.LOCK) {
       updateLoading(true);
       long version = mSource.reload();
       if (info.version != version) {
         info.reloadContent = true;
         info.size = mSource.getMediaItemCount();
       }
       if (!info.reloadContent) continue;
       info.items = mSource.getMediaItem(info.contentStart, info.contentEnd);
       MediaItem item = findCurrentMediaItem(info);
       if (item == null || item.getPath() != info.target) {
         info.indexHint = findIndexOfTarget(info);
       }
     }
     executeAndWait(new UpdateContent(info));
   }
 }
Esempio n. 4
0
  // Returns the task if we started the task or the task is already started.
  private Future<?> startTaskIfNeeded(int index, int which) {
    if (index < mActiveStart || index >= mActiveEnd) return null;

    ImageEntry entry = mImageCache.get(getVersion(index));
    if (entry == null) return null;

    if (which == BIT_SCREEN_NAIL && entry.screenNailTask != null) {
      return entry.screenNailTask;
    } else if (which == BIT_FULL_IMAGE && entry.fullImageTask != null) {
      return entry.fullImageTask;
    }

    MediaItem item = mData[index % DATA_CACHE_SIZE];
    Utils.assertTrue(item != null);

    if (which == BIT_SCREEN_NAIL && (entry.requestedBits & BIT_SCREEN_NAIL) == 0) {
      entry.requestedBits |= BIT_SCREEN_NAIL;
      entry.screenNailTask =
          mThreadPool.submit(
              new ScreenNailJob(item), new ScreenNailListener(item.getDataVersion()));
      // request screen nail
      return entry.screenNailTask;
    }
    if (which == BIT_FULL_IMAGE
        && (entry.requestedBits & BIT_FULL_IMAGE) == 0
        && (item.getSupportedOperations() & MediaItem.SUPPORT_FULL_IMAGE) != 0) {
      entry.requestedBits |= BIT_FULL_IMAGE;
      entry.fullImageTask =
          mThreadPool.submit(
              item.requestLargeImage(), new FullImageListener(item.getDataVersion()));
      // request full image
      return entry.fullImageTask;
    }
    return null;
  }
Esempio n. 5
0
  private void updateImageRequests() {
    if (!mIsActive) return;

    int currentIndex = mCurrentIndex;
    MediaItem item = mData[currentIndex % DATA_CACHE_SIZE];
    if (item == null || item.getPath() != mItemPath) {
      // current item mismatch - don't request image
      return;
    }

    // 1. Find the most wanted request and start it (if not already started).
    Future<?> task = null;
    for (int i = 0; i < sImageFetchSeq.length; i++) {
      int offset = sImageFetchSeq[i].indexOffset;
      int bit = sImageFetchSeq[i].imageBit;
      task = startTaskIfNeeded(currentIndex + offset, bit);
      if (task != null) break;
    }

    // 2. Cancel everything else.
    for (ImageEntry entry : mImageCache.values()) {
      if (entry.screenNailTask != null && entry.screenNailTask != task) {
        entry.screenNailTask.cancel();
        entry.screenNailTask = null;
        entry.requestedBits &= ~BIT_SCREEN_NAIL;
      }
      if (entry.fullImageTask != null && entry.fullImageTask != task) {
        entry.fullImageTask.cancel();
        entry.fullImageTask = null;
        entry.requestedBits &= ~BIT_FULL_IMAGE;
      }
    }
  }
Esempio n. 6
0
 private long getVersion(int index) {
   if (index < 0 || index >= mSize) return VERSION_OUT_OF_RANGE;
   if (index >= mContentStart && index < mContentEnd) {
     MediaItem item = mData[index % DATA_CACHE_SIZE];
     if (item != null) return item.getDataVersion();
   }
   return MediaObject.INVALID_DATA_VERSION;
 }
 public void onLongTap(int slotIndex) {
   if (mGetContent) return;
   MediaItem item = mAlbumDataAdapter.get(slotIndex);
   if (item == null) return;
   mSelectionManager.setAutoLeaveSelectionMode(true);
   mSelectionManager.toggle(item.getPath());
   mSlotView.invalidate();
 }
 @Override
 public int getItemIndex(Path path) {
   int start = mSlotView.getVisibleStart();
   int end = mSlotView.getVisibleEnd();
   for (int i = start; i < end; ++i) {
     MediaItem item = mAlbumDataAdapter.get(i);
     if (item != null && item.getPath() == path) return i;
   }
   return -1;
 }
Esempio n. 9
0
 @Override
 public Bitmap run(JobContext jc) {
   Bitmap bitmap = mItem.requestImage(MediaItem.TYPE_THUMBNAIL).run(jc);
   if (jc.isCancelled()) return null;
   if (bitmap != null) {
     bitmap =
         BitmapUtils.rotateBitmap(
             bitmap, mItem.getRotation() - mItem.getFullImageRotation(), true);
   }
   return bitmap;
 }
Esempio n. 10
0
  private boolean execute(DataManager manager, JobContext jc, int cmd, Path path) {
    boolean result = true;
    Log.v(TAG, "Execute cmd: " + cmd + " for " + path);
    long startTime = System.currentTimeMillis();

    switch (cmd) {
      case R.id.action_delete:
        manager.delete(path);
        break;
      case R.id.action_rotate_cw:
        manager.rotate(path, 90);
        break;
      case R.id.action_rotate_ccw:
        manager.rotate(path, -90);
        break;
      case R.id.action_toggle_full_caching:
        {
          MediaObject obj = manager.getMediaObject(path);
          int cacheFlag = obj.getCacheFlag();
          if (cacheFlag == MediaObject.CACHE_FLAG_FULL) {
            cacheFlag = MediaObject.CACHE_FLAG_SCREENNAIL;
          } else {
            cacheFlag = MediaObject.CACHE_FLAG_FULL;
          }
          obj.cache(cacheFlag);
          break;
        }
      case R.id.action_show_on_map:
        {
          MediaItem item = (MediaItem) manager.getMediaObject(path);
          double latlng[] = new double[2];
          item.getLatLong(latlng);
          if (GalleryUtils.isValidLocation(latlng[0], latlng[1])) {
            GalleryUtils.showOnMap((Context) mActivity, latlng[0], latlng[1]);
          }
          break;
        }
      case R.id.action_import:
        {
          MediaObject obj = manager.getMediaObject(path);
          result = obj.Import();
          break;
        }
      default:
        throw new AssertionError();
    }
    Log.v(
        TAG,
        "It takes " + (System.currentTimeMillis() - startTime) + " ms to execute cmd for " + path);
    return result;
  }
Esempio n. 11
0
  public void setCurrentPhoto(Path path, int indexHint) {
    if (mItemPath == path) return;
    mItemPath = path;
    mCurrentIndex = indexHint;
    updateSlidingWindow();
    updateImageCache();
    fireModelInvalidated();

    // We need to reload content if the path doesn't match.
    MediaItem item = getCurrentMediaItem();
    if (item != null && item.getPath() != path) {
      if (mReloadTask != null) mReloadTask.notifyDirty();
    }
  }
  private void onSingleTapUp(int slotIndex) {
    if (!mIsActive) return;

    if (mSelectionManager.inSelectionMode()) {
      MediaItem item = mAlbumDataAdapter.get(slotIndex);
      if (item == null) return; // Item not ready yet, ignore the click
      mSelectionManager.toggle(item.getPath());
      mSlotView.invalidate();
    } else {
      // Render transition in pressed state
      mAlbumView.setPressedIndex(slotIndex);
      mAlbumView.setPressedUp();
      mHandler.sendMessageDelayed(
          mHandler.obtainMessage(MSG_PICK_PHOTO, slotIndex, 0), FadeTexture.DURATION);
    }
  }
Esempio n. 13
0
  private void updateCurrentIndex(int index) {
    mCurrentIndex = index;
    updateSlidingWindow();

    MediaItem item = mData[index % DATA_CACHE_SIZE];
    mItemPath = item == null ? null : item.getPath();

    updateImageCache();
    updateImageRequests();
    updateTileProvider();
    mPhotoView.notifyOnNewImage();

    if (mDataListener != null) {
      mDataListener.onPhotoChanged(index, mItemPath);
    }
    fireModelInvalidated();
  }
Esempio n. 14
0
    @Override
    public Void call() throws Exception {
      UpdateInfo info = mUpdateInfo;
      mSourceVersion = info.version;

      if (info.size != mSize) {
        mSize = info.size;
        if (mContentEnd > mSize) mContentEnd = mSize;
        if (mActiveEnd > mSize) mActiveEnd = mSize;
      }

      if (info.indexHint == MediaSet.INDEX_NOT_FOUND) {
        // The image has been deleted, clear mItemPath, the
        // mCurrentIndex will be updated in the updateCurrentItem().
        mItemPath = null;
        updateCurrentItem();
      } else {
        mCurrentIndex = info.indexHint;
      }

      updateSlidingWindow();

      if (info.items != null) {
        int start = Math.max(info.contentStart, mContentStart);
        int end = Math.min(info.contentStart + info.items.size(), mContentEnd);
        int dataIndex = start % DATA_CACHE_SIZE;
        for (int i = start; i < end; ++i) {
          mData[dataIndex] = info.items.get(i - info.contentStart);
          if (++dataIndex == DATA_CACHE_SIZE) dataIndex = 0;
        }
      }
      if (mItemPath == null) {
        MediaItem current = mData[mCurrentIndex % DATA_CACHE_SIZE];
        mItemPath = current == null ? null : current.getPath();
      }
      updateImageCache();
      updateTileProvider();
      updateImageRequests();
      fireModelInvalidated();
      return null;
    }
 private void onGetContent(final MediaItem item) {
   DataManager dm = mActivity.getDataManager();
   Activity activity = mActivity;
   if (mData.getString(GalleryActivity.EXTRA_CROP) != null) {
     Uri uri = dm.getContentUri(item.getPath());
     Intent intent =
         new Intent(CropActivity.CROP_ACTION, uri)
             .addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT)
             .putExtras(getData());
     if (mData.getParcelable(MediaStore.EXTRA_OUTPUT) == null) {
       intent.putExtra(CropExtras.KEY_RETURN_DATA, true);
     }
     activity.startActivity(intent);
     activity.finish();
   } else {
     Intent intent =
         new Intent(null, item.getContentUri()).addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
     activity.setResult(Activity.RESULT_OK, intent);
     activity.finish();
   }
 }
  private void pickPhoto(int slotIndex, boolean startInFilmstrip) {
    if (!mIsActive) return;

    if (!startInFilmstrip) {
      // Launch photos in lights out mode
      mActivity.getGLRoot().setLightsOutMode(true);
    }

    MediaItem item = mAlbumDataAdapter.get(slotIndex);
    if (item == null) return; // Item not ready yet, ignore the click
    if (mGetContent) {
      onGetContent(item);
    } else if (mLaunchedFromPhotoPage) {
      TransitionStore transitions = mActivity.getTransitionStore();
      transitions.put(PhotoPage.KEY_ALBUMPAGE_TRANSITION, PhotoPage.MSG_ALBUMPAGE_PICKED);
      transitions.put(PhotoPage.KEY_INDEX_HINT, slotIndex);
      onBackPressed();
    } else {
      // Get into the PhotoPage.
      // mAlbumView.savePositions(PositionRepository.getInstance(mActivity));
      Bundle data = new Bundle();
      data.putInt(PhotoPage.KEY_INDEX_HINT, slotIndex);
      data.putParcelable(
          PhotoPage.KEY_OPEN_ANIMATION_RECT, mSlotView.getSlotRect(slotIndex, mRootPane));
      data.putString(PhotoPage.KEY_MEDIA_SET_PATH, mMediaSetPath.toString());
      data.putString(PhotoPage.KEY_MEDIA_ITEM_PATH, item.getPath().toString());
      data.putInt(PhotoPage.KEY_ALBUMPAGE_TRANSITION, PhotoPage.MSG_ALBUMPAGE_STARTED);
      data.putBoolean(PhotoPage.KEY_START_IN_FILMSTRIP, startInFilmstrip);
      data.putBoolean(PhotoPage.KEY_IN_CAMERA_ROLL, mMediaSet.isCameraRoll());
      if (startInFilmstrip) {
        mActivity.getStateManager().switchState(this, FilmstripPage.class, data);
      } else {
        mActivity.getStateManager().startStateForResult(SinglePhotoPage.class, REQUEST_PHOTO, data);
      }
    }
  }
Esempio n. 17
0
 public static boolean isPanorama(MediaItem item) {
   if (item == null) return false;
   int w = item.getWidth();
   int h = item.getHeight();
   return (h > 0 && w / h >= 2);
 }