community-cordova-plugin-filepath 1.7.0

package/.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: eyalin

package/CHANGELOG.md

@@ -0,0 +1,43 @@
+# 1.6.0
+
+* [#70](https://github.com/hiddentao/cordova-plugin-filepath/pull/70)
+* [#71](https://github.com/hiddentao/cordova-plugin-filepath/pull/71)
+
+# 1.5.8
+
+* Added "no longer actively maintained" message to README
+
+# 1.5.7
+
+* [Fixes issue #60](https://github.com/hiddentao/cordova-plugin-filepath/issues/60)
+
+# 1.5.6
+
+* [Fixes issue #50](https://github.com/hiddentao/cordova-plugin-filepath/issues/50)
+
+# 1.5.5
+
+* [Remove unneeded permission](https://github.com/hiddentao/cordova-plugin-filepath/pull/51)
+
+# 1.5.4
+
+* [Remove unneeded permission](https://github.com/hiddentao/cordova-plugin-filepath/pull/42)
+
+# 1.0.2
+
+Release notes:
+
+ * [da0e1c6](https://github.com/hiddentao/cordova-plugin-filepath/commit/da0e1c68e422caac9c196e41d2580460a6da6d67): Rename plugin to ``cordova-plugin-filepath``
+
+# 1.0.1
+
+Merged PR#4 ([e571105](https://github.com/hiddentao/cordova-plugin-filepath/commit/e571105e0ffa2bfa09b27a13613778755e017961)) with the following changes:
+
+ *  Added detection for Google Drive content uri. Better error description.
+ *  Fix resolving native path from external storage.
+ *  Fix resolving native path from Google Photos. Append "file://" to final result
+ *  Added new uri authority for Google Photos
+
+# 1.0.0
+
+Initial version.

package/LICENSE.md

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2015 [Ramesh Nair](https://hiddentao.com)
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,47 @@
+[![NPM version](https://img.shields.io/npm/v/community-cordova-plugin-filepath)](https://www.npmjs.com/package/community-cordova-plugin-filepath)
+[![Downloads](https://img.shields.io/npm/dm/community-cordova-plugin-filepath)](https://www.npmjs.com/package/community-cordova-plugin-filepath)
+
+#### This is a fork of the original plugin cordova-plugin-filepath
+
+# community-cordova-plugin-filepath
+
+This plugin allows you to resolve the native filesystem path for Android content
+URIs and is based on code in the [aFileChooser](https://github.com/iPaulPro/aFileChooser/blob/master/aFileChooser/src/com/ipaulpro/afilechooser/utils/FileUtils.java) library.
+
+Original inspiration [from StackOverflow](http://stackoverflow.com/questions/20067508/get-real-path-from-uri-android-kitkat-new-storage-access-framework).
+
+## Installation
+
+```bash
+$ cordova plugin add community-cordova-plugin-filepath
+```
+
+## Supported Platforms
+
+* Android
+
+## Usage    
+
+Once installed the plugin defines the `window.FilePath` object. To resolve a
+file path:
+
+```js
+window.FilePath.resolveNativePath('content://...', successCallback, errorCallback);
+```
+
+##### successCallback
+Returns the ``file://`` file path.
+
+##### errorCallback
+Returns the following object:
+```js
+{ code: <integer>, message: <string> }
+```
+Possible error codes are:
+* ``-1`` - describes an invalid action
+* ``0`` - ``file://`` path could not be resolved
+* ``1`` - the native path links to a cloud file (e.g: from Google Drive app)
+
+## LICENSE
+
+Apache (see LICENSE.md)

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "community-cordova-plugin-filepath",
+  "version": "1.7.0",
+  "description": "Resolve native file paths from content URLs for Cordova platforms",
+  "cordova": {
+    "id": "community-cordova-plugin-filepath",
+    "platforms": [
+      "android"
+    ]
+  },
+  "scripts": {
+    "version": "sync-cordova-xml package.json plugin.xml --output plugin.xml && git add plugin.xml"
+  },
+  "repository": "EYALIN/community-cordova-plugin-filepath/tree/master",
+  "homepage": "https://github.com/EYALIN/community-cordova-plugin-filepath/tree/master",
+  "funding": "https://github.com/sponsors/EYALIN",
+  "keywords": [
+    "cordova",
+    "file",
+    "ecosystem:cordova",
+    "cordova-android"
+  ],
+  "author": "Ramesh Nair <ram@hiddentao.com>",
+  "license": "Apache 2.0",
+  "devDependencies": {
+    "sync-cordova-xml": "^0.4.0"
+  }
+}

package/plugin.xml

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
+        xmlns:android="http://schemas.android.com/apk/res/android"
+        id="community-cordova-plugin-filepath" version="1.7.0">
+    <name>community-cordova-plugin-filepath</name>
+    <description>Resolve native file paths from content URLs for Cordova platforms</description>
+    <license>Apache 2.0</license>
+    <keywords>cordova,file,ecosystem:cordova,cordova-android</keywords>
+    <repo>https://github.com/hiddentao/cordova-plugin-filepath.git</repo>
+    <issue>https://github.com/hiddentao/cordova-plugin-filepath/issues</issue>
+
+    <engines>
+        <engine name="cordova-android" version=">=3.1.0"/><!-- Uses CordovaResourceApi -->
+    </engines>
+
+    <!-- android -->
+    <platform name="android">
+      <framework src="commons-io:commons-io:2.4" />
+        <js-module src="www/FilePath.js" name="FilePath">
+            <clobbers target="window.FilePath"/>
+        </js-module>
+
+        <config-file target="res/xml/config.xml" parent="/*">
+            <feature name="FilePath">
+                <param name="android-package" value="com.hiddentao.cordova.filepath.FilePath"/>
+                <param name="onload" value="true"/>
+            </feature>
+        </config-file>
+
+        <config-file target="AndroidManifest.xml" parent="/*">
+            <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+        </config-file>
+
+        <source-file src="src/android/FilePath.java" target-dir="src/com/hiddentao/cordova/filepath"/>
+    </platform>
+    <author email="ram@hiddentao.com">Ramesh Nair</author>
+</plugin>

package/src/android/FilePath.java

@@ -0,0 +1,512 @@
+package com.hiddentao.cordova.filepath;
+
+import android.text.TextUtils;
+import android.Manifest;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.provider.OpenableColumns;
+import android.util.Log;
+import android.database.Cursor;
+import android.os.Build;
+import android.os.Environment;
+import android.provider.DocumentsContract;
+import android.provider.MediaStore;
+import android.support.v4.app.ActivityCompat;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.PermissionHelper;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.json.JSONException;
+
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.util.List;
+import java.io.File;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+import android.content.pm.ApplicationInfo;
+
+
+import org.apache.commons.io.IOUtils;
+
+public class FilePath extends CordovaPlugin {
+
+    private static final String TAG = "[FilePath plugin]: ";
+
+    private static final int INVALID_ACTION_ERROR_CODE = -1;
+
+    private static final int GET_PATH_ERROR_CODE = 0;
+    private static final String GET_PATH_ERROR_ID = null;
+
+    private static final int GET_CLOUD_PATH_ERROR_CODE = 1;
+    private static final String GET_CLOUD_PATH_ERROR_ID = "cloud";
+
+    private static final int RC_READ_EXTERNAL_STORAGE = 5;
+
+    private static CallbackContext callback;
+    private static String uriStr;
+
+    public static final int READ_REQ_CODE = 0;
+
+    public static final String READ = Manifest.permission.READ_EXTERNAL_STORAGE;
+
+    protected void getReadPermission(int requestCode) {
+        PermissionHelper.requestPermission(this, requestCode, READ);
+    }
+
+    public void initialize(CordovaInterface cordova, final CordovaWebView webView) {
+        super.initialize(cordova, webView);
+    }
+
+    /**
+     * Executes the request and returns PluginResult.
+     *
+     * @param action        The action to execute.
+     * @param args          JSONArry of arguments for the plugin.
+     * @param callbackContext The callback context through which to return stuff to caller.
+     * @return              A PluginResult object with a status and message.
+     */
+    @Override
+    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+        this.callback = callbackContext;
+        this.uriStr = args.getString(0);
+        if (action.equals("resolveNativePath")) {
+            if (PermissionHelper.hasPermission(this, READ)) {
+                resolveNativePath();
+            }
+            else {
+                getReadPermission(READ_REQ_CODE);
+            }
+
+            return true;
+        }
+        else {
+            JSONObject resultObj = new JSONObject();
+
+            resultObj.put("code", INVALID_ACTION_ERROR_CODE);
+            resultObj.put("message", "Invalid action.");
+
+            callbackContext.error(resultObj);
+        }
+
+        return false;
+    }
+
+    public void resolveNativePath() throws JSONException {
+        JSONObject resultObj = new JSONObject();
+        /* content:///... */
+        Uri pvUrl = Uri.parse(this.uriStr);
+        Log.d(TAG, "URI: " + this.uriStr);
+
+        Context appContext = this.cordova.getActivity().getApplicationContext();
+
+        //String filePath = getPath(appContext, pvUrl);
+        String filePath = getFilePathFromURI(appContext, pvUrl);
+        //check result; send error/success callback
+        if (filePath == GET_PATH_ERROR_ID) {
+            resultObj.put("code", GET_PATH_ERROR_CODE);
+            resultObj.put("message", "Unable to resolve filesystem path.");
+
+            this.callback.error(resultObj);
+        }
+        else if (filePath.equals(GET_CLOUD_PATH_ERROR_ID)) {
+            resultObj.put("code", GET_CLOUD_PATH_ERROR_CODE);
+            resultObj.put("message", "Files from cloud cannot be resolved to filesystem, download is required.");
+
+            this.callback.error(resultObj);
+        }
+        else {
+            Log.d(TAG, "Filepath: " + filePath);
+
+            this.callback.success("file://" + filePath);
+        }
+    }
+
+    public static String getFilePathFromURI(Context context, Uri contentUri) {
+        //copy file and send new file path
+        String fileName = getFileName(contentUri);
+        if (!TextUtils.isEmpty(fileName)) {
+            File folder = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOCUMENTS).getPath() +
+                    File.separator +  getApplicationName(context));
+
+            boolean success = true;
+
+            if (!folder.exists()) {
+                success = folder.mkdirs();
+            }
+            
+            if (success) {
+                File copyFile = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOCUMENTS).getPath() +
+                        File.separator +  getApplicationName(context) + File.separator + fileName);
+                copy(context, contentUri, copyFile);
+                return copyFile.getAbsolutePath();
+            }
+
+        }
+        return null;
+    }
+
+    public static String getFileName(Uri uri) {
+        if (uri == null) return null;
+        String fileName = null;
+        String path = uri.getPath();
+        int cut = path.lastIndexOf('/');
+        if (cut != -1) {
+            fileName = path.substring(cut + 1);
+        }
+        return fileName;
+    }
+
+    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);
+            IOUtils.copy(inputStream, outputStream);
+            inputStream.close();
+            outputStream.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static String getApplicationName(Context context) {
+        ApplicationInfo applicationInfo = context.getApplicationInfo();
+        int stringId = applicationInfo.labelRes;
+        return stringId == 0 ? applicationInfo.nonLocalizedLabel.toString() : context.getString(stringId);
+    }
+
+    public void onRequestPermissionResult(int requestCode, String[] permissions, int[] grantResults) throws JSONException {
+        for (int r:grantResults) {
+            if (r == PackageManager.PERMISSION_DENIED) {
+                JSONObject resultObj = new JSONObject();
+                resultObj.put("code", 3);
+                resultObj.put("message", "Filesystem permission was denied.");
+
+                this.callback.error(resultObj);
+                return;
+            }
+        }
+
+        if (requestCode == READ_REQ_CODE) {
+            resolveNativePath();
+        }
+    }
+
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is ExternalStorageProvider.
+     */
+    private static boolean isExternalStorageDocument(Uri uri) {
+        return "com.android.externalstorage.documents".equals(uri.getAuthority());
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is DownloadsProvider.
+     */
+    private static boolean isDownloadsDocument(Uri uri) {
+        return "com.android.providers.downloads.documents".equals(uri.getAuthority());
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is MediaProvider.
+     */
+    private static boolean isMediaDocument(Uri uri) {
+        return "com.android.providers.media.documents".equals(uri.getAuthority());
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is Google Photos.
+     */
+    private static boolean isGooglePhotosUri(Uri uri) {
+        return ("com.google.android.apps.photos.content".equals(uri.getAuthority())
+                || "com.google.android.apps.photos.contentprovider".equals(uri.getAuthority()));
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is Google Drive.
+     */
+    private static boolean isGoogleDriveUri(Uri uri) {
+        return "com.google.android.apps.docs.storage".equals(uri.getAuthority()) || "com.google.android.apps.docs.storage.legacy".equals(uri.getAuthority());
+    }
+
+    /**
+     * Get the value of the data column for this Uri. This is useful for
+     * MediaStore Uris, and other file-based ContentProviders.
+     *
+     * @param context The context.
+     * @param uri The Uri to query.
+     * @param selection (Optional) Filter used in the query.
+     * @param selectionArgs (Optional) Selection arguments used in the query.
+     * @return The value of the _data column, which is typically a file path.
+     */
+    private static String getDataColumn(Context context, Uri uri, String selection,
+                                        String[] selectionArgs) {
+
+        Cursor cursor = null;
+        final String column = "_data";
+        final String[] projection = {
+                column
+        };
+
+        try {
+            cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs,
+                    null);
+            if (cursor != null && cursor.moveToFirst()) {
+                final int column_index = cursor.getColumnIndexOrThrow(column);
+                return cursor.getString(column_index);
+            }
+        } finally {
+            if (cursor != null)
+                cursor.close();
+        }
+        return null;
+    }
+
+    /**
+     * Get content:// from segment list
+     * In the new Uri Authority of Google Photos, the last segment is not the content:// anymore
+     * So let's iterate through all segments and find the content uri!
+     *
+     * @param segments The list of segment
+     */
+    private static String getContentFromSegments(List<String> segments) {
+        String contentPath = "";
+
+        for(String item : segments) {
+            if (item.startsWith("content://")) {
+                contentPath = item;
+                break;
+            }
+        }
+
+        return contentPath;
+    }
+
+    /**
+     * Check if a file exists on device
+     *
+     * @param filePath The absolute file path
+     */
+    private static boolean fileExists(String filePath) {
+        File file = new File(filePath);
+
+        return file.exists();
+    }
+
+    /**
+     * Get full file path from external storage
+     *
+     * @param pathData The storage type and the relative path
+     */
+    private static String getPathFromExtSD(String[] pathData) {
+        final String type = pathData[0];
+        final String relativePath = "/" + pathData[1];
+        String fullPath = "";
+
+        // on my Sony devices (4.4.4 & 5.1.1), `type` is a dynamic string
+        // something like "71F8-2C0A", some kind of unique id per storage
+        // don't know any API that can get the root path of that storage based on its id.
+        //
+        // so no "primary" type, but let the check here for other devices
+        if ("primary".equalsIgnoreCase(type)) {
+            fullPath = Environment.getExternalStorageDirectory() + relativePath;
+            if (fileExists(fullPath)) {
+                return fullPath;
+            }
+        }
+
+        // Environment.isExternalStorageRemovable() is `true` for external and internal storage
+        // so we cannot relay on it.
+        //
+        // instead, for each possible path, check if file exists
+        // we'll start with secondary storage as this could be our (physically) removable sd card
+        fullPath = System.getenv("SECONDARY_STORAGE") + relativePath;
+        if (fileExists(fullPath)) {
+            return fullPath;
+        }
+
+        fullPath = System.getenv("EXTERNAL_STORAGE") + relativePath;
+        if (fileExists(fullPath)) {
+            return fullPath;
+        }
+
+        return fullPath;
+    }
+
+    /**
+     * Get a file path from a Uri. This will get the the path for Storage Access
+     * Framework Documents, as well as the _data field for the MediaStore and
+     * other file-based ContentProviders.<br>
+     * <br>
+     * Callers should check whether the path is local before assuming it
+     * represents a local file.
+     *
+     * @param context The context.
+     * @param uri The Uri to query.
+     */
+    private static String getPath(final Context context, final Uri uri) {
+
+        Log.d(TAG, "File - " +
+                "Authority: " + uri.getAuthority() +
+                ", Fragment: " + uri.getFragment() +
+                ", Port: " + uri.getPort() +
+                ", Query: " + uri.getQuery() +
+                ", Scheme: " + uri.getScheme() +
+                ", Host: " + uri.getHost() +
+                ", Segments: " + uri.getPathSegments().toString()
+        );
+
+        final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
+
+        // DocumentProvider
+        if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {
+            // ExternalStorageProvider
+            if (isExternalStorageDocument(uri)) {
+                final String docId = DocumentsContract.getDocumentId(uri);
+                final String[] split = docId.split(":");
+                final String type = split[0];
+
+                String fullPath = getPathFromExtSD(split);
+                if (fullPath != "") {
+                    return fullPath;
+                }
+                else {
+                    return null;
+                }
+            }
+            // DownloadsProvider
+            else if (isDownloadsDocument(uri)) {
+                // thanks to https://github.com/hiddentao/cordova-plugin-filepath/issues/34#issuecomment-430129959
+                Cursor cursor = null;
+                try {
+                    cursor = context.getContentResolver().query(uri, new String[]{MediaStore.MediaColumns.DISPLAY_NAME}, null, null, null);
+                    if (cursor != null && cursor.moveToFirst()) {
+                        String fileName = cursor.getString(0);
+                        String path = Environment.getExternalStorageDirectory().toString() + "/Download/" + fileName;
+                        if (!TextUtils.isEmpty(path)) {
+                            return path;
+                        }
+                    }
+                } finally {
+                    if (cursor != null)
+                    cursor.close();
+                }
+                //
+                final String id = DocumentsContract.getDocumentId(uri);
+                try {
+                    final Uri contentUri = ContentUris.withAppendedId(
+                        Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
+
+                    return getDataColumn(context, contentUri, null, null);
+                } catch(NumberFormatException e) {
+                    //In Android 8 and Android P the id is not a number
+                    return uri.getPath().replaceFirst("^/document/raw:", "").replaceFirst("^raw:", "");
+                }
+            }
+            // MediaProvider
+            else if (isMediaDocument(uri)) {
+                final String docId = DocumentsContract.getDocumentId(uri);
+                final String[] split = docId.split(":");
+                final String type = split[0];
+
+                Uri contentUri = null;
+                if ("image".equals(type)) {
+                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
+                } else if ("video".equals(type)) {
+                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
+                } else if ("audio".equals(type)) {
+                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
+                }
+
+                final String selection = "_id=?";
+                final String[] selectionArgs = new String[] {
+                        split[1]
+                };
+
+                return getDataColumn(context, contentUri, selection, selectionArgs);
+            }
+            else if(isGoogleDriveUri(uri)){
+                return getDriveFilePath(uri,context);
+            }
+        }
+        // MediaStore (and general)
+        else if ("content".equalsIgnoreCase(uri.getScheme())) {
+
+            // Return the remote address
+            if (isGooglePhotosUri(uri)) {
+                String contentPath = getContentFromSegments(uri.getPathSegments());
+                if (contentPath != "") {
+                    return getPath(context, Uri.parse(contentPath));
+                }
+                else {
+                    return null;
+                }
+            }
+
+            if(isGoogleDriveUri(uri)){
+                return getDriveFilePath(uri,context);
+            }
+
+            return getDataColumn(context, uri, null, null);
+        }
+        // File
+        else if ("file".equalsIgnoreCase(uri.getScheme())) {
+            return uri.getPath();
+        }
+
+        return null;
+    }
+
+    private static String getDriveFilePath(Uri uri,Context context){
+        Uri returnUri =uri;
+        Cursor returnCursor = context.getContentResolver().query(returnUri, null, null, null, null);
+        /*
+        * Get the column indexes of the data in the Cursor,
+        *     * move to the first row in the Cursor, get the data,
+        *     * and display it.
+        * */
+        int nameIndex = returnCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
+        int sizeIndex = returnCursor.getColumnIndex(OpenableColumns.SIZE);
+        returnCursor.moveToFirst();
+        String name = (returnCursor.getString(nameIndex));
+        String size = (Long.toString(returnCursor.getLong(sizeIndex)));
+        File   file = new File(context.getCacheDir(),name);
+        try {
+            InputStream inputStream = context.getContentResolver().openInputStream(uri);
+            FileOutputStream outputStream = new FileOutputStream(file);
+            int read = 0;
+            int maxBufferSize = 1 * 1024 * 1024;
+            int  bytesAvailable = inputStream.available();
+
+            //int bufferSize = 1024;
+            int bufferSize = Math.min(bytesAvailable, maxBufferSize);
+
+            final byte[] buffers = new byte[bufferSize];
+            while ((read = inputStream.read(buffers)) != -1) {
+                outputStream.write(buffers, 0, read);
+            }
+            Log.e("File Size","Size " + file.length());
+            inputStream.close();
+            outputStream.close();
+            Log.e("File Path","Path " + file.getPath());
+            Log.e("File Size","Size " + file.length());
+        }catch (Exception e){
+            Log.e("Exception",e.getMessage());
+        }
+        return  file.getPath();
+    }
+}

package/www/FilePath.js

@@ -0,0 +1,14 @@
+var exec = require('cordova/exec');
+
+
+module.exports = {
+    /**
+     * Resolve native path for given content URL/path.
+     * @param {String} path  Content URL/path.
+     * @param successCallback  invoked with a native filesystem path string
+     * @param errorCallback  invoked if error occurs
+     */
+    resolveNativePath: function(path, successCallback, errorCallback) {
+        exec(successCallback, errorCallback, "FilePath", "resolveNativePath", [path]);
+    }
+};