Fatal编程技术网
  • android/
  • Android 将原始大小的图像上载到服务器

Android 将原始大小的图像上载到服务器

android image

Android 将原始大小的图像上载到服务器,android,image,Android,Image,我正在将图像上载到服务器，但问题是，当我缩放图像并将其上载到服务器时，图像工作正常，但图像太小…如何在服务器端获取原始大小的图像…如果不缩放，我将内存不足异常。。。。是否有任何方法可以使用，我可以上传我的图像到服务器或我可以转换成缩放图像回到以前的一个。我已经在清单中使用了大堆。请帮帮我 imageUpload=BitmapFactory.decodeFile(file_path); stream = new ByteArrayOutputStream();

我正在将图像上载到服务器，但问题是，当我缩放图像并将其上载到服务器时，图像工作正常，但图像太小…如何在服务器端获取原始大小的图像…如果不缩放，我将内存不足异常。。。。是否有任何方法可以使用，我可以上传我的图像到服务器或我可以转换成缩放图像回到以前的一个。我已经在清单中使用了大堆。请帮帮我

imageUpload=BitmapFactory.decodeFile(file_path);
           stream = new ByteArrayOutputStream();
          imageUpload1 = Bitmap.createScaledBitmap( imageUpload, 100, 50, true);
           imageUpload1.compress(Bitmap.CompressFormat.JPEG, 60, stream); //compress to which format you want.
           /*ImageView imageView = (ImageView) findViewById(R.id.imageView);
           imageView.setImageResource(imageupload1);*/

           byte_arr = stream.toByteArray();
