Sometimes I write a small program to deal with a minor inconvenience. This is one of those programs.

Spotify for Android decided to start doing something annoying recently. For several years it has been happily connecting to my car's bluetooth, auto playing, and then auto stopping when the car is turned off. That last part is what stopped working. Now when I turn off my car Spotify continues playing through the phone speaker. Literally no one would ever want things to work this way. I went through every setting in Spotify and on my phone twice. I read all the usual support articles. Most of them blame Android Auto which I don't have enabled. I quit.

Then I remembered my car has a couple USB ports that can play mp3s. It's pretty low tech, a $10 mp3 player has more features. I don't need much though. I just want it to play a random assortment of songs like how shuffle works on Spotify. Well, except for "Smart" Shuffle. Any time I accidentally click that it ruins my entire day.

So here's what I need a program to do:

• Accept a list of paths to mp3 files. How that list gets built is irrelevant to this article. It could be recursively reading a directory or based on a playlist file.
• Select files in a random order and copy them to the destination drive.
• Rename the files along the way (optional, but included in this code).
• Continuing copy files until there are no more files left or the destination drive is full.
• Or... until some "kill switch" amount of data has been copied. This is something to deal with accident prone people like myself who might point this to their hard drive.

Of course this will all work with any file type, I only care about copying mp3s in a random order today. For example this code could copy a random list of PDFs to a book reader. I will probably even do that with it one day. It would also work for an offline digital photo frame to shuffle the pictures every few months.

The first part to write is code to rename files. There are a couple reasons this is needed:

• Some operating systems, like those that start with "Mac", throw errors when copying files with UTF-16 characters in their name to a FAT drive.
• Some media players might get tripped up on certain characters in names, spaces especially.
• Some media players might get tripped up on file names over a certain length.
• The display in my car, and probably most others, uses the id3 tag and not the file name anyway.

And the code goes like...

public static String buildUUIDName(File f,boolean preserveExtension){
    String currentFileName=f.getName();
    String newFileName=UUID.randomUUID().toString().replace("-","");
    if(preserveExtension){
        newFileName=newFileName+getExtension(currentFileName);
    }
    return(newFileName);
}

There are many other perfectly good ways to solve this problem. Like simply renaming the files "000001.mp3" and so on.

Now the code to copy the files... after some notes about the parameters and return type:

• sourceFileList: the list of full paths to all source files that might be copied to the destination drive.
• destinationPath: the full path to the destination to write these files.
• uuidRename: whether or not to rename the files on copy.
• maxBytesKillswitch: the maximum number of bytes to copy before stopping. If this is greater than the available space on the destination drive then it is useless. Set it to Long.MAX_VALUE to ensure the entire list is copied or the drive is completely filled.
• It returns a Map of original file to copied file. I find that useful, others can ignore it.

public static Map<String,String> shuffleCopy(List<String> sourceFileList,String destinationPath,boolean uuidRename,long maxBytesKillswitch){
    Map<String,String> copyMap=new HashMap<String,String>();
    if(sourceFileList==null){
        return(copyMap);
    }
    if(!destinationPath.endsWith(File.separator)){
        destinationPath=destinationPath+File.separator;
    }
    File destinationRoot=new File(destinationPath);
    if(!destinationRoot.exists()){
        return(copyMap);
    }
    int filesRemaining=sourceFileList.size();
    Random r=new Random();
    while((filesRemaining>0)&&(maxBytesKillswitch>0)){
        int index=r.nextInt(filesRemaining);
        String filePath=sourceFileList.remove(index);
        filesRemaining--;
        //is there room for this file?
        File source=new File(filePath);
        long sourceSize=source.length();
        long usableSpace=destinationRoot.getUsableSpace();//yes, need to check this each time in case on concurrent operations
        if(sourceSize<usableSpace){
            try{
                String fileName;
                if(uuidRename){
                    fileName=buildUUIDName(source,true);
                }else{
                    fileName=source.getName();
                }
                File destination=new File(destinationPath+File.separator+fileName);
                Files.copy(source.toPath(),destination.toPath(),StandardCopyOption.COPY_ATTRIBUTES);
                copyMap.put(filePath,destination.getPath());
                maxBytesKillswitch-=sourceSize;
            }catch(IOException iox){
                if(iox.getMessage().toLowerCase().contains("no space left on device")){
                    filesRemaining=-1;
                }
            }
        }            
    }        
    return(copyMap);
}

It's pretty simple really. Some notes about it:

• "no space left on device" is the only error I'm doing anything about. From what I can tell that is a platform-independant error message. Obviously that means the disk is full. Maybe I should stop if any error occurs. Some of them could be transient or limited to a single problematic file. The more often I use this, the more likely I'll figure out which conditions are real problems.
• Why do we need to check at all though if we're tracking the usable space available? It's because that number is a lie. When you're down to roughly 4mb left the OS will stop allowing new writes.
• One consequence of this implementation is the drive will be filled with many small files toward the end.

Here's a main class to call this code and display the results:

import java.io.IOException;
import java.util.ArrayList;
import java.util.Map;

import com.huguesjohnson.dubbel.file.FileUtils;

public class SDCardRandomFill{
    public static void main(String[] args){
        String destinationPath="[path to where you want to copy files]";
        //build the list of files
        ArrayList<String> filePathList=[whatever you want to do to build a list of file paths];
        //try copying
        long maxBytesKillswitch=Long.MAX_VALUE; //or something like 32*1024*1024*1024 if you prefer;
        Map<String,String> copyMap=FileUtils.shuffleCopy(filePathList,destinationPath,true,maxBytesKillswitch);
        for(String key:copyMap.keySet()){
            String value=copyMap.get(key);
            System.out.println(key+"|"+value);
        }
    }
}

Alright, this was fun and something I will use often.

Related