Opening files with your application in Android Studio: a complete guide

Developing applications for Android often requires not only the creation of functionality, but also competent integration with the operating system. One of the key aspects of the user experience with your product is the ability to open certain types of files directly through your application. This creates a sense of nativeness and convenience, allowing the user to select your app from a list of available tools to view or edit documents, images or audio.

To implement this function, Android Studio you need to properly configure the application manifest and process the incoming data. The process involves declaring intent filters that tell the system what types of files your application is willing to process. Without this setting, even if the code is written perfectly, the system simply will not “see” your app as a potential handler for a specific extension.

In this article we will analyze all stages of configuration, from declaring filters in XML to processing URIs in Java or Kotlin code. You'll learn to recognize MIME types, work with permissions, and avoid common file system security pitfalls. Understanding these mechanisms is critical to creating a great user experience.

Basics of Intent filters in Android Manifest

The central element of the configuration is the file AndroidManifest.xml. This is where you declare that your application can act as a file receiver. The <intent-filter> inside an activity declaration that will be launched when the file is opened. The Android system scans the manifests of all installed applications and compiles a list of available actions for each file type.

It is important to correctly specify the action android.intent.action.VIEW and categories DEFAULT and BROWSABLE. Category BROWSABLE is especially important if you want your application to be able to launch from a web browser or other applications that pass data through a URI. Without it, the filter can only work inside the application itself.

