Upload an image from Android to Amazon S3?

Question

I need to upload a bitmap to Amazon S3. I have never used S3, and the docs are proving less than helpful as I can't see anything to cover this specific requirement. Unfortunately I'm struggling to find time on this project to spend a whole day learning how it all hangs together so hoping one of you kind people can give me some pointers.

Can you point to me to a source of reference that explains how to push a file to S3, and get a URL reference in return?

More specifically: - Where do the credentials go when using the S3 Android SDK? - Do I need to create a bucket before uploading a file, or can they exist outside buckets? - Which SDK method do I use to push a bitmap up to S3? - Am I right in thinking I need the CORE and S3 libs to do what I need, and no others?

Answer 1

you can upload image and download image in s3 amazon. you make a simple class use this WebserviceAmazon

public class WebserviceAmazon extends AsyncTask<Void, Void, Void> {
private String mParams;
private String mResult = "x";
WebServiceInterface<String, String> mInterface;
private int mRequestType;
private  String UserId;
private Context mContext;


public WebserviceAmazon(Context context,String imagePath,String AppId,int type) {
    this.mContext = context;
    this.mParams = imagePath;
    this.mRequestType = type;
    this.UserId = AppId;
}

public void result(WebServiceInterface<String, String> myInterface) {
    this.mInterface = myInterface;
}

@Override
protected Void doInBackground(Void... params) {
    String ACCESS_KEY ="abc..";
    String SECRET_KEY = "klm...";

    try {
        if (mRequestType == 1) { // POST
            AmazonS3Client s3Client = new AmazonS3Client(new BasicAWSCredentials(ACCESS_KEY, SECRET_KEY));
            PutObjectRequest request = new PutObjectRequest("bucketName", "imageName", new File(mParams));
            s3Client.putObject(request);

            mResult = "success";
        } if (mRequestType == 2) { // For get image data
            AmazonS3Client s3Client = new AmazonS3Client(new BasicAWSCredentials(ACCESS_KEY, SECRET_KEY));
            S3Object object = s3Client.getObject(new GetObjectRequest("bucketName", mParams));
            S3ObjectInputStream objectContent = object.getObjectContent();
            byte[] byteArray = IOUtils.toByteArray(objectContent);

           Bitmap bitmap = BitmapFactory.decodeByteArray(byteArray, 0, byteArray.length);



            mResult = "success";
        }

    } catch (Exception e) {
        mResult = e.toString();
        e.printStackTrace();
    }
    return null;
}

@Override
protected void onPreExecute() {
    // TODO Auto-generated method stub
    super.onPreExecute();
}

@Override
protected void onPostExecute(Void result) {
    // TODO Auto-generated method stub
  super.onPostExecute(result);
    mInterface.success(this.mResult);

}

public interface WebServiceInterface<E, R> {
    public void success(E reslut);

    public void error(R Error);
}

}

call this webservice any where in project

    WebserviceAmazon amazon = new WebserviceAmazon(getActivity(), imageName, "", 2);
    amazon.result(new WebserviceAmazon.WebServiceInterface<String, String>() {
        @Override
        public void success(String reslut) {

        }

        @Override
        public void error(String Error) {

        }
    });

    return totalPoints;
}

Answer 2

You can use a library called S3UploadService. First you would need to convert your Bitmap to a File. To do so take a look at this post:

Convert Bitmap to File

S3UploadService is a library that handles uploads to Amazon S3. It provides a service called S3UploadService with a static method where you provide a Context (so the static method can start the service), a File, a boolean indicating if said file should be deleted after upload completion and optionally you can set a callback (Not like an ordinary callback though. The way this works is explained in the README file).

It's an IntentService so the upload will run even if the user kills the app while uploading (because its lifecycle is not attached to the app's lifecycle).

To use this library you just have to declare the service in your manifest:

<application
    ...>

    ...

    <service
        android:name="com.onecode.s3.service.S3UploadService"
        android:exported="false" />
</application>

Then you build an S3BucketData instance and make a call to S3UploadService.upload():

    S3Credentials s3Credentials = new S3Credentials(accessKey, secretKey, sessionToken);
    S3BucketData s3BucketData = new S3BucketData.Builder()
            .setCredentials(s3Credentials)
            .setBucket(bucket)
            .setKey(key)
            .setRegion(region)
            .build();

    S3UploadService.upload(getActivity(), s3BucketData, file, null);

To add this library you need to add the JitPack repo to your root build.gradle:

allprojects {
    repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}

and then add the dependency:

dependencies {
    compile 'com.github.OneCodeLabs:S3UploadService:1.0.0@aar'
}

Here is a link to the repo: https://github.com/OneCodeLabs/S3UploadService

This answer is a bit late, but I hope it helps someone

Answer 3

you can use the below mentioned class to Upload data to amazon s3 buckets.

