コード例 #1
0
 private WPEditImageSpan createWPEditImageSpanLocal(Context context, MediaFile mediaFile) {
   Uri imageUri = Uri.parse(mediaFile.getFilePath());
   Bitmap thumbnailBitmap;
   if (MediaUtils.isVideo(imageUri.toString())) {
     thumbnailBitmap =
         BitmapFactory.decodeResource(context.getResources(), R.drawable.media_movieclip);
   } else {
     thumbnailBitmap =
         ImageUtils.getWPImageSpanThumbnailFromFilePath(
             context,
             imageUri.getEncodedPath(),
             ImageUtils.getMaximumThumbnailWidthForEditor(context));
     if (thumbnailBitmap == null) {
       // Use a placeholder in case thumbnail can't be decoded (OOM for instance)
       thumbnailBitmap =
           BitmapFactory.decodeResource(
               context.getResources(), R.drawable.legacy_dashicon_format_image_big_grey);
     }
   }
   WPEditImageSpan imageSpan = new WPEditImageSpan(context, thumbnailBitmap, imageUri);
   mediaFile.setWidth(
       MediaUtils.getMinimumImageWidth(context, imageUri, mBlogSettingMaxImageWidth));
   return imageSpan;
 }
コード例 #2
0
    private String uploadImage(MediaFile mediaFile) {
      AppLog.d(T.POSTS, "uploadImage: " + mediaFile.getFilePath());

      if (mediaFile.getFilePath() == null) {
        return null;
      }

      Uri imageUri = Uri.parse(mediaFile.getFilePath());
      File imageFile = null;
      String mimeType = "", path = "";

      if (imageUri.toString().contains("content:")) {
        String[] projection =
            new String[] {Images.Media._ID, Images.Media.DATA, Images.Media.MIME_TYPE};

        Cursor cur = mContext.getContentResolver().query(imageUri, projection, null, null, null);
        if (cur != null && cur.moveToFirst()) {
          int dataColumn = cur.getColumnIndex(Images.Media.DATA);
          int mimeTypeColumn = cur.getColumnIndex(Images.Media.MIME_TYPE);

          String thumbData = cur.getString(dataColumn);
          mimeType = cur.getString(mimeTypeColumn);
          imageFile = new File(thumbData);
          path = thumbData;
          mediaFile.setFilePath(imageFile.getPath());
        }
      } else { // file is not in media library
        path = imageUri.toString().replace("file://", "");
        imageFile = new File(path);
        mediaFile.setFilePath(path);
      }

      // check if the file exists
      if (imageFile == null) {
        mErrorMessage = mContext.getString(R.string.file_not_found);
        return null;
      }

      if (TextUtils.isEmpty(mimeType)) {
        mimeType = MediaUtils.getMediaFileMimeType(imageFile);
      }
      String fileName = MediaUtils.getMediaFileName(imageFile, mimeType);
      String fileExtension = MimeTypeMap.getFileExtensionFromUrl(fileName).toLowerCase();

      int orientation = ImageUtils.getImageOrientation(mContext, path);

      String resizedPictureURL = null;

      // We need to upload a resized version of the picture when the blog settings != original size,
      // or when
      // the user has selected a smaller size for the current picture in the picture settings screen
      // We won't resize gif images to keep them awesome.
      boolean shouldUploadResizedVersion = false;
      // If it's not a gif and blog don't keep original size, there is a chance we need to resize
      if (!mimeType.equals("image/gif") && !mBlog.getMaxImageWidth().equals("Original Size")) {
        // check the picture settings
        int pictureSettingWidth = mediaFile.getWidth();
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(path, options);
        int imageHeight = options.outHeight;
        int imageWidth = options.outWidth;
        int[] dimensions = {imageWidth, imageHeight};
        if (dimensions[0] != 0 && dimensions[0] != pictureSettingWidth) {
          shouldUploadResizedVersion = true;
        }
      }

      boolean shouldAddImageWidthCSS = false;

      if (shouldUploadResizedVersion) {
        MediaFile resizedMediaFile = new MediaFile(mediaFile);
        // Create resized image
        byte[] bytes =
            ImageUtils.createThumbnailFromUri(
                mContext, imageUri, resizedMediaFile.getWidth(), fileExtension, orientation);

        if (bytes == null) {
          // We weren't able to resize the image, so we will upload the full size image with css to
          // resize it
          shouldUploadResizedVersion = false;
          shouldAddImageWidthCSS = true;
        } else {
          // Save temp image
          String tempFilePath;
          File resizedImageFile;
          try {
            resizedImageFile = File.createTempFile("wp-image-", fileExtension);
            FileOutputStream out = new FileOutputStream(resizedImageFile);
            out.write(bytes);
            out.close();
            tempFilePath = resizedImageFile.getPath();
          } catch (IOException e) {
            AppLog.w(T.POSTS, "failed to create image temp file");
            mErrorMessage = mContext.getString(R.string.error_media_upload);
            return null;
          }

          // upload resized picture
          if (!TextUtils.isEmpty(tempFilePath)) {
            resizedMediaFile.setFilePath(tempFilePath);
            Map<String, Object> parameters = new HashMap<String, Object>();

            parameters.put("name", fileName);
            parameters.put("type", mimeType);
            parameters.put("bits", resizedMediaFile);
            parameters.put("overwrite", true);
            resizedPictureURL = uploadImageFile(parameters, resizedMediaFile, mBlog);
            if (resizedPictureURL == null) {
              AppLog.w(T.POSTS, "failed to upload resized picture");
              return null;
            } else if (resizedImageFile.exists()) {
              resizedImageFile.delete();
            }
          } else {
            AppLog.w(T.POSTS, "failed to create resized picture");
            mErrorMessage = mContext.getString(R.string.out_of_memory);
            return null;
          }
        }
      }

      String fullSizeUrl = null;
      // Upload the full size picture if "Original Size" is selected in settings,
      // or if 'link to full size' is checked.
      if (!shouldUploadResizedVersion || mBlog.isFullSizeImage()) {
        Map<String, Object> parameters = new HashMap<String, Object>();
        parameters.put("name", fileName);
        parameters.put("type", mimeType);
        parameters.put("bits", mediaFile);
        parameters.put("overwrite", true);

        fullSizeUrl = uploadImageFile(parameters, mediaFile, mBlog);
        if (fullSizeUrl == null) {
          mErrorMessage = mContext.getString(R.string.error_media_upload);
          return null;
        }
      }

      return mediaFile.getImageHtmlForUrls(fullSizeUrl, resizedPictureURL, shouldAddImageWidthCSS);
    }
