Transmission/transmission
1
0
Fork 0
mirror of https://github.com/transmission/transmission.git synced 2025-12-27 05:38:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: add generic favicon_cache class for reuse between Qt, GTK app (#5294)

Browse Source
This commit is contained in:
Charles Kerr
2023-04-22 21:11:16 -05:00
committed by GitHub
parent 9d2507c7e3
commit 1b6b85989c
21 changed files with 385 additions and 441 deletions
Download Patch File Download Diff File Expand all files Collapse all files

160
gtk/FaviconCache.cc
View File

@@ -3,164 +3,52 @@
// or any future license endorsed by Mnemosyne LLC.
// License text can be found in the licenses/ folder.
#include "FaviconCache.h"
#include "Utils.h" /* gtr_get_host_from_url() */
#include <libtransmission/transmission.h>
#include <libtransmission/web-utils.h>
#include <libtransmission/web.h> // tr_sessionFetch()
#include <libtransmission/favicon-cache.h>
#include <gdkmm/pixbuf.h>
#include <giomm/memoryinputstream.h>
#include <glibmm/error.h>
#include <glibmm/fileutils.h>
#include <glibmm/main.h>
#include <glibmm/miscutils.h>
#include <fmt/core.h>
using Icon = Glib::RefPtr<Gdk::Pixbuf>;
#include <array>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <glib/gstdio.h> /* g_remove() */
using namespace std::literals;
namespace
template<>
Icon FaviconCache<Icon>::create_from_file(std::string_view filename) const
{
constexpr auto TimeoutSecs = 15s;
constexpr auto ImageTypes = std::array<std::string_view, 4>{ "ico"sv, "png"sv, "gif"sv, "jpg"sv };
struct favicon_data
{
tr_session* session = nullptr;
std::function<void(Glib::RefPtr<Gdk::Pixbuf> const&)> func;
std::string host;
std::string contents;
size_t type = 0;
long code = 0;
};
Glib::ustring get_url(std::string const& host, size_t image_type)
{
return fmt::format("http://{}/favicon.{}", host, ImageTypes.at(image_type));
}
std::string favicon_get_cache_dir()
{
static std::string dir;
if (dir.empty())
{
dir = Glib::build_filename(Glib::get_user_cache_dir(), "transmission", "favicons");
(void)g_mkdir_with_parents(dir.c_str(), 0777);
}
return dir;
}
std::string favicon_get_cache_filename(std::string const& host)
{
return Glib::build_filename(favicon_get_cache_dir(), host);
}
void favicon_save_to_cache(std::string const& host, std::string const& data)
{
Glib::file_set_contents(favicon_get_cache_filename(host), data);
}
Glib::RefPtr<Gdk::Pixbuf> favicon_load_from_cache(std::string const& host)
{
auto const filename = favicon_get_cache_filename(host);
try
{
return Gdk::Pixbuf::create_from_file(filename, 16, 16, false);
return Gdk::Pixbuf::create_from_file(std::string{ filename }, Width, Height, false);
}
catch (Glib::Error const&)
{
(void)g_remove(filename.c_str());
return {};
}
}
void favicon_web_done_cb(tr_web::FetchResponse const& response);
constexpr bool should_keep_trying(long code)
template<>
Icon FaviconCache<Icon>::create_from_data(void const* data, size_t datalen) const
{
return code != 0 && code <= 500;
}
bool favicon_web_done_idle_cb(std::unique_ptr<favicon_data> fav)
{
Glib::RefPtr<Gdk::Pixbuf> pixbuf;
if (!fav->contents.empty()) /* we got something... try to make a pixbuf from it */
try
{
favicon_save_to_cache(fav->host, fav->contents);
pixbuf = favicon_load_from_cache(fav->host);
auto memory_stream = Gio::MemoryInputStream::create();
memory_stream->add_data(data, datalen, nullptr);
return Gdk::Pixbuf::create_from_stream_at_scale(memory_stream, Width, Height, false);
}
if (pixbuf == nullptr && should_keep_trying(fav->code) && ++fav->type < ImageTypes.size()) /* keep trying */
catch (Glib::Error const&)
{
fav->contents.clear();
auto* const session = fav->session;
auto const next_url = get_url(fav->host, fav->type);
tr_sessionFetch(session, { next_url.raw(), favicon_web_done_cb, fav.release(), TimeoutSecs });
return false;
}
// Not released into the next web request, means we're done trying (even if `pixbuf` is still invalid)
fav->func(pixbuf);
return false;
}
void favicon_web_done_cb(tr_web::FetchResponse const& response)
{
auto* const fav = static_cast<favicon_data*>(response.user_data);
fav->contents = response.body;
fav->code = response.status;
Glib::signal_idle().connect([fav]() { return favicon_web_done_idle_cb(std::unique_ptr<favicon_data>(fav)); });
}
} // namespace
void gtr_get_favicon(
tr_session* session,
std::string const& host,
std::function<void(Glib::RefPtr<Gdk::Pixbuf> const&)> const& pixbuf_ready_func)
{
auto pixbuf = favicon_load_from_cache(host);
if (pixbuf != nullptr)
{
pixbuf_ready_func(pixbuf);
}
else
{
auto data = std::make_unique<favicon_data>();
data->session = session;
data->func = pixbuf_ready_func;
data->host = host;
tr_sessionFetch(session, { get_url(host, 0).raw(), favicon_web_done_cb, data.release(), TimeoutSecs });
return {};
}
}
void gtr_get_favicon_from_url(
tr_session* session,
Glib::ustring const& url,
std::function<void(Glib::RefPtr<Gdk::Pixbuf> const&)> const& pixbuf_ready_func)
template<>
std::string FaviconCache<Icon>::app_cache_dir() const
{
if (auto const parsed_url = tr_urlParse(url.c_str()); parsed_url.has_value())
{
auto const host = std::string{ parsed_url->host };
gtr_get_favicon(session, host, pixbuf_ready_func);
}
else
{
pixbuf_ready_func({});
}
return fmt::format("{:s}/{:s}", Glib::get_user_cache_dir(), "transmission");
}
template<>
void FaviconCache<Icon>::add_to_ui_thread(std::function<void()> idlefunc)
{
Glib::signal_idle().connect_once([idlefunc = std::move(idlefunc)]() { idlefunc(); });
}