Tips

What are the main capabilities of Sony's Camera Remote SDK?
What can I control on the camera, and what are the system requirements?

• Comprehensive list of SDK capabilities and operations
• System requirements for all supported platforms
• Camera control functions and property management APIs

Main Capabilities:

• Image Capture: Control shutter release with SendCommand(CrCommandId_Release) for single and continuous shooting
• Camera Properties: Get/Set ISO, aperture (F-number), shutter speed, focus mode, white balance via GetDeviceProperties() and SetDeviceProperty()
• Live View: Stream real-time preview images with GetLiveViewImage() for on-screen display
• File Management: Transfer captured images to host PC with SetSaveInfo() and StillImageStoreDestination property
• Focus & Zoom: Control autofocus area, manual focus position, and motorized zoom operations

System Requirements:

• Windows: Windows 10 64-bit, Windows 11 64-bit
• Linux: Ubuntu 22.04 LTS, Ubuntu 24.04 LTS (PC and ARMv8)
• macOS: macOS 13.1+ (Ventura), 14+ (Sonoma), 15+ (Sequoia)

Basic Workflow: Init() → EnumCameraObjects() → Connect() → GetDeviceProperties() → control operations → Disconnect() → Release()

Which Sony cameras are supported by the Camera Remote SDK V2.00.00?
I'm particularly interested in [your camera model].

• Complete list of supported camera models by category
• Connection type support matrix for each camera
• SDK mode availability (RemoteControl, ContentsTransfer, RemoteTransfer)
• Special requirements and limitations per model

Supported Camera Models in SDK V2.00.00: Cinema Line:

• ILX-LR1, ILME-FX6 (Ver.3.00+), MPC-2610

Alpha Series:

• ILCE-1, ILCE-9M3, ILCE-7RM5, ILCE-7M4, ILCE-7RM4A, ILCE-7SM3, ILCE-7C, ILCE-7CR, and more

Connection Support by Model:

Model	USB	Wired LAN	Wireless LAN	Notes
ILX-LR1	✓ R/C/T	✓ R/C/T	✓ R/C/T	SSH auth required, USB-C to GigE adapter
ILCE-1	✓ R/C/T	✓ R/C/T	✓ R/C/T	All modes supported
ILCE-7RM4A	✓ R/C	✗	✗	USB only, no network

Legend: R=RemoteControlMode, C=ContentsTransferMode, T=RemoteTransferMode For complete compatibility tables with all models, see Function List documentation.

What connection types (USB, wired LAN, wireless LAN) are supported
for connecting to cameras? What are the differences between them?

• Detailed comparison of all physical connection types
• Performance characteristics and use case recommendations
• Hardware requirements for each connection type
• Connection mode compatibility per physical layer

Physical Connection Types: 1. USB Connection

• Interface: Direct USB cable (Type-C or Micro-USB depending on camera)
• Pros: Most stable, highest bandwidth, no network configuration needed
• Cons: Limited cable length (~5m), tethered operation only
• Best for: Studio setups, direct PC control, maximum reliability

2. Wired LAN (Ethernet)

• Interface: RJ45 network cable (cameras may need USB-C to Ethernet adapter)
• Pros: Stable, long-distance capable (100m+), network integration
• Cons: Requires network setup, some cameras need adapters, may require SSH pairing
• Best for: Fixed installations, multi-camera systems, industrial applications

3. Wireless LAN (Wi-Fi)

• Interface: Built-in Wi-Fi (camera creates access point or joins network)
• Pros: No cables, portable, flexible positioning
• Cons: Lower bandwidth, potential interference, not all cameras support all modes
• Cons: Linux ARMv7/ARMv8 SDK versions don’t support wireless
• Best for: Mobile applications, temporary setups, on-location shooting

Connection Modes by Physical Layer:

• RemoteControlMode (R): Real-time camera control - Available on all connection types
• ContentsTransferMode (C): File transfer only - Added in SDK v1.05.00
• RemoteTransferMode (T): Control + auto file transfer - Added in SDK v1.13.00

Important: Check camera compatibility table—not all cameras support all modes on all connection types.

What's the difference between SDK V1.14.00 and V2.00.00?
Which version should I use for a new project?

• Key differences between SDK versions
• New features and capabilities in each version
• Breaking changes and migration considerations
• Recommendation for new projects

SDK Version Comparison: V2.00.00 (Latest - Recommended for New Projects)

