Gadgetbridge/app/src/main/java/nodomain/freeyourgadget/gadgetbridge/util/UriHelper.java

/*  Copyright (C) 2016-2024 Carsten Pfeiffer, Daniele Gobbetti, Taavi Eomäe

    This file is part of Gadgetbridge.

    Gadgetbridge is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Gadgetbridge is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>. */
package nodomain.freeyourgadget.gadgetbridge.util;

import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.provider.MediaStore;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class UriHelper {
    @NonNull
    private final Uri uri;
    @NonNull
    private final Context context;
    private String fileName;
    private long fileSize;
    @Nullable
    private File file;

    private static final Logger LOG = LoggerFactory.getLogger(UriHelper.class);

    private UriHelper(@NonNull Uri uri, @NonNull Context context) {
        this.uri = uri;
        this.context = context;
    }

    /**
     * Returns the uri as passed to #get(Uri, Context)
     */
    @NonNull
    public Uri getUri() {
        return uri;
    }

    /**
     * Returns the context as passed to #get(Uri, Context)
     */
    @NonNull
    public Context getContext() {
        return context;
    }

    /**
     * Returns an immutable helper to access the given Uri. In case the uri cannot be read/resolved
     * an IOException is thrown.
     * @param uri the uri to access
     * @param context the context for accessing uris
     * @throws IOException
     */
    @NonNull
    public static UriHelper get(@NonNull Uri uri, @NonNull Context context) throws FileNotFoundException, IOException {
        UriHelper helper = new UriHelper(uri, context);
        helper.resolveMetadata();
        return helper;
    }

    /**
     * Opens a stream to read the contents of the uri.
     * Note: the caller has to close the stream after usage.
     * Every invocation of this method will open a new stream.
     * FIXME: make sure that every caller actually closes the returned stream!
     * @throws FileNotFoundException
     */
    @NonNull
    public InputStream openInputStream() throws FileNotFoundException {
        ContentResolver cr = context.getContentResolver();
        InputStream inputStream = cr.openInputStream(uri);
        if (inputStream != null) {
            return new BufferedInputStream(inputStream);
        }
        throw new FileNotFoundException("Unable to open inputstream for " + uri);
    }

    /**
     * Returns the content length (file size) in bytes
     */
    public long getFileSize() {
        return fileSize;
    }

    /**
     * Returns the name of the file referenced by the Uri. Does not include the path.
     */
    @NonNull
    public String getFileName() {
        return fileName;
    }

    /**
     * Returns the file behind the uri, or null in case it is not a file:/ Uri.
     * @return the file or null
     */
    @Nullable
    public File getFile() {
        return file;
    }

    private void resolveMetadata() throws IOException {
        if (uri == null) {
            throw new IOException("URI was null, can't query metadata");
        }

        String uriScheme = uri.getScheme();

        if (uriScheme == null) {
            throw new IOException("URI scheme was null, can't query metadata");
        }

        switch (uriScheme) {
            case ContentResolver.SCHEME_CONTENT:
                Cursor cursor;
                try {
                    ContentResolver resolver = context.getContentResolver();
                    cursor = resolver.query(
                            uri,
                            new String[]{
                                    MediaStore.MediaColumns.DISPLAY_NAME,
                                    MediaStore.MediaColumns.SIZE
                            }, null, null, null);
                } catch (IllegalStateException e) {
                    LOG.error(e.toString());
                    throw new IOException("IllegalStateException when trying to query metadata for: " + uri);
                }

                if (cursor == null) {
                    throw new IOException("Unable to query metadata for: " + uri);
                }

                try {
                    if (cursor.moveToFirst()) {
                        int name_index = cursor.getColumnIndex(MediaStore.MediaColumns.DISPLAY_NAME);
                        if (name_index == -1) {
                            throw new IOException("Unable to retrieve name for: " + uri);
                        }
                        int size_index = cursor.getColumnIndex(MediaStore.MediaColumns.SIZE);
                        if (size_index == -1) {
                            throw new IOException("Unable to retrieve size for: " + uri);
                        }
                        try {
                            fileName = cursor.getString(name_index);
                            if (fileName == null) {
                                throw new IOException("Unable to retrieve name for: " + uri);
                            }
                            fileSize = cursor.getLong(size_index);
                            if (fileSize < 0) {
                                throw new IOException("Unable to retrieve size for: " + uri);
                            }
                        } catch (Exception ex) {
                            throw new IOException("Unable to retrieve metadata for: " + uri + ": " + ex.getMessage());
                        }
                    }
                } finally {
                    cursor.close();
                }
                break;
            case ContentResolver.SCHEME_FILE:
                file = new File(uri.getPath());
                if (!file.exists()) {
                    throw new FileNotFoundException("Does not exist: " + file);
                }
                fileName = file.getName();
                fileSize = file.length();
                break;
            case ContentResolver.SCHEME_ANDROID_RESOURCE:
                // we could actually read it, but I don't see how we can determine the file size
                throw new IOException("Unsupported scheme for uri: " + uri);
            default:
                throw new IOException("Unsupported scheme for uri: " + uri);
        }
    }
}