The most difficult moment for beginners is often the correct indication of the MIME type. You can specify a specific type, for example application/pdf, or use a wildcard, for example image/to cover all images. However, using filters that are too broad (for example /*) may cause your application to prompt users to open completely inappropriate files, which will degrade the UX.

⚠️ Attention: Starting with Android 11 (API level 30), Package Visibility rules have become stricter. If your application needs to respond to files from other applications, make sure you configure visibility requests correctly, although for incoming Intent filters this usually works automatically if the filter is declared correctly.

Let's look at an example of the correct configuration for an activity that opens text files:

<activity android:name=".TextViewerActivity">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:mimeType="text/plain" />
</intent-filter>
</activity>

This configuration will ensure that when a user tries to open a file with a .txt extension, your application will appear in the "Open with" list. Please note that the file extension (.txt) in itself is not a determining factor; plays exactly MIME typethat the calling application or file manager transmits.

Setting MIME types and file extensions

In the Android world, file extensions (for example, .jpg, .mp4) are often just a hint for a person, but not strict rule for the system. The operating system relies on MIME types (Multipurpose Internet Mail Extensions). They allow you to accurately determine the contents of the file. In the <data> manifest tag, you can combine android:mimeType, android:scheme, android:host and android:pathPattern attributes for maximum precision.

Sometimes one MIME type is not enough. For example, if you are developing a specialized editor for files with the extension .myapp, you may need to specify both the path type and the path pattern. However, it is worth remembering that pathPattern works only with the file and content schemes, and its use requires caution, since regular expressions in XML can be capricious.

Below is a table showing common MIME types and their corresponding extensions, which are often used when setting up filters:

Content Type	MIME type	Common extensions	Usage example
Image	image/*	.jpg, .png, .gif	Gallery, photo editor
Video	video/mp4	.mp4, .m4v	Video player
Audio	audio/mpeg	.mp3	Music player
Document	application/pdf	.pdf	PDF reader
Text	text/plain	.txt, .log	Text editor

Using a wildcard (asterisk), for example image/*, allows you to cover all subtypes of images. This is convenient for universal viewers, but if your application is tailored to a specific format, it is better to specify it explicitly. This will increase the relevance of your application in the eyes of the user and the system.

Processing incoming data in an activity

Once the manifest is configured, you need to write code that will accept the file and display it. When a user selects your application, the system starts the specified activity and transmits data via Intent. Your job is to extract the URI from this Intent and interpret it correctly. Usually the data is located by key Intent.getData().

It is important to understand that you do not get a direct path to the file (for example, /sdcard/file.txt), but a URI (Uniform Resource Identifier). This URI may have the scheme content:// or file://. In modern versions of Android, the content://scheme is preferred because it provides a layer of abstraction and security while hiding the real structure of the file system.

The code for processing the incoming Intent should be placed in a onCreate() or onNewIntent() activity method. Checking for null is required, since the activity can be launched not only to open a file, but also as the main entry point into the application.

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)

handleIntent(intent)
}

private fun handleIntent(intent: Intent) {
if (intent.action == Intent.ACTION_VIEW) {
val data: Uri? = intent.data
if (data != null) {
// Logic for opening a file by URI
openFile(data)
}
}
}

The resulting URI is then passed to the component responsible for display. This could be ImageView, VideoView or a custom renderer. The main thing is to remember that direct access to the file system via File using such a URI is often impossible and requires the use of ContentResolver.

Working with permissions and ContentResolver

With the release of Android 6.0 (Marshmallow) and subsequent versions, the permissions model has changed. Now access to files, especially in shared storage, is regulated by the Scoped Storagemechanism. Direct access to a file path is often blocked. Instead, you should use ContentResolver, which acts as an intermediary between your application and the owner of the file.

When you receive a URI through an Intent, your application automatically gains temporary permission to read that specific resource. This permission only lasts while the activity is alive or until you explicitly pass it on. Trying to save this URI for long-term use without proper flags (such as FLAG_GRANT_READ_URI_PERMISSION) is not worth it, since access may be revoked by the system.

To read data from a URI, use the openInputStream() class method ContentResolver. This allows you to read data streamed without loading the entire file into memory at once, which is critical for large videos or documents.

fun readFileContent(uri: Uri) {
try {
contentResolver.openInputStream(uri)?.use { inputStream ->
// Reading data from a stream
val content = inputStream.bufferedReader().use { it.readText() }
textView.text = content
}
} catch (e: Exception) {
e.printStackTrace()
// Handling access errors
}
}

⚠️ Attention: File manager interfaces and file transfer mechanisms may change with Android updates. Always test opening files on different versions of the OS, since behavior ContentResolver and access rights may differ depending on the device manufacturer and API version.

Debugging and testing Intent filters

Checking the operation of Intent filters can be difficult not obvious. Just by installing the application, you will not see changes in the system immediately. For testing, it is best to use ADB (Android Debug Bridge). The command adb shell am start allows you to emulate the launch of your application with a specific Intent, checking whether the system routes the request correctly.

It is also useful to use logging. Add logs to the entry point onCreate i handleIntentto ensure that the data actually reaches your application and is in the expected format. It often happens that the file opens, but the MIME type is transmitted incorrectly, and the application crashes or shows a blank screen.

For a quick check, you can use the command:

adb shell am start -a android.intent.action.VIEW -d "file:///sdcard/test.txt" -t "text/plain" com.example.myapp/.MainActivity

This command will try to launch your activity indicating the path to the file and its type. If the filter is configured correctly, the application will launch. If not, you will receive an error stating that no activity is suitable for this Intent.

What to do if the filter does not work?

Check the case of the MIME type (it must be lowercase), make sure that the DEFAULT category is present, and check if the antivirus or security system is blocking access to the file.

Common errors and solutions

When implementing the file opening functionality, developers often encounter a number of typical problems. One of the most common is SecurityException. It occurs when an application tries to access a URI that it does not have permission to access. This often happens if you pass a URI to another component or service without a flag FLAG_GRANT_READ_URI_PERMISSION.

Another common mistake is misinterpreting the URI scheme. Attempting to create an object File from a schema URI content:// will result in an error. Always check the URI scheme before processing. If the scheme content, use ContentResolver; if file — you can work with the class File (although this is discouraged in new versions of Android).

• 📁 Path error: Trying to use an absolute path instead of a URI. Solution: Always work with URI.
• 🔒 Access error: No read permissions. Solution: request runtime permissions or use ContentResolver.
• 📄 Invalid MIME: The application does not open for the required file. Solution: extend the filter in the manifest or check the type being passed.
• 🚫 Crash at startup: No check for null for Intent data. Solution: add guards to the code.

Careful exception handling and input data validation will help make your application stable. Don't assume that all file managers transfer data the same way; some may add extra parameters or use non-standard URI schemes.

Understanding these nuances will allow you to create an application that seamlessly integrates into the Android ecosystem, giving the user convenient access to their data. Correct configuration of the manifest and proper work with URI are the key to success in implementing this function.

Questions and answers (FAQ)

How to open a file if I do not know its MIME type in advance?

In this case, you can use a wildcard in the manifest, for example application/ or even /*, but this will make the filter very wide. Inside the application code, you will have to parse the file extension or data header yourself to figure out how to process it. However, it is better to limit yourself to the types you know to preserve the quality of the user experience.

Is it possible to open a file directly along a path in memory, bypassing the URI?

On modern versions of Android (10 and higher), direct access to paths in shared storage is limited by the Scoped Storage policy. Even if you get the path, access to it may be blocked. The only reliable way is to work through the URI and ContentResolverprovided by the system.

Why doesn't my application appear in the "Open with" list?

Check three things: the presence of the category DEFAULT in the filter, the correctness of the specified MIME type (case is important) and that it is set Is there a default application for this file type in the system settings. Also make sure that there is at least one file of the appropriate type on the device to check.

Do you need to request permissions in the manifest to open files?

To open files transferred via Intent, separate permissions (like READ_EXTERNAL_STORAGE) are often not required, since access is granted temporarily through the URI. However, if you plan to scan the repository yourself, permissions will be required.