| Age | Commit message (Collapse) | Author |
|---|
|
When the input document in Android Viewer is a template,
a new doc is created and a plain '.uno:Save'
(which 'LibreOfficeMainActivity#saveDocument' triggers when the
"Save" menu entry is selected) will therefore fail.
A proper URI to save to (rather than overwriting the
template itself) is only known after a "Save As" anyway,
so don't set the 'mDocument' member until then, which leads to
the "Save" menu entry becoming disabled, just as is the
case when explicitly choosing to create a new document in
the start activity.
For now, the check whether the document is a template
checks whether the MIME type detected for the URI
ends with "template", which is the case for ODF and
OOXML types (like
"application/vnd.oasis.opendocument.text-template" or
"application/vnd.openxmlformats-officedocument.wordprocessingml.template").
This can be refined further as needed, e.g. by explicitly
adding more MIME types to check.
(Editing the actual template instead of creating a new doc
from it would be a different use case that remains
unsupported also with this change in place.)
Change-Id: I81ff957de27f620a026dbc01097b8061886293a1
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/114157
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 01521db61eb41447113c4bb671ac828a583c0cd1)
|
|
When creating a new document in Android Viewer,
don't show a file picker to choose where to save
the file at once, but create a new document and
only ask where to save the file once "Save As"
has been selected.
The plain "Save" entry is disabled until then,
since no URI to save to is known at this time.
The handling for the temporary local file,
which is used for all of the "actual work"
remains unchanged.
While at it, rename
'ToolbarController#disableMenuItem' to
'ToolbarController#enableMenuItem' and
invert the meaning of the boolean parameter
since I find that more straightforward and it also
better matches the naming of the underlying
'MenuItem' method as well.
Change-Id: I3eefada5531bfb2202aca25f2c9f170a463f87f6
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/114152
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 5ce43b2b4e79c51f0d8922caf77fa6492c05c2a7)
|
|
Change-Id: I8b7f268862c3800012548376b3e60ac1f7dca9e3
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/114151
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 865ec16158b04cf98efae4309b40244a7e41eb59)
|
|
Don't only enable the "Export To PDF" and "Print" menu
items if the experimental editing mode is enabled, but
always offer them, since they should be sufficiently stable
and don't require any editing of the document.
To do so, move them into a new menu group
"group_misc_actions", and move the entry for sending
UNO commands up, so it remains in the
"group_edit_actions" menu group whose entries are
hidden unless editing mode is enabled.
Change-Id: I425cf6d0a45306ff48b45dad6fd0e804b87a2546
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/114147
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 5306ecda9ceb5f9702c2ce6dc6207a3bd5f14a6a)
|
|
... and move the check for a new enough SDK version to
the beginning.
Change-Id: I7f5528985b8c43e218b88899409fdd22b640f72e
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/114145
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 40f30020b9e91d15c4d90e53b1d2e41770fbc58c)
|
|
In Android Viewer, show a file picker to select
where to save the PDF file on PDF export, rather
than unconditionally trying to save in the
"Documents" directory.
This also means that permission
'android.PERMISSION_WRITE_EXTERNAL_STORAGE' is
now no longer needed for this task, s. commit
message from
commit 7d9db806d65cb814af1e99a1e79c3db5aa7c17d5
Date: Fri Apr 9 11:24:16 2021 +0200
android: Request PERMISSION_WRITE_EXTERNAL_STORAGE again
for more details.
Also, adapt the 'TileKitProvider#saveDocumentAs'
methods to return a boolean value indicating
whether the save operation was successful,
and trigger showing the message right into
'LibreOfficeMainActivity#exportToPDF'.
Rename 'LOKitTileProvider#exportToPDF(boolean print)' to
just 'LOKitTileProvider#printDocument()', since the only
remaining use case for which it is used is printing now.
Change-Id: I779d782813ca01640811690a388a4b7fd3db4b2a
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/114143
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 9ebcb80e2e4335fca1e137d015fe4d84631e282a)
|
|
This adds a "Save As..." menu entry to Android
Viewer in order to save the currently opened file
to a different location.
Currently, the file is always saved in the corresponding
ODF format, regardless of the original file type,
i.e. that e.g. a DOCX file is saved in ODT format.
(This could be extended to allow a selection of the
target format as needed.)
Like "Save As" (and as compared to "Save a Copy")
in the desktop version, the app remembers the
new document URI and subsequent save operations
will overwrite the newly saved file, not the originally
opened one.
(There is no need to create a new temporary
local file to use, though.)
The directory of the currently used file
is preselected in the file chooser used to
specify where to save the new file.
Make sure to copy the file in a non-main thread,
since the destination URI might be handled
by a DocumentsProvider that does network access.
However, for now the main thread just waits for
the separate thread to finish, just like
commit 7f838b73e85eb6f0a1dce4647650a5cf5f34ccd2
Date: Fri Mar 19 15:46:36 2021 +0100
tdf#129833 android: Move reading file to separate thread
implemented it for copying from the URI to the
temporary file when opening a file.
This also adds a 'TileProvider#isDrawing' method
(like the already existing 'isTextDocument',
'isSpreadsheet' and 'isPresentation' ones).
Change-Id: I6f56b71763431b89a6c74be35cc1e81fad136cd0
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/114058
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit d16e569209fe40c2cb5776f7b9415e273d5b2387)
|
|
This essentially extracts what
commit 7f838b73e85eb6f0a1dce4647650a5cf5f34ccd2
Date: Fri Mar 19 15:46:36 2021 +0100
tdf#129833 android: Move reading file to separate thread
introduced into a separate helper method.
Change-Id: Ic70ba9f2e2bc125415ff1b3fa3375c3389181c43
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/114123
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit a2b4564d719e6efeb614052b9c833991e447c68c)
|
|
LOKitTileProvider has that information, so query it instead
and don't duplicate information in LibreOfficeMainActivity.
Change-Id: I233986d6e94e5676464cb3399303efd545e33d32
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/114057
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 4db8535fba00c476555e09e32e521993ab77dc4d)
|
|
Those are leftovers; they're unused since
commit a23bd42e9b2f6401c710ac95afcc3aa8f360d65c
Date: Tue Apr 6 14:26:06 2021 +0200
android: Drop custom file abstraction + UI
Change-Id: I898391cfccd465e4d18d51ee07ee847978872ef1
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113885
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit bcf0ed2f672646107b42cbe67e5c3c9d170bb33a)
|
|
It just calls the parent class method anyway.
Change-Id: I802e75ad650b71d6daa08494ff812985bb844a5f
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113884
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit c0c43f4742e9a78addafd9522779f7f55243a522)
|
|
Previously, the document was always closed in
LibreOfficeMainActivity's 'onStop' and loaded anew in
its 'onStart' method.
In order to not lose user changes, there was also
a caching mechanism in LOKitTileProvider, also triggered
in 'LibreOfficeMainActivity#onStop'.
This means that e.g. each time a switch to another
Activity/app happened, a cache document with the user
modifications in it should have been created for
restoration. That did not really seem to work
particularly well in a few tests, as also described
in tdf#95517 ("changes reset after show Settings").
The documentation aboue Activity lifecycle says [1]
> The entire lifetime of an activity happens between the first call to
> onCreate(Bundle) through to a single final call to onDestroy(). An
> activity will do all setup of "global" state in onCreate(), and release
> all remaining resources in onDestroy(). For example, if it has a thread
> running in the background to download data from the network, it may
> create that thread in onCreate() and then stop the thread in
> onDestroy().
This changes the handling to load the document in the
'onCreate' method and clos it only in 'onDestroy',
i.e. the document remains open while e.g. switching
to another Activity or app, thus making it unnecessary
to try to restore state as good as possible in 'onStart'.
An invalidation of the view (via 'LOEvent.REFRESH')
generally seems to be enough.
(Well, sometimes there is an issue with
invalidation/repaint and single tiles remain black,
but that happened previously - when the whole doc
was loaded anew - just the same way).
This allows dropping some extra handling needed
to try to restore the previous state, along with the
caching mechanism in LOKitTileProvider (that had some
other issues, e.g. it didn't reliably create the cache
file, since the file extension was not always set, and
'LOKitTileProvider#cacheDocument' was relying on that
to derive the document type).
I am not sure whether I missed any aspect that the
previous implementation was trying to solve, but
at least these scenarios I found and tested worked
as expected with the change in place:
* user changes still present after switching between apps
(s. tdf#106648 "Android: save current work when onSaveInstanceState is
called")
* for the Calc case, the sheet that was selected before
switching apps is still selected (s. tdf#101689
"Android Viewer calc returns to first sheet")
* user changes no longer get lost when selecting a menu item
(s. tdf#95517 "changes reset after show Settings")
* case where the user leaves the app by pressing Home, and starts it again
(as described in commit 83386129f5be002f2649db81bba4c468c7f6e4de
"android: Fix the application lifecycle.")
[1] https://developer.android.com/reference/android/app/Activity#activity-lifecycle
Change-Id: If59734cbfd62673884786066c94e2c2a1d6a916e
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113883
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 1bc42472200c32c9a0a10dd1c3cd6c6a8a5d47d2)
|
|
Always create a local copy of the original document
to work with, rather than doing a different handling
depending on the type of the URI used to specify the
file to load.
This will also simplify adding support for "Save As"
in upcoming commits, where the temporary
file can remain the same and only the URI for the
actual document will need to be changed.
Change-Id: I2587611fa56b76d8a5384ac25c57335e8d12e987
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113882
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit d8fea0b8cc92c3416df1e98d7f472e534eae38e8)
|
|
Make 'example.odt', 'license.txt' and 'notice.txt'
(which can be opened via the "About" dialog)
resources of the app by copying them to a new directory
'res_generated' instead of into assets, and include
'res_generated' into resources, then use an
'android.resource://' URI instead of a 'file:///assets/'
one in AboutDialogFragment.
The latter does not work with when passed as a parameter
to 'ContentResolver.openInputStream'.
Adapt/Simplify 'LibreOfficeMainActivity#copyFileToTemp' to
make loading those docs using the 'android.resource://'
URI work and use the existing 'copyStream' method for copying from
the input to the output stream.
This is in preparation for upcoming commit with Change-Id
I7731ef81a4242fa0ce3b3fd8ced1683a6a6bee8c,
"android: Always create a temporary local copy of the doc".
Change-Id: I7731ef81a4242fa0ce3b3fd8ced1683a6a6bee8c
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113881
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit d3f8f4b1663214ebe29e49e109b1ae704b680b9e)
|
|
Drop the fallback of opening 'example.odt' when
no file to open was given.
I see no valid way how that fallback should be
reached, so write an error log message instead,
just in case there is still a way to get there.
Change-Id: I8b8040ba0099cba9196f65982f09c67791be01c2
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113880
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit bcb74b50920a44729ba2c88db98738a61d8d9920)
|
|
Extract method 'copyStream' used to copy the
temporary file to the actual document URI when
saving.
It will also be used for copying the other way around
when initially opening the document.
Change-Id: I5382f4a7c49b454ff38fb8f95afab3c39145c11f
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113879
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 224df2980f0626b1e0b7f40c14348771ffff58fe)
|
|
Add a 'mDocumentUri' member in LibreOfficeMainActivity
to store the document URI rather than retrieving it from
the Intent using 'getIntent().getData()' all the time.
This is also in preparation to make it possible to change
the URI later, e.g. when doing a "Save As".
While at it, also switch to readonly mode for the
fallback to 'DEFAULT_DOC_PATH' (though I don't think
this should be relevant anyway).
Change-Id: I629bad1d743e458191dcfa2b1371ea4b280e7b13
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113878
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 79d9a7349174a7e2b2aa7fcf324a6987edbbd555)
|
|
Only try to retrieve the file URI and load the document
if a file was actually selected.
Change-Id: Icd47c197b67d593e74874e8136233b6e41a1a68d
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113845
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit d214ab444e73490f4c95dffd7f376978cbcd3ccc)
|
|
Requesting the permission on app start had been dropped in
commit a23bd42e9b2f6401c710ac95afcc3aa8f360d65c
Date: Tue Apr 6 14:26:06 2021 +0200
android: Drop custom file abstraction + UI
Since the app now uses the Android Storage Access Framework [1]
in order to open or create files from within the app,
it not longer needs PERMISSION_WRITE_EXTERNAL_STORAGE for this.
However, at least PDF export currently still directly writes
to local storage ("Documents" directory), which fails without
that permission being granted.
In addition, opening files passed with a 'file://' URI
in an 'Intent.ACTION_VIEW' also did not work anymore.
I'm not sure whether this use case is particularly
relevant in practice, though; at least all of the (few)
apps I used during testing passed 'content://' URIs in their
Intent.
In addition, in Android 11 (API level 30) or higher,
PERMISSION_WRITE_EXTERNAL_STORAGE no longer has any effect;
from [2]:
> More recent versions of Android rely more on a file's purpose than its
> location for determining an app's ability to access, and write to, a
> given file. In particular, if your app targets Android 11 (API level 30)
> or higher, the WRITE_EXTERNAL_STORAGE permission doesn't have any
> effect on your app's access to storage. This purpose-based storage
> model improves user privacy because apps are given access only to
> the areas of the device's file system that they actually use.
>
> Android 11 introduces the MANAGE_EXTERNAL_STORAGE permission, which
> provides write access to files outside the app-specific directory and
> MediaStore. To learn more about this permission, and why most apps don't
> need to declare it to fulfill their use cases, see the guide on how to
> manage all files [3] on a storage device.
For now, request the permission again, at least as long
as PDF export doesn't use the storage framework to
ask where to save files.
It certainly makes sense to reconsider this in the future (and decide to either
drop the permission completely or request MANAGE_EXTERNAL_STORAGE for API
level >=30).
[1] https://developer.android.com/training/data-storage/shared/documents-files
[2] https://developer.android.com/training/data-storage#permissions
[3] https://developer.android.com/training/data-storage/manage-all-files
Change-Id: Icc4c9c9b7b315d2a0b6a025439ae7e431cdd5b37
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113840
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 7d9db806d65cb814af1e99a1e79c3db5aa7c17d5)
|
|
Add 'com_sun_star_comp_dba_ODatabaseContext_get_implementation' to
liblo-native-code, needed to open mail merge files
with data source since
commit e64dc07ca8300a997d6d3eebfc3e198ae55d290d
Date: Mon Mar 29 11:52:05 2021 +0300
tdf#139906 Show warning message when data source is not avaible.
Change-Id: I6fdd500f9c3b9cc54310e78df694eba7103ff0b8
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113717
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit d3c5087b1f3edaf40fdd62311a3e9895a1fb7916)
|
|
Use the same height as is used for the "Recent files"
entries.
Change-Id: Ia6c1e02507ac12b554eb042d6dd32c0fc78cb578
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113675
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 4cfcc0f48a0bcdeb77b86455b463889ea1040bc3)
|
|
Move the view that opens the system file picker when tapped
above the "Recent files" view in the Android Viewer start
activity.
Change-Id: I63ee0ea7fb784a3405877fcf5ed587ce06e8e093
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113674
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 91eb5026f999ee349079c8cfcc77ac67b76c1ef2)
|
|
Android Viewer had its own file abstraction layer.
From the (now deleted) IFile.java:
> An abstraction of the File class, intended to be implemented by different
> Document Providers.
>
> It represents a file or a directory in the context of a certain Document
> Provider. It wraps the file-related operations and provides access to the
> final document as a local File, downloading it if necessary.
However, Android already provides such an abstraction by
what is called "documents provider" there as well, s. [1].
Android Viewer has previously been adapted to
support and make use of that.
Therefore, drop the custom implementation to avoid
duplication and having to reimplement functionality
already provided otherwise.
Also, drop the custom UI elements to display and
select files implemented on top of the custom
file abstraction. Support for using the system file
picker (via the corresponding Intents) has been added
earlier and is now the only available option to open
files from within the app.
[1] https://developer.android.com/training/data-storage/shared/documents-files
Change-Id: Ide529e836a32fd7e880e5a72d971af9f9c7e74bf
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113667
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit a23bd42e9b2f6401c710ac95afcc3aa8f360d65c)
|
|
Previously, a set was used to store the recently used files,
meaning the order was lost when restoring from the prefs.
Use a space-delimited string to store the entries in prefs
instead, and convert that into an (ordered) list.
This way, it's possible to always drop the oldest entry
(instead of a random one) when inserting a new one and
the max count has been reached, so the list of
recently used files shows those that are actually the
(up to 4) most recently used ones.
Change the key used for the preference
(variable 'RECENT_DOCUMENTS_KEY') to a different value,
so there is no problem about trying to
read old values stored as a Set<String> as a
plain String.
Change-Id: I95cc3627cd2975f0463f5ecb94292a26fe714066
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113462
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 2bbb2943845a8b580d1f6d009209e5f0a6cd09d4)
|
|
Switch the list of recently used documents in LibreOffice Android
Viewer to show the documents opened using the system file picker
instead of those shown using the custom UI elements for file
selection.
This way, files provided by DocumentsProviders, like Nextcloud,
can also be handled.
As described at [1], this requires persisting permissions
in order to be able to access the files after a device reboot.
The corresponding method to do this,
'ContentResolver#takePersistableUriPermission', is only
available from SDK level 19 on, so drop entries for
older SDK levels (current minSdkVersion is 16).
[1] https://developer.android.com/training/data-storage/shared/documents-files#persist-permissions
Change-Id: Ifbf7148cda687a8a2e3f0c14fe66651509b2f19a
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113459
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 2611b5c25551c38d047d8be058177bc7fbfc672d)
|
|
This is unnecessary, since minSdkVersion was bumped to 16
in
commit a7f6338875931d8afff55cb39ead8f6600af04cb
Date: Wed Aug 7 12:06:25 2019 +0200
android: support NDK 19 and above (20 as of this commit)
support for targeting API 14 and 15 was removed in NDK 18, so set
minimum version to 16
[...]
Change-Id: I70573f9e5e24b211ee7e84be5824d69e4f2b9f81
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113458
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 4003042af09d8335003c6b9faf3696221a44916c)
|
|
Will be used in LibreOfficeUIActivity as well.
Change-Id: Ie1b99f0d31dba1be263459d135ee7fcb36613a7b
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113457
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit af56d15d6bbe92c7df0248ec72dc4d759580c378)
|
|
The method will also be used from elsewhere in a follow-up commit.
Change-Id: I94cbdfa9faf54fcb655233f43d13ced8740b88a0
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113456
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 40115df50102bd5314a93f54042ae6d035c1f685)
|
|
Since input etc. is otherwise ignored in readonly mode,
also don't mark the document as changed on keypress.
This e.g. avoids an unnecessary dialog whether or not to
save the document after opening a document with experimental
editing mode disabled, then pressing a key (on hardware
keyboard, soft keyboard isn't shown in readonly mode)
and then pressing the "Back" button to close the document
again.
Change-Id: I095c79549719d3760666605e1c642c58e6b1bb9d
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113417
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 441342654e5b4c61317b9a596396a1d817dd8547)
|
|
Change-Id: If72949f949cba23397d87c8f67b9434861f9bb7c
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113414
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 51f6e11aee50cc429021be27bd33875593425683)
|
|
Drop the "Press back again to quit" info shown when pressing
"Back" in the file selection dialog in Android Viewer and
just quit the app right away.
It was originally added in
commit d1f671e053864d0bf54d04a855761b43a7f5a9c4
Date: Wed Jun 10 19:04:22 2015 +0200
tdf#87434: android: system back key to go one level up
Added an additional check so back has to be pressed twice on the root
folder to actually leave the application. It's a check seen in many
other apps.
but I don't really see any need to bother the user
about pressing "Back" again. Nothing is lost at
this stage when quitting the app, and I haven't
seen anything similar in many current apps myself
(but have rather seen some extra confirmation dialogs
disappear from desktop applications over the last
years).
The original request in tdf#87434 to go one level up
in the directory hierarchy is unaffected by this,
though this only applies for the custom widgets
to browse the file system, which will potentially be
dropped in the future anyway, now that support
for the system file picker has been added in
commit d678ee309b02b4cc8af29a097bf5053b8b1b4e06
Author: Michael Weghorn <m.weghorn@posteo.de>
Date: Fri Mar 19 14:29:36 2021 +0100
tdf#129833 android: Allow opening files using system file picker
Change-Id: Ib324b7f0b82427b04c7708665ff7492a758eec9b
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113413
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 1477401805e2a88cddb1df259456359398fa2b7d)
|
|
Similar to the way that existing documents can be
opened from within the Android Viewer app
using the system file picker by using
'Intent.ACTION_OPEN_DOCUMENT', use the system file picker
via 'Intent.ACTION_CREATE_DOCUMENT' to create new docs
as well, instead of providing a custom dialog to
insert a file name.
As described at [1], this allows to save files
in locations supported by any existing
DocumentsProvider (e.g. a Nextcloud share,
if the Nextcloud app is installed and set up),
not just locally.
This also allows to further unify the handling in
LOMainActivity. Just like for the cases where an
existing document is opened using the system file
picker or a document is passed from a third-party app,
the document URI is now set in the Intent, a
temporary file is used and writing back to the
actual URI happens on save.
Drop LibreOfficeMainActivity's method 'showSaveStatusMessage',
which was only meant to be used when a new file was created, but
was called from the more generic 'LOKitTileProvider::saveDocumentAs'.
Change that to show a more general error message when saving fails.
Since the actual file is now created by the DocumentsProvider,
LOKitTileProvider only operates on the temporary copy anyway.
Side note: With this change in place, overwriting
existing files also no longer just happens silently,
as used to be the case when typing the name of an existing
file in the custom dialog for creating new files
earlier.
Since 'Intent.ACTION_OPEN_DOCUMENT' was introduced
in SDK version 19 (Android 4.4), restrict creating
new docs to corresponding devices.
[1] https://developer.android.com/training/data-storage/shared/documents-files
Change-Id: I8932cb892ca8ac97a04d15cbd1540d0ee68350da
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113408
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 4b8540911bc8fabee0729b31780a1ba8b4663121)
|
|
Follow-up for commit a1abf2c865228e6ed33e99ab73b94357ddbc590f
(tdf#139350 android: Add param to allow a "real" "Save As").
The file path should only be updated when the newly saved
doc is actually used (i.e. 'takeOwnership=true'),
not when just saving a copy or exporting to a different
file format.
Change-Id: Ia3120a94b7fcc79c1a740a10bade8721f6771d78
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113404
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 19e1f3723d4bfb91dadf77b398261da0e8237a8b)
|
|
It appears to have been unused since it was added
in
commit 78098b8494be7123bc4a8b50faa13445e5afd8ce
Date: Mon Mar 27 22:26:47 2017 +0530
Add BottomSheetBehavior to formatting toolbar
Change-Id: I43cc75e0b7a1bcebd01bd77fc7132a39510c70ba
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113400
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 05a3ce9abb329969e7edaafd0a2e9057c73d0fbb)
|
|
Pass param 'takeOwnership=true' to the 'saveDocumentAs'
method when saving a newly created document in Android Viewer
in 'LOKitThread::loadNewDocument', so the newly
written document is used subsequently, rather
than continuing to more or less operate on
"private:factory/swriter" (for the Writer case,
similar for the others).
Extend 'LibreOfficeMainActivity::saveFileToOriginalSource'
to handle this case as well (show a proper message and
reset the modified state after saving).
Drop now unnecessary special handling for the case
of saving new files from the toolbar or the dialog
shown when exiting without having saved previously.
Change-Id: Ief95620e324aa2abc318f1add0b91376ffe669d6
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113376
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 2e86226cff95100e3c34d0f22ec5ce6429efb8cb)
|
|
So far, LOKitTileProvider's 'saveDocumentAs' method
was always saving a copy of the current document
(or doing an export), but was not continuing to use
the newly saved doc afterwards.
Add an additional parameter 'takeOwnership' to the
method to specify whether to do so.
In other words,
* the 'takeOwnership=false' case continues to
do what was done previously, it basically does what
"File" -> "Save a Copy" or "File" -> "Export"
does in the desktop version
* the 'takeOwnership=true' case now basically does the
same as "File" -> "Save As" in the desktop version
(except that the path is already known in the
Android case)
This essentially forwards the "TakeOwnership"
param to LibreOfficeKit, which was originally
added there in
commit a121074cbd07939713e169586469b934aedbe594
Date: Wed Feb 10 13:26:50 2016 +0100
lok: Introduce a "TakeOwnership" filter option for saveAs().
It is consumed by the saveAs() itself, and when provided, the document
identity changes to the provided pUrl - meaning that '.uno:ModifiedStatus' is
triggered as with the "Save As..." in the UI.
This mode must not be used when saving to PNG or PDF.
Change-Id: I11b5aa814476a8dcab9eac5202bd052828ebbd96
This also adds a new 'SAVE_COPY_AS' event type to save a
copy without taking ownership, and switches all uses of the
'SAVE_AS' event to that new one for now. (So the behavior
remains unchanged, but the terminology is hopefully clearer.)
Except for one instance in LOKitTileProver::saveDocument (where
the cached version of the document is written to the original
URI, if present), all other places are left with the previous
behaviour in this commit.
Further changes will be done in follow-up commits.
Change-Id: I11996cd7276a6c6f2774535cd3e53cb997c8cd4e
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113375
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit a1abf2c865228e6ed33e99ab73b94357ddbc590f)
|
|
Add an overload for the 'saveDocumentAs' method that takes just one
parameter and auto-detects the file type to use from the document.
Use it when creating new documents.
Change-Id: I0f275ce159176292ffa1e52ed37673a486ab9428
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113374
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 4dbc9c87a09922072c0250e4e932228de93961db)
|
|
The permission was requested since ownCloud support was added
in commit 69773f54bbac08953f0fbce16eecea0816e04338
("Android: initial implementation of ownCloud provider.",
2015-01-21).
Since the custom ownCloud support has been dropped in commit
6012599e17206ee7be9a83477654e7bd194079c3
("tdf#129833 android: Drop non-working ownCloud/nextCloud support"),
there should no longer be any need to require Internet access,
so drop the permission again.
Access to ownCloud and other Internet services providing file
access now goes via DocumentProviders, and the corresponding
apps providing those should take care of
being allowed to access the internet by themselves.
I tested that opening and editing a file located
on a NextCloud share still works OK when the NextCloud
app is installed and set up.
Change-Id: Id8425e7afcd5ecc26d14ba9f42018f536d0a6a6e
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112879
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 76a30ac646faf1c638736c10e834bb7b0ed243ef)
|
|
Trying to type in a read-only Writer section in Android Viewer
led to a crash due to
'/assets//config/soffice.cfg/modules/swriter/ui/inforeadonlydialog.ui'
not being present.
Include the .ui file to avoid this. (Trying to type now
doesn't do anything, no warning about this being
read-only is shown.)
Change-Id: I616d41c312187fa7855430715a47e80477ef2188
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112771
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 1bf8f4569502b7900c51f2e238acda6567c96281)
Conflicts:
android/source/build.gradle
Change-Id: Ied7833105a2efb0b0b1f340c806904cfa1bd877c
|
|
Reading the input file from the main thread is problematic
when that happens over the network.
For example, trying to opening a file in a NextCloud share
using the system file picker from within the LO Android Viewer
app (with NextCloud app 3.15.1 serving as DocumentsProvider
for the NextCloud share in the file chooser) previously
resulted in a crash, with this in ADB log:
I DownloadFileOperation: Download of /Documents/five_pages.odt to /storage/emulated/0/Android/media/com.nextcloud.client/nextcloud/<USERNAME>@demo2.nextcloud.com/Documents/five_pages.odt: Unexpected exception
E DocumentsStorageProvider: RemoteOperationResult(mSuccess=false, mHttpCode=-1, mHttpPhrase=null, mException=android.os.NetworkOnMainThreadException, mCode=HOST_NOT_AVAILABLE, message=null, getLogMessage=Unexpected exception)
Moving this to a separate thread fixes the
NetworkOnMainThreadException and made opening, editing
and saving the modified file back work successfully
for that scenario.
(Using a separate thread when writing back does not
seem to be necessary, but could be added in a similar
way.)
This just moves the IO to a new thread and then waits
for its completion.
For a better user experience in cases where the copy
operation may be slow, providing some additional
feedback in the UI might be useful.
Change-Id: I58e2c4bb1dcd2d59383fba0f216c9614f5d3e3a7
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112769
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 7f838b73e85eb6f0a1dce4647650a5cf5f34ccd2)
|
|
Extend Android Viewer with the possibility to select a file to
open using the "system file picker", which can be opened by
an Intent that has the action 'Intent.ACTION_OPEN_DOCUMENT'
(or 'Intent.ACTION_GET_CONTENT' for API level < 19) set.
This way, all locations supported by currently installed and
set up DocumentsProviders [1] are generally supported.
In a test, opening local files worked just fine, but trying
to open a file located in a NextCloud share failed
(with the corresponding app [2] installed), showing this
in ADB log:
I DownloadFileOperation: Download of /Documents/five_pages.odt to /storage/emulated/0/Android/media/com.nextcloud.client/nextcloud/<USERNAME>@demo2.nextcloud.com/Documents/five_pages.odt: Unexpected exception
E DocumentsStorageProvider: RemoteOperationResult(mSuccess=false, mHttpCode=-1, mHttpPhrase=null, mException=android.os.NetworkOnMainThreadException, mCode=HOST_NOT_AVAILABLE, message=null, getLogMessage=Unexpected exception)
This will be dealt with in a separate commit.
For now, this way to open files (and a corresponding menu
entry) is added in addition to the existing ones, but
since that method should in general be able to cover all of
the other use cases as well, the other options may be
dropped in the future.
[1] https://developer.android.com/reference/android/provider/DocumentsProvider
[2] https://github.com/nextcloud/android
Change-Id: I684a4aa770c0df7cc9fc35ff92445230405885f5
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112768
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit d678ee309b02b4cc8af29a097bf5053b8b1b4e06)
|
|
When a document is passed by an Intent in Android
Viewer, allow editing if the Intent has flag
'Intent.FLAG_GRANT_WRITE_URI_PERMISSION' set.
Since LibreOffice operates on a temporary copy
in this case, write the content of the
temporary file back to the original URI
when saving.
This in particular allows editing documents
passed from third-party apps, e.g. opened from
Android's "Files" app or the NextCloud app.
The online-based Android app already does
something similar.
Change-Id: Icf252a95dd9a8089ca8610ccf3edfbeee2682e1a
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112767
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 2df8b776e635efc5e59aaf6c8a5a7f4c218d74d0)
|
|
It's no longer used by Android Viewer and use in
the online-based Android app has already been removed
in online commit
commit 2a52d768dd61f2ef8fedccb32f015c9095915935
Date: Wed Feb 19 09:05:56 2020 +0100
android shell: Remove the 'storage framework', we have content providers.
Change-Id: I468c7121eb495eb8b1a8892f14f2c289b94b7a93
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112766
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 2fa33c89ffcf0bb5aa013ee71a06b12676b42997)
|
|
As mentioned in tdf#129833 comment 3, the idea is to
use Android's "system file dialog" to select files rather
than maintain a separate ownCloud/nextCloud connector in the
Android Viewer app.
This way, everything for which a DocumentsProvider [1] is
available will be available from within the app, once
Android Viewer has been adapted to support those, which is
planned for a subsequent step.
Corresponding DocumentsProviders for ownCloud [2] and nextCloud [3]
exist.
[1] https://developer.android.com/reference/android/provider/DocumentsProvider
[2] https://github.com/owncloud/android
[3] https://github.com/nextcloud/android
Change-Id: I6581ce36672f582f91d47598afdfd32c3a4a58da
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112765
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 6012599e17206ee7be9a83477654e7bd194079c3)
|
|
... according to the changes done in
commit 0dffc65236fbacf98047d6dbfc82b4efe7dd959b
Date: Fri Jun 5 08:59:26 2020 -0400
android: fix the build output directory
When compiling in a different build output directory,
the "liblo-native-code.so" file is created in the source directory and
it fails compiling the "online" project
Change-Id: I886231034bbe3937748d9b5ef56239aea3cf7b8c
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112702
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit b0d1ad82e33868683edd7a1e50f516f38d0634b0)
|
|
Previously when experimental mode was enabled in Android
Viewer, a "This file is read-only, saving is disabled."
info was shown to the user when opening a file read-only,
e.g. when the file was passed from a third-party app.
However, editing the document was still possible, a
dialog asking whether or not to save the modified doc
was shown when existing and only then saving would fail.
Disable editing completely for this case, rather than
having the user lose changes in the end.
Change-Id: Ie523971949d11909223aeac4f99023ecf28cb56c
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112693
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit bf6efbb808929bfba42f88c894be93d1aa6f4210)
|
|
Since editing is disabled in Android Viewer for non-experimental
mode anyway, there's no need to tell the user it's not possible
to edit a specific document if it's readonly.
Replace the 'usesTemporaryFile' method with a more explicit
'isReadOnlyMode' method since ToolbarController shouldn't
have to worry about implementation details like whether
temporary files are used and the new method will be reused in other
places in a follow-up commit as well.
Change-Id: Iaccf5b40bd19887b9e76b982ce7252368871c716
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112692
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 878cbe229fdb61501bf7889408a19fca14d1afdd)
|
|
Don't make the possibility to select and copy text
depending on editing being enabled, i.e. experimental
mode being enabled in Android Viewer.
In a quick test, this worked just fine in read-only mode
as well, so tapping on text in a document now shows two
cursors around the tapped word, and allows adapting the
selection using these and copying to the clipboard
by using the corresponding toolbar entry.
Change-Id: Icbd9d055a6cc700b78711df178f594c7a9c5cfbf
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112673
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit 88f4b76270c26ab1d99c14f68cdcbea4b6ee9031)
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112627
Tested-by: Michael Weghorn <m.weghorn@posteo.de>
|
|
When a temporary file is created in Android Viewer
(e.g. when a file is passed from another app, like
a file explorer or an email app), still show the
original file name in the toolbar, instead of the
name of the temporary file (like
"LibreOffice1588848072959345750.tmp").
Change-Id: I86f5cebfa8e2986fe812ace16c0df324d1420955
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112643
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
(cherry picked from commit a7c0039542fb015e34c56ec25f92f59a4c6ba1fa)
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112621
Tested-by: Michael Weghorn <m.weghorn@posteo.de>
|
|
... which has been added in
commit e00fd78e6e454491014f03370e14efa5ebc2eefe
Date: Thu Oct 22 19:41:17 2020 +0100
weld impress TabBarControl
and is now needed by Impress in Android Viewer
as well.
Change-Id: I7fd89fa78a277d9da2121a47765107166ada1fd3
[Note: This is a partial cherry-pick/backport of
pending Gerrit change
https://gerrit.libreoffice.org/c/core/+/112557 ;
only of the two commits mentioned in that one's
commit message is already contained in 7-1 branch
as well, so just one .ui file needs to be added
here.]
Conflicts:
android/source/build.gradle
Change-Id: I084655679eced073eed9db009cbbc598fce43eeb
|
