sample code - “Download and upload setting files”

usage:
   d      - download camera setting
   u      - upload camera setting
To exit, please enter 'q'.

This sample code is included in SimpleCli.

  1// "Download and Upload Setting File" sample
  2#include <chrono>
  3#include <cstdint>
  4#include <cstdlib>
  5#include <fstream>
  6#include <future>
  7#include <iostream>
  8#include <mutex>
  9#include <stdexcept>
 10#include <string>
 11#include <thread>
 12
 13#if !defined(__APPLE__)
 14  #if defined(USE_EXPERIMENTAL_FS) // for jetson
 15    #include <experimental/filesystem>
 16    namespace fs = std::experimental::filesystem;
 17  #else
 18    #include <filesystem>
 19    namespace fs = std::filesystem;
 20  #endif
 21#endif
 22
 23#if defined(__APPLE__) || defined(__linux__)
 24  #include <unistd.h>
 25#endif
 26
 27// macro for multibyte character
 28#if defined(_WIN32) || defined(_WIN64)
 29  using CrString = std::wstring;
 30  #define CRSTR(s) L ## s
 31  #define CrCout std::wcout
 32  #define CrCin std::wcin
 33  #define DELIMITER CRSTR("\\")
 34#else
 35  using CrString = std::string;
 36  #define CRSTR(s) s
 37  #define CrCout std::cout
 38  #define CrCin std::cin
 39  #define DELIMITER CRSTR("/")
 40#endif
 41
 42
 43#include "CrDeviceProperty.h"
 44#include "CameraRemote_SDK.h"
 45#include "IDeviceCallback.h"
 46#include "CrDebugString.h"   // use CrDebugString.cpp
 47
 48#define PrintError(msg, err) { fprintf(stderr, "Error in %s(%d):" msg ",%s\n", __FUNCTION__, __LINE__, (err ? CrErrorString(err).c_str():"")); }
 49#define GotoError(msg, err) { PrintError(msg, err); goto Error; }
 50
 51bool  m_connected = false;
 52CrString m_modelId;
 53
 54std::mutex m_eventPromiseMutex;
 55std::promise<void>* m_eventPromise = nullptr;
 56void setEventPromise(std::promise<void>* dp)
 57{
 58    std::lock_guard<std::mutex> lock(m_eventPromiseMutex);
 59    m_eventPromise = dp;
 60}
 61
 62SCRSDK::CrError _getDeviceProperty(int64_t device_handle, uint32_t code, SCRSDK::CrDeviceProperty* devProp)
 63{
 64    std::int32_t nprop = 0;
 65    SCRSDK::CrDeviceProperty* prop_list = nullptr;
 66    SCRSDK::CrError err = SCRSDK::GetSelectDeviceProperties(device_handle, 1, &code, &prop_list, &nprop);
 67    if(err) GotoError("", err);
 68    if(prop_list && nprop >= 1) {
 69        *devProp = prop_list[0];
 70    }
 71Error:
 72    if(prop_list) SCRSDK::ReleaseDeviceProperties(device_handle, prop_list);
 73    return err;
 74}
 75
 76class DeviceCallback : public SCRSDK::IDeviceCallback
 77{
 78public:
 79    DeviceCallback() {};
 80    ~DeviceCallback() {};
 81
 82    void OnConnected(SCRSDK::DeviceConnectionVersioin version)
 83    {
 84        CrCout << "Connected to " << m_modelId << "\n";
 85        m_connected = true;
 86        std::lock_guard<std::mutex> lock(m_eventPromiseMutex);
 87        if(m_eventPromise) {
 88            m_eventPromise->set_value();
 89            m_eventPromise = nullptr;
 90        }
 91    }
 92
 93    void OnError(CrInt32u error)
 94    {
 95        printf("Connection error:%s\n", CrErrorString(error).c_str());
 96        std::lock_guard<std::mutex> lock(m_eventPromiseMutex);
 97        if(m_eventPromise) {
 98            m_eventPromise->set_exception(std::make_exception_ptr(std::runtime_error("error")));
 99            m_eventPromise = nullptr;
100        }
101    }
102
103    void OnDisconnected(CrInt32u error)
104    {
105        CrCout << "Disconnected from " << m_modelId << "\n";
106        m_connected = false;
107        std::lock_guard<std::mutex> lock(m_eventPromiseMutex);
108        if(m_eventPromise) {
109            m_eventPromise->set_value();
110            m_eventPromise = nullptr;
111        }
112    }
113
114    void OnCompleteDownload(CrChar* filename, CrInt32u type)
115    {
116        CrCout << "OnCompleteDownload:" << filename << "\n";
117        std::lock_guard<std::mutex> lock(m_eventPromiseMutex);
118        if(m_eventPromise) {
119            m_eventPromise->set_value();
120            m_eventPromise = nullptr;
121        }
122    }
123
124    void OnNotifyContentsTransfer(CrInt32u notify, SCRSDK::CrContentHandle contentHandle, CrChar* filename)
125    {
126        std::cout << "OnNotifyContentsTransfer.\n";
127    }
128
129    void OnWarning(CrInt32u warning)
130    {
131        if (warning == SCRSDK::CrWarning_Connect_Reconnecting) {
132            CrCout << "Reconnecting to " << m_modelId << "\n";
133            return;
134        }
135        std::cout << "OnWarning:" << CrErrorString(warning) << "\n";
136        std::lock_guard<std::mutex> lock(m_eventPromiseMutex);
137        switch(warning) {
138        case SCRSDK::CrWarning_CameraSettings_Read_Result_OK:
139            if(m_eventPromise) {
140                m_eventPromise->set_value();
141                m_eventPromise = nullptr;
142            }
143            break;
144        case SCRSDK::CrWarning_CameraSettings_Save_Result_NG:
145        case SCRSDK::CrWarning_CameraSettings_Read_Result_Invalid:
146        case SCRSDK::CrWarning_CameraSettings_Read_Result_NG:
147            if(m_eventPromise) {
148                m_eventPromise->set_exception(std::make_exception_ptr(std::runtime_error("error")));
149                m_eventPromise = nullptr;
150            }
151            break;
152        }
153    }
154
155    void OnWarningExt(CrInt32u warning, CrInt32 param1, CrInt32 param2, CrInt32 param3)
156    {
157        std::cout << "OnWarningExt:" << CrWarningExtString(warning, param1, param2, param3).c_str() << "\n";
158    }
159
160    void OnLvPropertyChanged() {}
161    void OnLvPropertyChangedCodes(CrInt32u num, CrInt32u* codes) {}
162    void OnPropertyChanged() {}
163    void OnPropertyChangedCodes(CrInt32u num, CrInt32u* codes) {}
164};
165
166CrString _getModelId(const SCRSDK::ICrCameraObjectInfo* objInfo)
167{
168    CrString id;
169    if (CrString(objInfo->GetConnectionTypeName()) == CRSTR("IP")) {
170        id = CrString(objInfo->GetMACAddressChar());
171    } else {
172        id = CrString((CrChar*)objInfo->GetId());
173    }
174    return CrString(objInfo->GetModel()).append(CRSTR(" (")).append(id).append(CRSTR(")"));
175}
176
177SCRSDK::CrError _getIdPassword(SCRSDK::ICrCameraObjectInfo* objInfo, std::string& fingerprint, std::string& userId, std::string& userPassword)
178{
179    char fpBuff[128] = {0};
180    CrInt32u fpLen = 0;
181    SCRSDK::CrError err = SCRSDK::GetFingerprint(objInfo, fpBuff, &fpLen);
182    if(err) GotoError("", err);
183    fingerprint = std::string(fpBuff, fpLen);
184
185    std::cout << "fingerprint: " << fingerprint.c_str() << "\n";
186    std::cout << "id:";       std::getline(std::cin, userId);
187    std::cout << "password:"; std::getline(std::cin, userPassword);
188    return 0;
189Error:
190    return err;
191}
192
193SCRSDK::CrError _downloadCameraSettingFile(int64_t device_handle, CrString path)
194{
195    int result = SCRSDK::CrError_Generic_Unknown;
196    SCRSDK::CrError err = SCRSDK::CrError_None;
197    SCRSDK::CrDeviceProperty devProp;
198    CrString inputLine;
199    std::promise<void> eventPromise;
200    std::future<void> eventFuture = eventPromise.get_future();
201
202    err = _getDeviceProperty(device_handle, SCRSDK::CrDeviceProperty_CameraSetting_SaveOperationEnableStatus, &devProp);
203    if(err) GotoError("", err);
204    if(devProp.GetCurrentValue() != SCRSDK::CrCameraSettingSaveOperation_Enable) GotoError("disabled!", 0);
205
206    std::cout << "file name:"; std::getline(CrCin, inputLine);
207
208    setEventPromise(&eventPromise);
209
210    err = SCRSDK::DownloadSettingFile(device_handle, SCRSDK::CrDownloadSettingFileType_Setup, (CrChar*)path.c_str(), (CrChar*)inputLine.c_str());
211    if(err) GotoError("", err);
212
213    // callback:OnCompleteDownload, CrWarning_CameraSettings_Save_Result_NG
214    try{
215        eventFuture.get();
216    } catch(const std::exception&) GotoError("", 0);
217    result = 0;
218Error:
219    setEventPromise(nullptr);
220    return result;
221}
222
223SCRSDK::CrError _uploadCameraSettingFile(int64_t device_handle, CrString path)
224{
225    int result = SCRSDK::CrError_Generic_Unknown;
226    SCRSDK::CrError err = SCRSDK::CrError_None;
227    SCRSDK::CrDeviceProperty devProp;
228    CrString inputLine;
229    std::promise<void> eventPromise;
230    std::future<void> eventFuture = eventPromise.get_future();
231
232    err = _getDeviceProperty(device_handle, SCRSDK::CrDeviceProperty_CameraSetting_SaveRead_State, &devProp);
233    if(err) GotoError("", err);
234    if(devProp.GetCurrentValue() != SCRSDK::CrCameraSettingSaveReadState_Idle) GotoError("not idle!", 0);
235
236    err = _getDeviceProperty(device_handle, SCRSDK::CrDeviceProperty_CameraSetting_ReadOperationEnableStatus, &devProp);
237    if(err) GotoError("", err);
238    if(devProp.GetCurrentValue() != SCRSDK::CrCameraSettingReadOperation_Enable) GotoError("disabled!", 0);
239
240    std::cout << "file name:"; std::getline(CrCin, inputLine);
241    path.append(DELIMITER).append(inputLine);
242    CrCout << path << "\n";
243
244    setEventPromise(&eventPromise);
245
246    err = SCRSDK::UploadSettingFile(device_handle, SCRSDK::CrUploadSettingFileType_Setup, (CrChar*)path.c_str());
247    if(err) GotoError("", err);
248
249    // callback:CrWarning_CameraSettings_Read_Result_xx
250    try{
251        eventFuture.get();
252    } catch(const std::exception&) GotoError("", 0);
253    result = 0;
254Error:
255    setEventPromise(nullptr);
256    return result;
257}
258
259
260int main(void)
261{
262    int result = -1;
263    SCRSDK::CrError err = SCRSDK::CrError_None;
264    int64_t  m_device_handle = 0;
265    SCRSDK::ICrEnumCameraObjectInfo* enumCameraObjectInfo = nullptr;
266    SCRSDK::ICrCameraObjectInfo* objInfo = nullptr;
267    DeviceCallback deviceCallback;
268
269  #if defined(__APPLE__)
270    #define MAC_MAX_PATH 255
271    char pathBuf[MAC_MAX_PATH] = {0};
272    if(NULL == getcwd(pathBuf, sizeof(pathBuf) - 1)) return 1;
273    CrString path = pathBuf;
274  #else
275    CrString path = fs::current_path().native();
276  #endif
277
278    bool boolRet = SCRSDK::Init();
279    if(!boolRet) GotoError("", 0);
280
281    // enumeration
282    {
283        uint32_t count = 0;
284        uint32_t index = 1;
285
286        err = SCRSDK::EnumCameraObjects(&enumCameraObjectInfo, 3/*timeInSec*/);
287        if(err || !enumCameraObjectInfo) GotoError("no camera", err);
288
289        count = enumCameraObjectInfo->GetCount();
290        if(count >= 2) {
291            for (uint32_t i = 0; i < count; ++i) {
292                auto* info = enumCameraObjectInfo->GetCameraObjectInfo(i);
293                CrCout << '[' << i + 1 << "] " << _getModelId(info) << "\n";
294            }
295
296            std::string inputLine;
297            std::cout << "select camera:"; std::getline(std::cin, inputLine);
298            try { index = stoi(inputLine); } catch(const std::exception&) { GotoError("", 0); }
299            if(index < 1 || index > count) GotoError("", 0);
300        }
301        objInfo = (SCRSDK::ICrCameraObjectInfo*)enumCameraObjectInfo->GetCameraObjectInfo(index - 1);
302        m_modelId = _getModelId(objInfo);
303    }
304
305    // connect
306    {
307        std::string  fingerprint = "";
308        std::string  userId = "";
309        std::string  userPassword = "";
310        std::promise<void> eventPromise;
311        std::future<void> eventFuture = eventPromise.get_future();
312
313        if (objInfo->GetSSHsupport() == SCRSDK::CrSSHsupport_ON) {
314            err = _getIdPassword(objInfo, fingerprint, userId, userPassword); if(err) goto Error;
315        }
316
317        setEventPromise(&eventPromise);
318        err = SCRSDK::Connect(objInfo, &deviceCallback, &m_device_handle,
319            SCRSDK::CrSdkControlMode_Remote,
320            SCRSDK::CrReconnecting_ON,
321            userId.c_str(), userPassword.c_str(), fingerprint.c_str(), (uint32_t)fingerprint.size());
322        if(err) GotoError("", err);
323
324    //  std::future_status status = eventFuture.wait_for(std::chrono::milliseconds(3000));
325    //  if(status != std::future_status::ready) GotoError("timeout",0);
326        try{
327            eventFuture.get();
328        } catch(const std::exception&) GotoError("", 0);
329    }
330
331    // set work directory
332    {
333        CrCout << "path=" << path.data() << "\n";
334        err = SCRSDK::SetSaveInfo(m_device_handle, const_cast<CrChar*>(path.data()), const_cast<CrChar*>(CRSTR("DSC")), -1/*startNo*/);
335        if(err) GotoError("", err);
336    }
337
338    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
339
340    std::cout << "usage:\n";
341    std::cout << "   d      - download camera setting\n";
342    std::cout << "   u      - upload camera setting\n";
343    std::cout << "To exit, please enter 'q'.\n";
344
345    while(1) {
346        std::string inputLine;
347        std::getline(std::cin, inputLine);
348        if(inputLine == "d" || inputLine == "D") {
349            err = _downloadCameraSettingFile(m_device_handle, path);
350            if(err) goto Error;
351
352        } else if(inputLine == "u" || inputLine == "U") {
353            err = _uploadCameraSettingFile(m_device_handle, path);
354            if(err) goto Error;
355
356        } else if(inputLine == "q" || inputLine == "Q") {
357            break;
358        } else {
359            std::cout << "unknown command\n";
360        }
361    }
362
363    result = 0;
364Error:
365    if(enumCameraObjectInfo) enumCameraObjectInfo->Release();
366
367    if(m_connected) {
368        std::promise<void> eventPromise;
369        std::future<void> eventFuture = eventPromise.get_future();
370        setEventPromise(&eventPromise);
371        SCRSDK::Disconnect(m_device_handle);
372        eventFuture.wait_for(std::chrono::milliseconds(3000));
373    }
374    if(m_device_handle) SCRSDK::ReleaseDevice(m_device_handle);
375    SCRSDK::Release();
376
377    return result;
378}