I need to save some configuration from a DriverKit driver. I was reading How to save kext configuration between sessions and in this case it seems that the preferred way is to save the config from a user land app. Since DriverKit drivers are in user land is there an easier way to do this or is the preferred solution the same as for kexts?
Preferably the configuration should be saved in some place that is persistent, even if the app that installs the Dext is removed from the system, this to be able to carry over configuration when the app is uninstalled and then reinstalled.
Related
I have currently the problem specially on iOS, that when I select a file through the FilePicker, which is located in Nextcloud and integrated in the file manager through the file provider, I get a shared path to the file. The access is now possible to the file.
However, if I now save the path and want to access it when I restart the application, this is no longer possible. I ran this on a local device.
Access to the path'/private/var/mobile/Containers/Shared/AppGroup/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX/File Provider Storage/abcd.../test.xyz' is denied.
I couldn't figure it out from the documentation at apple.
https://developer.apple.com/documentation/fileprovider
Is the selected file only temporarily accessible? How can I permanently access e.g. a file in nextcloud via FilePicker without implement a WebDAV client to the app and constantly kept up to date the selected file?
With Android, as far as I have read, a permanent copy of the file is created, and access to the file also works when the application is restarted. Here, however, there is the problem that the file is not updated.
The permission checks and requests are automatically handled by .NET MAUI. But, when you use the FilePicker, you need to enable the iCloud capabilities.
For how to enable the capabilities, you could check the MS docs. https://learn.microsoft.com/en-us/dotnet/maui/ios/deployment/entitlements
My application has 2 features: "base" and "extend".
manifest extend feature:
<dist:module
dist:onDemand="true"
dist:title="#string/title_extend">
<dist:fusing dist:include="true" />
</dist:module>
download feature with SplitInstallManager -> startInstall
unintsalling with SplitInstallManager -> deferredUninstall
Check installed modules with SplitInstallManager -> getInstalledModules
Extend feature is loading from play store success and work as expected. When this feature has become unnecessary - uninstall it.
more, SplitInstallManager has callbacks: SuccessListener, FailureListener, CompleteListener. Install and Uninstall completely with success (no errors).
But, after uninstalling Extend feature (and after restart application) it is stay installed.
How to delete uninstalled feature from the application (need remove no used code and resources) ?
As explained in the API of the deferredUninstall method:
Once called, the Play Store will try to eventually remove those modules in the background.
The uninstalled modules will be removed while the app is not working at some point in the next 24 hours.
Here is what I noticed.
1) Uninstalling the app removes the downloaded modules, so the next time you run the app, the app will download the modules again.
2) Clearing the app data (e.g. adb shell pm clear APP_PACKAGE_NAME) makes the module not available to the app immediately, but if the module is already downloaded before clearing the app data, it won't be downloaded again. In other words, you won't see SplitInstallSessionStatus.DOWNLOADING.
3) Once the downloadable module becomes available to the app, clearing the app data of "Google Play services" (i.e. adb shell pm clear com.google.android.gms) doesn't make a difference. But occasionally, the downloadable module sticks around even after uninstalling the app, especially when the module's name changes. Then 3) becomes handy to clear the stale modules.
I think what's happening here is when the app requests a downloadable module, Google Play services downloads the module, hands it over to the app, and caches a copy of it, just in case the app requests it again. If the app is uninstalled, Google Play services removes the cached module. deferredUninstall() is just asking Google Play services to uninstall the modules if necessary, but we have no control on when that would happen, if ever.
from https://developer.android.com/guide/app-bundle/playcore#uninstall_modules:
Module uninstalls do not occur immediately. That is, the device uninstalls them in the background as needed to save storage space. You can confirm that the device has deleted a module by invoking SplitInstallManager.getInstalledModules() and inspecting the result, as described in the previous section.
So You could try to fill up storage space on your device and see if that triggers an uninstall :)
By the way: On the play store page for the app that I am currently testing via "internal early access", there is a section "deferred actions" which lists all modules marked for deferred uninstall. There also is a button "run deferred actions" which actually removes those modules completely.
As far as my own testing has gone, uninstall is deferred until the app is updated by Play Store. Otherwise I assume Play Store services will eventually wait for the app to be totally inactivate to update its uninstalled module (the app has to be restarted for that update to occur).
I've filled a bug to find out if there's anyway to force the (un)install of on-demand modules: https://issuetracker.google.com/u/1/issues/172108742. And a way to tell which modules are truly installed.
Same goes for installing actually, until app is updated, on-demand modules are "emulated", which prevents those 2 things from happening:
The platform can not apply any new manifest entries introduced by the module.
The platform can not access the module’s resources for system UI components, such as notifications. If you need to use such resources immediately, consider including those resource in the base module of your app.
As explained here: https://developer.android.com/guide/playcore/play-feature-delivery#access_downloaded_modules
There seem to be a long road ahead before on-demand modules work properly.
I had been working on Google app engine for some time with great success. However, recently I was forced to upgrade to Eclipse-Photon from Eclipse-Mars.
I can run a debugging version of the server on localhost:8080 just fine except when I change any of the TypeScript files. Formerly when I would run the TypeScript compiler to generate new JavaScript the server would automatically update the server. Now when I generate a new JavaScript file, the server continues to serve the old version. I have my expirations set to 0 and I have automatic publication turned on.
For a while I could make it work by telling the server to Publish. Now that has stopped working as well. If I save any file from inside of Eclipse I see a little message flash by indicating publication and then that file serves properly. If I load the generated JavaScript file and then modify it slightly then it will publish and serve correctly.
Obviously Photon is no longer tracking file changes that way that Mars did. I could easily copy the generated file to the correct place if I knew where that place was.
Are you running your TypeScript compilation from outside of Eclipse? If so, try doing a Refresh of your project. That should sync up Eclipse's notion of the filesystem state with what is on disk.
Cloud Tools for Eclipse relies on the Web Tools and Resources frameworks to determine whether a resource has changed and needs publishing. Eclipse is normally set up to detect resource changes automatically as configured by two options on the Preferences > General > Workspace preference page: Refresh on access and Refresh using native hooks or polling.
Is that possible to implement the update of my own p2 enabled RCP application in a way that it will function in multiuser environment. What I want to do is identical to eclipse, I want to have my application installed in a location that is read-only to the user. When the user runs, he gets his own writable location, usually under his home directory. The user can install additional features that are stored under this writable location. How is that possible to do. I tested my application and it doesn't work this way by default, my application tries to download updates fails and keep restarting.
Thank you in advance.
Ulyana
When you deploy your RCP app, follow the steps in Eclipse multi-user installs to create a configuration area that you can make read-only and then run as another user.
In theory it should be something like:
rcp.exe -initialize
make RCP application directory read-only
I'm writing an app that includes a folder/file explorer. That part is working. However, another app (Astro File Manager) has the ability to backup all of the installed apps to a backup location on the SD card. I cannot find or see the folder(s) where installed apps are stored. Supposedly it is in "/data/apps". My phone is NOT rooted and Astro works fine. Does anyone know what the trick is to seeing these folders/files? Is it possible to do this in B4A? Thanks!
Android doesn't allow you to access other programs files. Astro probably uses the backup API that allows you to backup other programs. However the backup API doesn't give you access to the files.