• Status: Latest stable release, actively maintained
• New Camera Support: Additional camera models including latest Alpha and Cinema Line cameras
• New Features: Enhanced property controls, additional device properties
• Compatibility: Full backward compatibility with V1.14.00 cameras

V1.14.00 (Stable Legacy)

• Status: Stable, mature codebase
• Use Case: Existing projects that don’t need latest features
• Camera Support: Broad support for Alpha 7/9 series and earlier Cinema Line
• ContentsTransferMode: Added in v1.05.00
• RemoteTransferMode: Added in v1.13.00

Key Differences:

• V2.00.00 supports newer camera models released after V1.14.00
• V2.00.00 includes additional device property codes and commands
• API compatibility maintained—migration typically requires minimal code changes
• DLL/library files must be updated when switching versions (rebuild required)

Recommendation: Use V2.00.00 for all new projects to ensure latest camera support and future compatibility.

I'm a developer for a drone manufacturer that builds remote control
solar panel and cell tower inspection systems using the ILX-LR1.

We want to:
- Control the camera to set F-stop and other basic settings
- Recall those settings at the start of flight
- Save photos to the host computer only (not camera SD card)
- Take photos every 1 second until a command is given

Can you help me understand:
1. Which SDK APIs and operations I'll need to use
2. What connection type and mode is best for this use case
3. Any special requirements for the ILX-LR1
4. How to structure the workflow from connection to capture

• ILX-LR1 compatibility details and requirements
• API recommendations for property management and capture
• Connection workflow with pairing instructions
• Code examples for device properties and image capture

• SSH authentication required (username: “admin”)
• USB Type-C to Gigabit Ethernet adapter recommended
• Supports all connection modes: RemoteControlMode, ContentsTransferMode, RemoteTransferMode
• Maximum 5 simultaneous connections supported

1. SDK Initialization & Connection:

Copy

Init() → EnumCameraObjects() → Connect() with RemoteControlMode + SSH

2. Camera Pairing (First Time):

• Set camera to: Network > Cnct./Remote Sht. > Remote Shoot Function > Pairing
• Call Connect() from your app
• Accept pairing on camera
• Power cycle camera (wait 10+ seconds) to save pairing info

3. Configure Save Destination (Host Only):

Copy

SetSaveInfo(deviceHandle, "C:\\Photos", "inspection_", 1);
SetDeviceProperty(CrDeviceProperty_StillImageStoreDestination,
                 CrStillImageStoreDestination_HostPC);

4. Set Camera Properties (F-stop, ISO, etc.):

Copy

GetDeviceProperties() // Check current values and available options
SetDeviceProperty(CrDeviceProperty_FNumber, f_28_value);
SetDeviceProperty(CrDeviceProperty_IsoSensitivity, iso_value);
// Save settings to camera memory slot for recall

5. Timelapse Capture Loop (Every 1 Second):

Copy

while (capture_active) {
    SendCommand(CrCommandId_Release, CrCommandParam_Down);
    Sleep(35); // ms
    SendCommand(CrCommandId_Release, CrCommandParam_Up);
    Sleep(965); // Wait remaining time for 1-second interval
}

Recommended Connection: Wired LAN (Ethernet) for reliable continuous operation during flight

I need to implement [specific feature, e.g., "live view streaming"].

What's the recommended workflow? What APIs do I need to call,
in what order, and what are the prerequisites?

• Complete step-by-step operation guides with API sequences
• Timing considerations and camera state requirements
• Prerequisites and property dependencies

Prerequisites:

• Camera must be connected in RemoteControlMode
• Check CrDeviceProperty_LiveViewStatus is supported
• Camera may not accept operations immediately after connection—wait for OnConnected() callback

Workflow:

Copy

1. Enable Live View:
   SetDeviceProperty(CrDeviceProperty_LiveView_Enable, CrLiveView_Enable)

2. Configure Live View Quality (optional):
   SetDeviceProperty(CrDeviceProperty_LiveView_Image_Quality, quality_setting)

3. Start Image Retrieval Loop:
   while (streaming) {
       GetLiveViewImage() // Returns JPEG image data
       Display image on screen
       Process at 30fps or camera's native rate
   }

4. Cleanup:
   SetDeviceProperty(CrDeviceProperty_LiveView_Enable, CrLiveView_Disable)

Important Notes:

• Network traffic affects stability; avoid simultaneous heavy operations
• Image data is retrieved from internal buffer updated by background task
• Camera Remote SDK does not support “Enlarge Screen” mode—disable it on camera

