public OutputStream openOutputStream(boolean pub, String filename, boolean append) throws IOException
{
/*
	String uriString = getSharedPreferences(CONFIG_FILE, MODE_PRIVATE).getString(CONFIG_KEY, null);
	if (uriString != null)
	{
		try
		{
			Uri treeUri = Uri.parse(uriString);
			DocumentFile root = DocumentFile.fromTreeUri(this, treeUri);
			DocumentFile file = root.findFile(filename);
			if (file == null)
			{
				String mime;

				if( filename.endsWith(".gpx") )
					mime = "application/gpx+xml";
				else if( filename.endsWith(".xml") )
					mime = "text/xml";
				else if( filename.endsWith(".txt") )
					mime = "text/plain";
				else
					mime = "application/octet-stream";

				file = root.createFile(mime, filename);
			}
			if( file != null && file.exists())
			{
				// "wa" steht für Write-Append
				return getContentResolver().openOutputStream(file.getUri(), append ? "wa" : "w");
			}
		}
		catch (java.lang.Exception e)
		{
			Log.e("GPS", "SAF write failed", e);
		}
	}
*/
	// fall back for old androids
	File file = getExternalFileName(filename);
	return new FileOutputStream(file, append);
}

m_rawFile = getExternalFileName(getRawTrackFileName());
m_rawFile.createNewFile();
m_rawFileOS = new FileOutputStream(m_rawFile, true);

m_rawFileOS = (FileOutputStream)openOutputStream(getRawTrackFileName(), true);

dependencies {
	implementation 'androidx.appcompat:appcompat:1.7.1'
	implementation 'androidx.documentfile:documentfile:1.0.1'	// <- das ist neu
}

public void selectStorageFolder()
{
	Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
	// Erlaubt dauerhaften Zugriff
	intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION
			| Intent.FLAG_GRANT_WRITE_URI_PERMISSION
			| Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION);
	startActivityForResult(intent, REQUEST_CODE_OPEN_DIRECTORY);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data)
{
	super.onActivityResult(requestCode, resultCode, data);

	if (requestCode == REQUEST_CODE_OPEN_DIRECTORY && resultCode == RESULT_OK)
	{
		if (data != null && data.getData() != null)
		{
			Uri treeUri = data.getData();

			// WICHTIG: Die Berechtigung dauerhaft beim System registrieren ("Persistable Permission")
			final int takeFlags = data.getFlags()
					& (Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);

			try
			{
				getContentResolver().takePersistableUriPermission(treeUri, takeFlags);

				// URI in SharedPreferences speichern
				getSharedPreferences(CONFIG_FILE, MODE_PRIVATE)
						.edit()
						.putString(CONFIG_KEY, treeUri.toString())
						.apply();

				// Activity neu starten oder Initialisierung fortsetzen
				recreate();
			}
			catch (SecurityException e)
			{
				Log.e("GPS", "Failed to take persistable permission", e);
			}
		}
	}
}

File xmlFile = getExternalFileName(getXmlTrackFileName());
if( xmlFile.exists() )

private void deleteLocalFile(String filename)
{
	// Strategy 1: Standard File API (Works for private internal storage or legacy)
	File file = getExternalFileName(filename);
	if( file != null && file.exists() )
	{
		if( file.delete() )
			return;
	}

	String uriString = getSharedPreferences(CONFIG_FILE, MODE_PRIVATE).getString(CONFIG_KEY, null);

	if( uriString != null )
	{
		try
		{
			Uri treeUri = Uri.parse(uriString);
			DocumentFile root = DocumentFile.fromTreeUri(this, treeUri);
			DocumentFile dFile = root.findFile(filename);

			if( dFile != null && dFile.exists() )
			{
				if( dFile.delete() )
				{
					Log.d("GPS", "File deleted via SAF: " + filename);
				}				}
		}
		catch (Exception e)
		{
			Log.e("GPS", "SAF failed, trying legacy", e);
		}
	}
}

private boolean checkSafFolderPermissions( boolean writePermission )
{
	String uriString = getSharedPreferences(CONFIG_FILE, MODE_PRIVATE).getString(CONFIG_KEY, null);
	if (uriString == null)
		return false;
	Uri treeUri = Uri.parse(uriString);
	if (treeUri == null)
		return false;

	int modeFlags = Intent.FLAG_GRANT_READ_URI_PERMISSION;
	if( writePermission )
		modeFlags |= Intent.FLAG_GRANT_WRITE_URI_PERMISSION;

	try
	{
		// Diese Methode wirft keine Exception, wenn man keine Rechte hat,
		// aber man kann damit prüfen, ob der Zugriff noch valide ist.
		getContentResolver().takePersistableUriPermission(treeUri, modeFlags);
	}
	catch (SecurityException e)
	{
		return false;
	}

	// 2. Prüfung via DocumentFile (ist der Ordner noch vorhanden?)
	DocumentFile folder = DocumentFile.fromTreeUri(this, treeUri);
	return folder != null && folder.exists()
			&& folder.canRead()
			&& (!writePermission || folder.canWrite());
}

public RequestCode requestStoragePermission( @DrawableRes int iconId, String title )
{
	if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
	{
		if( hasStorageFolder() )
			return RequestCode.OK;

		if( !Environment.isExternalStorageManager() )
		{
			displayStorageManagePermission();
			return RequestCode.REQUESTED;
		}
	}
	else if(
			ContextCompat.checkSelfPermission(this, READ_EXTERNAL_STORAGE)
					!= PackageManager.PERMISSION_GRANTED
					|| ContextCompat.checkSelfPermission(this, WRITE_EXTERNAL_STORAGE)
					!= PackageManager.PERMISSION_GRANTED
	)
	{
		// Suggestion: Request the permission instead of just failing
		ActivityCompat.requestPermissions(
				this,
				new String[]{READ_EXTERNAL_STORAGE, WRITE_EXTERNAL_STORAGE},
				STORAGE_PERMISSION_REQUEST_CODE
		);
		return RequestCode.DENIED;
	}
	else if( checkCallingOrSelfPermission("android.permission.READ_EXTERNAL_STORAGE") == PackageManager.PERMISSION_DENIED )
	{
		showMessage(iconId, title, "Read Permission Missing", true, null);
		return RequestCode.DENIED;
	}
	else if( checkCallingOrSelfPermission("android.permission.WRITE_EXTERNAL_STORAGE") == PackageManager.PERMISSION_DENIED )
	{
		showMessage( iconId, title, "Write Premission Missing", true, null);
		return RequestCode.DENIED;
	}
	return RequestCode.OK;
}