public class UploadAmazonS3{

private CognitoCachingCredentialsProvider credentialsProvider = null;
private AmazonS3Client s3Client = null;
private TransferUtility transferUtility = null;
private static UploadAmazonS3 uploadAmazonS3;

/**
 * Creating single tone object by defining private.
 * <P>
 *     At the time of creating
 * </P>*/
private UploadAmazonS3(Context context, String canito_pool_id)
{
    /**
     * Creating the object of the getCredentialProvider object. */
    credentialsProvider=getCredentialProvider(context,canito_pool_id);
    /**
     * Creating the object  of the s3Client */
    s3Client=getS3Client(context,credentialsProvider);

    /**
     * Creating the object of the TransferUtility of the Amazone.*/
    transferUtility=getTransferUtility(context,s3Client);

}

public static UploadAmazonS3 getInstance(Context context, String canito_pool_id)
{
    if(uploadAmazonS3 ==null)
    {
        uploadAmazonS3 =new UploadAmazonS3(context,canito_pool_id);
        return uploadAmazonS3;
    }else
    {
        return uploadAmazonS3;
    }

}

/**
 * <h3>Upload_data</h3>
 * <P>
 *     Method is use to upload data in the amazone server.
 *
 * </P>*/

public void uploadData(final String bukkate_name, final File file, final Upload_CallBack callBack)
{
    Utility.printLog("in amazon upload class uploadData "+file.getName());

    if(transferUtility!=null&&file!=null)
    {
        TransferObserver observer=transferUtility.upload(bukkate_name,file.getName(),file);
        observer.setTransferListener(new TransferListener()
        {
            @Override
            public void onStateChanged(int id, TransferState state)
            {
                if(state.equals(TransferState.COMPLETED))
                {
                    callBack.sucess(com.tarha_taxi.R.string.AMAZON_END_POINT_LINK+bukkate_name+"/"+file.getName());
                }
            }

            @Override
            public void onProgressChanged(int id, long bytesCurrent, long bytesTotal)
            {

            }
            @Override
            public void onError(int id, Exception ex)
            {
                callBack.error(id+":"+ex.toString());

            }
        });
    }else
    {
        callBack.error("Amamzones3 is not intialize or File is empty !");
    }
}

/**
 * This method is used to get the CredentialProvider and we provide only context as a parameter.
 * @param context Here, we are getting the context from calling Activity.*/
private CognitoCachingCredentialsProvider getCredentialProvider(Context context,String pool_id)
{
    if (credentialsProvider == null)
    {
        credentialsProvider = new CognitoCachingCredentialsProvider(
                context.getApplicationContext(),
                pool_id, // Identity Pool ID
                AMAZON_REGION // Region
        );
    }
    return credentialsProvider;
}

/**
 * This method is used to get the AmazonS3 Client
 * and we provide only context as a parameter.
 * and from here we are calling getCredentialProvider() function.
 * @param context Here, we are getting the context from calling Activity.*/
private AmazonS3Client getS3Client(Context context,CognitoCachingCredentialsProvider cognitoCachingCredentialsProvider)
{
    if (s3Client == null)
    {
        s3Client = new AmazonS3Client(cognitoCachingCredentialsProvider);
        s3Client.setRegion(Region.getRegion(AMAZON_REGION));
        s3Client.setEndpoint(context.getString(com.tarha_taxi.R.string.AMAZON_END_POINT_LINK));
    }
    return s3Client;
}

/**
 * This method is used to get the Transfer Utility
 * and we provide only context as a parameter.
 * and from here we are, calling getS3Client() function.
 * @param context Here, we are getting the context from calling Activity.*/
private TransferUtility getTransferUtility(Context context,AmazonS3Client amazonS3Client)
{
    if (transferUtility == null)
    {
        transferUtility = new TransferUtility(amazonS3Client,context.getApplicationContext());
    }
    return transferUtility;
}

/**
 * Interface for the sucess callback fro the Amazon uploading .
 * */
public interface Upload_CallBack
{
    /**
     *Method for sucess .
     * @param sucess it is true on sucess and false for falure.*/
    void sucess(String sucess);
    /**
     * Method for falure.
     * @param errormsg contains the error message.*/
    void error(String errormsg);

}

}

use the below method to access the above calss :

 private void uploadToAmazon() {
    dialogL.show();
    UploadAmazonS3 amazonS3 = UploadAmazonS3.getInstance(getActivity(), getString(R.string.AMAZON_POOL_ID));
    amazonS3.uploadData(getString(R.string.BUCKET_NAME), Utility.renameFile(VariableConstants.TEMP_PHOTO_FILE_NAME, phone.getText().toString().substring(1) + ".jpg"), new UploadAmazonS3.Upload_CallBack() {
        @Override
        public void sucess(String sucess) {
            if (Utility.isNetworkAvailable(getActivity())) {
                dialogL.dismiss();
                /**
                 * to set the image into image view and
                 * add the write the image in the file
                 */
                activity.user_image.setTag(setTarget(progress_bar));
                Picasso.with(getActivity()).load(getString(R.string.AMAZON_IMAGE_LINK) + phone.getText().toString().substring(1) + ".jpg").
                        networkPolicy(NetworkPolicy.NO_CACHE).memoryPolicy(MemoryPolicy.NO_CACHE).into((Target) activity.user_image.getTag());

                Utility.printLog("amazon upload success ");
                new BackgroundForUpdateProfile().execute();
            } else {
                dialogL.dismiss();
                Utility.showToast(getActivity(), getResources().getString(R.string.network_connection_fail));
            }
        }

        @Override
        public void error(String errormsg) {
            dialogL.dismiss();
            Utility.showToast(getActivity(), getResources().getString(R.string.network_connection_fail));
        }
    });
}

