Android: enregistrer un fichier à partir d'un URI

Comment enregistrer un fichier multimédia (dites .mp3) à partir d'un URI qui, j'en suis arriver à partir d'une Intention Implicite?

Je suis URI de l'intention de l'Uri mediaUri = (Uri) de l'intention.getParcelableExtra(Intention.EXTRA_STREAM);

OriginalL'auteur CyBer2t | 2012-10-30

  1. 24

    Utiliser cette méthode, il fonctionne

    void savefile(URI sourceuri)
{
    String sourceFilename= sourceuri.getPath();
    String destinationFilename = android.os.Environment.getExternalStorageDirectory().getPath()+File.separatorChar+"abc.mp3";

    BufferedInputStream bis = null;
    BufferedOutputStream bos = null;

    try {
      bis = new BufferedInputStream(new FileInputStream(sourceFilename));
      bos = new BufferedOutputStream(new FileOutputStream(destinationFilename, false));
      byte[] buf = new byte[1024];
      bis.read(buf);
      do {
        bos.write(buf);
      } while(bis.read(buf) != -1);
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      try {
        if (bis != null) bis.close();
        if (bos != null) bos.close();
      } catch (IOException e) {
            e.printStackTrace();
      }
    }
}
    dans Android 5.x (Lollipop), doit inclure: - Créer un fichier vide pour ‘destinationFilename’ avant d'utiliser FileOutputStream pour éviter de jeter IOException!
    ne fonctionne pas pour Google Drive Uri
    Ne fonctionne pas sur api26

    OriginalL'auteur Shiva

  2. 8
    private static String FILE_NAM  = "video";
String outputfile = getFilesDir() + File.separator+FILE_NAM+"_tmp.mp4";