I need to control multiple cameras simultaneously from one host PC.

What are the limitations, and how should I structure my application
to handle multiple camera connections?

• Multi-camera connection limits and constraints
• Architecture patterns for multi-camera control
• Device handle management strategies
• Callback handling for multiple cameras

Multi-Camera Limitations:

• Per Camera: Maximum 5 simultaneous connections from different hosts/applications
• Per Host PC: No SDK-imposed limit on number of cameras (limited by system resources)
• Connection Completion: Connection isn’t complete until OnConnected() callback is received
• Exceeded Limit: Connect() fails with error if camera already has 5 connections

Recommended Architecture:

Copy

// 1. Single SDK instance manages all cameras
Init(); // Call once for entire application

// 2. Enumerate all connected cameras
ICrEnumCameraObjectInfo* cameraList;
EnumCameraObjects(&cameraList);

// 3. Store device handles in a collection
std::vector<CrDeviceHandle> cameras;
for (int i = 0; i < cameraCount; i++) {
    CrDeviceHandle handle;
    Connect(cameraInfo[i], callback, &handle, mode);
    cameras.push_back(handle);
}

// 4. Manage each camera independently
for (auto handle : cameras) {
    GetDeviceProperties(handle, ...);
    SendCommand(handle, ...);
}

Best Practices:

• Use separate callback objects or camera identifiers to distinguish events from different cameras
• Implement thread-safe queue for handling callbacks from multiple cameras
• Consider network bandwidth when using multiple cameras over LAN
• For time-synchronized capture, account for network latency variations
• Properly clean up each device handle with Disconnect() before Release()

For my use case [describe briefly], which specific SDK APIs should I use?

I need to:
- [Requirement 1, e.g., "connect to camera"]
- [Requirement 2, e.g., "set exposure settings"]
- [Requirement 3, e.g., "capture images"]

What's the minimal set of APIs I need to implement?

• Complete list of required and optional APIs
• Function signatures with parameter descriptions
• Call order and dependencies

Minimal API Set for Basic Camera Control: Required (Core Operations):

• Init() - Initialize SDK at application start
• EnumCameraObjects() - Discover connected cameras
• Connect(pCameraInfo, callback, &deviceHandle, mode) - Establish camera connection
• Disconnect(deviceHandle) - Close camera connection
• Release() - Cleanup SDK resources at application end

Camera Property Management:

• GetDeviceProperties(deviceHandle, &propList, &count) - Read all camera properties
• SetDeviceProperty(deviceHandle, &property) - Change writable properties
• Property codes for your use case:
  • CrDeviceProperty_FNumber - Aperture/F-stop
  • CrDeviceProperty_IsoSensitivity - ISO setting
  • CrDeviceProperty_ShutterSpeed - Shutter speed
  • CrDeviceProperty_ExposureProgramMode - P/A/S/M mode

Image Capture:

• SendCommand(deviceHandle, CrCommandId_Release, param) - Trigger shutter (Down/Up)
• SetSaveInfo(deviceHandle, path, prefix, number) - Configure file save location
• SetDeviceProperty(CrDeviceProperty_StillImageStoreDestination) - Set save destination (camera/host/both)

Optional (Enhanced Features):

• GetLiveViewImage() - Live preview streaming
• GetLiveViewProperties() - Live view-specific properties
• ReleaseDeviceProperties() - Free property list memory

I'm designing a system with [camera model] that needs [connection type].

What hardware do I need? Are there specific network adapters,
cables, or other equipment required? Does this camera need SSH authentication?

• Camera-specific hardware requirements
• Network adapter recommendations
• Authentication requirements (SSH)
• Cable and connection specifications

Connection-Specific Hardware Requirements: USB Connection:

• Standard USB cable (camera-specific type - e.g., USB Type-C for newer models)
• Direct connection to host PC USB port
• Cable length limitation: ~5m maximum
• No additional adapters needed for basic USB

Wired LAN (Ethernet) Connection:

• For ILX-LR1, ILME-FX6, MPC-2610: USB Type-C to Gigabit Ethernet adapter required
  • Recommendation: Use Gigabit Ethernet compatible adapter for best performance
  • Standard Ethernet cable (Cat5e or better)
  • Can extend up to 100m+ with quality cables
• For PXW-Z200, HXR-NX800, BRC-AM7: Built-in Ethernet port (no adapter needed)

Wireless LAN Connection:

• Camera’s built-in Wi-Fi (if supported)
• Wireless network infrastructure (router/access point)
• Platform limitation: Not supported on Linux ARMv7/ARMv8

