Backing up photos from Android to Debian

9 minute read

One would think that since Android is a Linux-based operating system, that integration between Android devices and Linux computers would work rather seamlessly. Unfortunately, that’s not always the case. Things have, however, improved over the years. Here are a few of the tools that I’ve used in the past to transfer my photos from my Android mobile phone to my Debian laptop system.


Usually it’s not possible to mount a mobile phone’s storage device directly to your computer (for instance, as if it were a USB drive). The Android device can, however, report itself as a camera (e.g. via the “Connect as Camera (PTP)” option when connecting the device to a computer via USB) and therefore one can use the gphotofs command from the gPhoto project to expose the camera as a filesystem (hence the fs in the command’s name). The gPhoto library behind the command speaks the Picture Transfer Protocol (PTP) and hence can be used either with a normal digital camera or (as in the case discussed here) an Android mobile phone.

To get started, first install the package:

$ sudo apt install gphotofs

Before we can start backing up photos, we need to create a mountpoint for the filesystem to be mounted, as well as a location to which we can back up the images.

Create a directory onto which we want to mount the filesystem

$ mkdir -p ~/Camera/mnt

and the directory into which the images will be copied1:

$ mkdir -p ~/Camera/ShiftPhone

Now set the mobile phone to PTP mode (when connected via USB, connect “as a camera”).

The filesystem can now be simply mounted via the gphotofs command

$ gphotofs ~/Camera/mnt

Let’s have a look what’s in the mounted directory:

$ ls ~/Camera/mnt

This directory contains two further directories, DCIM and Pictures.

├── DCIM
│   └── Camera
└── Pictures

The Pictures directory doesn’t interest us for the purposes of this post (it contains images saved from applications such as Twitter or Telegram or whatever).

The DCIM directory should be familiar to you if you’ve seen directories stored on a digital camera before. If you haven’t, don’t worry, you just need to know that there’s a Camera subdirectory which contains all of the images we want to back up.

If you look at a directory listing of the Camera directory, you will probably find lots of JPEG images (and maybe some MP4 video files if you’ve recorded some videos). Let’s back up all of these files to our backup directory

$ rsync -av ~/Camera/mnt/store_00010001/DCIM/Camera/ ~/Camera/ShiftPhone/

Now that we’ve finished using using the mountpoint we can unmount it:

$ fusermount -u ~/Camera/mnt

Backup done!


Another option is the gphoto2 command line interface to digital cameras. This is more of a direct interface to the files the camera makes available.

Although this is part of the gPhoto suite of applications, it comes as a separate package on Debian. Therefore, the first thing to do is to install it:

$ sudo apt install gphoto2

gphoto2 has lots of options, as you will be able to see by passing the --help option to the command, or by reading the man page.

$ gphoto2 --help
$ man gphoto2

For a quick start guide about using the gphoto2 command line interface, check out the gPhoto docs for gphoto2.

After connecting your phone to your laptop via USB–and ensuring that it’s connected as a Camera via PTP–you can check if gphoto2 can detect the camera. You do this by passing gphoto2 the --auto-detect option, e.g. for my SHIFT phone:

$ gphoto2 --auto-detect
Model                          Port
USB PTP Class Camera           usb:001,040

That’s cool, it seems that the camera has been detected. We can get more information about what’s been detected by using the --summary option:

Camera summary:
Manufacturer: SHIFT
Model: SHIFT6m
  Version: 1.0
  Serial Number:

Capture Formats:
Display Formats: Undefined Type, Association/Directory, Text, HTML, MS Wave,
Unknown(b902), Unknown(b903), Unknown(b982), Unknown(b983), Unknown(b984),
Unknown(ba05), Unknown(ba10), Unknown(ba11), Unknown(ba14), Unknown(ba82),
Unknown(b906), DNG

Device Capabilities:
        File Download, File Deletion, File Upload
        No Image Capture, No Open Capture, No vendor specific capture

Storage Devices Summary:
        StorageDescription: Interner gemeinsamer Speicher
        VolumeLabel: None
        Storage Type: Builtin RAM
        Filesystemtype: Generic Hierarchical
        Access Capability: Read-Write
        Maximum Capability: 53387345920 (50914 MB)
        Free Space (Bytes): 36395479040 (34709 MB)
        Free Space (Images): 1073741824

Device Property Summary:
Property 0xd401:(readwrite) (type=0x0) Undefined
Property 0xd402:(readwrite) (type=0x0) Undefined
Image Size(0x5003):(read only) (type=0xffff) '1920x1920'
Battery Level(0x5001):(read only) (type=0x2) Range [0 - 100, step 1] value:
100% (100)
Property 0xd407:(read only) (type=0x6) 0

As you can see, there is a lot of information one can ascertain about the camera which has been attached. We see that it’s from the company SHIFT and what its model is, namely a SHIFT6m, which is correct. Obviously you will see different information here, unless you’ve also bought a SHIFT6m.

Now that we’re happy that the information about the attached device is as we expect, we can find out what files are available on the camera. This we find out by using the --list-folders command:

$ gphoto2 --list-folders
There is 1 folder in folder '/'.
 - store_00010001
There are 2 folders in folder '/store_00010001'.
 - Pictures
There is 1 folder in folder '/store_00010001/DCIM'.
 - Camera
There are 0 folders in folder '/store_00010001/DCIM/Camera'.
There are 2 folders in folder '/store_00010001/Pictures'.
 - Telegram
 - Twitter
