Hello Kin

I am completely blocked on it. Please do let me know if I need try out
something 🙏
1. I want to stream the video
2. Control camera settings
3. Send commands
4. Transfer files

Will be thankful to your kind input.

Regards
Anand

On Tue, 17 Sept, 2024, 8:10 am Anand Walvekar, <
anand.walve...@onemorehustle.com> wrote:

> Hello Kin
> Could you please guide me on what you did?
>
> Thanks
> Anand
>
> On Tue, 17 Sept, 2024, 8:00 am Kin, <geniusw...@qq.com> wrote:
>
>> I can do it without libgphoto. Compiling libgphoto on an iPad or iOS is
>> impossible. I tried, but it failed. So, I found an alternative solution.
>>
>> ------------------ Original ------------------
>> *From:* Anand Walvekar <anand.walve...@onemorehustle.com>
>> *Date:* Tue,Sep 17,2024 9:41 AM
>> *To:* Ole Aamot <o...@gnu.org>
>> *Cc:* gphoto-devel <gphoto-devel@lists.sourceforge.net>, Marcus Meissner
>> <mar...@jet.franken.de>
>> *Subject:* Re: [gphoto-devel] iPad USB Support
>>
>> Thank you. libgphoto2 depends on other dylb. Compilation seems to be a
>> task
>>
>> Regards
>> Anand
>>
>> On Tue, 17 Sept, 2024, 6:18 am Ole Aamot, <o...@gnu.org> wrote:
>>
>>> Implement libgphoto2 Camera Driver for iPad USB
>>>
>>> Implementing a camera driver using `libgphoto2` and `libusb` for iPadOS
>>> is complex, particularly due to iOS's restrictions on direct USB access.
>>> However, I can guide you through writing code that integrates `libgphoto2`
>>> and `libusb` in a general way, while recognizing the unique hurdles on
>>> iPadOS.
>>>
>>> Here’s an example that assumes you're able to compile `libusb` and
>>> `libgphoto2` for iOS. This example sets up a simple app that uses a camera
>>> connected via USB. Keep in mind that on iPad, actual USB access will likely
>>> be limited unless you have the proper entitlements from Apple.
>>>
>>> ### 1. **Cross-Compiling `libgphoto2` and `libusb`**
>>>
>>> First, you need to cross-compile `libgphoto2` and `libusb` for iPad.
>>> This process involves setting up a toolchain and using CMake to build the
>>> libraries as static libraries for ARM architecture. Here’s a guide for that
>>> process:
>>>
>>> ```bash
>>> # Install dependencies (on macOS)
>>> brew install automake libtool cmake
>>>
>>> # Clone libgphoto2
>>> git clone https://github.com/gphoto/libgphoto2.git
>>> cd libgphoto2
>>>
>>> # Build for iOS (ensure you have an iOS toolchain configured)
>>> ./autogen.sh
>>> ./configure --host=arm-apple-darwin
>>> make
>>> ```
>>>
>>> ### 2. **Basic iOS App Setup (Swift + Objective-C)**
>>>
>>> In Xcode, create a new iOS project in Swift, then add the compiled
>>> static libraries for `libgphoto2` and `libusb`.
>>>
>>> ### 3. **Bridging Header for `libgphoto2` in Swift**
>>>
>>> Since `libgphoto2` is a C library, you will need to create a bridging
>>> header to use it within a Swift-based iOS project.
>>>
>>> **Create `gphoto2_bridge.h` (Objective-C bridging header):**
>>>
>>> ```objective-c
>>> // gphoto2_bridge.h
>>> #import <Foundation/Foundation.h>
>>>
>>> #ifdef __cplusplus
>>> extern "C" {
>>> #endif
>>>
>>> #include <gphoto2/gphoto2.h>
>>>
>>> int detect_camera(GPContext *context);
>>>
>>> #ifdef __cplusplus
>>> }
>>> #endif
>>> ```
>>>
>>> **Create `gphoto2_bridge.c` (C code that interacts with libgphoto2):**
>>>
>>> ```c
>>> #include "gphoto2_bridge.h"
>>>
>>> int detect_camera(GPContext *context) {
>>>     int ret;
>>>     Camera *camera;
>>>     GPPortInfoList *portinfolist = NULL;
>>>     CameraAbilitiesList *abilities = NULL;
>>>
>>>     ret = gp_camera_new(&camera);
>>>     if (ret < GP_OK) return ret;
>>>
>>>     ret = gp_abilities_list_new(&abilities);
>>>     if (ret < GP_OK) return ret;
>>>
>>>     ret = gp_port_info_list_new(&portinfolist);
>>>     if (ret < GP_OK) return ret;
>>>
>>>     ret = gp_abilities_list_load(abilities, context);
>>>     if (ret < GP_OK) return ret;
>>>
>>>     ret = gp_port_info_list_load(portinfolist);
>>>     if (ret < GP_OK) return ret;
>>>
>>>     return GP_OK;
>>> }
>>> ```
>>>
>>> ### 4. **Swift Code (ViewController.swift)**
>>>
>>> This Swift code will interact with the `libgphoto2` library via the
>>> bridging header.
>>>
>>> ```swift
>>> import UIKit
>>>
>>> class ViewController: UIViewController {
>>>
>>>     override func viewDidLoad() {
>>>         super.viewDidLoad()
>>>
>>>         // Call the C function to detect the camera
>>>         detectCamera()
>>>     }
>>>
>>>     func detectCamera() {
>>>         // Create the GPContext
>>>         let context = createGPContext()
>>>
>>>         // Call the detect_camera function from the C library
>>>         let result = detect_camera(context)
>>>         if result == 0 {
>>>             print("Camera detected successfully!")
>>>         } else {
>>>             print("Failed to detect camera.")
>>>         }
>>>     }
>>>
>>>     // GPContext is a placeholder for actual libgphoto2 context
>>> management
>>>     func createGPContext() -> OpaquePointer? {
>>>         let context: OpaquePointer? = nil
>>>         // You'd need to properly initialize the context here
>>>         return context
>>>     }
>>> }
>>> ```
>>>
>>> ### 5. **Handling USB Access (libusb)**
>>>
>>> You would similarly add a bridging header and interact with `libusb`.
>>> However, due to iOS restrictions, `libusb` is likely to require
>>> entitlements to access USB devices directly.
>>>
>>> **Create `usb_bridge.h` (bridging header for libusb):**
>>>
>>> ```objective-c
>>> #import <Foundation/Foundation.h>
>>>
>>> #ifdef __cplusplus
>>> extern "C" {
>>> #endif
>>>
>>> #include <libusb-1.0/libusb.h>
>>>
>>> int initialize_usb();
>>>
>>> #ifdef __cplusplus
>>> }
>>> #endif
>>> ```
>>>
>>> **Create `usb_bridge.c`:**
>>>
>>> ```c
>>> #include "usb_bridge.h"
>>>
>>> int initialize_usb() {
>>>     libusb_context *ctx = NULL;
>>>     int r = libusb_init(&ctx);
>>>     if (r < 0) {
>>>         return r;
>>>     }
>>>
>>>     // Find connected USB devices
>>>     libusb_device **devs;
>>>     ssize_t cnt = libusb_get_device_list(ctx, &devs);
>>>     if (cnt < 0) return (int)cnt;
>>>
>>>     libusb_free_device_list(devs, 1);
>>>     libusb_exit(ctx);
>>>     return 0;
>>> }
>>> ```
>>>
>>> ### 6. **Swift Code for USB Initialization**
>>>
>>> ```swift
>>> func initializeUSB() {
>>>     let result = initialize_usb()
>>>     if result == 0 {
>>>         print("USB initialized successfully.")
>>>     } else {
>>>         print("Failed to initialize USB.")
>>>     }
>>> }
>>> ```
>>>
>>> ### 7. **Handle iOS Permissions and Testing**
>>>
>>> Given iOS’s restrictions on USB access, you’ll need to consider using
>>> Apple’s `ExternalAccessory` framework for official USB hardware access.
>>> Alternatively, if the camera supports wireless (e.g., Wi-Fi), you can
>>> communicate over the network to avoid USB restrictions altogether.
>>>
>>> Testing on an actual device will be critical because the iOS Simulator
>>> does not support USB or accessory connections.
>>>
>>> ### 8. **Next Steps and Entitlements**
>>>
>>> - **Request Entitlements**: To access USB devices, you will likely need
>>> to join Apple's MFi (Made for iPhone/iPad) program and request the
>>> necessary entitlements.
>>> - **Test and Debug**: Testing on actual hardware will help you
>>> understand how the app behaves when communicating with a camera via USB.
>>>
>>> Would you like assistance with any specific part of the code, or do you
>>> need further guidance on handling USB in iOS?
>>>
>>> Sincerely,
>>>
>>>
>>> Ole Aamot
>>>
>>> o...@aamot.org
>>>
>>> www.aamot.org
>>>
>>> +47-4173-2002
>>>
>>>
>>>
>>> On Mon, Sep 16, 2024 at 7:28 AM Anand Walvekar <
>>> anand.walve...@onemorehustle.com> wrote:
>>>
>>>> Thank you Ole for your time.
>>>>
>>>> ChatGPT seems to be more descriptive to you 😊
>>>>
>>>> I have been trying to recompile the libgphoto2 and its dependencies
>>>> with clang and linking with iOS framework. Clang treats warning as errors
>>>> and it needs source code changes. Also libgphoto2 loads dylb from system
>>>> path which also needs to be taken into account.
>>>>
>>>> Over it's not straightforward.
>>>>
>>>> Thank you
>>>> Anand
>>>>
>>>>
>>>>
>>>> On Mon, 16 Sept, 2024, 3:37 am Ole Aamot, <o...@gnu.org> wrote:
>>>>
>>>>> ChatGPT gave this answer:
>>>>>
>>>>> To implement a **libgphoto2** camera driver for an iPad over USB, you
>>>>> would need to address several layers of challenges including hardware
>>>>> support, communication protocols, and OS-level restrictions. Here's a
>>>>> high-level approach to guide the development:
>>>>>
>>>>> ### Steps to Implement libgphoto2 Camera Driver for iPad USB
>>>>>
>>>>> #### 1. **Understand the iPad USB Accessory Framework**
>>>>>    - Apple provides the **External Accessory framework** to
>>>>> communicate with external hardware. However, it's quite restrictive and
>>>>> typically meant for licensed manufacturers.
>>>>>    - iOS and iPadOS don't natively support generic USB drivers like on
>>>>> Linux or Windows, so the challenge is creating a bridge for libgphoto2 to
>>>>> access the camera hardware over USB.
>>>>>    - Check if the camera can be accessed via a **Camera Connection
>>>>> Kit** or Lightning-to-USB adapter and whether it's recognized as a USB
>>>>> accessory.
>>>>>
>>>>> #### 2. **Develop a Custom iOS App**
>>>>>    - You would likely need to create a custom iOS application using
>>>>> **Swift** or **Objective-C** to interface with the camera.
>>>>>    - Investigate the **USBDevice** API (for iOS 16+) if available,
>>>>> which offers more flexibility in accessing USB devices directly on
>>>>> iOS/iPadOS.
>>>>>    - Use the **USB Accessory Mode** for detecting connected devices.
>>>>>
>>>>> #### 3. **Compile libgphoto2 for iOS**
>>>>>    - Libgphoto2 is built for POSIX systems, so you’ll need to
>>>>> cross-compile it for iOS using tools like **Xcode** or **CMake** with
>>>>> specific target flags for ARM architecture.
>>>>>    - It may require modifications to libgphoto2 code to interact with
>>>>> iOS's unique environment and APIs.
>>>>>    - Remove or adapt dependencies in libgphoto2 that might not be
>>>>> supported by iOS (such as certain POSIX libraries).
>>>>>
>>>>> #### 4. **USB Communication Bridge**
>>>>>    - Libgphoto2 communicates with cameras using PTP (Picture Transfer
>>>>> Protocol) or proprietary protocols over USB.
>>>>>    - Implement a communication bridge between libgphoto2 and iOS's USB
>>>>> interface. This may involve writing code to mimic Linux's USB driver
>>>>> behavior within the iOS app.
>>>>>    - The **libusb** library might also need to be ported or modified
>>>>> for iOS to enable USB communication, since it is widely used by 
>>>>> libgphoto2.
>>>>>
>>>>> #### 5. **Sandboxing and Permissions**
>>>>>    - iOS has strict sandboxing. Ensure that your app requests the
>>>>> necessary permissions to communicate with USB devices and interact with
>>>>> external hardware.
>>>>>    - Add necessary entitlements in the **Info.plist** file, like
>>>>> `com.apple.external-accessory` or `com.apple.developer.usb`.
>>>>>
>>>>> #### 6. **Testing with Different Cameras**
>>>>>    - Libgphoto2 supports a wide range of cameras, so you'll need to
>>>>> test with specific camera models.
>>>>>    - Ensure that the camera can be recognized by the app, and you can
>>>>> trigger functions like capturing images, downloading files, or controlling
>>>>> camera settings.
>>>>>
>>>>> #### 7. **Distributing the App**
>>>>>    - If the app is for personal use, you can sideload it to your iPad
>>>>> using Xcode and a developer account.
>>>>>    - If the goal is broader distribution, you would need to ensure
>>>>> compliance with Apple's guidelines, especially for apps interacting with
>>>>> external hardware.
>>>>>
>>>>> ### Challenges
>>>>>    - **Apple's closed ecosystem**: iOS is not designed to be an open
>>>>> system like Linux, so you will face challenges accessing hardware.
>>>>>    - **Licensing**: If this driver is to be distributed, you may need
>>>>> Apple's MFi (Made for iPhone/iPad) certification for USB accessory
>>>>> communication.
>>>>>
>>>>> ### Summary
>>>>> This task involves cross-compiling libgphoto2 for iOS, interfacing
>>>>> with iPad USB APIs, and overcoming OS-level restrictions. Starting with
>>>>> Apple’s USBDevice APIs and building a custom iOS app to bridge 
>>>>> libgphoto2’s
>>>>> functionality is the best approach. You will likely need to experiment 
>>>>> with
>>>>> lower-level hardware protocols and iOS permissions to make it work
>>>>> effectively.
>>>>>
>>>>> Sincerely,
>>>>>
>>>>>
>>>>> Ole Aamot
>>>>>
>>>>> o...@aamot.org
>>>>>
>>>>> www.aamot.org
>>>>>
>>>>> +47-4173-2002
>>>>>
>>>>>
>>>>>
>>>>> On Tue, Sep 10, 2024 at 9:11 AM Marcus Meissner <mar...@jet.franken.de>
>>>>> wrote:
>>>>>
>>>>>> Hi,
>>>>>>
>>>>>> On Sun, Sep 08, 2024 at 07:21:03PM +0530, Anand Walvekar wrote:
>>>>>> > Hi Team
>>>>>> > Hope you are doing well.
>>>>>> >
>>>>>> > I need your help to integrate libgphoto2 in iPad application. Could
>>>>>> you
>>>>>> > please share me few links which I can try it out.
>>>>>> >
>>>>>> > Thank you
>>>>>> > Anand
>>>>>>
>>>>>> This likely means the iPad as USB Host for cameras?
>>>>>>
>>>>>> I am not familar with either iPad or if iPad USB-Host is even
>>>>>> possible,
>>>>>> perhaps someone else knows it :/
>>>>>>
>>>>>> Ciao, Marcus
>>>>>>
>>>>>>
>>>>>> _______________________________________________
>>>>>> Gphoto-devel mailing list
>>>>>> Gphoto-devel@lists.sourceforge.net
>>>>>> https://lists.sourceforge.net/lists/listinfo/gphoto-devel
>>>>>>
>>>>>
_______________________________________________
Gphoto-devel mailing list
Gphoto-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/gphoto-devel

Reply via email to