What Characters Allowed in File Names on Android?

According to wiki and assuming that you are using external data storage which has FAT32.

Allowable characters in directory entries

are

Any byte except for values 0-31, 127 (DEL) and: " * / : < > ? \ | + , . ; = [] (lowcase a-z are stored as A-Z). With VFAT LFN any Unicode except NUL

From android.os.FileUtils

    private static boolean isValidFatFilenameChar(char c) {
        if ((0x00 <= c && c <= 0x1f)) {
            return false;
        }
        switch (c) {
            case '"':
            case '*':
            case '/':
            case ':':
            case '<':
            case '>':
            case '?':
            case '\\':
            case '|':
            case 0x7F:
                return false;
            default:
                return true;
        }
    }

    private static boolean isValidExtFilenameChar(char c) {
        switch (c) {
            case '\0':
            case '/':
                return false;
            default:
                return true;
        }
    }

Note: FileUtils are hidden APIs (not for apps; for AOSP usage). Use as a reference (or by reflection at one's own risk)

final String[] ReservedChars = {"|", "\\", "?", "*", "<", "\"", ":", ">"};

for(String c :ReservedChars){
    System.out.println(dd.indexOf(c));
    dd.indexOf(c);
}

This is correct InputFilter for File Names in Android:

    InputFilter filter = new InputFilter()
    {
        public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) 
        { 
            if (source.length() < 1) return null;
            char last = source.charAt(source.length() - 1);
            String reservedChars = "?:\"*|/\\<>";
            if(reservedChars.indexOf(last) > -1) return source.subSequence(0, source.length() - 1);
            return null;
        }  
    };

I tested this quickly on my Galaxy Note 8 on Android 4.4.2. The default My Files app helpfully greys out invalid characters which are as follows:

? : " * | / \ < >

I put all the other special chars available into a filename and it saved. This may not be consistent across all Android versions so maybe it's best to be conservative and replace them with similarly meaningful characters.

This is clearly filesystem and Android operating system dependent. On my oneplus/oxygenOS, the only characters in the accepted answer

private static final String ReservedChars = "|\\?*<\":>+[]/'";

that I could not use to rename a file were / and *

However, Android wide, the list above would seem to be sensible.

On Android as suggested there you can use an input filter to prevent user entering invalid characters, here is a better implementation of it:

/**
 * An input filter which can be attached to an EditText widget to filter out invalid filename characters
 */
class FileNameInputFilter: InputFilter
{
override fun filter(source: CharSequence?, start: Int, end: Int, dest: Spanned?, dstart: Int, dend: Int): CharSequence? {
    if (source.isNullOrBlank()) {
        return null
    }

    val reservedChars = "?:\"*|/\\<>\u0000"
    // Extract actual source
    val actualSource = source.subSequence(start, end)
    // Filter out unsupported characters
    val filtered = actualSource.filter { c -> reservedChars.indexOf(c) == -1 }
    // Check if something was filtered out
    return if (actualSource.length != filtered.length) {
        // Something was caught by our filter, provide visual feedback
            if (actualSource.length - filtered.length == 1) {
                // A single character was removed
                BrowserApp.instance.applicationContext.toast(R.string.invalid_character_removed)
            } else {
                // Multiple characters were removed                    
     BrowserApp.instance.applicationContext.toast(R.string.invalid_characters_removed)
                }
            // Provide filtered results then
            filtered
        } else {
            // Nothing was caught in our filter
            null
        }
    }
}