Welcome to Android Upload Video to Server using volley, retrofit 2 and multipart.
Table of Content
1. Android Upload Video To Server (PHP-MySQL) Programmatically
2. Android Upload Video To Server Using Volley PHP MySQL Server Multipart
3. Android Upload Video To Server Using Retrofit 2 Multipart PHP-MySQL
1. Android Upload Video To Server (PHP-MySQL) Programmatically
Read Android Upload Video To Server (PHP-MySQL) Programmatically in this tutorial.
You will learn how to upload video to server using multipart in android with example.
We will first select the video from gallery and then we will upload it using multipart.
First of all, check the output video to see the demonstration of this example.
Upload Video To Server
PHP Workaround
We need to use php files to save the video from android device to the web or remote server.
so create a new PHP file and give it a name like config.php
Source structure for this file is as the below
<?php
$host="localhost";
$user="your username";
$password="your password";
$db = "your db name";
$con = mysqli_connect($host,$user,$password,$db);
// Check connection
if (mysqli_connect_errno())
{
echo "Failed to connect to MySQL: " . mysqli_connect_error();
}else{ //echo "Connect";
}
?>
We also need one more PHP file. Give these newly created file a name like uploadfile.php
Following is the source writings for uploadfile.php
<?php
if($_SERVER['REQUEST_METHOD']=='POST'){
// echo $_SERVER["DOCUMENT_ROOT"]; // /home1/demonuts/public_html
//including the database connection file
include_once("config.php");
//$_FILES['image']['name'] give original name from parameter where 'image' == parametername eg. city.jpg
//$_FILES['image']['tmp_name'] temporary system generated name
$originalImgName= $_FILES['filename']['name'];
$tempName= $_FILES['filename']['tmp_name'];
$folder="uploadedFiles/";
$url = "https://www.demonuts.com/Demonuts/JsonTest/Tennis/uploadedFiles/".$originalImgName; //update path as per your directory structure
if(move_uploaded_file($tempName,$folder.$originalImgName)){
$query = "INSERT INTO upload_image_video (pathToFile) VALUES ('$url')";
if(mysqli_query($con,$query)){
$query= "SELECT * FROM upload_image_video WHERE pathToFile='$url'";
$result= mysqli_query($con, $query);
$emparray = array();
if(mysqli_num_rows($result) > 0){
while ($row = mysqli_fetch_assoc($result)) {
$emparray[] = $row;
}
echo json_encode(array( "status" => "true","message" => "Successfully file added!" , "data" => $emparray) );
}else{
echo json_encode(array( "status" => "false","message" => "Failed!") );
}
}else{
echo json_encode(array( "status" => "false","message" => "Failed!") );
}
//echo "moved to ".$url;
}else{
echo json_encode(array( "status" => "false","message" => "Failed!") );
}
}
?>
Okay, now come to android studio and make a new project with empty activity.
Step 1. Updating Gradle files
To use multipart, we need to import some files regarding http classes.
So in your build.gradle(Module :app) file, write the following lines
implementation group: 'org.apache.httpcomponents' , name: 'httpclient-android' , version: '4.3.5.1'
implementation('org.apache.httpcomponents:httpmime:4.3') {
exclude module: "httpclient"
}
implementation 'com.karumi:dexter:5.0.0'
First three lines from the above code are giving us the access to the classes related to http client, http mime and other useful apache resources.
These resources will allow us to make http calls fluently.
Last line is integrating the dexter library. This library is designed to simplify the runtime permission architecture.
Now in this same file build.gradle(Module :app) , also add below snippet inside the android {..} structure.
android{
useLibrary 'org.apache.http.legacy'
}
packagingOptions {
exclude 'META-INF/LICENSE'
exclude 'META-INF/NOTICE'
}
So the final source code for build.gradle(Module :app) file is looking like the following snippet
apply plugin: 'com.android.application'
android {
compileSdkVersion 27
defaultConfig {
applicationId "com.example.parsaniahardik.uploadvideozerone"
minSdkVersion 15
targetSdkVersion 27
versionCode 1
versionName "1.0"
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
android{
useLibrary 'org.apache.http.legacy'
}
packagingOptions {
exclude 'META-INF/LICENSE'
exclude 'META-INF/NOTICE'
}
}
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'com.android.support:appcompat-v7:27.1.1'
implementation 'com.android.support.constraint:constraint-layout:1.1.3'
testImplementation 'junit:junit:4.12'
androidTestImplementation 'com.android.support.test:runner:1.0.2'
androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
implementation group: 'org.apache.httpcomponents' , name: 'httpclient-android' , version: '4.3.5.1'
implementation('org.apache.httpcomponents:httpmime:4.3') {
exclude module: "httpclient"
}
implementation 'com.karumi:dexter:5.0.0'
}
Now we also have another gradle file and it should have the name like build.gradle(Project: uploadVideoZerone)
In this file, you need to add the following line
maven { url 'https://jitpack.io' }
After this, whole code for build.gradle(Project: uploadVideoZerone) file is like the below
// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
repositories {
google()
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.1.2'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
}
}
allprojects {
repositories {
google()
jcenter()
maven { url 'https://jitpack.io' }
}
}
task clean(type: Delete) {
delete rootProject.buildDir
}
Make sure that you have updated both the gradle files correctly.
It is primary requirement to develop this upload video from android project.
Step 2. Manifest and Permissions
Now we need to have some basic permissions in this tutorial.
In your AndroidManifest.xml file, add the following lines
<uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
Three permissions are there. First one is internet, which will allow system to use the internet of android device.
Second and third lines will allow our app to read and write some files in external storage of android device.
We also need to ask for runtime permissions but, we will do this in Main Activity.
Step 3. One and only Interface
Make a new JAVA class and give it a name like AsyncTaskCompleteListener.java
Source code for this interface is like the following
/**
* Created by Parsania Hardik on 19/01/2016.
*/
public interface AsyncTaskCompleteListener {
void onTaskCompleted(String response, int serviceCode);
}
We will implement this interface in main activity. So we will override onTaskCompleted() method in main activity.
Step 4. Multipart Class
Create a new JAVA class and give it a name like MultiPartRequester.java
Add the following source code in MultiPartRequester.java
import android.app.Activity;
import android.app.ActivityManager;
import android.content.Context;
import android.os.AsyncTask;
import android.util.Log;
import android.widget.Toast;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.MIME;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.util.EntityUtils;
import java.io.File;
import java.util.Map;
public class MultiPartRequester {
private Map<String, String> map;
private AsyncTaskCompleteListener mAsynclistener;
private int serviceCode;
private HttpClient httpclient;
private Activity activity;
private AsyncHttpRequest request;
public MultiPartRequester(Activity activity, Map<String, String> map,
int serviceCode, AsyncTaskCompleteListener asyncTaskCompleteListener) {
this.map = map;
this.serviceCode = serviceCode;
this.activity = activity;
mAsynclistener = (AsyncTaskCompleteListener) asyncTaskCompleteListener;
request = (AsyncHttpRequest) new AsyncHttpRequest().execute(map
.get("url"));
}
class AsyncHttpRequest extends AsyncTask<String, Void, String> {
@Override
protected String doInBackground(String... urls) {
map.remove("url");
try {
HttpPost httppost = new HttpPost(urls[0]);
httpclient = new DefaultHttpClient();
HttpConnectionParams.setConnectionTimeout(
httpclient.getParams(), 600000);
MultipartEntityBuilder builder = MultipartEntityBuilder
.create();
for (String key : map.keySet()) {
if (key.equalsIgnoreCase("filename")) {
File f = new File(map.get(key));
builder.addBinaryBody(key, f,
ContentType.MULTIPART_FORM_DATA, f.getName());
} else {
builder.addTextBody(key, map.get(key), ContentType
.create("text/plain", MIME.DEFAULT_CHARSET));
}
Log.d("TAG", key + "---->" + map.get(key));
// System.out.println(key + "---->" + map.get(key));
}
httppost.setEntity(builder.build());
ActivityManager manager = (ActivityManager) activity
.getSystemService(Context.ACTIVITY_SERVICE);
if (manager.getMemoryClass() < 25) {
System.gc();
}
HttpResponse response = httpclient.execute(httppost);
String responseBody = EntityUtils.toString(
response.getEntity(), "UTF-8");
return responseBody;
} catch (Exception e) {
e.printStackTrace();
} catch (OutOfMemoryError oume) {
System.gc();
Toast.makeText(
activity.getParent().getParent(),
"Run out of memory please colse the other background apps and try again!",
Toast.LENGTH_LONG).show();
} finally {
if (httpclient != null)
httpclient.getConnectionManager().shutdown();
}
return null;
}
@Override
protected void onPostExecute(String response) {
if (mAsynclistener != null) {
mAsynclistener.onTaskCompleted(response, serviceCode);
}
}
}
private void showToast(String msg) {
Toast.makeText(activity, msg, Toast.LENGTH_SHORT).show();
}
}
Step 5. Final but important tasks
Now we are left with only two files : activity_main.xml and MainActivity.java
Update the writings of your activity_main.xml as per the following one
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@color/colorAccent"
android:orientation="vertical"
tools:context=".MainActivity">
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/btn"
android:layout_marginLeft="10dp"
android:layout_marginTop="10dp"
android:text="Select VIDEO"
/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="10dp"
android:layout_marginTop="10dp"
android:textColor="#fff"
android:textSize="25sp"
android:textAllCaps="true"
android:text="Below is the URL to uploaded VIDEO"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/tv"
android:layout_marginLeft="10dp"
android:layout_marginTop="10dp"
android:textColor="#fff"
android:textSize="25sp"
android:text="URL to uploaded Video"/>
</LinearLayout>
Main XML file contains one button and two text views.
When the user clicks the button, system will redirect him to the new screen. From this screen, he can choose the video to upload.
One text view is static and it will not change it’s value.
Another text view will get the URL of the uploaded video. When user taps on this URL, we will open this uploaded URL in web browser.
Now in MainActivity.java class, write down the below source
import android.Manifest;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
import com.karumi.dexter.Dexter;
import com.karumi.dexter.MultiplePermissionsReport;
import com.karumi.dexter.PermissionToken;
import com.karumi.dexter.listener.DexterError;
import com.karumi.dexter.listener.PermissionRequest;
import com.karumi.dexter.listener.PermissionRequestErrorListener;
import com.karumi.dexter.listener.multi.MultiplePermissionsListener;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
public class MainActivity extends AppCompatActivity implements AsyncTaskCompleteListener{
private Button btn;
private TextView tv;
private String url = "https://www.google.com";
private static final int BUFFER_SIZE = 1024 * 2;
private static final String IMAGE_DIRECTORY = "/demonuts_video";
private final int GALLERY = 1;
private ArrayList<HashMap<String, String>> arraylist;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
requestMultiplePermissions();
btn = findViewById(R.id.btn);
tv = findViewById(R.id.tv);
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent();
intent.setAction(Intent.ACTION_GET_CONTENT);
intent.setType("video/*");
startActivityForResult(intent,1);
}
});
tv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
startActivity(browserIntent);
}
});
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == RESULT_OK) {
// Get the Uri of the selected file
Uri uri = data.getData();
String path = getFilePathFromURI(MainActivity.this,uri);
Log.d("ioooo",path);
uploadPDFfile(path);
}
super.onActivityResult(requestCode, resultCode, data);
}
private void uploadPDFfile(String path) {
HashMap<String, String> map = new HashMap<String, String>();
map.put("url", "https://demonuts.com/Demonuts/JsonTest/Tennis/uploadfile.php");
map.put("filename", path);
new MultiPartRequester(this, map, GALLERY, this);
}
@Override
public void onTaskCompleted(String response, int serviceCode) {
Log.d("res", response);
switch (serviceCode) {
case GALLERY:
try {
JSONObject jsonObject = new JSONObject(response);
jsonObject.toString().replace("\\\\","");
if (jsonObject.getString("status").equals("true")) {
arraylist = new ArrayList<HashMap<String, String>>();
JSONArray dataArray = jsonObject.getJSONArray("data");
for (int i = 0; i < dataArray.length(); i++) {
JSONObject dataobj = dataArray.getJSONObject(i);
url = dataobj.optString("pathToFile");
}
tv.setText(url);
}
} catch (JSONException e) {
e.printStackTrace();
}
}
}
public static String getFilePathFromURI(Context context, Uri contentUri) {
//copy file and send new file path
File wallpaperDirectory = new File(
Environment.getExternalStorageDirectory() + IMAGE_DIRECTORY);
// have the object build the directory structure, if needed.
if (!wallpaperDirectory.exists()) {
wallpaperDirectory.mkdirs();
}
File copyFile = new File(wallpaperDirectory + File.separator + Calendar.getInstance()
.getTimeInMillis()+".mp4");
// create folder if not exists
copy(context, contentUri, copyFile);
Log.d("vPath--->",copyFile.getAbsolutePath());
return copyFile.getAbsolutePath();
}
public static void copy(Context context, Uri srcUri, File dstFile) {
try {
InputStream inputStream = context.getContentResolver().openInputStream(srcUri);
if (inputStream == null) return;
OutputStream outputStream = new FileOutputStream(dstFile);
copystream(inputStream, outputStream);
inputStream.close();
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public static int copystream(InputStream input, OutputStream output) throws Exception, IOException {
byte[] buffer = new byte[BUFFER_SIZE];
BufferedInputStream in = new BufferedInputStream(input, BUFFER_SIZE);
BufferedOutputStream out = new BufferedOutputStream(output, BUFFER_SIZE);
int count = 0, n = 0;
try {
while ((n = in.read(buffer, 0, BUFFER_SIZE)) != -1) {
out.write(buffer, 0, n);
count += n;
}
out.flush();
} finally {
try {
out.close();
} catch (IOException e) {
Log.e(e.getMessage(), String.valueOf(e));
}
try {
in.close();
} catch (IOException e) {
Log.e(e.getMessage(), String.valueOf(e));
}
}
return count;
}
private void requestMultiplePermissions(){
Dexter.withActivity(this)
.withPermissions(
Manifest.permission.WRITE_EXTERNAL_STORAGE,
Manifest.permission.READ_EXTERNAL_STORAGE)
.withListener(new MultiplePermissionsListener() {
@Override
public void onPermissionsChecked(MultiplePermissionsReport report) {
// check if all permissions are granted
if (report.areAllPermissionsGranted()) {
Toast.makeText(getApplicationContext(), "All permissions are granted by user!", Toast.LENGTH_SHORT).show();
}
// check for permanent denial of any permission
if (report.isAnyPermissionPermanentlyDenied()) {
// show alert dialog navigating to Settings
}
}
@Override
public void onPermissionRationaleShouldBeShown(List<PermissionRequest> permissions, PermissionToken token) {
token.continuePermissionRequest();
}
}).
withErrorListener(new PermissionRequestErrorListener() {
@Override
public void onError(DexterError error) {
Toast.makeText(getApplicationContext(), "Some Error! ", Toast.LENGTH_SHORT).show();
}
})
.onSameThread()
.check();
}
}
Going Deep in Above
Let us step by step understand what above code is doing.
First of all, read the following lines
public class MainActivity extends AppCompatActivity implements AsyncTaskCompleteListener{
private Button btn;
private TextView tv;
private String url = "https://www.google.com";
private static final int BUFFER_SIZE = 1024 * 2;
private static final String IMAGE_DIRECTORY = "/demonuts_video";
private final int GALLERY = 1;
private ArrayList<HashMap<String, String>> arraylist;
Very first line is the definition of main class. It is implementing the AsyncTaskCompleteListener interface.
Then an object of Button and Text view class is created.
After this, there is one string variable with google URL as it’s value.
Inside onCreate() method, compiler will first call the requestMultiplePermissions() method.
Code for requestMultiplePermissions() method is as the below
private void requestMultiplePermissions(){
Dexter.withActivity(this)
.withPermissions(
Manifest.permission.WRITE_EXTERNAL_STORAGE,
Manifest.permission.READ_EXTERNAL_STORAGE)
.withListener(new MultiplePermissionsListener() {
@Override
public void onPermissionsChecked(MultiplePermissionsReport report) {
// check if all permissions are granted
if (report.areAllPermissionsGranted()) {
Toast.makeText(getApplicationContext(), "All permissions are granted by user!", Toast.LENGTH_SHORT).show();
}
// check for permanent denial of any permission
if (report.isAnyPermissionPermanentlyDenied()) {
// show alert dialog navigating to Settings
}
}
@Override
public void onPermissionRationaleShouldBeShown(List<PermissionRequest> permissions, PermissionToken token) {
token.continuePermissionRequest();
}
}).
withErrorListener(new PermissionRequestErrorListener() {
@Override
public void onError(DexterError error) {
Toast.makeText(getApplicationContext(), "Some Error! ", Toast.LENGTH_SHORT).show();
}
})
.onSameThread()
.check();
}
Above method is using the dexter library to implement the runtime permissions.
It will handle all the scenarios like allow, deny, never ask again etc. in an efficient manner.
Compiler will execute the below snippet when the user clicks the text view.
tv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
startActivity(browserIntent);
}
});
Compiler will simply open the URL in the web browser.
Following is the code for the button click.
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent();
intent.setAction(Intent.ACTION_GET_CONTENT);
intent.setType("video/*");
startActivityForResult(intent,1);
}
});
Compiler will take the user to another screen where he can choose the desired video to upload.
When the user selects the video, compiler will execute the onActivityResult() method.
Following is the code lines for onActivityResult() method
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == RESULT_OK) {
// Get the Uri of the selected file
Uri uri = data.getData();
String path = getFilePathFromURI(MainActivity.this,uri);
Log.d("ioooo",path);
uploadPDFfile(path);
}
super.onActivityResult(requestCode, resultCode, data);
}
First of all, compiler will get the Uri of the selected video.
Then it will fetch the path of the video using getFilePathFromURI() method.
Now it will run the uploadPDFfile() method using the path returned by the getFilePathFromURI() method.
Source writings for uploadPDFfile() method is as the below
private void uploadPDFfile(String path) {
HashMap<String, String> map = new HashMap<String, String>();
map.put("url", "https://demonuts.com/Demonuts/JsonTest/Tennis/uploadfile.php");
map.put("filename", path);
new MultiPartRequester(this, map, GALLERY, this);
}
Inside this method, compiler will create a hash map with url and path to the video.
Then it will fire the multipart request. When it gets the json response from the server, it will call onTaskCompleted() method.
Following is the lines for onTaskCompleted() method.
@Override
public void onTaskCompleted(String response, int serviceCode) {
Log.d("res", response);
switch (serviceCode) {
case GALLERY:
try {
JSONObject jsonObject = new JSONObject(response);
jsonObject.toString().replace("\\\\","");
if (jsonObject.getString("status").equals("true")) {
arraylist = new ArrayList<HashMap<String, String>>();
JSONArray dataArray = jsonObject.getJSONArray("data");
for (int i = 0; i < dataArray.length(); i++) {
JSONObject dataobj = dataArray.getJSONObject(i);
url = dataobj.optString("pathToFile");
}
tv.setText(url);
}
} catch (JSONException e) {
e.printStackTrace();
}
}
}
In JSON response, we will get the URL to the latest uploaded video.
We will get this URL in string format and will save it into the text view, so when the user clicks on this text view, system will open this URL.
2. Android Upload Video To Server Using Volley PHP MySQL Server Multipart
Android Upload Video To Server Using Volley is the topic of today.
You will learn to upload video to remote server (PHP-MySQL) using the volley library.
We will use multipart method of volley in this tutorial.
Check the Output
Below shows the working of this android upload video with volley example.
PHP related files
To insert the video into the web server, we need to write two PHP scripts.
Make a new PHP file and give it a name like config.php
Write down the below source lines in config.php
<?php
$host="localhost";
$user="your username";
$password="your password";
$db = "your db name";
$con = mysqli_connect($host,$user,$password,$db);
// Check connection
if (mysqli_connect_errno())
{
echo "Failed to connect to MySQL: " . mysqli_connect_error();
}else{ //echo "Connect";
}
?>
Above file will make the connection to the MySQL database.
Now create another file with the name uploadfile.php
Add the following source lines in uploadfile.php
<?php
if($_SERVER['REQUEST_METHOD']=='POST'){
// echo $_SERVER["DOCUMENT_ROOT"]; // /home1/demonuts/public_html
//including the database connection file
include_once("config.php");
//$_FILES['image']['name'] give original name from parameter where 'image' == parametername eg. city.jpg
//$_FILES['image']['tmp_name'] temporary system generated name
$originalImgName= $_FILES['filename']['name'];
$tempName= $_FILES['filename']['tmp_name'];
$folder="uploadedFiles/";
$url = "https://www.demonuts.com/Demonuts/JsonTest/Tennis/uploadedFiles/".$originalImgName; //update path as per your directory structure
if(move_uploaded_file($tempName,$folder.$originalImgName)){
$query = "INSERT INTO upload_image_video (pathToFile) VALUES ('$url')";
if(mysqli_query($con,$query)){
$query= "SELECT * FROM upload_image_video WHERE pathToFile='$url'";
$result= mysqli_query($con, $query);
$emparray = array();
if(mysqli_num_rows($result) > 0){
while ($row = mysqli_fetch_assoc($result)) {
$emparray[] = $row;
}
echo json_encode(array( "status" => "true","message" => "Successfully file added!" , "data" => $emparray) );
}else{
echo json_encode(array( "status" => "false","message" => "Failed!") );
}
}else{
echo json_encode(array( "status" => "false","message" => "Failed!") );
}
//echo "moved to ".$url;
}else{
echo json_encode(array( "status" => "false","message" => "Failed!") );
}
}
?>
Above file is responsible to upload the video to the server. It will also add the entry into the MySQL database.
Now go to the android studio and make a new project.
Step 1. Gradle and Manifest changes
After making a new project, open the build.gradle(Module :app) file. Insert the below line in this file
implementation 'com.android.volley:volley:1.1.1'
Above line will fetch the volley library in to our android studio project. So that we can use various classes of volley library very easily.
Now open your AndroidManifest.xml file. Copy the below line in this file.
<uses-permission android:name="android.permission.INTERNET" />
This line will give access to internet in our project because without internet you can not upload video.
Internet permission is not much harmful to user privacy. So android have put this permission into the normal permission list and we do not need to ask for runtime permission for internet.
Step 2. Volley Multipart Class
Make a new JAVA class and give it a name VolleyMultipartRequest.java
Write down the following source lines in VolleyMultipartRequest.java
import com.android.volley.AuthFailureError;
import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.HttpHeaderParser;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;
public class VolleyMultipartRequest extends Request<NetworkResponse> {
private final String twoHyphens = "--";
private final String lineEnd = "\r\n";
private final String boundary = "apiclient-" + System.currentTimeMillis();
private Response.Listener<NetworkResponse> mListener;
private Response.ErrorListener mErrorListener;
private Map<String, String> mHeaders;
public VolleyMultipartRequest(int method, String url,
Response.Listener<NetworkResponse> listener,
Response.ErrorListener errorListener) {
super(method, url, errorListener);
this.mListener = listener;
this.mErrorListener = errorListener;
}
@Override
public Map<String, String> getHeaders() throws AuthFailureError {
return (mHeaders != null) ? mHeaders : super.getHeaders();
}
@Override
public String getBodyContentType() {
return "multipart/form-data;boundary=" + boundary;
}
@Override
public byte[] getBody() throws AuthFailureError {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(bos);
try {
// populate text payload
Map<String, String> params = getParams();
if (params != null && params.size() > 0) {
textParse(dos, params, getParamsEncoding());
}
// populate data byte payload
Map<String, DataPart> data = getByteData();
if (data != null && data.size() > 0) {
dataParse(dos, data);
}
// close multipart form data after text and file data
dos.writeBytes(twoHyphens + boundary + twoHyphens + lineEnd);
return bos.toByteArray();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* Custom method handle data payload.
*
* @return Map data part label with data byte
* @throws AuthFailureError
*/
protected Map<String, DataPart> getByteData() throws AuthFailureError {
return null;
}
@Override
protected Response<NetworkResponse> parseNetworkResponse(NetworkResponse response) {
try {
return Response.success(
response,
HttpHeaderParser.parseCacheHeaders(response));
} catch (Exception e) {
return Response.error(new ParseError(e));
}
}
@Override
protected void deliverResponse(NetworkResponse response) {
mListener.onResponse(response);
}
@Override
public void deliverError(VolleyError error) {
mErrorListener.onErrorResponse(error);
}
/**
* Parse string map into data output stream by key and value.
*
* @param dataOutputStream data output stream handle string parsing
* @param params string inputs collection
* @param encoding encode the inputs, default UTF-8
* @throws IOException
*/
private void textParse(DataOutputStream dataOutputStream, Map<String, String> params, String encoding) throws IOException {
try {
for (Map.Entry<String, String> entry : params.entrySet()) {
buildTextPart(dataOutputStream, entry.getKey(), entry.getValue());
}
} catch (UnsupportedEncodingException uee) {
throw new RuntimeException("Encoding not supported: " + encoding, uee);
}
}
/**
* Parse data into data output stream.
*
* @param dataOutputStream data output stream handle file attachment
* @param data loop through data
* @throws IOException
*/
private void dataParse(DataOutputStream dataOutputStream, Map<String, DataPart> data) throws IOException {
for (Map.Entry<String, DataPart> entry : data.entrySet()) {
buildDataPart(dataOutputStream, entry.getValue(), entry.getKey());
}
}
/**
* Write string data into header and data output stream.
*
* @param dataOutputStream data output stream handle string parsing
* @param parameterName name of input
* @param parameterValue value of input
* @throws IOException
*/
private void buildTextPart(DataOutputStream dataOutputStream, String parameterName, String parameterValue) throws IOException {
dataOutputStream.writeBytes(twoHyphens + boundary + lineEnd);
dataOutputStream.writeBytes("Content-Disposition: form-data; name=\"" + parameterName + "\"" + lineEnd);
dataOutputStream.writeBytes(lineEnd);
dataOutputStream.writeBytes(parameterValue + lineEnd);
}
/**
* Write data file into header and data output stream.
*
* @param dataOutputStream data output stream handle data parsing
* @param dataFile data byte as DataPart from collection
* @param inputName name of data input
* @throws IOException
*/
private void buildDataPart(DataOutputStream dataOutputStream, DataPart dataFile, String inputName) throws IOException {
dataOutputStream.writeBytes(twoHyphens + boundary + lineEnd);
dataOutputStream.writeBytes("Content-Disposition: form-data; name=\"" +
inputName + "\"; filename=\"" + dataFile.getFileName() + "\"" + lineEnd);
if (dataFile.getType() != null && !dataFile.getType().trim().isEmpty()) {
dataOutputStream.writeBytes("Content-Type: " + dataFile.getType() + lineEnd);
}
dataOutputStream.writeBytes(lineEnd);
ByteArrayInputStream fileInputStream = new ByteArrayInputStream(dataFile.getContent());
int bytesAvailable = fileInputStream.available();
int maxBufferSize = 1024 * 1024;
int bufferSize = Math.min(bytesAvailable, maxBufferSize);
byte[] buffer = new byte[bufferSize];
int bytesRead = fileInputStream.read(buffer, 0, bufferSize);
while (bytesRead > 0) {
dataOutputStream.write(buffer, 0, bufferSize);
bytesAvailable = fileInputStream.available();
bufferSize = Math.min(bytesAvailable, maxBufferSize);
bytesRead = fileInputStream.read(buffer, 0, bufferSize);
}
dataOutputStream.writeBytes(lineEnd);
}
class DataPart {
private String fileName;
private byte[] content;
private String type;
public DataPart() {
}
DataPart(String name, byte[] data) {
fileName = name;
content = data;
}
String getFileName() {
return fileName;
}
byte[] getContent() {
return content;
}
String getType() {
return type;
}
}
}
Above class is the heart of volley multipart functionality.
Using the object of the above class, we can make http calls within few lines of code.
We will use this class in the main activity.
Step 3. Main Files for main purpose
All other tasks are done. Now we are just left with main files modification.
These two main files are activity_main.xml and MainActivity.java
In your activity_main.xml file, add the below source items
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity">
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/btn"
android:layout_marginLeft="10dp"
android:layout_marginTop="10dp"
android:text="Select Video To upload with Volley"
/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="10dp"
android:layout_marginTop="10dp"
android:textColor="#000"
android:textSize="25sp"
android:text="Below is URL to Uploaded video with volley"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/tv"
android:layout_marginLeft="10dp"
android:layout_marginTop="10dp"
android:textColor="#000"
android:textSize="25sp"
android:text="URL to PDF"/>
</LinearLayout>
Above file will create the main activity layout of our project.
This file contains one button and two text views. When the user clicks the button, system will redirect him to another screen.
From this screen, user can choose any video which he wants to upload to the server.
One text view has the static value and we will not change it’s text.
Another text view will get the URL to the recently uploaded video. When the user clicks on this text view, compiler will open this URL in the web browser.
Now in your MainActivity.java file, you should write down the below source code lines.
import android.content.Intent;
import android.net.Uri;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
import com.android.volley.AuthFailureError;
import com.android.volley.DefaultRetryPolicy;
import com.android.volley.NetworkResponse;
import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.Volley;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Map;
public class MainActivity extends AppCompatActivity {
private Button btn;
private TextView tv;
private String upload_URL = "https://demonuts.com/Demonuts/JsonTest/Tennis/uploadfile.php?";
private RequestQueue rQueue;
private ArrayList<HashMap<String, String>> arraylist;
String url = "https://www.google.com";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btn = findViewById(R.id.btn);
tv = findViewById(R.id.tv);
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent();
intent.setAction(Intent.ACTION_GET_CONTENT);
intent.setType("video/*");
startActivityForResult(intent,1);
}
});
tv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
startActivity(browserIntent);
}
});
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == RESULT_OK) {
// Get the Uri of the selected file
Uri uri = data.getData();
String uriString = uri.toString();
File myFile = new File(uriString);
String path = myFile.getAbsolutePath();
String displayName = String.valueOf(Calendar.getInstance().getTimeInMillis()+".mp4");
Log.d("ooooooo",displayName);
uploadPDF(displayName,uri);
}
super.onActivityResult(requestCode, resultCode, data);
}
private void uploadPDF(final String pdfname, Uri pdffile){
InputStream iStream = null;
try {
iStream = getContentResolver().openInputStream(pdffile);
final byte[] inputData = getBytes(iStream);
VolleyMultipartRequest volleyMultipartRequest = new VolleyMultipartRequest(Request.Method.POST, upload_URL,
new Response.Listener<NetworkResponse>() {
@Override
public void onResponse(NetworkResponse response) {
Log.d("ressssssoo",new String(response.data));
rQueue.getCache().clear();
try {
JSONObject jsonObject = new JSONObject(new String(response.data));
Toast.makeText(getApplicationContext(), jsonObject.getString("message"), Toast.LENGTH_SHORT).show();
jsonObject.toString().replace("\\\\","");
if (jsonObject.getString("status").equals("true")) {
Log.d("come::: >>> ","yessssss");
arraylist = new ArrayList<HashMap<String, String>>();
JSONArray dataArray = jsonObject.getJSONArray("data");
for (int i = 0; i < dataArray.length(); i++) {
JSONObject dataobj = dataArray.getJSONObject(i);
url = dataobj.optString("pathToFile");
tv.setText(url);
}
}
} catch (JSONException e) {
e.printStackTrace();
}
}
},
new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
Toast.makeText(getApplicationContext(), error.getMessage(), Toast.LENGTH_SHORT).show();
}
}) {
/*
* If you want to add more parameters with the image
* you can do it here
* here we have only one parameter with the image
* which is tags
* */
@Override
protected Map<String, String> getParams() throws AuthFailureError {
Map<String, String> params = new HashMap<>();
// params.put("tags", "ccccc"); add string parameters
return params;
}
/*
*pass files using below method
* */
@Override
protected Map<String, DataPart> getByteData() {
Map<String, DataPart> params = new HashMap<>();
params.put("filename", new DataPart(pdfname ,inputData));
return params;
}
};
volleyMultipartRequest.setRetryPolicy(new DefaultRetryPolicy(
0,
DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
rQueue = Volley.newRequestQueue(MainActivity.this);
rQueue.add(volleyMultipartRequest);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public byte[] getBytes(InputStream inputStream) throws IOException {
ByteArrayOutputStream byteBuffer = new ByteArrayOutputStream();
int bufferSize = 1024;
byte[] buffer = new byte[bufferSize];
int len = 0;
while ((len = inputStream.read(buffer)) != -1) {
byteBuffer.write(buffer, 0, len);
}
return byteBuffer.toByteArray();
}
}
What is above code for android upload video?
Let us see what above code wants to say to the compiler and also to us.
First of all, consider the below code snippet
private Button btn;
private TextView tv;
private String upload_URL = "https://demonuts.com/Demonuts/JsonTest/Tennis/uploadfile.php?";
private RequestQueue rQueue;
private ArrayList<HashMap<String, String>> arraylist;
String url = "https://www.google.com";
First and second line is creating the object of Button and Text View class respectively.
Third line is the string variable with URL to the uploadfile.php
With this uploadfile.php file, we need to pass parameter so I have added a question mark “?” at the end of the URL.
Fourth line is making the object of the RequestQueue class, fifth line is making an array list with hash map.
Last one is the string variable with the Google URL as it’s value. We will update it’s value with the URL where our app will upload the video using volley.
Now look at the below code
tv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
startActivity(browserIntent);
}
});
Compiler will hit the above code when the user clicks the text view. It will open the URL to uploaded video in web browser.
See the following lines
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent();
intent.setAction(Intent.ACTION_GET_CONTENT);
intent.setType("video/*");
startActivityForResult(intent,1);
}
});
Above is the button click scenario. Compiler will open one new intent which will present all the videos from android device.
User can select any video to upload it to the server.
When the user successfully selects the video, compiler will run the onActivityResult() method.
Below is the source code for onActivityResult() method.
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == RESULT_OK) {
// Get the Uri of the selected file
Uri uri = data.getData();
String uriString = uri.toString();
File myFile = new File(uriString);
String path = myFile.getAbsolutePath();
String displayName = String.valueOf(Calendar.getInstance().getTimeInMillis()+".mp4");
Log.d("ooooooo",displayName);
uploadPDF(displayName,uri);
}
super.onActivityResult(requestCode, resultCode, data);
}
First of all, compiler will get the Uri of the video from data. Then it will make one string variable from this uri.
From this string variable, it will make one file object.
A string variable called “displayName” will contain the current time in milli second in string format.
Finally, execution of uploadPDF() method will take place.
Code writings for uploadPDF() method is as the following
private void uploadPDF(final String pdfname, Uri pdffile){
InputStream iStream = null;
try {
iStream = getContentResolver().openInputStream(pdffile);
final byte[] inputData = getBytes(iStream);
VolleyMultipartRequest volleyMultipartRequest = new VolleyMultipartRequest(Request.Method.POST, upload_URL,
new Response.Listener<NetworkResponse>() {
@Override
public void onResponse(NetworkResponse response) {
Log.d("ressssssoo",new String(response.data));
rQueue.getCache().clear();
try {
JSONObject jsonObject = new JSONObject(new String(response.data));
Toast.makeText(getApplicationContext(), jsonObject.getString("message"), Toast.LENGTH_SHORT).show();
jsonObject.toString().replace("\\\\","");
if (jsonObject.getString("status").equals("true")) {
Log.d("come::: >>> ","yessssss");
arraylist = new ArrayList<HashMap<String, String>>();
JSONArray dataArray = jsonObject.getJSONArray("data");
for (int i = 0; i < dataArray.length(); i++) {
JSONObject dataobj = dataArray.getJSONObject(i);
url = dataobj.optString("pathToFile");
tv.setText(url);
}
}
} catch (JSONException e) {
e.printStackTrace();
}
}
},
new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
Toast.makeText(getApplicationContext(), error.getMessage(), Toast.LENGTH_SHORT).show();
}
}) {
/*
* If you want to add more parameters with the image
* you can do it here
* here we have only one parameter with the image
* which is tags
* */
@Override
protected Map<String, String> getParams() throws AuthFailureError {
Map<String, String> params = new HashMap<>();
// params.put("tags", "ccccc"); add string parameters
return params;
}
/*
*pass files using below method
* */
@Override
protected Map<String, DataPart> getByteData() {
Map<String, DataPart> params = new HashMap<>();
params.put("filename", new DataPart(pdfname ,inputData));
return params;
}
};
volleyMultipartRequest.setRetryPolicy(new DefaultRetryPolicy(
0,
DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
rQueue = Volley.newRequestQueue(MainActivity.this);
rQueue.add(volleyMultipartRequest);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
Above method will make the http call to the uploadfile.php file.
When the compiler gets the JSON response from the server, it will call onResponse() method.
JSON response contains the URL to the uploaded video. Inside onResponse() method, compiler will fetch this URL and will set it as the value of the text view.
Now see the below line
params.put("filename", new DataPart(pdfname ,inputData));
The above line is the place, where we are placing the name and the data of the video.
3. Android Upload Video To Server Using Retrofit 2 Multipart PHP-MySQL
Android Upload Video To Server Using Retrofit 2 is written here.
In this example, you will learn how to upload video to PHP-MySQL server using retrofit from android device.
We will use MultipartBody class of retrofit library to make simple http calls to the web service.
Final Video
Below video shows us how this example is working.
PHP related tasks
We need to write two PHP files in this tutorial.
Make a new PHP file named config.php and add the below code block in it.
<?php
$host="localhost";
$user="your username";
$password="your password";
$db = "your db name";
$con = mysqli_connect($host,$user,$password,$db);
// Check connection
if (mysqli_connect_errno())
{
echo "Failed to connect to MySQL: " . mysqli_connect_error();
}else{ //echo "Connect";
}
?>
Now create another PHP filed called uploadfile.php
Source code for uploadfile.php is as the following
<?php
if($_SERVER['REQUEST_METHOD']=='POST'){
// echo $_SERVER["DOCUMENT_ROOT"]; // /home1/demonuts/public_html
//including the database connection file
include_once("config.php");
//$_FILES['image']['name'] give original name from parameter where 'image' == parametername eg. city.jpg
//$_FILES['image']['tmp_name'] temporary system generated name
$originalImgName= $_FILES['filename']['name'];
$tempName= $_FILES['filename']['tmp_name'];
$folder="uploadedFiles/";
$url = "https://www.demonuts.com/Demonuts/JsonTest/Tennis/uploadedFiles/".$originalImgName; //update path as per your directory structure
if(move_uploaded_file($tempName,$folder.$originalImgName)){
$query = "INSERT INTO upload_image_video (pathToFile) VALUES ('$url')";
if(mysqli_query($con,$query)){
$query= "SELECT * FROM upload_image_video WHERE pathToFile='$url'";
$result= mysqli_query($con, $query);
$emparray = array();
if(mysqli_num_rows($result) > 0){
while ($row = mysqli_fetch_assoc($result)) {
$emparray[] = $row;
}
echo json_encode(array( "status" => "true","message" => "Successfully file added!" , "data" => $emparray) );
}else{
echo json_encode(array( "status" => "false","message" => "Failed!") );
}
}else{
echo json_encode(array( "status" => "false","message" => "Failed!") );
}
//echo "moved to ".$url;
}else{
echo json_encode(array( "status" => "false","message" => "Failed!") );
}
}
?>
Above file will get the video sent from the android device and will upload it to the web server.
Now open your android studio and make a new project.
Step 1. Permissions and gradle dependencies
In your AndroidManifest.xml file, add the below permissions
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
First line will allow our app to use the internet connection of android device.
Second and third will give us permission to read and write data on the external storage.
We will also ask for the runtime permissions in the main activity java class.
In your build.gradle(Module :app) file, write the following lines
implementation 'com.squareup.retrofit2:retrofit:2.5.0'
implementation 'com.squareup.retrofit2:converter-scalars:2.5.0'
implementation 'com.karumi:dexter:5.0.0'
First line is about retrofit and second one will integrate scalar library in our project.
Retrofit will help us to make http calls and scalar will convert the JSON response into the string format.
Last one is about dexter library. This library will simplify the runtime permissions task.
Step 2. Interface for Retrofit
Create a new JAVA class and give it a name like VideoInterface.java
Below is the source snippet for VideoInterface.java class.
import okhttp3.MultipartBody;
import okhttp3.RequestBody;
import retrofit2.Call;
import retrofit2.http.Multipart;
import retrofit2.http.POST;
import retrofit2.http.Part;
public interface VideoInterface {
String VIDEOURL = "https://demonuts.com/Demonuts/JsonTest/Tennis/";
@Multipart
@POST("uploadfile.php")
Call<String> uploadImage(
@Part MultipartBody.Part file, @Part("filename") RequestBody name
);
}
First line is the string variable which holds the URL to our web service.
@Multipart annotation is telling the compiler that we are using multipart functionality of retrofit.
@POST is suggesting that we will make POST request to the uploadfile.php file.
uploadImage() method (don’t judge this method with it’s name 🙂 It will still upload video) will help us to make http call with required parameters.
Step 3. Main Files Writings
Now we need to write two main files and we are done.
First of all, add the below source code in your activity_main.xml file.
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:background="#f19e0e"
tools:context=".MainActivity">
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/btn"
android:layout_marginLeft="10dp"
android:layout_marginTop="10dp"
android:text="Select Video To upload with retrofit"
/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="10dp"
android:layout_marginTop="10dp"
android:textColor="#000"
android:textSize="25sp"
android:text="Below is URL to uploaded Video with Retrofit"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/tv"
android:layout_marginLeft="10dp"
android:layout_marginTop="10dp"
android:textColor="#fff"
android:textSize="25sp"
android:text="URL to Video"/>
</LinearLayout>
Main XML file has one button and two text views.
A button will open a new screen when the user clicks it. This screen will show various videos from which user can select any one.
One text view has the fixed text and it will not be changed.
Another text view will get the value of just uploaded video’s URL. When the user clicks this text view, system will open this URL in the web browser.
Step 4. Main JAVA file
In your MainActivity.java file, you should note down the following source structure.
import android.Manifest;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
import com.karumi.dexter.Dexter;
import com.karumi.dexter.MultiplePermissionsReport;
import com.karumi.dexter.PermissionToken;
import com.karumi.dexter.listener.DexterError;
import com.karumi.dexter.listener.PermissionRequest;
import com.karumi.dexter.listener.PermissionRequestErrorListener;
import com.karumi.dexter.listener.multi.MultiplePermissionsListener;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Calendar;
import java.util.List;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.RequestBody;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.scalars.ScalarsConverterFactory;
public class MainActivity extends AppCompatActivity {
private Button btn;
private TextView tv;
private String url = "https://www.google.com";
private static final int BUFFER_SIZE = 1024 * 2;
private static final String IMAGE_DIRECTORY = "/demonuts_upload_gallery";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
requestMultiplePermissions();
btn = findViewById(R.id.btn);
tv = findViewById(R.id.tv);
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent();
intent.setAction(Intent.ACTION_GET_CONTENT);
intent.setType("video/*");
startActivityForResult(intent,1);
}
});
tv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
startActivity(browserIntent);
}
});
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == RESULT_OK) {
// Get the Uri of the selected file
Uri uri = data.getData();
String path = getFilePathFromURI(MainActivity.this,uri);
Log.d("ioooossss",path);
uploadVideo(path);
}
super.onActivityResult(requestCode, resultCode, data);
}
private void uploadVideo(String path){
String pdfname = String.valueOf(Calendar.getInstance().getTimeInMillis());
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(VideoInterface.VIDEOURL)
.addConverterFactory(ScalarsConverterFactory.create())
.build();
//Create a file object using file path
File file = new File(path);
// Parsing any Media type file
RequestBody requestBody = RequestBody.create(MediaType.parse("*/*"), file);
MultipartBody.Part fileToUpload = MultipartBody.Part.createFormData("filename", file.getName(), requestBody);
RequestBody filename = RequestBody.create(MediaType.parse("text/plain"), pdfname);
VideoInterface getResponse = retrofit.create(VideoInterface.class);
Call<String> call = getResponse.uploadImage(fileToUpload, filename);
Log.d("assss","asss");
call.enqueue(new Callback<String>() {
@Override
public void onResponse(Call<String> call, Response<String> response) {
Log.d("mullllll", response.body().toString());
try {
JSONObject jsonObject = new JSONObject(response.body().toString());
Toast.makeText(getApplicationContext(), jsonObject.getString("message"), Toast.LENGTH_SHORT).show();
jsonObject.toString().replace("\\\\","");
if (jsonObject.getString("status").equals("true")) {
JSONArray dataArray = jsonObject.getJSONArray("data");
for (int i = 0; i < dataArray.length(); i++) {
JSONObject dataobj = dataArray.getJSONObject(i);
url = dataobj.optString("pathToFile");
tv.setText(url);
}
}
} catch (JSONException e) {
e.printStackTrace();
}
}
@Override
public void onFailure(Call call, Throwable t) {
Log.d("gttt", call.toString());
}
});
}
public static String getFilePathFromURI(Context context, Uri contentUri) {
//copy file and send new file path
File wallpaperDirectory = new File(
Environment.getExternalStorageDirectory() + IMAGE_DIRECTORY);
// have the object build the directory structure, if needed.
if (!wallpaperDirectory.exists()) {
wallpaperDirectory.mkdirs();
}
File copyFile = new File(wallpaperDirectory + File.separator + Calendar.getInstance()
.getTimeInMillis()+".mp4");
// create folder if not exists
copy(context, contentUri, copyFile);
Log.d("vPath--->",copyFile.getAbsolutePath());
return copyFile.getAbsolutePath();
}
public static void copy(Context context, Uri srcUri, File dstFile) {
try {
InputStream inputStream = context.getContentResolver().openInputStream(srcUri);
if (inputStream == null) return;
OutputStream outputStream = new FileOutputStream(dstFile);
copystream(inputStream, outputStream);
inputStream.close();
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public static int copystream(InputStream input, OutputStream output) throws Exception, IOException {
byte[] buffer = new byte[BUFFER_SIZE];
BufferedInputStream in = new BufferedInputStream(input, BUFFER_SIZE);
BufferedOutputStream out = new BufferedOutputStream(output, BUFFER_SIZE);
int count = 0, n = 0;
try {
while ((n = in.read(buffer, 0, BUFFER_SIZE)) != -1) {
out.write(buffer, 0, n);
count += n;
}
out.flush();
} finally {
try {
out.close();
} catch (IOException e) {
Log.e(e.getMessage(), String.valueOf(e));
}
try {
in.close();
} catch (IOException e) {
Log.e(e.getMessage(), String.valueOf(e));
}
}
return count;
}
private void requestMultiplePermissions(){
Dexter.withActivity(this)
.withPermissions(
Manifest.permission.WRITE_EXTERNAL_STORAGE,
Manifest.permission.READ_EXTERNAL_STORAGE)
.withListener(new MultiplePermissionsListener() {
@Override
public void onPermissionsChecked(MultiplePermissionsReport report) {
// check if all permissions are granted
if (report.areAllPermissionsGranted()) {
Toast.makeText(getApplicationContext(), "All permissions are granted by user!", Toast.LENGTH_SHORT).show();
}
// check for permanent denial of any permission
if (report.isAnyPermissionPermanentlyDenied()) {
// show alert dialog navigating to Settings
}
}
@Override
public void onPermissionRationaleShouldBeShown(List<PermissionRequest> permissions, PermissionToken token) {
token.continuePermissionRequest();
}
}).
withErrorListener(new PermissionRequestErrorListener() {
@Override
public void onError(DexterError error) {
Toast.makeText(getApplicationContext(), "Some Error! ", Toast.LENGTH_SHORT).show();
}
})
.onSameThread()
.check();
}
}
Above code looks little lengthy, so let us check it step by step.
First of all, consider the below code
private Button btn;
private TextView tv;
private String url = "https://www.google.com";
private static final int BUFFER_SIZE = 1024 * 2;
private static final String IMAGE_DIRECTORY = "/demonuts_upload_gallery";
First line is making the object of the Button class while second one is of Text View class.
Third line is the google URL string variable. We will update it’s value later.
Fourth line is the final integer variable which will work as the buffer size.
Last one is the string variable which is the name of the directory folder in which we will save the video.
Inside onCreate() method, compiler will execute requestMultiplePermissions() method like below.
private void requestMultiplePermissions(){
Dexter.withActivity(this)
.withPermissions(
Manifest.permission.WRITE_EXTERNAL_STORAGE,
Manifest.permission.READ_EXTERNAL_STORAGE)
.withListener(new MultiplePermissionsListener() {
@Override
public void onPermissionsChecked(MultiplePermissionsReport report) {
// check if all permissions are granted
if (report.areAllPermissionsGranted()) {
Toast.makeText(getApplicationContext(), "All permissions are granted by user!", Toast.LENGTH_SHORT).show();
}
// check for permanent denial of any permission
if (report.isAnyPermissionPermanentlyDenied()) {
// show alert dialog navigating to Settings
}
}
@Override
public void onPermissionRationaleShouldBeShown(List<PermissionRequest> permissions, PermissionToken token) {
token.continuePermissionRequest();
}
}).
withErrorListener(new PermissionRequestErrorListener() {
@Override
public void onError(DexterError error) {
Toast.makeText(getApplicationContext(), "Some Error! ", Toast.LENGTH_SHORT).show();
}
})
.onSameThread()
.check();
}
This method is executing the runtime permission scenario using dexter library.
It will handle all the aspects regarding this topic and will save our time.
Compiler will run below code when the user clicks the button
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent();
intent.setAction(Intent.ACTION_GET_CONTENT);
intent.setType("video/*");
startActivityForResult(intent,1);
}
});
Compiler will make a new screen with new intent. It will showcase various videos from which user can select any to upload to server.
When the user selects any one video, compiler will call onActivityResult() method.
Below is the snippet for onActivityResult() method.
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == RESULT_OK) {
// Get the Uri of the selected file
Uri uri = data.getData();
String path = getFilePathFromURI(MainActivity.this,uri);
Log.d("ioooossss",path);
uploadVideo(path);
}
super.onActivityResult(requestCode, resultCode, data);
}
First of all, compiler will get the Uri of the video. Then it will get the path of the video using getFilePathFromURI() method.
Using this path, compiler will execute uploadVideo() method.
Following is the code snippet for uploadVideo() method
private void uploadVideo(String path){
String pdfname = String.valueOf(Calendar.getInstance().getTimeInMillis());
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(VideoInterface.VIDEOURL)
.addConverterFactory(ScalarsConverterFactory.create())
.build();
//Create a file object using file path
File file = new File(path);
// Parsing any Media type file
RequestBody requestBody = RequestBody.create(MediaType.parse("*/*"), file);
MultipartBody.Part fileToUpload = MultipartBody.Part.createFormData("filename", file.getName(), requestBody);
RequestBody filename = RequestBody.create(MediaType.parse("text/plain"), pdfname);
VideoInterface getResponse = retrofit.create(VideoInterface.class);
Call<String> call = getResponse.uploadImage(fileToUpload, filename);
Log.d("assss","asss");
call.enqueue(new Callback<String>() {
@Override
public void onResponse(Call<String> call, Response<String> response) {
Log.d("mullllll", response.body().toString());
try {
JSONObject jsonObject = new JSONObject(response.body().toString());
Toast.makeText(getApplicationContext(), jsonObject.getString("message"), Toast.LENGTH_SHORT).show();
jsonObject.toString().replace("\\\\","");
if (jsonObject.getString("status").equals("true")) {
JSONArray dataArray = jsonObject.getJSONArray("data");
for (int i = 0; i < dataArray.length(); i++) {
JSONObject dataobj = dataArray.getJSONObject(i);
url = dataobj.optString("pathToFile");
tv.setText(url);
}
}
} catch (JSONException e) {
e.printStackTrace();
}
}
@Override
public void onFailure(Call call, Throwable t) {
Log.d("gttt", call.toString());
}
});
}
First line is making one string variable. This variable is getting the value of current time in milli second in string format.
We will use this variable as the name of the video which is going to be uploaded on server.
Then compiler will create the object of Retrofit, File, RequestBody, VideoInterface etc classes. and will make http call using these objects.
When server sends the JSON response, compiler will run onRespose() method.
Inside this onRespose() method, compiler will parse JSON and will get the URL at which our uploaded video residing.
Then it will this URL as the value of the text view.