Java ImagesService类代码示例

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
public byte[] convert(byte[] image, String destType, boolean reverse) {
	if (destType == null) {
		throw new IllegalArgumentException("dest type is null.");
	} else {
		destType = destType.toLowerCase();
	}

	ImagesService.OutputEncoding encoding = null;
	if ("png".equals(destType)) {
		encoding = OutputEncoding.PNG;
	} else if ("jpeg".equals(destType)) {
		encoding = OutputEncoding.JPEG;
	} else {
		throw new UnsupportedOperationException("unsupported image encoding: " + destType);
	}

	ImagesService imagesService = ImagesServiceFactory.getImagesService();
	Image bmp = ImagesServiceFactory.makeImage(image);

	Transform t = (reverse) ? ImagesServiceFactory.makeVerticalFlip() : ImagesServiceFactory.makeCompositeTransform();
	return imagesService.applyTransform(t, bmp, encoding).getImageData();
}
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException {

BlobKey blobKey = new BlobKey(req.getParameter("blobkey"));
      String maxLengthString = req.getParameter("s");
      ImagesService imagesService = ImagesServiceFactory.getImagesService();
      ServingUrlOptions servingUrlOptions = ServingUrlOptions.Builder.withBlobKey(blobKey);

      if (maxLengthString == null || maxLengthString.isEmpty()) {
      	//res.sendRedirect(imagesService.getServingUrl(blobKey));
      	res.sendRedirect(imagesService.getServingUrl(servingUrlOptions));
      }
      else {
      	int maxLength = Integer.parseInt(maxLengthString);
      	//res.sendRedirect(imagesService.getServingUrl(blobKey, maxLength, false));
      	res.sendRedirect(imagesService.getServingUrl(servingUrlOptions.imageSize(maxLength)));
      }
  }
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public void doPost(HttpServletRequest req, HttpServletResponse resp)
		throws ServletException, IOException {

	List<BlobKey> blobKeys = blobstoreService.getUploads(req).get("data");
	BlobKey key = blobKeys.get(0);
	ImagesService imagesService = ImagesServiceFactory.getImagesService();
	ServingUrlOptions servingOptions = ServingUrlOptions.Builder
			.withBlobKey(key);

	String servingUrl = imagesService.getServingUrl(servingOptions);
	resp.setStatus(HttpServletResponse.SC_OK);

	resp.setContentType("application/json");
	JSONObject json = new JSONObject();

	json.put("servingUrl", servingUrl);
	json.put("blobKey", key.getKeyString());

	PrintWriter out = resp.getWriter();
	out.print(json.toString());
	out.flush();
	out.close();

}
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
@Inject
public RawAttachmentService(BlobstoreService blobstoreService, ImagesService imagesService,
    BlobInfoFactory blobInfoFactory,
    @Flag(FlagName.ATTACHMENT_HEADER_BYTES_UPPER_BOUND) int headerBytesUpperBound,
    RandomBase64Generator random64,
    MetadataDirectory metadataDirectory) {
  this.blobstoreService = blobstoreService;
  this.imagesService = imagesService;
  this.blobInfoFactory = blobInfoFactory;
  this.headerBytesUpperBound = headerBytesUpperBound;
  this.random64 = random64;
  this.metadataDirectory = metadataDirectory;
}
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
@Override
public byte[] resizeImage(byte[] imageBlob, int width, int height) {
  ImagesService imagesService = ImagesServiceFactory.getImagesService();
  Transform resize = ImagesServiceFactory.makeResize(width, height);

  Image oldImage = ImagesServiceFactory.makeImage(imageBlob);
  Image newImage = imagesService.applyTransform(resize, oldImage);

  imageBlob = newImage.getImageData();
  return imageBlob;
}
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
public MomentEndpoint(UserDAO userDAO,
                      FriendDAO friendDAO,
                      MomentDAO momentDAO,
                      ImagesService imagesService,
                      GcmHelper gcmHelper) {
    this.userDAO = userDAO;
    this.friendDAO = friendDAO;
    this.momentDAO = momentDAO;
    this.imagesService = imagesService;
    this.gcmHelper = gcmHelper;
}
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		resp.setHeader("Cache-Control", "max-age=2592000");

		String path = req.getPathInfo();