//          image_str = Base64.encodeToString(byte_arr, Base64.DEFAULT);




          //  albumThumbnail = Base64.encodeToString(byte_arr, Base64.DEFAULT);
             albumThumbnail = Base64.encodeBytes(byte_arr);

          //add this line
            imageUpload1.recycle();
            imageUpload1= null;

          }
    }

    private void uplaodImageServer() 
    {
        getDateAndTime();
        albumName=albumTitle.getText().toString();

        Log.e("albumname",albumName);
        Log.e("filePath",file_path);

        List<NameValuePair> params = new ArrayList<NameValuePair>();
        params.add(new BasicNameValuePair("albumtitle",albumName));
        params.add(new BasicNameValuePair("albumthumbnail", albumThumbnail));
        params.add(new BasicNameValuePair("dateCreated",dateCreated));
        params.add(new BasicNameValuePair("filePath",file_path));
        params.add(new BasicNameValuePair("imagename",uploadImageName));
         // FileBody bin = new FileBody(file);


          try
          {
                HttpClient httpclient = new DefaultHttpClient();
                httppost=new HttpPost("http://ur ip address/freeJeetoAndroid/CreateAlbum.php");
                httppost.setEntity(new UrlEncodedFormEntity(params));
                HttpResponse response = httpclient.execute(httppost);
                HttpEntity entity = response.getEntity();
                is = entity.getContent();
        }catch(Exception e){
                Log.e("log_tag", "Error in http connection "+e.toString());
        }

imageUpload=BitmapFactory.decodeFile（文件路径）；
stream=newbytearrayoutputstream（）；
imageUpload1=Bitmap.createScaledBitmap（imageUpload，100，50，true）；
imageUpload1.compress（位图.CompressFormat.JPEG，60，流）//压缩到您想要的格式。
/*ImageView ImageView=（ImageView）findViewById（R.id.ImageView）；
setImageResource（imageupload1）*/
byte_arr=stream.toByteArray（）；
//image\u str=Base64.encodeToString（byte\u arr，Base64.DEFAULT）；
//albumThumbnail=Base64.encodeToString（byte\u arr，Base64.DEFAULT）；
albumThumbnail=Base64.encodeBytes（byte_arr）；
//添加这一行
imageUpload1.recycle（）；
imageUpload1=null；
}
}
私有void uplaodImageServer（）
{
getDateAndTime（）；
albumName=albumTitle.getText（）.toString（）；
Log.e（“albumname”，albumname）；
Log.e（“文件路径”，文件路径）；
List params=new ArrayList（）；
添加（新的BasicNameValuePair（“albumtitle”，albumName））；
添加（新的BasicNameValuePair（“相册缩略图”，相册缩略图））；
添加（新的BasicNameValuePair（“dateCreated”，dateCreated））；
添加（新的BasicNameValuePair（“文件路径”，文件路径））；
添加（新的BasicNameValuePair（“imagename”，uploadImageName））；
//FileBody bin=新的FileBody（文件）；
尝试
{
HttpClient HttpClient=新的DefaultHttpClient（）；
httppost=新的httppost（“http://ur ip地址/freeJeetoAndroid/CreateAlbum.php”）；
setEntity（新的UrlEncodedFormEntity（参数））；
HttpResponse response=httpclient.execute（httppost）；
HttpEntity=response.getEntity（）；
is=entity.getContent（）；
}捕获（例外e）{
e（“Log_标记”，“http连接错误”+e.toString（））；
}
您好，我找到了上述问题的解决方案。希望它能帮助其他人

protected void onActivityResult(int requestCode, int resultCode, Intent data) {
          if (requestCode == PICK_IMAGE && resultCode == RESULT_OK) {

           Uri selectedImage = data.getData();
           String[] filePathColumn = { MediaStore.Images.Media.DATA };

           Cursor cursor = getContentResolver().query(selectedImage,
             filePathColumn, null, null, null);
           cursor.moveToFirst();
           columnindex = cursor.getColumnIndex(filePathColumn[0]);
           file_path = cursor.getString(columnindex);
           // Log.e("Attachment Path:", attachmentFile);
          // tv_attach.setText(file_path);
           Log.e("file_path",file_path);
           URI = Uri.parse("file://" + file_path);

           //Retrieve filename and extension

           Filename imageFileName = new Filename(file_path, '/', '.');
           extension=imageFileName.extension();
           fileName=imageFileName.filename();
           System.out.println("Extension = " + imageFileName.extension());
           System.out.println("Filename = " + imageFileName.filename());
           //System.out.println("Path = " + imageFileName.path());
           cursor.close();

           uploadImageName=fileName+"."+extension;
           imagename.setText(uploadImageName);


           BitmapFactory.Options options = new BitmapFactory.Options();

//        by setting this field as true, the actual bitmap pixels are not loaded in the memory. Just the bounds are loaded. If
//        you try the use the bitmap here, you will get null.
            options.inJustDecodeBounds = true;
            Bitmap bmp = BitmapFactory.decodeFile(file_path, options);

            int actualHeight = options.outHeight;
            int actualWidth = options.outWidth;

//        max Height and width values of the compressed image is taken as 816x612

            float maxHeight = 816.0f;
            float maxWidth = 612.0f;
            float imgRatio = actualWidth / actualHeight;
            float maxRatio = maxWidth / maxHeight;

//        width and height values are set maintaining the aspect ratio of the image

            if (actualHeight > maxHeight || actualWidth > maxWidth) {
                if (imgRatio < maxRatio) {               imgRatio = maxHeight / actualHeight;                actualWidth = (int) (imgRatio * actualWidth);               actualHeight = (int) maxHeight;             } else if (imgRatio > maxRatio) {
                    imgRatio = maxWidth / actualWidth;
                    actualHeight = (int) (imgRatio * actualHeight);
                    actualWidth = (int) maxWidth;
                } else {
                    actualHeight = (int) maxHeight;
                    actualWidth = (int) maxWidth;

                }
            }

//        setting inSampleSize value allows to load a scaled down version of the original image

            options.inSampleSize = calculateInSampleSize(options, actualWidth, actualHeight);

//        inJustDecodeBounds set to false to load the actual bitmap
            options.inJustDecodeBounds = false;

//        this options allow android to claim the bitmap memory if it runs low on memory
            options.inPurgeable = true;
            options.inInputShareable = true;
            options.inTempStorage = new byte[16 * 1024];

            try {
//            load the bitmap from its path
                bmp = BitmapFactory.decodeFile(file_path, options);
            } catch (OutOfMemoryError exception) {
                exception.printStackTrace();

            }
            try {
                scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight,Bitmap.Config.ARGB_8888);
            } catch (OutOfMemoryError exception) {
                exception.printStackTrace();
            }

            float ratioX = actualWidth / (float) options.outWidth;
            float ratioY = actualHeight / (float) options.outHeight;
            float middleX = actualWidth / 2.0f;
            float middleY = actualHeight / 2.0f;

            Matrix scaleMatrix = new Matrix();
            scaleMatrix.setScale(ratioX, ratioY, middleX, middleY);

            Canvas canvas = new Canvas(scaledBitmap);
            canvas.setMatrix(scaleMatrix);
            canvas.drawBitmap(bmp, middleX - bmp.getWidth() / 2, middleY - bmp.getHeight() / 2, new Paint(Paint.FILTER_BITMAP_FLAG));

//        check the rotation of the image and display it properly
            ExifInterface exif;
            try {
                exif = new ExifInterface(file_path);

                int orientation = exif.getAttributeInt(
                        ExifInterface.TAG_ORIENTATION, 0);
                Log.d("EXIF", "Exif: " + orientation);
                Matrix matrix = new Matrix();
                if (orientation == 6) {
                    matrix.postRotate(90);
                    Log.d("EXIF", "Exif: " + orientation);
                } else if (orientation == 3) {
                    matrix.postRotate(180);
                    Log.d("EXIF", "Exif: " + orientation);
                } else if (orientation == 8) {
                    matrix.postRotate(270);
                    Log.d("EXIF", "Exif: " + orientation);
                }
                scaledBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                        scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix,
                        true);
            } catch (IOException e) {
                e.printStackTrace();
            }


            stream = new ByteArrayOutputStream();
//            write the compressed bitmap at the destination specified by filename.
                scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 80, stream);




