0

I'm using SqliteImportExporter library to import and export my database file to public folder "Documents". I don't think the file has a MIME type, it's just created from a stream of bytes and has a .db file extension.

After targeting Android API 30, if I uninstall and reinstall my app, it cannot access the file it created earlier, to either import it or overwrite it.

The Android documentation talks about using ACTION_OPEN_DOCUMENT_TREE intents to give access to the entire directory and it's contents. After selecting the directory to give permission, it still have no access. Is there something magic about the URI returned by this process, or can I still use the library after getting permission? I am providing the library with an absolute path to the file - which works until I target API 30 and run the app on an API 30 AVD.

Can someone point me in the right direction on how to proceed please?

EDIT: My question simply now boils down to, How can one simply copy a file to/from the shared folders (e.g. documents folder) when targeting API 30, and still maintain support for API 21 onwards.

grolschie
  • 2,163
  • 2
  • 12
  • 29
  • 1
    `After selecting the directory to give permission, it still have no access` After selecting the directory and getting permission, you have full access. You can read all files then. But using absolute paths is not done. Use the uri. Update the library. – blackapps Nov 17 '21 at 06:09
  • Thanks. It's disappointing that absolute paths cannot be used. Is the granted access permanent, or need to be requested every run? – grolschie Nov 17 '21 at 17:42
  • 1
    You can make it permanent by taking persistable uri permission. – blackapps Nov 17 '21 at 18:16
  • I guess I also need to learn about implementing a DocumentsProvider and ContentResolver now. Just to read/write a simple file after targeting API 30. :-/ – grolschie Nov 17 '21 at 18:58
  • 1
    No. Non of that all are needed. – blackapps Nov 17 '21 at 20:43
  • Do you know what library/methods I should use with the resulting Uri for simple file read/write/overwrite, please? I might just use the SqliteImporterExporter library to output the .db file into my app's storage and then use SAF to do the public storage file operations rather than modify the library. – grolschie Nov 18 '21 at 18:53
  • Why cant you export to public Documents directory? Did you try? Well you started your post with telling that you did. Well then at reinstall you can let the user select the file with ACTION_OPEN_DOCUMENT. After that use the uri to copy the file to getDatabasePath(). Reboot device when done. – blackapps Nov 18 '21 at 19:30
  • Yes, I am importing/exporting there until targeting API 30 breaks it. You most recent reply makes me wonder why I'm even using the library - i.e. can I simply copy/replace the actual ```.db``` file at ```getDatabasePath()``` to backup/restore an Sqlite database? What is the best library for simple file copying/overwriting in Android? – grolschie Nov 18 '21 at 20:44
  • One does not need a library to copy a file. Ten lines of code will do. – blackapps Nov 18 '21 at 20:59
  • [IOUtils](https://commons.apache.org/proper/commons-io/javadocs/api-2.4/org/apache/commons/io/IOUtils.html) and [Guava](https://guava.dev/releases/snapshot-jre/api/docs/com/google/common/io/ByteStreams.html) have ```copy``` commands to copy an ```InputStream``` to an ```OutputStream```. – grolschie Dec 12 '21 at 06:17

2 Answers2

2

I'm using SqliteImportExporter library

Note that this library does not appear to be being maintained.

Is there something magic about the URI returned by this process

Yes. For example, you could wrap it in a DocumentFile using DocumentFile.fromTreeUri(), then use that DocumentFile to get DocumentFile objects representing the documents directly in the root of that tree, etc.

Personally, I used ACTION_CREATE_DOCUMENT/ActivityResultContracts.CreateDocument() and ACTION_OPEN_DOCUMENT/ActivityResultContracts.OpenDocument() in this sample project demonstrating importing and exporting databases (covered in this book, FWIW).

How can one simply copy a file to/from the shared folders (e.g. documents folder)

You already have code for this. Your issue is with an uninstall/reinstall cycle and losing permissions to that file. You have a few choices for dealing with that.

First, you could ask the user to remove that file created by your old app installation, so you can write your hard-coded(?) filename to your hard-coded destination again. The user could do this with a pre-installed file manager, for example, if the user has one.

Second, you could let the user choose a filename. If they choose one that you cannot use due to this permissions issue, tell the user and ask the user to give you another filename. Or, you could automatically adjust the filename, the way that Web browsers do when downloading files (e.g., add (1) to the name).

Third, you could stop writing to Documents/ and instead write to getExternalFilesDir() (method on Context). The two main downsides is that this directory is not as convenient and that its contents get removed when your app is uninstalled.

Fourth, you could do what I do in that sample: use ACTION_CREATE_DOCUMENT/ActivityResultContracts.CreateDocument() to let the user choose where to create the exported database and what to call it. You can then use ContentResolver and openOutputStream() to get an OutputStream for the Uri that you get back, and you can copy the bytes of the database to that OutputStream. For a later import, use ACTION_OPEN_DOCUMENT/ActivityResultContracts.OpenDocument() to let the user choose an exported database for you to use, and use ContentResolver and openInputStream() to reverse the process. This gives the user maximum flexibility, as you are not locking them into a particular location and a particular filename. It does mean that the user will need to choose a location and confirm your suggestion of a filename.

There are other possibilities, such as fussing with ACTION_OPEN_DOCUMENT_TREE, but that one in particular is cumbersome IMHO.

CommonsWare
  • 986,068
  • 189
  • 2,389
  • 2,491
  • Thank you. I ended up using option 4, the first part, i.e. ```ACTION_OPEN_DOCUMENT``` and ```.getActivity().getApplication().getContentResolver``` (in my case), ```openInputStream```, and then ```.read()``` and ```.write()``` in a ```while``` loop. Reversing the process for exporting and using ```ACTION_CREATE_DOCUMENT``` instead. – grolschie Dec 11 '21 at 01:58
  • This might help somebody. [IOUtils](https://commons.apache.org/proper/commons-io/javadocs/api-2.4/org/apache/commons/io/IOUtils.html) and [Guava](https://guava.dev/releases/snapshot-jre/api/docs/com/google/common/io/ByteStreams.html) have ```copy``` commands to copy an ```InputStream``` to an ```OutputStream```. – grolschie Dec 12 '21 at 06:18
  • `Thank you. I ended up using option 4, ` Nice. That's exactly what i suggested. Thanks. – blackapps Dec 12 '21 at 07:57
1

Reputation below 50 so adding my comment as answer.

Please refer to this question. As explained here, Once uninstalled your app don't have ownership of its own created files and you will have to work with permission of that folder.

Nayab
  • 112
  • 14