//        long gameIdString = Long.parseLong(path.split("/", -1)[2]);
		String account = req.getParameter("account");
//        String fileName = path.split("/", -1)[3];
		BlobKey bk = FilePathManager.getBlobKey(account, null, null, path);
		if (bk != null) {
			if (req.getParameter("thumbnail") == null) {
				blobstoreService.serve(bk, resp);
			}  else {
				ImagesService imagesService = ImagesServiceFactory.getImagesService();
				ServingUrlOptions options = ServingUrlOptions.Builder.withBlobKey(bk);
				options.imageSize(Integer.parseInt(req.getParameter("thumbnail")));
				boolean crop = false;
				if (req.getParameter("crop")!=null) {
					crop = Boolean.parseBoolean(req.getParameter("crop"));
				}
				options.crop(req.getParameter("crop")!=null);
				String thumbnailUrl =imagesService.getServingUrl(options);

				resp.sendRedirect(thumbnailUrl);
			}

		} else {
			resp.setStatus(404);
		}
	}
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
@Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setHeader("Cache-Control", "max-age=2592000");

        String path = req.getPathInfo();
//        long gameIdString = Long.parseLong(path.split("/", -1)[2]);
        Long gameIdString = Long.parseLong(req.getParameter("gameId"));
//        String fileName = path.split("/", -1)[3];
        BlobKey bk = FilePathManager.getBlobKey(null, null, gameIdString, path);
        if (bk != null) {
            if (req.getParameter("thumbnail") == null) {
                blobstoreService.serve(bk, resp);
            }  else {
                ImagesService imagesService = ImagesServiceFactory.getImagesService();
                ServingUrlOptions options = ServingUrlOptions.Builder.withBlobKey(bk);
                options.imageSize(Integer.parseInt(req.getParameter("thumbnail")));
                boolean crop = false;
                if (req.getParameter("crop")!=null) {
                    crop = Boolean.parseBoolean(req.getParameter("crop"));
                }
                options.crop(req.getParameter("crop")!=null);
                String thumbnailUrl =imagesService.getServingUrl(options);

                resp.sendRedirect(thumbnailUrl);
            }

        } else {
            resp.setStatus(404);
        }
    }
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    String path = req.getPathInfo();
    System.out.println(path);
    String gameIdString = getFirstPath(path);
    Long gameId = Long.parseLong(gameIdString);
    path = "/"+getReminder(path);
    BlobKey bk = FilePathManager.getBlobKey(null, null,gameId, path);
    if (bk != null) {

        if (req.getParameter("thumbnail") == null) {
            blobstoreService.serve(bk, resp);
        }  else {
            ImagesService imagesService = ImagesServiceFactory.getImagesService();
            ServingUrlOptions options = ServingUrlOptions.Builder.withBlobKey(bk);
            options.imageSize(Integer.parseInt(req.getParameter("thumbnail")));
            boolean crop = false;
            if (req.getParameter("crop")!=null) {
                crop = Boolean.parseBoolean(req.getParameter("crop"));
            }
            options.crop(req.getParameter("crop")!=null);
            String thumbnailUrl =imagesService.getServingUrl(options);

            resp.sendRedirect(thumbnailUrl);
        }

    } else {
        resp.setStatus(404);
    }
}
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
public ServiceImageIO(ImagesService imagesService) {
	super();
	this.imagesService = imagesService;
	if (imagesService == null) {
		throw new NullPointerException("images service must be non-null");
	}
}
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
public IO getIO(ImagesService imagesService) {
	switch (this) {
		case IMAGEIO: return new ImageIOIO();
		case SANSELAN: return new SanselanIO();
		case SERVICE: return new ServiceIO(imagesService);
		default: return new NullIO();
	}
}
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
private Image getTransformedImage() {
    Assumption.assertNotNull(blobKey);

    Image oldImage = ImagesServiceFactory.makeImageFromBlob(blobKey);
    CompositeTransform finalTransform = getCompositeTransformToApply();
    OutputSettings settings = new OutputSettings(ImagesService.OutputEncoding.PNG);

    return ImagesServiceFactory.getImagesService().applyTransform(finalTransform, oldImage, settings);
}
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
private static Image processImage(InputStream inputStream, int maxWidthPx, int maxHeightPx)
    throws IOException {
  ImagesService imagesService = ImagesServiceFactory.getImagesService();
  Image inputImage = ImagesServiceFactory.makeImage(IOUtils.toByteArray(inputStream));
  Transform resize = ImagesServiceFactory.makeResize(maxWidthPx, maxHeightPx);
  return imagesService.applyTransform(resize, inputImage);
}
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
/**
 * when an app is published/updated, we need to move the image
 * that was temporarily uploaded into projects/projectid/image
 * into the gallery image
 * @param app gallery app
 */
