Upload any file android

Android Upload File to Server with Progress using Retrofit

Hi everyone, “Uploading File or Image to Backend Server” this is something that we often need to do in many applications. We already learned this concept in many previous posts. But things keep changing in this tech world and old methods are obsolete now. That is why here I am with this Android Upload File to Server with Progress Tutorial.

The method we will learn in this post is fully updated and will work in all devices, including Android 10.

Prerequisites

• XAMPP Server: We will use it for the backend, and ofcourse we will be using PHP and MySQL here for the backend part. But if you are comfortable with some other tech for handling the backend you can do it. We basically just need the API that will accept a file.
• Retrofit: We will be using this networking library in our Android Project.

If you want to learn building RESTFul API, that you can use in your production application then please subscribe to my YouTube channel and comment to any video that you want a production level RESTFul API Development Tutorial.

You can also learn the basics of RESTFul API Development using SLIM3 PHP Framework from the below given link.

Now let’s move into our post. We will start by designing our database.

What we will do is we will store the uploaded image to an uploads directory in the backend server and we will store the path to that image in our MySQL database. And you should remember this thing, we don’t store files in our MySQL database, we just store path to the file in the database.

Android Upload File to Server with Progress – Video

In case you are more comfortable watching video tutorial, then you can watch the above playlist that explains complete step by step guide about Uploading File to Server with Progress.

But in case you are ok reading a written tutorial, keep reading, we will do the same thing here.

Designing Database

• We will be using a very simple table. So just open PhpMyAdmin (I hope your XAMPP Server is running) and create a database. In my case I have created a table named ImageUploader.
• Now we need to create a table where we will store the uploaded files info. Run the following SQL query to create a table named uploads.

• As you can see we have 3 columns in our table (id, path and description).

Building Image Upload API

• We have the database, now let’s build the Image Upload API. For this I have a directory named ImageUploader inside my root folder that is htdocs for xampp.
• Inside this directory we will create a file named DbConnect.php.

• The above file will make our database connection. Now let’s create the script that will handle the file upload.
• Create a file named Api.php and write the following code.

• The above code handle two cases. The first one is to upload the file and the next is to fetch the uploaded files.

If you need the source code of the PHP Scripts, then you can get it from the below given link.

So we have the APIs ready, now let’s create our Android Project.

Android Upload File to Server with Progress

Creating an Android Project

• I have created a new project named ImageUploader using an EmptyActivity. Once the project is loaded, we will add required dependencies and internet permission.
• First add internet permission in your AndroidManifest.xml, you also need to add the usesCleartextTraffic=”true”.

• Now we will add the required dependencies.

Adding Dependencies

• Open app level build.gradle file and add the following dependencies inside dependencies block.

• After adding these lines, sync the project.

Designing User Interface

• Now let’s design the UI. Open activity_main.xml and write the following xml code.

• The above XML Code will generate the following output.

Android Upload File to Server with Progress

• As you can see we have a very simple User Interface for our upload operation.
• Now we need an Image to Upload it. And we will let the user choose the image from device. So our first task here is to let the user choose the image to upload.

Choosing an Image from Androids Gallery

• First define a var inside your MainActivity.kt. This var will keep the uri of the selected image file.

• Now we will create two different function inside our MainActivity.kt. One is to choose the image that we will use now and other to upload the image.
• We will also attach the click listeners to our ImageView and Button to call the functions as you can see in the below code.

• The above code snippet you need to put inside your onCreate() function.
• Inside MainActivity.kt we will define a constant that we will use for getting the selected image.

• Now we will define the function openImageChooser() that will open the image picker, and we will also override the function onActivityResult() to get the selected image.

• As you can see inside the function onActivityResult() we are storing the uri of the image to the var that we defined at the beginning. We are also displaying the image selected in our ImageView.

Here we have the tricky part, we have the Uri of the image, but to upload the image we need the real path of it. If you have seen my last tutorial about Uploading Image with Retrofit, then here we have used a function that provides the real path from Uri. But this doesn’t work anymore in Android 10.