コード例 #3
0
  private void loadWPImageSpanThumbnail(
      MediaFile mediaFile, String imageURL, ImageLoader imageLoader) {
    if (mediaFile == null || imageURL == null) {
      return;
    }
    final String mediaId = mediaFile.getMediaId();
    if (mediaId == null) {
      return;
    }

    final int maxThumbWidth = ImageUtils.getMaximumThumbnailWidthForEditor(getActivity());

    imageLoader.get(
        imageURL,
        new ImageLoader.ImageListener() {
          @Override
          public void onErrorResponse(VolleyError arg0) {}

          @Override
          public void onResponse(ImageLoader.ImageContainer container, boolean arg1) {
            Bitmap downloadedBitmap = container.getBitmap();
            if (downloadedBitmap == null) {
              // no bitmap downloaded from the server.
              return;
            }

            if (downloadedBitmap.getWidth() < MIN_THUMBNAIL_WIDTH) {
              // Picture is too small. Show the placeholder in this case.
              return;
            }

            Bitmap resizedBitmap;
            // resize the downloaded bitmap
            resizedBitmap =
                ImageUtils.getScaledBitmapAtLongestSide(downloadedBitmap, maxThumbWidth);

            if (resizedBitmap == null) {
              return;
            }

            final EditText editText = mContentEditText;
            Editable s = editText.getText();
            if (s == null) {
              return;
            }
            WPImageSpan[] spans = s.getSpans(0, s.length(), WPImageSpan.class);
            if (spans.length != 0 && getActivity() != null) {
              for (WPImageSpan is : spans) {
                MediaFile mediaFile = is.getMediaFile();
                if (mediaFile == null) {
                  continue;
                }
                if (mediaId.equals(mediaFile.getMediaId()) && !is.isNetworkImageLoaded()) {
                  // replace the existing span with a new one with the correct image, re-add
                  // it to the same position.
                  int spanStart = is.getStartPosition();
                  int spanEnd = is.getEndPosition();
                  WPEditImageSpan imageSpan =
                      new WPEditImageSpan(getActivity(), resizedBitmap, is.getImageSource());
                  imageSpan.setMediaFile(is.getMediaFile());
                  imageSpan.setNetworkImageLoaded(true);
                  imageSpan.setPosition(spanStart, spanEnd);
                  s.removeSpan(is);
                  s.setSpan(imageSpan, spanStart, spanEnd + 1, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                  break;
                }
              }
            }
          }
        },
        0,
        0);
  }
コード例 #4
0
    /** Finds media in post content, uploads them, and returns the HTML to insert in the post */
    private String processPostMedia(String postContent) {
      String imageTagsPattern = "<img[^>]+android-uri\\s*=\\s*['\"]([^'\"]+)['\"][^>]*>";
      Pattern pattern = Pattern.compile(imageTagsPattern);
      Matcher matcher = pattern.matcher(postContent);

      int totalMediaItems = 0;
      List<String> imageTags = new ArrayList<String>();
      while (matcher.find()) {
        imageTags.add(matcher.group());
        totalMediaItems++;
      }

      mPostUploadNotifier.setTotalMediaItems(totalMediaItems);

      int mediaItemCount = 0;
      for (String tag : imageTags) {
        Pattern p = Pattern.compile("android-uri=\"([^\"]+)\"");
        Matcher m = p.matcher(tag);
        if (m.find()) {
          String imageUri = m.group(1);
          if (!imageUri.equals("")) {
            MediaFile mediaFile = WordPress.wpDB.getMediaFile(imageUri, mPost);
            if (mediaFile != null) {
              // Get image thumbnail for notification icon
              Bitmap imageIcon =
                  ImageUtils.getWPImageSpanThumbnailFromFilePath(
                      mContext, imageUri, DisplayUtils.dpToPx(mContext, 128));

              // Crop the thumbnail to be squared in the center
              if (imageIcon != null) {
                int squaredSize = DisplayUtils.dpToPx(mContext, 64);
                imageIcon = ThumbnailUtils.extractThumbnail(imageIcon, squaredSize, squaredSize);
                mLatestIcon = imageIcon;
              }

              mediaItemCount++;
              mPostUploadNotifier.setCurrentMediaItem(mediaItemCount);
              mPostUploadNotifier.updateNotificationIcon(imageIcon);

              String mediaUploadOutput;
              if (mediaFile.isVideo()) {
                mHasVideo = true;
                mediaUploadOutput = uploadVideo(mediaFile);
              } else {
                mHasImage = true;
                mediaUploadOutput = uploadImage(mediaFile);
              }

              if (mediaUploadOutput != null) {
                postContent = postContent.replace(tag, mediaUploadOutput);
              } else {
                postContent = postContent.replace(tag, "");
                mIsMediaError = true;
              }
            }
          }
        }
      }

      return postContent;
    }