Answer 4

We can directly use "Amazone s3" bucket for storing any type of file on server, and we did not need to send any of file to Api server it will reduce the request time.

Gradle File :-

 compile 'com.amazonaws:aws-android-sdk-core:2.2.+'
    compile 'com.amazonaws:aws-android-sdk-s3:2.2.+'
    compile 'com.amazonaws:aws-android-sdk-ddb:2.2.+'

Manifest File :-

<service android:name="com.amazonaws.mobileconnectors.s3.transferutility.TransferService"
            android:enabled="true" />

FileUploader Function in any Class :-

 private void setUPAmazon() {
 //we Need Identity Pool ID  like :- "us-east-1:f224****************8"
        CognitoCachingCredentialsProvider credentialsProvider = new CognitoCachingCredentialsProvider(getActivity(),
                "us-east-1:f224****************8", Regions.US_EAST_1);
        AmazonS3 s3 = new AmazonS3Client(credentialsProvider);
        final TransferUtility transferUtility = new TransferUtility(s3, getActivity());
        final File file = new File(mCameraUri.getPath());
        final TransferObserver observer = transferUtility.upload(GeneralValues.AMAZON_BUCKET, file.getName(), file, CannedAccessControlList.PublicRead);
        observer.setTransferListener(new TransferListener() {
            @Override
            public void onStateChanged(int id, TransferState state) {
                Log.e("onStateChanged", id + state.name());
                if (state == TransferState.COMPLETED) {
                    String url = "https://"+GeneralValues.AMAZON_BUCKET+".s3.amazonaws.com/" + observer.getKey();
                    Log.e("URL :,", url);
//we just need to share this File url with Api service request.  
                }
            }

            @Override
            public void onProgressChanged(int id, long bytesCurrent, long bytesTotal) {
            }

            @Override
            public void onError(int id, Exception ex) {
                Toast.makeText(getActivity(), "Unable to Upload", Toast.LENGTH_SHORT).show();
                ex.printStackTrace();
            }
        });
    }

Answer 5

Take a look at the Amazon S3 API documentation to get a feel for what can and can't be done with Amazon S3. Note that there are two APIs, a simpler REST API and a more-involved SOAP API.

You can write your own code to make HTTP requests to interact with the REST API, or use a SOAP library to consume the SOAP API. All of the Amazon services have these standard API endpoints (REST, SOAP) and in theory you can write a client in any programming language!

Fortunately for Android developers, Amazon have released a (Beta) SDK that does all of this work for you. There's a Getting Started guide and Javadocs too. With this SDK you should be able to integrate S3 with your application in a matter of hours.

The Getting Started guide comes with a full sample and shows how to supply the required credentials.

Conceptually, Amazon S3 stores data in Buckets where a bucket contains Objects. Generally you'll use one bucket per application, and add as many objects as you like. S3 doesn't support or have any concept of folders, but you can put slashes (/) in your object names.

Answer 6

String      ACCESS_KEY="****************",
            SECRET_KEY="****************",
            MY_BUCKET="bucket_name",
            OBJECT_KEY="unique_id";              
  AWSCredentials credentials = new BasicAWSCredentials(ACCESS_KEY, SECRET_KEY);
                AmazonS3 s3 = new AmazonS3Client(credentials);
                java.security.Security.setProperty("networkaddress.cache.ttl" , "60");
                s3.setRegion(Region.getRegion(Regions.AP_SOUTHEAST_1));
                s3.setEndpoint("https://s3-ap-southeast-1.amazonaws.com/");
                List<Bucket> buckets=s3.listBuckets();
                for(Bucket bucket:buckets){
                    Log.e("Bucket ","Name "+bucket.getName()+" Owner "+bucket.getOwner()+ " Date " + bucket.getCreationDate());
                }
                Log.e("Size ", "" + s3.listBuckets().size());
                TransferUtility transferUtility = new TransferUtility(s3, getApplicationContext());
                UPLOADING_IMAGE=new File(Environment.getExternalStorageDirectory().getPath()+"/Screenshot.png");
                TransferObserver observer = transferUtility.upload(MY_BUCKET,OBJECT_KEY,UPLOADING_IMAGE);
                observer.setTransferListener(new TransferListener() {
                    @Override
                    public void onStateChanged(int id, TransferState state) {
                        // do something
                        progress.hide();
                        path.setText("ID "+id+"\nState "+state.name()+"\nImage ID "+OBJECT_KEY);

                    }

                    @Override
                    public void onProgressChanged(int id, long bytesCurrent, long bytesTotal) {
                        int percentage = (int) (bytesCurrent / bytesTotal * 100);
                        progress.setProgress(percentage);
                        //Display percentage transfered to user
                    }

                    @Override
                    public void onError(int id, Exception ex) {
                        // do something
                        Log.e("Error  ",""+ex );
                    }

                });