How to support camera hot-plug via udev

[miccoli]

I'm writing an app for controlling consumer cameras from a headless linux machine: I would like to support USB cameras hot-plug.

The devised workflow shoud be as follows:

1. the camera is connected
2. a udev rule is fired and a script is launched,
3. the script notifies the USB address of the newly connected camera to the camera control systemd service,
4. the systemd service creates a gphoto2.Camera instance

I know how to implement 2.–3. and I'm prototyping 4. in Python: so I'm in a situation in which I know the path name, and I have to construct a gphoto2.Camera instance connected to a known USB port.

It seems to me that point 4. would be straightforward with access to the internal functions at

python-gphoto2/src/gphoto2/port_info_list.i

Lines 119 to 123 in b2b09c3

	// Don't wrap internal functions
	%ignore gp_port_info_new;
	%ignore gp_port_info_set_name;
	%ignore gp_port_info_set_path;
	%ignore gp_port_info_set_type;

In particular I would use gp_port_info_new and gp_port_info_set_path to create the data structure to be fed to the set_port_info mehod of a gp.Camera instance.

But these functions are not accessible, so the only way to go I was able to find is to

• create an empy port info list with gp_port_info_list_new(),
• populate it with the load method, and finally
• lookup the desired port info with the lookup_path method.

I dislike this apporach, because it seems to me that the with the load method I'm performing a totally uneccessery port autodiscovery (udev hadles this for me, no need to resort to libghoto2 machinery) and I'm creating a redundant port info list, when in fact I'm interrested only in a single port info item.

Am I missing something? Is this indeed the correct way to handle this problem?

[jim-easterbrook]

I think this is how it should be done, but I'm just a libgphoto2 user, not its author. This is not really the place to ask questions about how libgphoto2 works.

An important function of gp_abilities_list_load appears to be dynamically loading the camera drivers. I'm not sure where that would happen in your preferred way of doing things.

[miccoli]

Thanks for the support. I know that this is more a libgphoto2 question, but my hope was that someone in the python-libgphoto2 community would have some suggestion for my use case.

Let me add just a few considerations (which could be useful to other users reading this discussion.)

1. I'm writing a long lived service (daemon). Of course the camera drives should be loaded only once, at service start.
2. If possibile I would like to avoid loading unecessary drivers (only USB is needed) and performing multiple auto-discoveries. The reason is to reduce the probability of triggering bugs... exploring unecessaring code branches is never a good idea, from the point of view of defensive programming.

Writing this reply it occurred to me that a different approach is possible.

• call the load method once at service startup
• call lookup_path only when a new camera appears... in fact I noticed that calling this method can add items to the port info list.

This is still suboptimal, but for sure better than calling load every time that a new USB camera is plugged. I will report back here if this approach works.