//         imageUpload=BitmapFactory.decodeFile(file_path);

            //imageUpload1 = Bitmap.createScaledBitmap( imageUpload, 256, 256, true);
//           imageUpload.compress(Bitmap.CompressFormat.PNG, 50, stream); //compress to which format you want.
           /*ImageView imageView = (ImageView) findViewById(R.id.imageView);
           imageView.setImageResource(imageupload1);*/

           byte_arr = stream.toByteArray();
//          image_str = Base64.encodeToString(byte_arr, Base64.DEFAULT);




          //  albumThumbnail = Base64.encodeToString(byte_arr, Base64.DEFAULT);
             albumThumbnail = Base64.encodeBytes(byte_arr);

          //add this line
//          imageUpload.recycle();
//          imageUpload= null;

          }
    }

          public int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
                final int height = options.outHeight;
                final int width = options.outWidth;
                int inSampleSize = 1;

                if (height > reqHeight || width > reqWidth) {
                    final int heightRatio = Math.round((float) height/ (float) reqHeight);
                    final int widthRatio = Math.round((float) width / (float) reqWidth);
                    inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;      }       final float totalPixels = width * height;       final float totalReqPixelsCap = reqWidth * reqHeight * 2;       while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) {
                    inSampleSize++;
                }

                return inSampleSize;
            }

activityresult上受保护的void（int-requestCode、int-resultCode、Intent-data）{
if（requestCode==PICK_IMAGE&&resultCode==RESULT_OK）{
Uri selectedImage=data.getData（）；
字符串[]filePathColumn={MediaStore.Images.Media.DATA}；
Cursor Cursor=getContentResolver（）.query（selectedImage，
filePathColumn，null，null，null）；
cursor.moveToFirst（）；
columnindex=cursor.getColumnIndex（filePathColumn[0]）；
file_path=cursor.getString（columnindex）；
//Log.e（“附件路径：”，attachmentFile）；
//tv_attach.setText（文件路径）；
Log.e（“文件路径”，文件路径）；
URI=URI.parse（“文件：/”+文件路径）；
//检索文件名和扩展名
Filename imageFileName=新文件名（文件路径“/”、“.”）；
extension=imageFileName.extension（）；
fileName=imageFileName.fileName（）；
System.out.println（“Extension=“+imageFileName.Extension（））；
System.out.println（“Filename=“+imageFileName.Filename（））；
//System.out.println（“Path=“+imageFileName.Path（））；
cursor.close（）；
uploadImageName=文件名+“+”扩展名；
setText（上传的imagename）；
BitmapFactory.Options=new-BitmapFactory.Options（）；
//通过将此字段设置为true，实际位图像素不会加载到内存中。只加载边界。如果
//如果您尝试在此处使用位图，将得到null。
options.inJustDecodeBounds=true；
位图bmp=BitmapFactory.decodeFile（文件路径，选项）；
int实际高度=options.outHeight；
int actualWidth=options.outWidth；
//压缩图像的最大高度和宽度值为816x612
浮动最大高度=816.0f；
浮动最大宽度=612.0f；
浮动高度=实际宽度/实际高度；
浮点最大比值=最大宽度/最大高度；
//设置宽度和高度值以保持图像的纵横比
如果（实际高度>最大高度| |实际宽度>最大宽度）{
if（imgRatiomaxRatio）{
imgRatio=最大宽度/实际宽度；
实际高度=（int）（imgRatio*实际高度）；
实际宽度=（int）最大宽度；
}否则{
实际高度=（int）最大高度；
实际宽度=（int）最大宽度；
}
}
//设置inSampleSize值允许加载原始图像的缩小版本
options.inSampleSize=calculateInSampleSize（选项、实际宽度、实际高度）；
//inJustDecodeBounds设置为false以加载实际位图
options.inJustDecodeBounds=false；
//此选项允许android在内存不足时声明位图内存
options.inpurgable=true；
options.inInputShareable=true；
options.inTempStorage=新字节[16*1024]；
试一试{
//从位图路径加载位图
bmp=BitmapFactory.decodeFile（文件路径，选项）；