InputStream in = getContentResolver().openInputStream(videoFileUri);
private static File createFileFromInputStream(InputStream inputStream, String fileName) {

   try{
      File f = new File(fileName);
      f.setWritable(true, false);
      OutputStream outputStream = new FileOutputStream(f);
      byte buffer[] = new byte[1024];
      int length = 0;

      while((length=inputStream.read(buffer)) > 0) {
        outputStream.write(buffer,0,length);
      }

      outputStream.close();
      inputStream.close();

      return f;
   }catch (IOException e) {
       System.out.println("error in creating a file");
       e.printStackTrace();
   }

return null;

   }
    Salut, pourquoi un buffer[] nécessaire? Est que spécifiques à l'enregistrement d'un Uri?

    OriginalL'auteur PKV

  3. 4

    Si l'Uri est reçu à partir de Google Drive, il peut être un Fichier Virtuel Uri trop. Cochez cette article de CommonsWare pour plus d'informations. Donc, vous avez à considérer que la condition de trop, tout en économisant de fichier à partir de l'Uri.

    À trouver si l'Uri du fichier est virtuel ou pas, vous pouvez utiliser

    private static boolean isVirtualFile(Context context, Uri uri) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        if (!DocumentsContract.isDocumentUri(context, uri)) {
            return false;
        }
        Cursor cursor = context.getContentResolver().query(
                uri,
                new String[]{DocumentsContract.Document.COLUMN_FLAGS},
                null, null, null);
        int flags = 0;
        if (cursor.moveToFirst()) {
            flags = cursor.getInt(0);
        }
        cursor.close();
        return (flags & DocumentsContract.Document.FLAG_VIRTUAL_DOCUMENT) != 0;
    } else {
        return false;
    }
}

    Vous pouvez obtenir le flux de données à partir de ce fichier virtuel comme ceci:

    private static InputStream getInputStreamForVirtualFile(Context context, Uri uri, String mimeTypeFilter)
        throws IOException {

    ContentResolver resolver = context.getContentResolver();
    String[] openableMimeTypes = resolver.getStreamTypes(uri, mimeTypeFilter);
    if (openableMimeTypes == null || openableMimeTypes.length < 1) {
        throw new FileNotFoundException();
    }
    return resolver
            .openTypedAssetFileDescriptor(uri, openableMimeTypes[0], null)
            .createInputStream();
}

    Pour trouver type MIME essayer

    private static String getMimeType(String url) {
    String type = null;
    String extension = MimeTypeMap.getFileExtensionFromUrl(url);
    if (extension != null) {
        type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }
    return type;
}

    Dans l'ensemble, vous pouvez utiliser

    public static boolean saveFile(Context context, String name, Uri sourceuri, String destinationDir, String destFileName) {
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
InputStream input = null;
boolean hasError = false;
try {
if (isVirtualFile(context, sourceuri)) {
input = getInputStreamForVirtualFile(context, sourceuri, getMimeType(name));
} else {
input = context.getContentResolver().openInputStream(sourceuri);
}
boolean directorySetupResult;
File destDir = new File(destinationDir);
if (!destDir.exists()) {
directorySetupResult = destDir.mkdirs();
} else if (!destDir.isDirectory()) {
directorySetupResult = replaceFileWithDir(destinationDir);
} else {
directorySetupResult = true;
}
if (!directorySetupResult) {
hasError = true;
} else {
String destination = destinationDir + File.separator + destFileName;
int originalsize = input.available();
bis = new BufferedInputStream(input);
bos = new BufferedOutputStream(new FileOutputStream(destination));
byte[] buf = new byte[originalsize];
bis.read(buf);
do {
bos.write(buf);
} while (bis.read(buf) != -1);
}
} catch (Exception e) {
e.printStackTrace();
hasError = true;
} finally {
try {
if (bos != null) {
bos.flush();
bos.close();
}
} catch (Exception ignored) {
}
}
return !hasError;
}
private static boolean replaceFileWithDir(String path) {
File file = new File(path);
if (!file.exists()) {
if (file.mkdirs()) {
return true;
}
} else if (file.delete()) {
File folder = new File(path);
if (folder.mkdirs()) {
return true;
}
}
return false;
}

    Appeler cette méthode à partir d'un AsycTask. Laissez-moi savoir si cela aide.

    OriginalL'auteur Ankur

  4. 2

    1.Créer un fichier à partir d'un chemin de l'URI:

    File from = new File(uri.toString());

    2.Créez un autre Fichier dans lequel vous souhaitez enregistrer le fichier enregistrer sous:

    File to = new File("target file path");

    3.Renommer le fichier en tant que:

    from.renameTo(to);

    Avec ce fichier à partir du chemin d'accès par défaut est automatiquement supprimé et créé à la nouvelle voie.

    Gurmeet, Si je dois conserver le fichier existant, puis la façon de procéder? J'ai besoin de créer un nouveau fichier ou un duplicata.
    Ensuite, vous avez besoin d'une copie de fichier.Voici la stackoverflow liens internes montrant la copie de fichier.
    uri.toString et de l'uri.toPath() ne fonctionne pas toujours, surtout avec la galerie. Je soupçonne l'aide de inputstreams est le chemin à parcourir.

    OriginalL'auteur AppMobiGurmeet

  5. 1

    Voici la méthode la plus simple et la plus propre:

    private void saveFile(Uri sourceUri, File destination)
try {
File source = new File(sourceUri.getPath());
FileChannel src = new FileInputStream(source).getChannel();
FileChannel dst = new FileOutputStream(destination).getChannel();
dst.transferFrom(src, 0, src.size());
src.close();
dst.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
    Salut, serait - destination être l'ensemble de la File chemin, y compris le nom de fichier? Ou tout simplement le nom du répertoire/chemin?
    La Destination est le type de File désignant la totalité du fichier avec son nom.
    En utilisant ce code j'obtiens java.io.FileNotFoundException: /document/image:18019: open failed: ENOENT (No such file or directory)
    l'exception parle de lui-même.
    Il parle, que votre code ne fonctionne pas avec URI renvoyé par la Intent ouverture de la galerie pour choisir une image. Au moins, il n'a pas travaillé pour moi et probablement quelqu'un qui a voté mon commentaire. Je l'ai testé avec Android 5.1.1.

    OriginalL'auteur Ε Г И І И О