juli/OrcaSlicer
1
1
Fork 0
mirror of https://github.com/OrcaSlicer/OrcaSlicer.git synced 2026-09-19 15:03:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
686b7f66ac2d4e147e24de6458e402492934dc85
OrcaSlicer/src/slic3r/GUI/Printer/PrinterFileSystem.cpp
T
Kris AustinandRodrigo Faselli 1749c293a6 build: clear 237 warnings - unused lambda captures (#15417) 
* build: enable /Zc:lambda for MSVC

MSVC keeps its legacy lambda processor under /std:c++17, which rejects
reading a constexpr constant inside a lambda that does not capture it
(C3493). No other compiler requires that capture, and clang reports it as
an unused one, so the two cannot both be satisfied without the flag.

/Zc:lambda selects the conforming lambda parser that clang and GCC
already use. It is implied by /std:c++20 and /permissive-, so it is only
needed while we are on C++17. clang-cl is conforming already and does not
take the flag.

It requires VS2019 16.8, so build_release_vs.bat now says 16.8+.

* build: clear 237 unused lambda capture warnings

236 captures across 81 files, 142 of them `this`. Removing an unused
capture changes no behavior; clang does not report a capture whose type
has a non-trivial destructor, so nothing held only to extend an object's
lifetime is in this set.

Nine of them are the second half of the warning, "is not required to be
captured for this use", where the capture is a const or constexpr value
the body does read. Those depend on the /Zc:lambda change in the previous
commit. One of them, in FillRectilinear.cpp, had been worked around with
an #ifndef __APPLE__ guard around the capture list, which is now gone.

GUI_ObjectTableSettings.cpp captured its reset button only to read it
inside #ifdef __WXOSX_MAC__. That branch now takes the button from the
event it is already handling.

* build: fail configure on MSVC older than 19.28 instead of dropping /Zc:lambda

cl.exe answers an unrecognized /Zc: sub-option with warning D9002 and keeps
going, so on VS2019 before 16.8 the flag is silently ignored and the build
instead dies with C3493 in FillRectilinear.cpp, nowhere near the cause.

* fix: delete three locals that are now unused

Their only remaining use was the lambda capture this branch removed. The
Clang builds set -Wno-unused-variable, so the build never flagged them.

---------

Co-authored-by: Rodrigo Faselli <162915171+RF47@users.noreply.github.com>
2026-09-02 07:38:05 -03:00

1873 lines
68 KiB
C++
Raw Blame History

#include "PrinterFileSystem.h"
#include "libslic3r/Utils.hpp"
#include "libslic3r/Format/bbs_3mf.hpp"
#include "libslic3r/Model.hpp"
#include "slic3r/GUI/I18N.hpp"
#include "../../Utils/NetworkAgent.hpp"
#include "../BitmapCache.hpp"
#include <boost/algorithm/hex.hpp>
#include <boost/endian/conversion.hpp>
#include <boost/log/trivial.hpp>
#include <boost/uuid/detail/md5.hpp>
#include <boost/regex.hpp>
#include <wx/mstream.h>
#include "nlohmann/json.hpp"
#include <cstring>
#ifndef NDEBUG
//#define PRINTER_FILE_SYSTEM_TEST
#endif
std::string last_system_error() {
return Slic3r::decode_path(std::error_code(
#ifdef _WIN32
GetLastError(),
#else
errno,
#endif
std::system_category()).message().c_str());
}
wxDEFINE_EVENT(EVT_STATUS_CHANGED, wxCommandEvent);
wxDEFINE_EVENT(EVT_MODE_CHANGED, wxCommandEvent);
wxDEFINE_EVENT(EVT_FILE_CHANGED, wxCommandEvent);
wxDEFINE_EVENT(EVT_SELECT_CHANGED, wxCommandEvent);
wxDEFINE_EVENT(EVT_THUMBNAIL, wxCommandEvent);
wxDEFINE_EVENT(EVT_DOWNLOAD, wxCommandEvent);
wxDEFINE_EVENT(EVT_RAMDOWNLOAD, wxCommandEvent);
wxDEFINE_EVENT(EVT_MEDIA_ABILITY_CHANGED, wxCommandEvent);
wxDEFINE_EVENT(EVT_UPLOADING, wxCommandEvent);
wxDEFINE_EVENT(EVT_UPLOAD_CHANGED, wxCommandEvent);
wxDEFINE_EVENT(EVT_FILE_CALLBACK, wxCommandEvent);
static wxBitmap default_thumbnail;
static std::map<int, std::string> error_messages = {
{PrinterFileSystem::ERROR_PIPE, L("Reconnecting the printer, the operation cannot be completed immediately, please try again later.")},
{PrinterFileSystem::ERROR_RES_BUSY, L("The device cannot handle more conversations. Please retry later.")},
{PrinterFileSystem::ERROR_TIME_OUT, L("Timeout, please try again.")},
{PrinterFileSystem::FILE_NO_EXIST, L("File does not exist.")},
{PrinterFileSystem::FILE_CHECK_ERR, L("File checksum error. Please retry.")},
{PrinterFileSystem::FILE_TYPE_ERR, L("Not supported on the current printer version.")},
{PrinterFileSystem::STORAGE_UNAVAILABLE, L("Please check if the storage is inserted into the printer.\nIf it still cannot be read, you can try formatting the storage.")},
{PrinterFileSystem::API_VERSION_UNSUPPORT, L("The firmware version of the printer is too low. Please update the firmware and try again.")},
{PrinterFileSystem::FILE_EXIST, L("The file already exists, do you want to replace it?")},
{PrinterFileSystem::STORAGE_SPACE_NOT_ENOUGH, L("Insufficient storage space, please clear the space and try again.")},
{PrinterFileSystem::FILE_CREATE_ERR, L("File creation failed, please try again.")},
{PrinterFileSystem::FILE_WRITE_ERR, L("File write failed, please try again.")},
{PrinterFileSystem::MD5_COMPARE_ERR, L("MD5 verification failed, please try again.")},
{PrinterFileSystem::FILE_RENAME_ERR, L("File renaming failed, please try again.")},
{PrinterFileSystem::SEND_ERR, L("File upload failed, please try again.")}
};
struct StaticBambuLib : BambuLib {
static StaticBambuLib &get(BambuLib * copy = nullptr);
static int Fake_Bambu_Create(Bambu_Tunnel*, char const*) { return -2; }
static void reset();
static void release();
private:
std::vector<BambuLib *> copies_;
};
PrinterFileSystem::PrinterFileSystem()
: BambuLib(StaticBambuLib::get(this))
{
if (!default_thumbnail.IsOk()) {
default_thumbnail = *Slic3r::GUI::BitmapCache().load_svg("printer_file", 0, 0);
#ifdef __APPLE__
default_thumbnail = wxBitmap(default_thumbnail.ConvertToImage(), -1, 1);
#endif
}
m_session.owner = this;
#ifdef PRINTER_FILE_SYSTEM_TEST
auto time = wxDateTime::Now();
wxString path = "D:\\work\\pic\\";
for (int i = 0; i < 10; ++i) {
auto name = wxString::Format(L"gcode-%02d.3mf", i + 1);
m_file_list.push_back({name.ToUTF8().data(), "", time.GetTicks(), 26937, i < 5 ? FF_DOWNLOAD : 0, default_thumbnail});
std::ifstream ifs((path + name).ToUTF8().data(), std::ios::binary);
if (ifs)
ParseThumbnail(m_file_list.back(), ifs);
time.Add(wxDateSpan::Days(-1));
}
m_file_list.swap(m_file_list_cache[{F_MODEL, ""}]);
time = wxDateTime::Now();
for (int i = 0; i < 100; ++i) {
auto name = wxString::Format(L"img-%03d.jpg", i + 1);
wxImage im(path + name);
m_file_list.push_back({name.ToUTF8().data(), "", time.GetTicks(), 26937, i < 20 ? FF_DOWNLOAD : 0, i > 3 ? im : default_thumbnail});
time.Add(wxDateSpan::Days(-1));
}
m_file_list[0].thumbnail = default_thumbnail;
m_file_list.swap(m_file_list_cache[{F_TIMELAPSE, ""}]);
#endif
}
PrinterFileSystem::~PrinterFileSystem()
{
m_recv_thread.detach();
}
void PrinterFileSystem::SetFileType(FileType type, std::string const &storage)
{
if (m_file_type == type && m_file_storage == storage)
return;
SelectAll(false);
assert(m_file_list_cache[std::make_pair(m_file_type, m_file_storage)].empty());
m_file_list.swap(m_file_list_cache[{m_file_type, m_file_storage}]);
std::swap(m_file_type, type);
m_file_storage = storage;
m_file_list.swap(m_file_list_cache[{m_file_type, m_file_storage}]);
m_lock_start = m_lock_end = 0;
BuildGroups();
UpdateGroupSelect();
SendChangedEvent(EVT_FILE_CHANGED);
if (type == F_INVALID_TYPE)
return;
if (m_session.tunnel == nullptr)
return;
m_status = Status::ListSyncing;
SendChangedEvent(EVT_STATUS_CHANGED, m_status);
}
void PrinterFileSystem::SetGroupMode(GroupMode mode)
{
if (this->m_group_mode == mode)
return;
this->m_group_mode = mode;
m_lock_start = m_lock_end = 0;
UpdateGroupSelect();
SendChangedEvent(EVT_MODE_CHANGED);
}
size_t PrinterFileSystem::EnterSubGroup(size_t index)
{
if (m_group_mode == G_NONE)
return index;
index = m_group_mode == G_YEAR ? m_group_year[index] : m_group_month[index];
SetGroupMode((GroupMode)(m_group_mode - 1));
return index;
}
void PrinterFileSystem::ListAllFiles()
{
json req;
char const * types[] {"timelapse","video", "model" };
req["type"] = types[m_file_type];
if (!m_file_storage.empty())
req["storage"] = m_file_storage;
req["api_version"] = 2;
req["notify"] = "DETAIL";
SendRequest<FileList>(LIST_INFO, req, [type = m_file_type](json const& resp, FileList & list, auto) -> int {
json files = resp["file_lists"];
for (auto& f : files) {
std::string name = f["name"];
std::string path = f.value("path", "");
time_t time = f.value("time", 0);
boost::uint64_t size = f["size"];
if (type > F_TIMELAPSE && path.empty()) // Fix old printer that always return timelapses
return FILE_TYPE_ERR;
File ff = {name, path, time, size, 0};
list.push_back(ff);
}
return 0;
}, [this, type = m_file_type](int result, FileList list) {
if (result != 0) {
m_last_error = result;
m_status = Status::Failed;
m_file_list.clear();
BuildGroups();
UpdateGroupSelect();
SendChangedEvent(EVT_STATUS_CHANGED, m_status, "", result);
SendChangedEvent(EVT_FILE_CHANGED);
return 0;
}
if (type != m_file_type)
return 0;
m_file_list.swap(list);
for (auto & file : m_file_list)
file.thumbnail = default_thumbnail;
std::sort(m_file_list.begin(), m_file_list.end());
auto iter1 = m_file_list.begin();
auto end1 = m_file_list.end();
auto iter2 = list.begin();
auto end2 = list.end();
while (iter1 != end1 && iter2 != end2) {
if (*iter1 < *iter2) {
++iter1;
} else if (*iter2 < *iter1) {
++iter2;
} else {
if (iter1->path == iter2->path && iter1->name == iter2->name) {
iter1->thumbnail = iter2->thumbnail;
iter1->flags = iter2->flags;
if (!iter1->thumbnail.IsOk())
iter1->flags &= ~FF_THUMNAIL;
iter1->download = iter2->download;
iter1->local_path = iter2->local_path;
iter1->metadata = iter2->metadata;
}
++iter1;
++iter2;
}
}
BuildGroups();
UpdateGroupSelect();
m_last_error = 0;
m_status = Status::ListReady;
SendChangedEvent(EVT_STATUS_CHANGED, m_status);
SendChangedEvent(EVT_FILE_CHANGED);
if ((m_task_flags & FF_DOWNLOAD) == 0)
DownloadNextFile();
return 0;
});
}
void PrinterFileSystem::DeleteFiles(size_t index)
{
if (index == size_t(-1)) {
size_t n = 0;
for (size_t i = 0; i < m_file_list.size(); ++i) {
auto &file = m_file_list[i];
if ((file.flags & FF_SELECT) != 0 && (file.flags & FF_DELETED) == 0) {
file.flags |= FF_DELETED;
++n;
}
}
if (n == 0) return;
} else {
if (index >= m_file_list.size())
return;
auto &file = m_file_list[index];
if ((file.flags & FF_DELETED) != 0)
return;
file.flags |= FF_DELETED;
}
if ((m_task_flags & FF_DELETED) == 0)
DeleteFilesContinue();
}
struct PrinterFileSystem::Download : Progress
{
size_t index;
std::string name;
std::string path;
std::string local_path;
std::string error;
boost::filesystem::ofstream ofs;
boost::uuids::detail::md5 boost_md5;
};
struct PrinterFileSystem::Upload : Progress
{
std::string error;
boost::uint32_t frag_id{0};
MD5_CTX ctx;
boost::filesystem::ifstream ifs;
};
void PrinterFileSystem::GetPickImages(const std::vector<std::string> &local_paths, const std::vector<std::string> &targetpaths)
{
m_download_states.clear();
GetPickImage(1, local_paths[0], targetpaths[0]);
GetPickImage(2, local_paths[1], targetpaths[1]);
GetPickImage(3, local_paths[2], targetpaths[2]);
}
void PrinterFileSystem::GetPickImage(int id, const std::string &local_path, const std::string &targetpath)
{
json j;
j["sequence_id"] = id;
j["version"] = 1;
j["peer_host"] = "studio";
j["command"] = "get_project_file";
j["file_rel_path"] = targetpath;
std::string param = j.dump();
DownloadRamFile(16, local_path, param);
}
void PrinterFileSystem::DownloadRamFile(int index, const std::string &local_path, const std::string & param)
{
std::shared_ptr<Download> download(new Download);
download->local_path = local_path;
json req;
req["path"] = "mem:/" + std::to_string(index);
req["offset"] = 0;
req["mem_dl_param_size"] = param.size();
m_download_seq = SendRequest<Progress>(
FILE_DOWNLOAD, req,
[download](json const &resp, Progress &prog, unsigned char const *data) -> int {
size_t size = resp.value("size", 0);
prog.size = resp["offset"];
prog.total = resp["total"];
if (resp.contains("mem_dl_param_size")) {
size_t s = resp["mem_dl_param_size"].get<size_t>();
std::string json_str(reinterpret_cast<const char *>(data), s);
// OutputDebugStringA(json_str.c_str());
// OutputDebugStringA("\n");
json mem_dl_json = json::parse(json_str);
// download->mem_dl_param_size = size;
if (!mem_dl_json.contains("result") || mem_dl_json["result"] == 1 ) {
wxLogWarning("Download failed: result = 1");
return ERROR_JSON;
}
if(mem_dl_json.contains("size") && mem_dl_json["size"] == 0 )
return FILE_SIZE_ERR;
return CONTINUE;
}
if (prog.size == 0 ) {
download->ofs.open(download->local_path, std::ios::binary);
if (!download->ofs) {
download->error = last_system_error();
wxLogWarning("DownloadImageFromRam open error: %s\n", wxString::FromUTF8(download->error));
return FILE_OPEN_ERR;
}
}
download->ofs.write(reinterpret_cast<const char *>(data), size);
if (!download->ofs) {
download->error = last_system_error();
wxLogWarning("DownloadImageFromRam write error: %s\n", wxString::FromUTF8(download->error));
return FILE_READ_WRITE_ERR;
}
download->boost_md5.process_bytes(data, size);
prog.size += size;
download->total = prog.total;
download->size = prog.size;
if (prog.size < prog.total) {
return 0;
}
download->ofs.close();
std::string md5 = resp["file_md5"];
boost::uuids::detail::md5::digest_type digest;
download->boost_md5.get_digest(digest);
for (int i = 0; i < 4; ++i) digest[i] = boost::endian::endian_reverse(digest[i]);
std::string str_md5;
const auto char_digest = reinterpret_cast<const char *>(&digest[0]);
boost::algorithm::hex(char_digest, char_digest + sizeof(digest), std::back_inserter(str_md5));
if (!boost::iequals(str_md5, md5)) {
wxLogWarning("DownloadImageFromRam checksum error: %s != %s\n", str_md5, md5);
boost::system::error_code ec;
boost::filesystem::rename(download->local_path, download->local_path + ".tmp", ec);
return FILE_CHECK_ERR;
}
return SUCCESS;
},
[this, download](int result, Progress const &data) {
//OutputDebugStringA(std::to_string(result).c_str());
//OutputDebugStringA("\n");
if (result == CONTINUE) { return; }
std::string msg;
if (result == SUCCESS) {
if (std::filesystem::exists(download->local_path)) {
m_download_states.emplace_back(true);
BOOST_LOG_TRIVIAL(info) <<"DownloadImageFromRam finished: " << download->local_path << "result = " << result;
}else{
m_download_states.emplace_back(false);
BOOST_LOG_TRIVIAL(warning) <<"DownloadImageFromRam finished, but file not exist: " << download->local_path << "result = " << result;
}
} else if (result != CONTINUE) {
m_download_states.emplace_back(false);
BOOST_LOG_TRIVIAL(warning) << "DownloadImageFromRam failed: " << download->error << "result = " << result;
}
if(m_download_states.size() == 3){
if(m_download_states[0] && m_download_states[1] && m_download_states[2]){
SendChangedEvent(EVT_RAMDOWNLOAD, SUCCESS);
}else{
// FILE_NO_EXIST is not really error_code
SendChangedEvent(EVT_RAMDOWNLOAD, FILE_NO_EXIST);
}
}else{
BOOST_LOG_TRIVIAL(warning) << "m_download_states current size is : " << m_download_states.size();
}
},param);
}
void PrinterFileSystem::SendExistedFile(){
SendChangedEvent(EVT_RAMDOWNLOAD, SUCCESS);
}
void PrinterFileSystem::SendConnectFail(){
SendChangedEvent(EVT_RAMDOWNLOAD, ERROR_PIPE);
}
void PrinterFileSystem::DownloadFiles(size_t index, std::string const &path)
{
if (index == (size_t) -1) {
size_t n = 0;
for (size_t i = 0; i < m_file_list.size(); ++i) {
auto &file = m_file_list[i];
if ((file.flags & FF_SELECT) == 0) continue;
if ((file.flags & FF_DOWNLOAD) != 0 && file.DownloadProgress() >= -1) continue;
file.flags |= FF_DOWNLOAD;
std::shared_ptr<Download> download(new Download);
download->progress = -1;
download->local_path = (boost::filesystem::path(path) / file.name).string();
file.download = download;
++n;
}
if (n == 0) return;
} else {
if (index >= m_file_list.size())
return;
auto &file = m_file_list[index];
if ((file.flags & FF_DOWNLOAD) != 0 && file.DownloadProgress() >= -1)
return;
file.flags |= FF_DOWNLOAD;
std::shared_ptr<Download> download(new Download);
download->progress = -1;
download->local_path = (boost::filesystem::path(path) / file.name).string();
file.download = download;
}
boost::filesystem::create_directories(path);
if ((m_task_flags & FF_DOWNLOAD) == 0)
DownloadNextFile();
}
void PrinterFileSystem::DownloadCheckFiles(std::string const &path)
{
for (size_t i = 0; i < m_file_list.size(); ++i) {
auto &file = m_file_list[i];
if ((file.flags & FF_DOWNLOAD) != 0 && file.download) continue;
auto path2 = boost::filesystem::path(path) / file.name;
boost::system::error_code ec;
if (boost::filesystem::file_size(path2, ec) == file.size) {
file.flags |= FF_DOWNLOAD;
file.local_path = path2.string();
}
}
}
bool PrinterFileSystem::DownloadCheckFile(size_t index)
{
if (index >= m_file_list.size()) return false;
auto &file = m_file_list[index];
if ((file.flags & FF_DOWNLOAD) == 0 || file.local_path.empty())
return false;
if (!boost::filesystem::exists(file.local_path)) {
file.flags &= ~FF_DOWNLOAD;
file.local_path.clear();
SendChangedEvent(EVT_DOWNLOAD, index, file.local_path);
return false;
}
return true;
}
void PrinterFileSystem::DownloadCancel(size_t index)
{
if (index == (size_t) -1) return;
if (index >= m_file_list.size()) return;
auto &file = m_file_list[index];
if ((file.flags & FF_DOWNLOAD) == 0 || !file.download) return;
if (file.DownloadProgress() >= 0)
CancelRequest(m_download_seq);
else
file.flags &= ~FF_DOWNLOAD, file.download.reset();
}
void PrinterFileSystem::FetchModel(size_t index, std::function<void(int, std::string const &)> callback)
{
if (m_task_flags & FF_FETCH_MODEL)
return;
json req;
json arr;
if (index == (size_t) -1) return;
if (index >= m_file_list.size()) return;
auto &file = m_file_list[index];
arr.push_back(file.path + "#_rels/.rels");
arr.push_back(file.path + "#3D/3dmodel.model");
arr.push_back(file.path + "#Metadata/model_settings.config");
arr.push_back(file.path + "#Metadata/slice_info.config");
arr.push_back(file.path + "#Metadata/project_settings.config");
for (auto & meta : file.metadata) {
if (boost::algorithm::starts_with(meta.first, "plate_thumbnail_"))
arr.push_back(file.path + "#" + meta.second);
}
req["paths"] = arr;
req["zip"] = true;
m_task_flags |= FF_FETCH_MODEL;
std::shared_ptr<std::string> file_data(new std::string());
m_fetch_model_seq = SendRequest<Void>(
SUB_FILE, req,
[file_data](json const &resp, Void &, unsigned char const *data) -> int {
// in work thread, continue recv
// receive data
boost::uint32_t size = resp["size"];
if (size > 0) {
*file_data += std::string((char *) data, size);
}
return 0;
},
[this, file_data, callback](int result, Void const &) {
if (result == CONTINUE) return;
m_task_flags &= ~FF_FETCH_MODEL;
if (result != 0) {
auto iter = error_messages.find(result);
if (iter != error_messages.end())
*file_data = _u8L(iter->second.c_str());
else
file_data->clear();
}
callback(result, *file_data);
});
}
void PrinterFileSystem::FetchModelCancel()
{
if ((m_task_flags & FF_FETCH_MODEL) == 0) return;
CancelRequests2({m_fetch_model_seq});
}
size_t PrinterFileSystem::GetCount() const
{
if (m_group_mode == G_NONE)
return m_file_list.size();
return m_group_mode == G_YEAR ? m_group_year.size() : m_group_month.size();
}
int PrinterFileSystem::File::DownloadProgress() const { return download ? download->progress : !local_path.empty() ? 100 : -2; }
std::string PrinterFileSystem::File::Title() const { return Metadata("Title", ""); }
std::string PrinterFileSystem::File::Metadata(std::string const &key, std::string const &dflt) const
{
auto iter = metadata.find(key);
return iter == metadata.end() || iter->second.empty() ? dflt : iter->second;
}
PrinterFileSystem::UploadFile::~UploadFile()
{
if (upload && upload->ifs.is_open()) {
upload->ifs.close();
}
}
size_t PrinterFileSystem::GetIndexAtTime(boost::uint32_t time)
{
auto iter = std::upper_bound(m_file_list.begin(), m_file_list.end(), File{"", "", time});
size_t n = std::distance(m_file_list.begin(), iter) - 1;
if (m_group_mode == G_NONE) {
return n;
}
auto & group = m_group_mode == G_YEAR ? m_group_year : m_group_month;
auto iter2 = std::upper_bound(group.begin(), group.end(), n);
return std::distance(group.begin(), iter2) - 1;
}
void PrinterFileSystem::ToggleSelect(size_t index)
{
if (m_group_mode != G_NONE) {
size_t beg = m_group_mode == G_YEAR ? m_group_month[m_group_year[index]] : m_group_month[index];
size_t end_month = m_group_mode == G_YEAR ? ((index + 1) < m_group_year.size() ? m_group_year[index + 1] : m_group_month.size()) : index + 1;
size_t end = end_month < m_group_month.size() ? m_group_month[end_month] : m_file_list.size();
if ((m_group_flags[index] & FF_SELECT) == 0) {
for (int i = beg; i < end; ++i) {
if ((m_file_list[i].flags & FF_SELECT) == 0) {
m_file_list[i].flags |= FF_SELECT;
++m_select_count;
}
}
m_group_flags[index] |= FF_SELECT;
} else {
for (int i = beg; i < end; ++i) {
if (m_file_list[i].flags & FF_SELECT) {
m_file_list[i].flags &= ~FF_SELECT;
--m_select_count;
}
}
m_group_flags[index] &= ~FF_SELECT;
}
} else if (index < m_file_list.size()) {
m_file_list[index].flags ^= FF_SELECT;
if (m_file_list[index].flags & FF_SELECT)
++m_select_count;
else
--m_select_count;
}
SendChangedEvent(EVT_SELECT_CHANGED, m_select_count);
}
void PrinterFileSystem::SelectAll(bool select)
{
if (select) {
for (auto &f : m_file_list) f.flags |= FF_SELECT;
m_select_count = m_file_list.size();
for (auto &s : m_group_flags) s |= FF_SELECT;
} else {
for (auto &f : m_file_list) f.flags &= ~FF_SELECT;
m_select_count = 0;
for (auto &s : m_group_flags) s &= ~FF_SELECT;
}
SendChangedEvent(EVT_SELECT_CHANGED, m_select_count);
}
size_t PrinterFileSystem::GetSelectCount() const { return m_select_count; }
void PrinterFileSystem::SetFocusRange(size_t start, size_t count)
{
m_lock_start = start;
m_lock_end = start + count;
if (!m_stopped && (m_task_flags & FF_THUMNAIL) == 0)
UpdateFocusThumbnail();
}
PrinterFileSystem::File const &PrinterFileSystem::GetFile(size_t index)
{
if (m_group_mode == G_NONE)
return m_file_list[index];
if (m_group_mode == G_YEAR) index = m_group_year[index];
return m_file_list[m_group_month[index]];
}
PrinterFileSystem::File const &PrinterFileSystem::GetFile(size_t index, bool &select)
{
if (m_group_mode == G_NONE) {
select = m_file_list[index].IsSelect();
return m_file_list[index];
}
select = m_group_flags[index] & FF_SELECT;
if (m_group_mode == G_YEAR)
index = m_group_year[index];
return m_file_list[m_group_month[index]];
}
void PrinterFileSystem::Attached()
{
boost::unique_lock lock(m_mutex);
m_recv_thread = boost::thread([w = weak_from_this()] {
boost::shared_ptr<PrinterFileSystem> s = w.lock();
if (s) s->RecvMessageThread();
});
}
void PrinterFileSystem::Start()
{
boost::unique_lock l(m_mutex);
if (!m_stopped) return;
m_stopped = false;
m_cond.notify_all();
}
void PrinterFileSystem::Retry()
{
boost::unique_lock l(m_mutex);
m_stopped = false;
m_cond.notify_all();
}
void PrinterFileSystem::SetUrl(std::string const &url)
{
boost::unique_lock l(m_mutex);
m_messages.push_back(url);
m_cond.notify_all();
}
void PrinterFileSystem::Stop(bool quit)
{
boost::unique_lock l(m_mutex);
if (quit) {
m_session.owner = nullptr;
} else if (m_stopped) {
return;
}
m_stopped = true;
m_cond.notify_all();
}
void PrinterFileSystem::SetUploadFile(const std::string &path, const std::string &name, const std::string &select_storage)
{
boost::unique_lock l(m_mutex);
if (!m_upload_file) {
m_upload_file = std::make_unique<UploadFile>();
}
m_upload_file->path = path;
m_upload_file->name = name;
m_upload_file->select_storage = select_storage;
}
void PrinterFileSystem::BuildGroups()
{
m_group_year.clear();
m_group_month.clear();
if (m_file_list.empty())
return;
wxDateTime t = wxDateTime((time_t) m_file_list.front().time);
m_group_year.push_back(0);
m_group_month.push_back(0);
for (size_t i = 0; i < m_file_list.size(); ++i) {
wxDateTime s = wxDateTime((time_t) m_file_list[i].time);
if (s.GetYear() != t.GetYear()) {
m_group_year.push_back(m_group_month.size());
m_group_month.push_back(i);
} else if (s.GetMonth() != t.GetMonth()) {
m_group_month.push_back(i);
}
t = s;
}
}
void PrinterFileSystem::UpdateGroupSelect()
{
m_group_flags.clear();
int beg = 0;
if (m_group_mode != G_NONE) {
auto group = m_group_mode == G_YEAR ? m_group_year : m_group_month;
if (m_group_mode == G_YEAR)
for (auto &g : group) g = m_group_month[g];
m_group_flags.resize(group.size(), FF_SELECT);
for (int i = 0; i < m_file_list.size(); ++i) {
if ((m_file_list[i].flags & FF_SELECT) == 0) {
auto iter = std::upper_bound(group.begin(), group.end(), i);
m_group_flags[iter - group.begin() - 1] &= ~FF_SELECT;
if (iter == group.end()) break;
i = *iter - 1; // start from next group
}
}
}
}
void PrinterFileSystem::DeleteFilesContinue()
{
std::vector<size_t> indexes;
std::vector<std::string> names;
std::vector<std::string> paths;
for (size_t i = 0; i < m_file_list.size(); ++i)
if ((m_file_list[i].flags & FF_DELETED) && !m_file_list[i].name.empty()) {
indexes.push_back(i);
auto &file = m_file_list[i];
if (file.path.empty())
names.push_back(file.name);
else
paths.push_back(file.path);
if (names.size() >= 64 || paths.size() >= 64)
break;
}
m_task_flags &= ~FF_DELETED;
if (names.empty() && paths.empty())
return;
json req;
json arr;
if (paths.empty()) {
for (auto &name : names) arr.push_back(name);
req["delete"] = arr;
} else {
for (auto &path : paths) arr.push_back(path);
req["paths"] = arr;
}
m_task_flags |= FF_DELETED;
auto type = std::make_pair(m_file_type, m_file_storage);
SendRequest<Void>(
FILE_DEL, req, nullptr,
[indexes, type, names = paths.empty() ? names : paths, bypath = !paths.empty(), this](int, Void const &) {
// TODO:
for (size_t i = indexes.size() - 1; i != size_t(-1); --i)
FileRemoved(type, indexes[i], names[i], bypath);
SendChangedEvent(EVT_FILE_CHANGED, indexes.size());
DeleteFilesContinue();
});
}
void PrinterFileSystem::DownloadNextFile()
{
size_t index = size_t(-1);
for (size_t i = 0; i < m_file_list.size(); ++i) {
if (m_file_list[i].IsDownload() && m_file_list[i].DownloadProgress() == -1) {
index = i;
break;
}
}
m_task_flags &= ~FF_DOWNLOAD;
if (index >= m_file_list.size())
return;
auto &file = m_file_list[index];
json req;
if (file.path.empty())
req["file"] = file.name;
else
req["path"] = file.path;
SendChangedEvent(EVT_DOWNLOAD, index, m_file_list[index].name);
std::shared_ptr<Download> download(m_file_list[index].download);
download->index = index;
download->name = file.name;
download->path = file.path;
m_task_flags |= FF_DOWNLOAD;
m_download_seq = SendRequest<Progress>(
FILE_DOWNLOAD, req,
[download](json const &resp, Progress &prog, unsigned char const *data) -> int {
// in work thread, continue recv
size_t size = resp.value("size", 0);
prog.size = resp["offset"];
prog.total = resp["total"];
if (prog.size == 0) {
download->ofs.open(download->local_path, std::ios::binary);
if (!download->ofs) {
download->error = last_system_error();
wxLogWarning("PrinterFileSystem::DownloadNextFile open error: %s\n", wxString::FromUTF8(download->error));
return FILE_OPEN_ERR;
}
}
if (download->total && (download->size != prog.size || download->total != prog.total)) {
wxLogWarning("PrinterFileSystem::DownloadNextFile data error: %d != %d\n", download->size, prog.size);
}
// receive data
download->ofs.write((char const *) data, size);
if (!download->ofs) {
download->error = last_system_error();
wxLogWarning("PrinterFileSystem::DownloadNextFile write error: %s\n", wxString::FromUTF8(download->error));
return FILE_READ_WRITE_ERR;
}
download->boost_md5.process_bytes(data, size);
prog.size += size;
download->total = prog.total;
download->size = prog.size;
if (prog.size < prog.total) { return 0; }
download->ofs.close();
int result = 0;
std::string md5 = resp["file_md5"];
// check size and md5
if (prog.size == prog.total) {
boost::uuids::detail::md5::digest_type digest;
download->boost_md5.get_digest(digest);
for (int i = 0; i < 4; ++i) digest[i] = boost::endian::endian_reverse(digest[i]);
std::string str_md5;
const auto char_digest = reinterpret_cast<const char *>(&digest[0]);
boost::algorithm::hex(char_digest, char_digest + sizeof(digest), std::back_inserter(str_md5));
if (!boost::iequals(str_md5, md5)) {
wxLogWarning("PrinterFileSystem::DownloadNextFile checksum error: %s != %s\n", str_md5, md5);
boost::system::error_code ec;
boost::filesystem::rename(download->local_path, download->local_path + ".tmp", ec);
result = FILE_CHECK_ERR;
}
} else {
result = FILE_SIZE_ERR;
}
if (result != 0) {
boost::system::error_code ec;
boost::filesystem::remove(download->local_path, ec);
}
return result;
},
[this, download, type = std::make_pair(m_file_type, m_file_storage)](int result, Progress const &data) {
int progress = data.total ? data.size * 100 / data.total : 0;
if (result == CONTINUE) {
if (download->progress == progress)
return;
}
download->progress = progress;
if (download->index != size_t(-1)) {
auto file_index = FindFile(type, download->index, download->path.empty() ? download->name : download->path, !download->path.empty());
download->index = file_index.second;
if (download->index != size_t(-1)) {
auto &file = file_index.first[download->index];
if (result == CONTINUE)
;
else if (result == SUCCESS)
file.download.reset(), file.local_path = download->local_path;
else if (result == ERROR_CANCEL)
file.download.reset(), file.flags &= ~FF_DOWNLOAD;
else // FAILED
file.download.reset();
if (&file_index.first == &m_file_list)
SendChangedEvent(EVT_DOWNLOAD, download->index, result ? download->error : file.local_path, result);
}
}
if (result != CONTINUE) DownloadNextFile();
});
}
enum ThumbnailType
{
OldThumbnail = 0,
VideoThumbnail = 1,
ModelMetadata = 2,
ModelThumbnail = 3,
FinishThumbnail
};
void PrinterFileSystem::UpdateFocusThumbnail()
{
m_task_flags &= ~FF_THUMNAIL;
if (m_lock_start >= m_file_list.size() || m_lock_start >= m_lock_end)
return;
size_t start = m_lock_start;
size_t end = std::min(m_lock_end, GetCount());
std::vector<File> names;
std::vector<File> paths;
for (; start < end; ++start) {
auto &file = GetFile(start);
if ((file.flags & FF_THUMNAIL) == 0) {
if (m_file_type == F_MODEL) {
const_cast<File &>(file).metadata.emplace("Time", "...");
const_cast<File &>(file).metadata.emplace("Weight", "...");
}
if (file.path.empty())
names.push_back({file.name, ""});
else
paths.push_back({file.name, file.path});
if (names.size() >= 2 || paths.size() >= 2)
break;
if ((file.flags & FF_THUMNAIL_RETRY) != 0) {
const_cast<File&>(file).flags &= ~FF_THUMNAIL_RETRY;
break;
}
}
}
if (names.empty() && paths.empty())
return;
m_task_flags |= FF_THUMNAIL;
UpdateFocusThumbnail2(std::make_shared<std::vector<File>>(paths.empty() ? names : paths),
paths.empty() ? OldThumbnail : m_file_type == F_MODEL ? ModelMetadata : VideoThumbnail);
}
bool PrinterFileSystem::ParseThumbnail(File &file)
{
std::istringstream iss(file.local_path, std::ios::binary);
return ParseThumbnail(file, iss);
}
static std::string durationString(long duration)
{
static boost::regex rx("^0d(0h)?");
auto time = boost::format("%1%d%2%h%3%m") % (duration / 86400) % ((duration % 86400) / 3600) % ((duration % 3600) / 60);
return boost::regex_replace(time.str(), rx, "");
}
bool PrinterFileSystem::ParseThumbnail(File &file, std::istream &is)
{
Slic3r::DynamicPrintConfig config;
Slic3r::Model model;
Slic3r::PlateDataPtrs plate_data_list;
Slic3r::Semver file_version;
if (!Slic3r::load_gcode_3mf_from_stream(is, &config, &model, &plate_data_list, &file_version))
return false;
float time = 0.f;
float weight = 0.f;
for (auto &plate : plate_data_list) {
time += atof(plate->gcode_prediction.c_str());
weight += atof(plate->gcode_weight.c_str());
if (!plate->gcode_file.empty() && !plate->thumbnail_file.empty())
file.metadata.emplace("plate_thumbnail_" + std::to_string(plate->plate_index), plate->thumbnail_file);
}
file.metadata.emplace("Title", model.model_info->model_name);
file.metadata.emplace("Time", durationString(round(time)));
file.metadata.emplace("Weight", std::to_string(int(round(weight))) + 'g');
auto thumbnail = model.model_info->metadata_items["Thumbnail"];
if (thumbnail.empty() && !plate_data_list.empty()) {
thumbnail = plate_data_list.front()->thumbnail_file;
}
file.metadata.emplace("Thumbnail", thumbnail);
return true;
}
void PrinterFileSystem::UpdateFocusThumbnail2(std::shared_ptr<std::vector<File>> files, int type)
{
json req;
json arr;
if (type == OldThumbnail) {
for (auto &file : *files) arr.push_back(file.name);
req["files"] = arr;
} else {
if (type == VideoThumbnail) {
for (auto &file : *files) arr.push_back(file.path + "#thumbnail");
} else if (type == ModelMetadata) {
for (auto &file : *files) {
arr.push_back(file.path + "#_rels/.rels");
arr.push_back(file.path + "#3D/3dmodel.model");
arr.push_back(file.path + "#Metadata/model_settings.config");
arr.push_back(file.path + "#Metadata/slice_info.config");
arr.push_back(file.path + "#Metadata/project_settings.config");
}
req["zip"] = true;
} else { // ModelThumbnail, FinishThumbnail
std::vector<std::string> fails;
for (auto &file : *files) {
if ((file.flags & FF_THUMNAIL) == 0) {
fails.push_back(file.path);
file.flags |= FF_THUMNAIL;
}
}
for (auto &path : fails) {
auto iter = std::find_if(m_file_list.begin(), m_file_list.end(), [&path](auto &f) { return f.path == path; });
if (iter != m_file_list.end()) {
if (type == ModelThumbnail) iter->metadata.clear();
iter->flags |= fails.size() == 1 ? FF_THUMNAIL : FF_THUMNAIL_RETRY;
}
}
if (type == ModelThumbnail) {
for (auto &file : *files) {
auto thumbnail = file.metadata["Thumbnail"];
if (!thumbnail.empty()) {
arr.push_back(file.path + "#" + thumbnail);
file.flags &= ~FF_THUMNAIL;
file.local_path.clear();
}
}
}
if (arr.empty()) {
UpdateFocusThumbnail();
return;
}
}
req["paths"] = arr;
}
SendRequest<File>(
SUB_FILE, req, [type, files](json const &resp, File &file, unsigned char const *data) -> int {
// in work thread, continue recv
// receive data
wxString mimetype = resp.value("mimetype", "");
std::string thumbnail = resp.value("thumbnail", "");
std::string path = resp.value("path", "");
boost::uint32_t size = resp.value("size", 0);
bool cont = resp.value("continue", false);
if (size == 0) {
file.name = thumbnail;
file.path = path;
return FILE_SIZE_ERR;
}
auto n = type == ModelMetadata ? std::string::npos : path.find_last_of('#'); // ModelMetadata is zipped without subpath
auto path2 = n == std::string::npos ? path : path.substr(0, n);
auto subpath = n == std::string::npos ? path : path.substr(n + 1);
auto iter = std::find_if(files->begin(), files->end(), [&path2](auto &f) { return f.path == path2; });
if (cont) {
if (iter != files->end())
iter->local_path += std::string((char *) data, size);
return 0;
}
if (type == ModelMetadata) {
if (iter != files->end())
file.local_path = iter->local_path + std::string((char *) data, size);
else
file.local_path = std::string((char *) data, size);
ParseThumbnail(file);
} else {
if (mimetype.empty()) {
if (subpath.empty()) subpath = thumbnail;
auto n = subpath.find_last_of('.');
if (n != std::string::npos)
mimetype = "image/" + subpath.substr(n + 1);
else if (subpath == "thumbnail")
mimetype = "image/jpeg"; // default jpg
}
if (iter != files->end() && !iter->local_path.empty()) {
iter->local_path += std::string((char *) data, size);
data = reinterpret_cast<unsigned char const *>(iter->local_path.c_str());
size = iter->local_path.size();
}
wxMemoryInputStream mis(data, size);
mimetype.Replace("jpg", "jpeg");
file.thumbnail = wxImage(mis, mimetype);
if (!file.thumbnail.IsOk()) {
BOOST_LOG_TRIVIAL(info) << "PrinterFileSystem: parse thumbnail failed" << size << mimetype;
}
}
file.name = thumbnail;
file.path = path;
return 0;
},
[this, files, type](int result, File const &file) {
auto n = file.name.find_last_of('.');
auto name = n == std::string::npos ? file.name : file.name.substr(0, n) + ".mp4";
n = (type == ModelMetadata) ? std::string::npos : file.path.find_last_of('#');
auto path = n == std::string::npos ? file.path : file.path.substr(0, n);
auto iter = path.empty() ? std::find_if(m_file_list.begin(), m_file_list.end(), [&name](auto &f) { return f.name == name; }) :
std::find_if(m_file_list.begin(), m_file_list.end(), [&path](auto &f) { return f.path == path; });
auto iter2 = path.empty() ? std::find_if(files->begin(), files->end(), [&name](auto &f) { return f.name == name; }) :
std::find_if(files->begin(), files->end(), [&path](auto &f) { return f.path == path; });
if (iter != m_file_list.end()) {
if (type == ModelMetadata) {
iter->metadata = file.metadata;
auto thumbnail = iter->metadata["Thumbnail"];
if (thumbnail.empty())
iter->flags |= FF_THUMNAIL; // DOTO: retry on fail
int index = iter - m_file_list.begin();
SendChangedEvent(EVT_THUMBNAIL, index, file.name);
if (iter2 != files->end())
iter2->metadata = file.metadata;
} else {
iter->flags |= FF_THUMNAIL; // DOTO: retry on fail
if (file.thumbnail.IsOk()) {
iter->thumbnail = file.thumbnail;
int index = iter - m_file_list.begin();
SendChangedEvent(EVT_THUMBNAIL, index, file.name);
}
}
}
if (iter2 != files->end())
iter2->flags |= FF_THUMNAIL; // have received response
if (result != CONTINUE)
UpdateFocusThumbnail2(files, type == ModelMetadata ? ModelThumbnail : FinishThumbnail);
});
}
std::pair<PrinterFileSystem::FileList &, size_t> PrinterFileSystem::FindFile(std::pair<FileType, std::string> type, size_t index, std::string const &name, bool by_path)
{
FileList & file_list = type == std::make_pair(m_file_type, m_file_storage) ?
m_file_list :
m_file_list_cache[type];
if (index >= file_list.size() || (by_path ? file_list[index].path : file_list[index].name) != name) {
auto iter = std::find_if(m_file_list.begin(), file_list.end(),
[name, by_path](File &f) { return (by_path ? f.path : f.name) == name; });
if (iter == m_file_list.end()) return {file_list, -1};
index = std::distance(m_file_list.begin(), iter);
}
return {file_list, index};
}
void PrinterFileSystem::FileRemoved(std::pair<FileType, std::string> type, size_t index, std::string const &name, bool by_path)
{
auto file_index = FindFile(type, index, name, by_path);
if (file_index.second == size_t(-1))
return;
if (&file_index.first == &m_file_list) {
auto removeFromGroup = [](std::vector<size_t> &group, size_t index, size_t total) {
for (auto iter = group.begin(); iter != group.end(); ++iter) {
size_t index2 = -1;
if (*iter < index) continue;
if (*iter == index) {
auto iter2 = iter + 1;
if (index + 1 == (iter2 == group.end() ? total : *iter2)) {
index2 = std::distance(group.begin(), iter);
}
++iter;
}
for (; iter != group.end(); ++iter) {
--*iter;
}
return index2;
}
return size_t(-1);
};
size_t index2 = removeFromGroup(m_group_month, index, m_file_list.size());
if (index2 < m_group_month.size()) {
int index3 = removeFromGroup(m_group_year, index2, m_group_month.size());
if (index3 < m_group_year.size()) {
m_group_year.erase(m_group_year.begin() + index3);
if (m_group_mode == G_YEAR)
m_group_flags.erase(m_group_flags.begin() + index3);
}
m_group_month.erase(m_group_month.begin() + index2);
if (m_group_mode == G_MONTH)
m_group_flags.erase(m_group_flags.begin() + index2);
}
}
file_index.first.erase(file_index.first.begin() + index);
}
struct CallbackEvent : wxCommandEvent
{
CallbackEvent(std::function<void(void)> const &callback, boost::weak_ptr<PrinterFileSystem> owner) : wxCommandEvent(EVT_FILE_CALLBACK), callback(callback), owner(owner) {}
~CallbackEvent(){ if (!owner.expired()) callback(); }
std::function<void(void)> const callback;
boost::weak_ptr<PrinterFileSystem> owner;
};
void PrinterFileSystem::PostCallback(std::function<void(void)> const& callback)
{
wxCommandEvent *e = new CallbackEvent(callback, boost::weak_ptr(shared_from_this()));
wxQueueEvent(this, e);
}
void PrinterFileSystem::SendChangedEvent(wxEventType type, size_t index, std::string const &str, long extra)
{
wxCommandEvent event(type);
event.SetEventObject(this);
event.SetInt(index);
if (!str.empty())
event.SetString(wxString::FromUTF8(str.c_str()));
else if (auto iter = error_messages.find(extra); iter != error_messages.end())
event.SetString(_L(iter->second.c_str()));
else if (extra > CONTINUE && extra != ERROR_CANCEL)
event.SetString(wxString::Format(_L("Error code: %d"), int(extra)));
event.SetExtraLong(extra);
if (wxThread::IsMain())
ProcessEventLocally(event);
else
wxPostEvent(this, event);
}
void PrinterFileSystem::DumpLog(void * thiz, int, tchar const *msg)
{
#if !BBL_RELEASE_TO_PUBLIC
BOOST_LOG_TRIVIAL(info) << "PrinterFileSystem: " << wxString(msg).ToUTF8().data();
#endif
static_cast<PrinterFileSystem*>(thiz)->Bambu_FreeLogMsg(msg);
}
boost::uint32_t PrinterFileSystem::RequestMediaAbility(int api_version)
{
json req;
req["peer"] = "studio";
req["api_version"] = api_version;
return SendRequest<MediaAbilityList>(
REQUEST_MEDIA_ABILITY, req, [](const json &resp, MediaAbilityList &list, auto) -> int {
json abliity_list = resp["storage"];
list = abliity_list.get<MediaAbilityList>();
return 0;
},
[this](int result, MediaAbilityList list){
if (result != 0) {
m_last_error = result;
m_media_ability_list.clear();
SendChangedEvent(EVT_MEDIA_ABILITY_CHANGED, RequestMediaAbilityStatus::S_FAILED, "", m_last_error);
return result;
}
m_media_ability_list.swap(list);
SendChangedEvent(EVT_MEDIA_ABILITY_CHANGED, RequestMediaAbilityStatus::S_SUCCESS);
return 0;
});
}
void PrinterFileSystem::RequestUploadFile()
{
if (!m_upload_file) {
return;
}
json req;
req["type"] = "model";
req["storage"] = m_upload_file->select_storage;
req["path"] = m_upload_file->name;
m_upload_file->upload = std::make_unique<Upload>();
boost::filesystem::path path = boost::filesystem::path(m_upload_file->path);
boost::system::error_code ec;
boost::uint32_t file_size = boost::filesystem::file_size(path, ec);
req["total"] = file_size;
m_upload_file->size = file_size;
m_upload_file->upload->total = file_size;
m_upload_seq = SendRequest(
FILE_UPLOAD, req,
[this](int result, const json& resp, auto) -> int{
if (result != SUCCESS && result != CONTINUE && result != FILE_EXIST) {
std::string error_msg = "";
if (result == ERROR_CANCEL) {
error_msg = _L("User cancels task.").ToStdString();
} else if (result == FILE_READ_WRITE_ERR || result == FILE_OPEN_ERR) {
error_msg = _L("Failed to read file, please try again.").ToStdString();
}
wxLogWarning("PrinterFileSystem::UploadFile error: %d\n", result);
SendChangedEvent(EVT_UPLOAD_CHANGED, FF_UPLOADCANCEL, error_msg, result);
} else if (result == SUCCESS) {
SendChangedEvent(EVT_UPLOADING, 100);
SendChangedEvent(EVT_UPLOAD_CHANGED, FF_UPLOADDONE);
} else if (result == CONTINUE || result == FILE_EXIST) {
if (m_upload_file) {
m_upload_file->chunk_size = resp["chunk_size"];
m_upload_file->upload->size = resp["offset"];
m_upload_file->flags |= FF_UPLOADING;
}
{
boost::unique_lock l(m_mutex);
auto cb = [this, upload_file = m_upload_file, seq = m_upload_seq](std::string &msg) -> int {
return UploadFileTask(upload_file, seq, msg);
};
m_produce_message_cb_map[m_upload_seq] = cb;
}
return CONTINUE;
}
// reset m_upload_file
if (m_upload_file) {
if (m_upload_file->upload->ifs.is_open()) {
m_upload_file->upload->ifs.close();
}
m_upload_file.reset();
}
return result;
});
}
int PrinterFileSystem::UploadFileTask(std::shared_ptr<UploadFile> upload_file, boost::uint64_t seq, std::string &msg)
{
if (!upload_file)
return FILE_OPEN_ERR;
if (!(upload_file->flags & FF_UPLOADING))
return FILE_OPEN_ERR;
auto &upload = upload_file->upload;
if (!upload->ifs.is_open()) {
upload->ifs.open(upload_file->path, std::ios::binary);
if (!upload_file->upload->ifs) {
wxLogWarning("PrinterFileSystem::UploadFile open error: %s\n", wxString::FromUTF8(upload_file->path));
return FILE_OPEN_ERR;
}
MD5_Init(&upload->ctx);
}
const boost::uint32_t buffer_size = upload_file->chunk_size * 1024;
char *buffer = new char[buffer_size];
upload->ifs.seekg(upload->size, std::ios::beg);
upload->ifs.read(buffer, buffer_size);
boost::int32_t read_size = upload->ifs.gcount();
if (read_size <= 0) {
wxLogWarning("PrinterFileSystem::Upload read error.\n");
upload->ifs.close();
if (buffer) {
delete[] buffer;
buffer = nullptr;
}
return FILE_READ_WRITE_ERR;
}
json req;
req["frag_id"] = upload->frag_id;
req["offset"] = upload->size;
req["size"] = read_size;
MD5_Update(&upload->ctx, buffer, read_size);
upload->size += read_size;
if (upload->size == upload->total) {
unsigned char digest[16];
MD5_Final(digest, &upload->ctx);
char md5_str[33];
for (int j = 0; j < 16; j++) { sprintf(&md5_str[j * 2], "%02X", (unsigned int) digest[j]); }
std::string md5_out = std::string(md5_str);
std::transform(md5_out.begin(), md5_out.end(), md5_out.begin(), ::tolower);
req["file_md5"] = md5_out;
// OutputDebugStringA(md5_out.c_str());
// OutputDebugStringA("\n");
}
if (m_upload_file && m_upload_file->flags & FF_UPLOADING) {
upload->frag_id++;
upload->progress = upload->size * 100 / upload->total;
int progress = upload->progress == 100 ? 99 : upload->progress;
SendChangedEvent(EVT_UPLOADING, progress);
}
json root;
root["cmdtype"] = FILE_UPLOAD;
root["sequence"] = seq;
root["req"] = req;
std::ostringstream oss;
oss << root;
oss << "\n\n";
oss << std::string(buffer, read_size);
msg = oss.str();
if (buffer) {
delete[] buffer;
buffer = nullptr;
}
if (upload->size == upload->total) {
upload->ifs.close();
return SUCCESS;
}
return CONTINUE;
}
PrinterFileSystem::MediaAbilityList PrinterFileSystem::GetMediaAbilityList() const
{
return m_media_ability_list;
}
void PrinterFileSystem::CancelUploadTask(bool send_cancel_req)
{
if (!m_upload_file)
return;
{
boost::unique_lock l(m_mutex);
if (m_produce_message_cb_map.find(m_upload_seq) != m_produce_message_cb_map.end())
m_produce_message_cb_map.erase(m_upload_seq);
if (m_upload_file->upload->ifs.is_open()) {
m_upload_file->upload->ifs.close();
}
m_upload_file.reset();
}
if (send_cancel_req) {
CancelRequest(m_upload_seq);
} else {
CancelRequests2({m_upload_seq});
}
}
boost::uint32_t PrinterFileSystem::SendRequest(int type, json const &req, callback_t2 const &callback,const std::string& param)
{
if (m_session.tunnel == nullptr) {
Retry();
callback(ERROR_PIPE, json(), nullptr);
return 0;
}
boost::uint32_t seq = m_sequence + m_callbacks.size();
json root;
root["cmdtype"] = type;
root["sequence"] = seq;
root["req"] = req;
std::ostringstream oss;
oss << root;
if (!param.empty()) {
oss << "\n\n";
oss << param;
}
// OutputDebugStringA(oss.str().c_str());
// OutputDebugStringA("\n");
auto msg = oss.str();
boost::unique_lock l(m_mutex);
m_messages.push_back(msg);
m_callbacks.push_back(callback);
m_cond.notify_all();
return seq;
}
void PrinterFileSystem::InstallNotify(int type, callback_t2 const &callback)
{
type -= NOTIFY_FIRST;
if (m_notifies.size() <= size_t(type)) m_notifies.resize(type + 1);
m_notifies[type] = callback;
}
void PrinterFileSystem::CancelRequest(boost::uint32_t seq) { CancelRequests({seq}); }
void PrinterFileSystem::CancelRequests(std::vector<boost::uint32_t> const &seqs)
{
json req;
json arr;
for (auto seq : seqs)
arr.push_back(seq);
req["tasks"] = arr;
SendRequest(TASK_CANCEL, req, [this](int result, json const &resp, unsigned char const *) -> int {
if (result != 0) return result;
json tasks = resp["tasks"];
std::vector<boost::uint32_t> seqs;
for (auto &f : tasks) seqs.push_back(f);
CancelRequests2(seqs);
return 0;
});
}
void PrinterFileSystem::CancelRequests2(std::vector<boost::uint32_t> const &seqs)
{
std::vector<std::pair<boost::uint32_t, callback_t2>> callbacks;
boost::unique_lock l(m_mutex);
for (auto &f : seqs) {
boost::uint32_t seq = f;
seq -= m_sequence;
if (size_t(seq) >= m_callbacks.size()) continue;
auto &c = m_callbacks[seq];
if (c == nullptr) continue;
callbacks.emplace_back(f, c);
c = nullptr;
// erase m_produce_message_cb
if (m_produce_message_cb_map.find(seq) != m_produce_message_cb_map.end())
m_produce_message_cb_map.erase(seq);
}
while (!m_callbacks.empty() && m_callbacks.front() == nullptr) {
m_callbacks.pop_front();
++m_sequence;
}
l.unlock();
for (auto &c : callbacks) {
wxLogInfo("PrinterFileSystem::CancelRequests2: %u\n", c.first);
c.second(ERROR_CANCEL, json(), nullptr);
}
}
void PrinterFileSystem::RecvMessageThread()
{
Bambu_Sample sample;
boost::unique_lock l(m_mutex);
Reconnect(l, 0);
while (true) {
if (m_stopped && (m_session.owner == nullptr || (m_messages.empty() && m_callbacks.empty()))) {
Reconnect(l, 0); // Close and wait start again
if (m_session.owner == nullptr) {
// clear callbacks first
auto callbacks(std::move(m_callbacks));
break;
}
}
if (m_messages.empty() && !m_produce_message_cb_map.empty()) {
auto it = m_produce_message_cb_map.begin();
while(it != m_produce_message_cb_map.end()) {
std::string msg;
auto prodeuce_message_cb = it->second;
l.unlock();
int res = prodeuce_message_cb(msg);
l.lock();
if (res == CONTINUE || res == SUCCESS) {
m_messages.emplace_back(msg);
if (res == SUCCESS) {
it = m_produce_message_cb_map.erase(it);
continue;
}
it++;
} else {
int seq2 = it->first - m_sequence;
// erase it
it = m_produce_message_cb_map.erase(it);
if (size_t(seq2) >= m_callbacks.size())
continue;
auto c = m_callbacks[seq2];
if (c == nullptr)
continue;;
m_callbacks[seq2] = nullptr;
if (seq2 == 0) {
// if produce message return error, erase callback and sequence should plus
while (!m_callbacks.empty() && m_callbacks.front() == nullptr) {
m_callbacks.pop_front();
++m_sequence;
}
}
l.unlock();
c(res, json(), nullptr);
l.lock();
}
}
}
if (!m_messages.empty()) {
auto & msg = m_messages.front();
// OutputDebugStringA(msg.c_str());
// OutputDebugStringA("\n");
wxLogInfo("PrinterFileSystem::SendRequest >>>: \n%s\n", wxString::FromUTF8(msg));
l.unlock();
int n = Bambu_SendMessage(m_session.tunnel, CTRL_TYPE, msg.c_str(), msg.length());
l.lock();
if (n == 0)
m_messages.pop_front();
else if (n != Bambu_would_block) {
Reconnect(l, n);
continue;
}
}
l.unlock();
int n = Bambu_ReadSample(m_session.tunnel, &sample);
l.lock();
if (n == 0) {
HandleResponse(l, sample);
} else if (n == Bambu_stream_end) {
m_stopped = true;
Reconnect(l, m_status == ListSyncing ? ERROR_RES_BUSY : ERROR_PIPE);
} else if (n == Bambu_would_block) {
m_cond.timed_wait(l, boost::posix_time::milliseconds(m_messages.empty() && m_callbacks.empty() ? 1000 : 20));
} else {
Reconnect(l, n);
}
} // while
}
void PrinterFileSystem::HandleResponse(boost::unique_lock<boost::mutex> &l, Bambu_Sample const &sample)
{
unsigned char const *end = sample.buffer + sample.size;
unsigned char const *json_end = (unsigned char const *) memchr(sample.buffer, '\n', sample.size);
while (json_end && json_end + 3 < end && json_end[1] != '\n') json_end = (unsigned char const *) memchr(json_end + 2, '\n', end - json_end - 2);
if (json_end)
json_end += 2;
else
json_end = end;
std::string msg((char const *) sample.buffer, json_end - sample.buffer);
json root;
// OutputDebugStringA(msg.c_str());
// OutputDebugStringA("\n");
wxLogInfo("PrinterFileSystem::HandleResponse <<<: \n%s\n", wxString::FromUTF8(msg));
std::istringstream iss(msg);
int cmd = 0;
int seq = -1;
int result = 0;
json resp;
try {
iss >> root;
if (!root["result"].is_null()) {
result = root["result"];
seq = root["sequence"];
resp = root["reply"];
} else {
// maybe notify
cmd = root["cmdtype"];
seq = root["sequence"];
resp = root["notify"];
}
} catch (...) {
result = ERROR_JSON;
return;
}
if (cmd > 0) {
if (cmd < NOTIFY_FIRST) return;
cmd -= NOTIFY_FIRST;
if (size_t(cmd) >= m_notifies.size()) return;
auto n = m_notifies[cmd];
l.unlock();
n(result, resp, json_end);
l.lock();
} else {
int seq2 = seq - m_sequence;
if (size_t(seq2) >= m_callbacks.size()) return;
auto c = m_callbacks[seq2];
if (c == nullptr) return;
l.unlock();
int result2 = c(result, resp, json_end);
l.lock();
if (result2 != CONTINUE) {
int seq2 = seq - m_sequence;
m_callbacks[seq2] = callback_t2();
if (seq2 == 0) {
while (!m_callbacks.empty() && m_callbacks.front() == nullptr) {
m_callbacks.pop_front();
++m_sequence;
}
}
if (result == CONTINUE) {
l.unlock();
CancelRequest(seq);
l.lock();
}
// error should erase m_produce_message_cb
if (m_produce_message_cb_map.find(seq2) != m_produce_message_cb_map.end()) {
m_produce_message_cb_map.erase(seq2);
}
}
}
}
void PrinterFileSystem::Reconnect(boost::unique_lock<boost::mutex> &l, int result)
{
if (m_session.tunnel) {
auto tunnel = m_session.tunnel;
m_session.tunnel = nullptr;
wxLogMessage("PrinterFileSystem::Reconnect close %d", result);
l.unlock();
Bambu_Close(tunnel);
Bambu_Destroy(tunnel);
l.lock();
}
if (m_session.owner == nullptr)
return;
json r;
while(!m_callbacks.empty()) {
auto c = m_callbacks.front();
m_callbacks.pop_front();
++m_sequence;
if (c) c(result, r, nullptr);
}
m_messages.clear();
if (result)
m_cond.timed_wait(l, boost::posix_time::seconds(10));
while (true) {
while (m_stopped) {
if (m_session.owner == nullptr)
return;
m_status = Status::Reconnecting;
SendChangedEvent(EVT_STATUS_CHANGED, m_status);
m_cond.wait(l);
}
wxLogMessage("PrinterFileSystem::Reconnect Initializing");
m_status = Status::Initializing;
m_last_error = 0;
SendChangedEvent(EVT_STATUS_CHANGED, m_status);
// wait for url
while (!m_stopped && m_messages.empty())
m_cond.wait(l);
if (m_stopped || m_messages.empty()) continue;
std::string url = m_messages.front();
m_messages.clear();
if (url.size() < 2) {
wxLogMessage("PrinterFileSystem::Reconnect Initialize failed: %s", wxString::FromUTF8(url));
m_last_error = atoi(url.c_str());
if (m_last_error == 0)
m_stopped = true;
} else {
wxLogInfo("PrinterFileSystem::Reconnect Initialized: %s", wxString::FromUTF8(url));
l.unlock();
m_status = Status::Connecting;
wxLogMessage("PrinterFileSystem::Reconnect Connecting");
SendChangedEvent(EVT_STATUS_CHANGED, m_status);
Bambu_Tunnel tunnel = nullptr;
int ret = Bambu_Create(&tunnel, url.c_str());
if (ret == 0) {
Bambu_SetLogger(tunnel, DumpLog, this);
ret = Bambu_Open(tunnel);
}
if (ret == 0)
{
auto start_time = boost::posix_time::microsec_clock::universal_time();
boost::posix_time::time_duration timeout = boost::posix_time::seconds(3);
do{
ret = Bambu_StartStreamEx ? Bambu_StartStreamEx(tunnel, CTRL_TYPE) : Bambu_StartStream(tunnel, false);
if (ret == Bambu_would_block)
boost::this_thread::sleep(boost::posix_time::milliseconds(100));
auto now = boost::posix_time::microsec_clock::universal_time();
if (now - start_time > timeout) {
BOOST_LOG_TRIVIAL(warning) << "StartStream timeout after 5 seconds.";
break;
}
} while (ret == Bambu_would_block && !m_stopped);
}
l.lock();
if (ret == 0) {
m_session.tunnel = tunnel;
wxLogMessage("PrinterFileSystem::Reconnect Connected");
break;
} else if (ret == 1) {
m_stopped = true;
ret = ERROR_RES_BUSY;
}
if (tunnel) {
Bambu_Close(tunnel);
Bambu_Destroy(tunnel);
}
m_last_error = ret;
}
wxLogMessage("PrinterFileSystem::Reconnect Failed");
m_status = Status::Failed;
SendChangedEvent(EVT_STATUS_CHANGED, m_status, "", url.size() < 2 ? 1 : m_last_error);
m_cond.timed_wait(l, boost::posix_time::seconds(10));
}
#ifdef PRINTER_FILE_SYSTEM_TEST
PostCallback([this] { SendChangedEvent(EVT_FILE_CHANGED); });
#else
PostCallback([this] {
m_task_flags = 0;
m_status = Status::ListSyncing;
SendChangedEvent(EVT_STATUS_CHANGED, m_status);
});
#endif
}
#include <stdlib.h>
#if defined(_MSC_VER) || defined(_WIN32)
#include <Windows.h>
#else
#include <dlfcn.h>
#endif
#if defined(_MSC_VER) || defined(_WIN32)
static HMODULE module = NULL;
#else
static void* module = NULL;
#endif
static void* get_function(const char* name)
{
void* function = nullptr;
if (!module)
return function;
#if defined(_MSC_VER) || defined(_WIN32)
function = GetProcAddress(module, name);
#else
function = dlsym(module, name);
#endif
if (!function) {
BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", can not find function %1%") % name;
}
return function;
}
#define GET_FUNC(x) lib.x = reinterpret_cast<decltype(lib.x)>(get_function(#x))
StaticBambuLib &StaticBambuLib::get(BambuLib *copy)
{
static StaticBambuLib lib;
// first load the library
if (lib.Bambu_Create)
return lib;
if (!module) {
module = Slic3r::NetworkAgent::get_bambu_source_entry();
}
if (!module) {
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", can not Load Library";
}
GET_FUNC(Bambu_Create);
GET_FUNC(Bambu_Open);
GET_FUNC(Bambu_StartStream);
GET_FUNC(Bambu_StartStreamEx);
GET_FUNC(Bambu_GetStreamCount);
GET_FUNC(Bambu_GetStreamInfo);
GET_FUNC(Bambu_SendMessage);
GET_FUNC(Bambu_ReadSample);
GET_FUNC(Bambu_Close);
GET_FUNC(Bambu_Destroy);
GET_FUNC(Bambu_SetLogger);
GET_FUNC(Bambu_FreeLogMsg);
GET_FUNC(Bambu_Deinit);
if (!lib.Bambu_Create) {
lib.Bambu_Create = Fake_Bambu_Create;
if (copy)
lib.copies_.push_back(copy);
}
return lib;
}
void StaticBambuLib::reset()
{
get().Bambu_Create = nullptr;
auto &lib = get();
for (auto c : lib.copies_)
*c = lib;
}
void StaticBambuLib::release()
{
if (auto f = get().Bambu_Deinit)
f();
}
extern "C" BambuLib *bambulib_get() {
return &StaticBambuLib::get(); }
Reference in New Issue View Git Blame Copy Permalink