Nowadays, android recommends us to use the app directory for file storage. Every app has its own app-specific storage directory for file storage that is not accessible to other apps, and all files stored here are removed when we uninstall the application. And the good thing is too access this area you don’t need any permission.

So what we need to do is, we need to select the file from the gallery and make a copy of it inside the app-specific storage directory.

But before doing the above mentioned thing we will setup the Retrofit.

Setting Up Retrofit for File Upload

If you have used Retrofit earlier, you know what we need to do. First we will create an interface to define the API Calls.

Источник

Android Upload File To Server Programmatically PHP-MySQL Tutorial

Read on Android Upload File To Server Programmatically PHP-MySQL Tutorial.

I will guide you how to upload any file to php-MySQL server from android app.

We will use httpclient and multipart functionality to accomplish our goal.

A PHP script will help us to establish interaction between android app and remote server.

Final Output Video

See the following video which gives the output.

PHP Scripts

We need to create one PHP file which will help us to insert the file on to the remote server as well as MySQL database.

Make a new php file and give it a name like config.php

Write down the below source lines in config.php

Create another PHP file and its name should be uploadfile.php

Following is the code for uploadfile.php

Now our PHP related work is complete. Now in your android studio, create a new project.

Step 1. Gradle Modifications

Every android studio have two types of gradle files.

First of all, open your build.gradle(Module :app) file, you need to add below lines in this file

First two lines are integrating some classes which will allow us to use httpclient and multipart in our android project.

Last line is for dexter library. This library will help us to simplify the process of asking the runtime permissions to the user.

After this, write the following lines in build.gradle(Module :app) file

So, final code for build.gradle(Module :app) file is as the below

Now it is time to update second gradle file which have the name like build.gradle(Project: Upload_file_Zerone). In this file name Upload_file_Zerone is the name of our android studio project.

Add the below line in this file

So last source code for build.gradle(Project: Upload_file_Zerone) is like the below

Step 2. Making Permissions

In this project, we need to have three permissions from user.

Add the following source lines in AndroidManifest.xml file.

I have defined three permissions : Internet, Read external storage and Write external storage.

We also need to write runtime permissions code but I will cover them in MainActivity.java file.

Step 3. Necessary Interface

Create a new Interface and set the name as “AsyncTaskCompleteListener.java”

Source snippet for AsyncTaskCompleteListener.java is as the below

We need to implement this interface in the main activity.

Step 4. Multipart related Class

Create a new JAVA class and set its name as MultiPartRequester.java

Write down the below lines in MultiPartRequester.java

This multipart class will help us to make http calls using its objects.

We will use this class as a library, so do not change anything in this class.

Step 5. Main Activity Works

This is the final step in this tutorial.

There are two main files in this project. One is activity_main.xml and another is MainActivity.java

First, add the below code in activity_main.xml

This layout file has one button and two text views.

One text view is static and we will not change it’s value. Another text view will hold the text as the URL of the uploaded file.

When the user clicks the button, system will open the file manager.

Now following is the code block for MainActivity.java file

Reading above code

First of all, see the below source

First line is making an object of button class. Second one is for text view class.

Third line is making one string variable and its value is google URL.

Fourth one making an integer variable which defines buffer size.

Fifth line is string variable which holds the “directory” where we will save the file.

Sixth line is integer variable and last one is making one araylist of Hashmaps.

Now read the onCreate() method. It holds a method requestMultiplePermissions()

Source lines for requestMultiplePermissions() method is as the following

This method is taking care of runtime permissions stuff.

We will ask for two permissions : Read and write external storage.

Method will use dexter library to implement professional behavior regarding runtime permission environment.

Now consider the following source snippet

System will run the above code when the user clicks the button.

It will create one intent which will led the user to the new screen.

New screen will open all the files of android device and user can select any one to upload it to the server.

Now see the below source lines

When user clicks the text view, compiler will open the URL in web browser to which file is uploaded.