There are 0 folders in folder '/store_00010001/Pictures/Telegram'.
There are 0 folders in folder '/store_00010001/Pictures/Twitter'.

Here we see effectively the same directory structure as in the gphotofs example above. Now that we know where the files are, we need to get them somehow; after all, we want to back the files up to the laptop, not just see what’s available!

Assuming we have the same directory structure outlined above, we can change into the ~/Camera/ShiftPhone directory and use the --get-all-files option to copy the files to the current directory on the laptop’s hard drive:

$ cd ~/Camera/ShiftPhone
$ gphoto2 --get-all-files --folder=/store_00010001/DCIM/Camera

Note that we specify here the path to the directory containing the images that the mobile phone’s camera has taken. This allows you to avoid the funny pictures that your coworkers sent to you via Telegram or the cat video you found on Twitter. The default value of the --folder option is /, which means that quite literally all files will be retrieved, but that’s not what we want to do here, hence we limit the source directory to get only the files we are interested in.

You should see output something along these lines:

Saving file as IMG_20190604_124651_4.jpg
Saving file as IMG_20190604_124730_4.jpg
Saving file as IMG_20190605_135402_5.jpg
Saving file as IMG_20190619_124805_0.jpg
Saving file as IMG_20190630_155523_4.jpg
Saving file as IMG_20190701_150034_4.jpg
Saving file as IMG_20190702_115445_6.jpg
Saving file as IMG_20190722_160812_1.jpg
Saving file as IMG_20190722_160821_2.jpg
Saving file as IMG_20190723_160056_3.jpg
Saving file as IMG_20190723_162642_5.jpg
Downloading... |-----------------                            -  38.5%

and the files will downloaded from the phone to the current directory.

Note that since we didn’t mount any filesystems, there’s no need to unmount anything, hence we’re done with the backup! Yay!


The final option that I’d like to mention is jmtpfs. This is a user-space filesystem for accessing Media Transfer Protocol (MTP) devices. The Media Transfer Protocol is useful for devices that don’t allow (or don’t support) USB mass storage. In other words, it’s useful for devices that you can’t just mount like a USB stick. For more Debian-related details concerning MTP, see the Debian MTP page.

To use jmtpfs you’ll need to install the package, if you haven’t done so already:

$ sudo apt install jmtpfs

Connect your mobile phone to your laptop via USB and ensure it is attached as a media device (MTP). If you check the dmesg output you’ll notice that a new USB device has been connected, e.g. for my phone I got this output:

[675519.623499] usb 1-9: USB disconnect, device number 40
[675520.113262] usb 1-9: new high-speed USB device number 41 using xhci_hcd
[675520.134432] usb 1-9: New USB device found, idVendor=0e8d, idProduct=201d, bcdDevice=ff.ff
[675520.134441] usb 1-9: New USB device strings: Mfr=3, Product=4, SerialNumber=5
[675520.134446] usb 1-9: Product: SHIFT6m
[675520.134449] usb 1-9: Manufacturer: MediaTek
[675520.134453] usb 1-9: SerialNumber:

This might look like you might be able to just mount the device as a USB stick, but it’s not quite enough, hence the need for a tool like jmtpfs.

Assuming that we’ve got the directory layout described in the section about gphotofs above, you can now mount the device by using the jmtpfs command:

$ jmtpfs ~/Camera/mnt
Device 0 (VID=0e8d and PID=201d) is a MediaTek Inc Elephone P8000.
Android device detected, assigning default bug flags

Having a look at the contents of the ~/Camera/mnt directory, you’ll see something like this:

ls ~/Camera/mnt/
'Internal Storage'

The directory name could be different, depending upon the language you use on your phone. For instance, mine says 'Interner gemeinsamer Speicher' because my phone’s default language is German. Your situation might also say 'Phone storage'. Either way, you should see something that points to the storage device on your phone.

If you look inside this directory, you’ll see many more directories than were available with gphotofs, for instance Android, DCIM, Documents, Download, Music, Pictures among many others. As with the gphotofs example, we aren’t interested in the Pictures folder but the DCIM folder (again, we want to avoid cat videos and funny meme pictures from colleagues).

To transfer the files taken with the phone’s camera, we can again use rsync as we did in the gphotofs example:

$ rsync -av ~/Camera/mnt/Internal\ Storage/DCIM/Camera/ ~/Camera/ShiftPhone/

Note that the only real difference between this example and the one mentioned in the first section is the Internal\ Storage component. You might also notice that transferring files with jmtpfs isn’t as fast as using gphotofs or gphoto2, however with jmtpfs we have the ability to access more files than is possible with the other options should we wish to.

When the files have finished transferring, simply use

$ fusermount -u ~/Camera/mnt

to unmount the partition and ensure all buffered data is written to disk.

Our photos are now all nicely backed up. Nice!

Wrap up

I remember in the days before jmtpfs came on the scene that it was quite frustrating trying to access the files on my Android device and that it seemed to be easier on Windows or MacOS rather than on Linux, which seemed silly given Android’s Linux foundation. Fortunately, things have improved over the years and there are several options one can use to access the photos, documents, videos and other files saved on your Android phone and transfer them to your laptop if you want or need to.

Is there anything that I’ve missed? Was this post helpful? How could I make it better? Let me know in the comments section or simply drop me a line via email or ping me on Twitter.

  1. My mobile phone is from the company SHIFT GmbH which makes modular phones with a focus on sustainability, hence the directory name ShiftPhone


If you liked this post and want to see more like this, please buy me a coffee!

buy me a coffee logo