The URL “content://cz.mobilesoft.appblock.fileprovider/cache/blank.html” is an Android Content URI provided by the AppBlock application, developed by MobileSoft s.r.o.
This URI indicates that AppBlock is exposing a file named blank.html, which is located in its cache directory via its FileProvider.
In Android, FileProvider is a special subclass of ContentProvider that facilitates secure sharing of files associated with an app by creating a content URI for a file instead of a file:/// URI.
This mechanism is commonly used to grant temporary access to files to other apps without exposing the underlying file paths.
Table Of Contents 👉
Solutions To This Problem “content://cz.mobilesoft.appblock.fileprovider/cache/blank.html”
Solution 1. Accessing the Content via ContentResolver
If your application receives this URI and needs to access the underlying file, you can use Android’s ContentResolver to open an input stream to the file:
Uri uri = Uri.parse("content://cz.mobilesoft.appblock.fileprovider/cache/blank.html");
try (InputStream inputStream = getContentResolver().openInputStream(uri)) {
if (inputStream != null) {
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
StringBuilder stringBuilder = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
stringBuilder.append(line);
}
String fileContents = stringBuilder.toString();
// Process the file contents as needed
}
} catch (IOException e) {
e.printStackTrace();
}Considerations:
- Permissions: Ensure that your app has the necessary permissions to access external content.
- URI Validity: The URI must be valid and accessible; otherwise, openInputStream will return null.
Second Scenario:
In some hybrid mobile apps like those built with Cordova or PhoneGap or others, developers use an old method called AppCache to store files such as HTML, JavaScript, or CSS for offline use.
However, many developers face an error like this (content://cz.mobilesoft.appblock.fileprovider/cache/blank.html) when they try to read the contents of these cached files through code.
Unfortunately, AppCache does not provide a direct way to do this using normal browser or JavaScript functions. This guide explains simple and effective ways to work around this limitation and access the cached file contents.
Relevant Posts You May Like
Solution 2. JavaScript (AJAX) Request
Simply request the file’s URL via AJAX/XHR, exactly as you would online. In theory, if the file is in the AppCache, the browser or WebView should intercept the request and return the cached content.
In practice, this is the most straightforward approach and the one recommended in the SO thread: “the same way it would access the contents of the resources if they weren’t in the AppCache: request the URL with Ajax.
// Example: fetch the cached JS file via AJAX
$.ajax({
url: "js/abc.scripts.min.js",
dataType: "text",
success: function(data) {
console.log("File contents:", data);
},
error: function(xhr, status) {
console.error("Failed to load file:", status);
}
});If /js/abc.scripts.min.js is listed in your cache manifest and you are offline, the request should still succeed with the file’s contents. You would then have data containing the entire JavaScript file as a string.
Pros:
- Simple and standard: Uses familiar AJAX/XHR; no special plugins needed.
- Cross-platform: Works in any Cordova WebView (Android, iOS, etc.) just like on the web.
Cons:
- Offline anomalies: Some environments or older WebViews may not actually return AppCache content via XHR when offline, even if they execute the file. The original question noted exactly this problem. In such cases the AJAX call may fail or return empty.
- No binary support: Works only for text-based resources. (As noted by the SO answer, binary blobs won’t be usable unless the browser can handle them.
- Caching config: You must ensure the URL used in AJAX matches exactly what’s in the manifest (including scheme/domain). Otherwise it won’t be found in the AppCache.
Note: The above solution is only relevant if your app is using an AppCache manifest and you’re trying to fetch cached JavaScript or HTML
Solution 3: Handling in WebView
If you’re displaying content in a WebView and encounter this URI, you can override the shouldOverrideUrlLoading method to handle it appropriately:
webView.setWebViewClient(new WebViewClient() {
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
if (url.startsWith("content://")) {
// Handle the content URI
return true;
}
return false;
}
});Considerations:
- Security: Ensure that handling of content URIs does not expose your app to security vulnerabilities.
- Compatibility: Test across different Android versions to ensure consistent behavior.
Relevant Posts You May Like
Solution 4: Native / File-System Access
Bypass the WebView caching altogether and let native code or Cordova file APIs read the cached files directly from storage. On Android, WebView’s AppCache files may reside under file:///data/data//app_cache/ or similar.
On iOS, UIWebView/WKWebView might store them in the app bundle or Library directories. A native plugin or code could locate these files and read their contents. For example, with Cordova you might use the File plugin to read from known directories.
However, AppCache files are often in protected locations. As the SO thread [^1] notes, there’s “no way to view the cache via PhoneGap”, except by inspecting the device filesystem. In other words, you’d typically need a rooted/jailbroken device or debugging tools to browse those cache folders.
You could run an ADB shell or file explorer on a rooted Android device, navigate to your app’s data directory, and open the files in app_webview/ or cache. Similarly, on iOS, you’d inspect the app’s sandbox (which is not available on non-jailbroken devices). In development, you can copy out the files and examine them.
Pros:
- Full access: You get the actual files as stored on disk, not an abstract request. This works for any file type (text, images, etc.).
- Guaranteed content: Reading the file path bypasses any AppCache quirks; you’ll see exactly what’s cached.
Cons:
- Not programmatic in-app: This isn’t something your JS code can do at runtime in a production app. It requires developer intervention or a special plugin.
- Platform-specific: File locations differ by OS and WebView version, and are often undocumented.
- Requires permissions: On Android, you need a rooted device or adb root; on iOS needs a jailbroken device or copying from the app bundle/Simulator. Not suitable for end-users.
Conclusion
The content://cz.mobilesoft.appblock.fileprovider/cache/blank.html URI is a content URI provided by the AppBlock application, pointing to a blank.html file in its cache directory.
Handling such URIs requires understanding of Android’s ContentProvider and FileProvider mechanisms.
By using ContentResolver or appropriately configuring WebView, you can manage and display the content as needed.
Always ensure to implement proper error handling and user feedback to enhance the user experience.
Relevant Posts You May Like