After selecting the file from file manager, compiler will run the onActivityResult() method.

Below is the source for onActivityResult() method.

Compiler will first get the Uri of the selected file.

Then it will store the file using getFilePathFromURI() method. This method will return the path to the saved file.

Using this path, compiler will run the uploadPDFfile() function.

Below is the source lines for uploadPDFfile() function.

Here, compiler will create one Hashmap with string as a key and value.

It will add url in first map and a path to the file in the second map.

Then it will make the http call using the MultipartRequester class.

After successful http call, compiler will run the onTaskCompleted() method.

Following is the code snippet for onTaskCompleted() method.

In this method, compiler will have a JSON response in the string format.

It will parse this JSON response and will get the URL where the uploaded file resides.

Then it will set this URL as the value of the text view.

Источник

Android Upload File to Server with Progress

In this article, I’m going to explain how to upload file to server using Retrofit with ProgressBar. File uploading is very common functionality so now we brought a complete solution with the latest technology. In this demo, we are using Retrofit with RxJava for file uploading in the MVP design pattern.

Objective

• Get image from Camera/Gallery using FileProvider and show preview on ImageView
• Upload selected to server with progress and without ProgressBar

Android Upload File to Server with Progress

Prerequisite

To better understanding this article, You need to have basic knowledge of the following topics.

• You have to the idea about android Camera utilities
• Have basic knowledge of FileProvider
• How to use retrofit with RxJava
• Have working experience of the MVP Design Pattern.

Read our previous article that give you idea about Camera, FileProvider and MVP

1. Create a new Project

Open Android Studio and create a new project with BasicActivity template in Android

2. Add Dependency

2.1 Now open build.gradle file and add following dependency

2.2 Now go to parent build.gradle (Project level build.gradle) add all dependency version in single place

2.3. Set Java Source 1.8 for using lambda expression

Inside build.gradle set source compatibility and target compatibility java version 1.8 in compile options

3. Add Uses Permission

Add Storage, Camera and Internet permission and uses features in AndroidManifest.xml

4. Create a FileProvider

4.1 In this demo, we get file and Camera/Gallery so we need file provider access for getting file URI. So declare provider in AndroidManifest.xml inside Tag.

4.2 So, define a file provider path. go to res folder and create an XML folder after that create a file with name file_provider_paths.

You must replace com.androidwave.fileupload with your package name

5. Create a Contract for Image for developing MVP design pattern

Go to src folder and create a new source folder name picker for image src ImageContract. Meanwhile, Create a new file inside picker folder with ImageContract.java .

6. Prepare Image Presenter

Go to src=>picker folder and create a new file with ImagePresenter which implementing ImageContract.Presenter class.

So now first part of this project is defined now come to second part which is image uploading

7. Write a Contract for File Uploading

Go to src folder and create a new file with name FileUploaderContract and defined blueprint of Model, View and Presenter.

8. Furthermore, Define File Uploader Model

Simply create a file with FileUploaderModel names and implement FileUploaderContract.Model

9. Create a presenter for File Uploading

Same as previously create a file with FileUploaderPresenter and implement FileUploaderContract.Presenter

Finally, MVP stuff is almost complete

10. Create an API interface for using Retrofit lib

Go in src folder and create an interface with FileUploadService names and create an on file upload method

11. Create Retrofit instance

In src folder create a Retrofit utility class which return Retrofit client using OkHttpClient and RxJava2 CallAdapter

12 . Open build.gradle file define BASE_URL like below

While creating the project, We were selected BasicActivity template. So, MainActivty.java and activity_main.xml was automatically created.

13. Open activity_main.xml and create a profile view using below code

14. Open MainActivity and do following this

In this activity, I dividing into three-part

1. Bind view with an activity using Butterknife
2. Getting Image from camera/gallery
3. Compress the file using FileCompressor utility. (I have explained or the previous article Read Here )
4. Upload selected to the server

Bind view with activity using Butterknife

Go to setContentView layout xml name do right click and sleeted generate after that generate butter knife injection

Источник