Authentication Requirements:

• SSH authentication required for: ILX-LR1, MPC-2610, ILME-FX6, PXW-Z200, HXR-NX800
  • Default username: admin
  • Password setup during initial pairing
  • SSH fingerprint verification on first connection
• Standard USB connection: No SSH authentication needed (most Alpha series cameras)

Multi-Camera Setups:

• Network switch/hub (for wired multi-camera with LAN)
• Maximum 5 simultaneous connections per camera (MPC-2610 and similar models)
• Adequate network bandwidth planning for live view streaming

I need to control F-stop, ISO, and shutter speed on an [camera model]
via [connection type].

Can you check the compatibility: does this camera support these features
with this connection type? Are there any limitations?

• Detailed compatibility tables with feature support
• Connection type limitations by camera
• Property availability and access modes

Camera Connection Compatibility: ILX-LR1 Full Support Matrix:

• USB: RemoteControl ✓, ContentsTransfer ✓, RemoteTransfer ✓
• Ethernet Wired: RemoteControl ✓, ContentsTransfer ✓, RemoteTransfer ✓
• Ethernet Wireless: RemoteControl ✓, ContentsTransfer ✓, RemoteTransfer ✓

ILCE-7RM4A (Alpha 7R IV) Support Matrix:

• USB: RemoteControl ✓, ContentsTransfer ✓
• Ethernet: Not supported

Property Feature Validation Approach: To verify if specific features (F-stop, ISO, shutter speed) are supported on your camera:

1. Call GetDeviceProperties() with property codes:
   Copy

   SDK::CrDeviceProperty* prop_list = nullptr;
   std::int32_t nprop = 0;
   SDK::GetDeviceProperties(deviceHandle, &prop_list, &nprop);
   

2. Check CrPropertyEnableFlag for each property:
   • Property exists in the returned list → Feature is supported
   • Property not in list → Feature not available on this camera
3. Validate writability with IsSetEnableCurrentValue():
   Copy

   if (prop.IsSetEnableCurrentValue()) {
       // Property is writable - you can set values
   } else {
       // Property is read-only or not currently settable
   }
   

4. Example validation pattern from SDK:
   Copy

   if (m_prop.f_number.writable == -1) {
       tout << "F-stop control is not supported on this camera\n";
       return false;
   }
   // Property is supported - safe to use
   

Important Notes:

• Some properties may be read-only in certain camera modes (e.g., Auto mode)
• Property availability can change based on camera settings (mode dial position, lens attached)
• Always validate before attempting to set values to avoid SDK errors

What's the difference between RemoteControlMode, ContentsTransferMode,
and RemoteTransferMode?

For my use case [describe], which mode should I use and why?

• Mode descriptions and use cases
• SDK version requirements for each mode
• Camera support by mode
• Performance and capability trade-offs

Connection Mode Comparison & Decision Matrix:

Mode	Abbreviation	SDK Version	Capabilities	Best For
RemoteControlMode	R	1.00.00+	Camera control + automatic transfer of newly captured images	Studio setups, live control apps, automated capture workflows
ContentsTransferMode	C	1.05.00+	Pull existing files from camera media (no control)	Backup operations, downloading existing images from SD card
RemoteTransferMode	T	1.13.00+	Combined: control + transfer new captures + pull existing media	Remote production, full file management workflows

Detailed Mode Characteristics: RemoteControlMode (R):

• Full camera remote control capabilities
• Live view image streaming available
• Real-time property changes (ISO, F-stop, shutter speed)
• Capture commands and shutter control
• CAN automatically transfer newly captured images to host (via SetSaveInfo + StillImageStoreDestination)
• CANNOT pull existing images from camera SD card/media
• Use when: You need control and automatic transfer of new captures, but don’t need to access existing files on the card

ContentsTransferMode (C):

• File transfer ONLY - no camera control
• Pull existing images from camera media slots
• Cannot trigger captures or change settings
• Requires disconnect/reconnect to switch to control mode
• Use when: Batch downloading existing files from camera storage (no control needed)

RemoteTransferMode (T):

• Full feature set: control + automatic transfer of new captures + pull existing media files
• Eliminates need for mode switching (disconnect/reconnect)
• Can execute shooting process during content transfer
• Maximizes efficiency for remote production workflows
• Trade-off: Content transfer speed may decrease during simultaneous operations
• Recommendation: Measure actual performance in your environment before production use
• Use when: You need complete file management (new captures + existing media access) with camera control