private void setGalleryAppImage(GalleryApp app) {
  // best thing would be if GCS has a mv op, we can just do that.
  // don't think that is there, though, so for now read one and write to other
  // First, read the file from projects name
  boolean lockForRead = false;
  //String projectImageKey = app.getProjectImageKey();
  GallerySettings settings = loadGallerySettings();
  String projectImageKey = settings.getProjectImageKey(app.getProjectId());
  try {
    GcsService gcsService = GcsServiceFactory.createGcsService();
    //GcsFilename filename = new GcsFilename(GalleryApp.GALLERYBUCKET, projectImageKey);
    GcsFilename filename = new GcsFilename(settings.getBucket(), projectImageKey);
    GcsInputChannel readChannel = gcsService.openReadChannel(filename, 0);
    InputStream gcsis = Channels.newInputStream(readChannel);

    byte[] buffer = new byte[8000];
    int bytesRead = 0;
    ByteArrayOutputStream bao = new ByteArrayOutputStream();

    while ((bytesRead = gcsis.read(buffer)) != -1) {
      bao.write(buffer, 0, bytesRead);
    }
    // close the project image file
    readChannel.close();

    // if image is greater than 200 X 200, it will be scaled (200 X 200).
    // otherwise, it will be stored as origin.
    byte[] oldImageData = bao.toByteArray();
    byte[] newImageData;
    ImagesService imagesService = ImagesServiceFactory.getImagesService();
    Image oldImage = ImagesServiceFactory.makeImage(oldImageData);
    //if image size is too big, scale it to a smaller size.
    if(oldImage.getWidth() > 200 && oldImage.getHeight() > 200){
        Transform resize = ImagesServiceFactory.makeResize(200, 200);
        Image newImage = imagesService.applyTransform(resize, oldImage);
        newImageData = newImage.getImageData();
    }else{
        newImageData = oldImageData;
    }

    // set up the cloud file (options)
    // After publish, copy the /projects/projectId image into /apps/appId
    //String galleryKey = app.getImageKey();
    String galleryKey = settings.getImageKey(app.getGalleryAppId());

    //GcsFilename outfilename = new GcsFilename(GalleryApp.GALLERYBUCKET, galleryKey);
    GcsFilename outfilename = new GcsFilename(settings.getBucket(), galleryKey);
    GcsFileOptions options = new GcsFileOptions.Builder().mimeType("image/jpeg")
        .acl("public-read").cacheControl("no-cache").build();
    GcsOutputChannel writeChannel = gcsService.createOrReplace(outfilename, options);
    writeChannel.write(ByteBuffer.wrap(newImageData));

    // Now finalize
    writeChannel.close();

  } catch (IOException e) {
    // TODO Auto-generated catch block
    LOG.log(Level.INFO, "FAILED WRITING IMAGE TO GCS");
    e.printStackTrace();
  }
}
 

import com.google.appengine.api.images.ImagesService; //导入依赖的package包/类
@Provides
ImagesService provideImagesService() {
  return ImagesServiceFactory.getImagesService();
}