Decision Tree:

Copy

Do you need to control the camera?
  ├─ NO  → Use ContentsTransferMode (C)
  │         (Just pulling existing files from media)
  │
  └─ YES → Do you need to pull existing files from SD card?
            ├─ NO  → Use RemoteControlMode (R)
            │         (Control + auto-transfer new captures only)
            │
            └─ YES → Use RemoteTransferMode (T)
                      (Control + new captures + pull existing media)
                      SDK 1.13.00+ required

Camera Support Notes:

• Check compatibility tables - not all cameras support all modes
• ILX-LR1: Supports all three modes (R/C/T) on all connection types
• Many Alpha series cameras: Only support RemoteControlMode (R)
• Verify your specific camera model’s capabilities before implementation

Show me complete [C++/C#] code to:
1. Initialize the SDK
2. Enumerate and connect to an [camera model] via [connection type]
3. Set camera properties: [list specific properties]
4. Capture an image and save to host
5. Handle errors and cleanup

Use SDK V2.00.00 and include proper error handling.

• Complete, working code examples from SDK samples
• Proper initialization and cleanup patterns
• Error handling with SDK error codes
• Camera connection with SSH authentication (if required)

bool CameraDevice::connect(SCRSDK::CrSdkControlMode openMode,
                           SCRSDK::CrReconnectingSet reconnect)
{
    m_modeSDK = openMode;
    const char* inputId = "admin";
    char inputPassword[32] = { 0 };

    // SSH fingerprint verification and password handling...

    auto connect_status = SDK::Connect(m_info, this, &m_device_handle,
                                      openMode, reconnect, inputId,
                                      m_userPassword.c_str(),
                                      m_fingerprint.c_str(),
                                      (CrInt32u)m_fingerprint.size());
    if (CR_FAILED(connect_status)) {
        tout << "Failed to connect: 0x" << std::hex
             << connect_status << std::dec;
        return false;
    }
    set_save_info();
    return true;
}

Show me [C++/C#] code to get the current F-stop value,
check what values are available, and set it to f/2.8.

Include error handling for cases where the property isn't writable.

• Property loading and parsing code
• Writable status checking
• Value validation and setting
• Error handling patterns

void CameraDevice::load_properties(CrInt32u num, CrInt32u* codes)
{
    SDK::CrDeviceProperty* prop_list = nullptr;
    std::int32_t nprop = 0;

    SDK::CrError status = SDK::GetDeviceProperties(
        m_device_handle, &prop_list, &nprop);

    if (CR_FAILED(status)) {
        tout << "Failed to get device properties.\n";
        return;
    }

    for (std::int32_t i = 0; i < nprop; ++i) {
        auto prop = prop_list[i];
        switch (prop.GetCode()) {
            case SDK::CrDevicePropertyCode::CrDeviceProperty_FNumber:
                m_prop.f_number.writable = prop.IsSetEnableCurrentValue();
                m_prop.f_number.current =
                    static_cast<std::uint16_t>(prop.GetCurrentValue());
                // Parse possible values...
                break;
        }
    }
    SDK::ReleaseDeviceProperties(m_device_handle, prop_list);
}

Show me how to properly implement SDK callbacks in [C++/C#]:
- OnConnected
- OnDisconnected
- OnPropertyChanged
- OnError

What's the best practice for handling these events?

• Complete callback implementations
• Thread-safety considerations
• Event handling patterns
• Connection state management

void CameraDevice::OnConnected(SDK::DeviceConnectionVersioin version)
{
    m_connected.store(true);
    text id(this->get_id());
    tout << "Connected to " << m_info->GetModel()
         << " (" << id.data() << ")\n";
}

void CameraDevice::OnError(CrInt32u error)
{
    text msg = get_message_desc(error);
    if (!msg.empty()) {
        tout << std::endl << msg.data() << std::endl;

        if (SDK::CrError_Connect_TimeOut == error) {
            tout << "Please input '0' after Connect camera"
                 << std::endl;
            return;
        }
    }
}

Show me [C++/C#] code to capture a single image using the shutter
release command. Include proper timing and error handling.

• Shutter control command sequences
• Timing recommendations between commands
• Image capture completion detection

void CameraDevice::capture_image() const
{
    tout << "Capture image...\n";
    tout << "Shutter down\n";
    SDK::SendCommand(m_device_handle,
                    SDK::CrCommandId::CrCommandId_Release,
                    SDK::CrCommandParam_Down);

    // Wait, then send shutter up
    std::this_thread::sleep_for(35ms);
    tout << "Shutter up\n";
    SDK::SendCommand(m_device_handle,
                    SDK::CrCommandId::CrCommandId_Release,
                    SDK::CrCommandParam_Up);
}

I'm getting error code [CrError_Connect_TimeOut / 0x80010001]
when trying to [describe operation].

What does this error mean, what causes it, and how do I fix it?

• Error code definitions and explanations
• Common causes and troubleshooting steps
• Code examples showing error handling
• Related error conditions

Error Code: CrError_Connect_TimeOut
Explanation: "A connection operation timed out"

Common handling:
if (SDK::CrError_Connect_TimeOut == error) {
    tout << "Please input '0' after Connect camera" << std::endl;
    return;
}

I can't connect to my [camera model] via [connection type].

The camera is on and connected, but SDK::Connect() is failing.
What should I check? Do I need to configure anything on the camera?

• Camera pairing instructions
• Network configuration requirements
• Connection prerequisites and timing
• Camera menu settings to verify

“When connecting via wired LAN, you need to perform the ‘Network > Cnct./Remote Sht. > Remote Shoot Function > Pairing’ operation on the camera to make it memorize the host PC. Once the pairing is established, turn off the camera, pause for about 10 seconds, and then turn it back on again. (The information is stored in the camera when the power is turned off.)”

I don't understand [SDK concept, e.g., "the difference between
GetDeviceProperties and GetSelectDeviceProperties"].

Can you explain what this means and when to use each?

• Detailed API explanations
• Use case comparisons
• Performance implications
• Code examples demonstrating differences

// Get all properties
if (0 == num) {
    status = SDK::GetDeviceProperties(m_device_handle,
                                     &prop_list, &nprop);
}
else {
    // Get specific properties (more efficient)
    status = SDK::GetSelectDeviceProperties(m_device_handle,
                                           num, codes,
                                           &prop_list, &nprop);
}

My code successfully connects and sets properties, but when I try to
capture an image, nothing happens. No error is returned.

Here's my code: [paste relevant code]

What could be wrong?

• Common pitfalls and timing issues
• Camera state requirements
• Missing prerequisite operations
• Debugging strategies

“The camera may not accept shooting operations immediately after connection. Camera Remote SDK supports only the Remote-Control Protocol Version 3.”

I've implemented [describe feature] using the Camera Remote SDK.

What should I test to ensure it works correctly?
What edge cases and error conditions should I handle?

• Common error scenarios to test
• Connection state transitions
• Property value validation
• Timeout and disconnection handling

• Connection timeout (CrError_Connect_TimeOut)
• Too many connections (CrError_Connect_FailBusy)
• SSH authentication failures
• Property write failures when not writable
• Spontaneous disconnection handling

My application needs to capture images every [X] seconds for [Y] hours.

Are there any SDK limitations I should be aware of?
How can I validate that my implementation meets these requirements?

• Timing considerations and limitations
• Resource management best practices
• Long-running operation guidance
• Performance monitoring approaches

“The camera may not accept shooting operations immediately after connection. Wait for proper callback notifications before sending commands.”

I need to test controlling [number] cameras simultaneously.

What's the recommended testing approach? What are common pitfalls
when managing multiple camera connections?

• Connection limits per camera
• Device handle management patterns
• Callback synchronization
• Resource cleanup requirements

“One camera can be controlled by multiple host PCs. The maximum number of simultaneous connections is 5 users (applications). If the number of Connect requests exceeds the limit, the Connect() will fail. Note that the connection is not complete until the OnConnected() callback is received.”

My code works on [OS 1] but fails on [OS 2].

Are there platform-specific considerations for the Camera Remote SDK?
What should I check?

• Platform-specific implementation details
• String handling differences (wide char vs. char)
• Path separator differences
• OS-specific limitations

“Camera Remote SDK for Linux 64bit (ARMv8) and Linux 32bit (ARMv7) are not supported for wireless connections.”

• Complex multi-step implementations (connection + property management + image capture)
• Debugging and troubleshooting (systematic error resolution)
• C# development (ensures C#-specific code examples are retrieved)
• Production code generation (enforces proper error handling and citations)
• Long development sessions (maintains context and consistency)

• Quick one-off questions (simple API lookups, basic compatibility checks)
• Exploratory research (browsing SDK capabilities without coding)
• Initial testing (trying out the AI SDK Assistant for the first time)