Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-12-08 06:09:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Ladybird/Android/src/main/cpp/LadybirdActivity.cpp

235 lines
8.7 KiB
C++
Raw Normal View History

Ladybird: Add new template Kotlin Android application without Qt This template app from Android Studio should hopefully be more fun to work on than the Qt wrapped application we were using before. :^) It currently builds the native code using gradle rules, and has a stub WebViewImplementationNative class that will wrap a c++ class of the same name that inhertis from WebView::ViewImplementation. Spawning helper processes and creating proper views in Kotlin is next on the list.
2023-09-02 17:30:21 +02:00
/*
* Copyright (c) 2023, Andrew Kaster <akaster@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
Ladybird/Android: Add EventLoopImplementation for ALooper Timers run in their own thread, to take advantage of existing Java Executor features. By hooking into ALooper, we can spin the main Activity's UI thread event loop without causing a fuss, or spinning the CPU by just polling our event loop constantly.
2023-09-08 22:12:42 -06:00
#include "ALooperEventLoopImplementation.h"
Ladybird/Android: Explicitly schedule Core::EventLoop in main activity Instead of having an annoying loop that constantly reschedules a Core::EventLoop trigger, have the ALooperEventLoopManager do it itself in the did_post_event() function. We cannot simply re-use the Unix implementation directly because that implementation expects to actually be called all the time in order to service timers. If you don't call its' pump() method, timers do not get triggered. So, we do still need the seconary thread for Timers that was added earlier.
2023-09-15 19:55:59 -06:00
#include "JNIHelpers.h"
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
#include <AK/ByteString.h>
Ladybird/Android: Implement enough of WebContent to load local files The local files can only be loaded by calling loadURL on the WebView, but it's a start.
2023-09-13 23:22:44 -06:00
#include <AK/Format.h>
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
#include <AK/HashMap.h>
#include <AK/LexicalPath.h>
Ladybird/Android: Add EventLoopImplementation for ALooper Timers run in their own thread, to take advantage of existing Java Executor features. By hooking into ALooper, we can spin the main Activity's UI thread event loop without causing a fuss, or spinning the CPU by just polling our event loop constantly.
2023-09-08 22:12:42 -06:00
#include <AK/OwnPtr.h>
Ladybird: Add new template Kotlin Android application without Qt This template app from Android Studio should hopefully be more fun to work on than the Qt wrapped application we were using before. :^) It currently builds the native code using gradle rules, and has a stub WebViewImplementationNative class that will wrap a c++ class of the same name that inhertis from WebView::ViewImplementation. Spawning helper processes and creating proper views in Kotlin is next on the list.
2023-09-02 17:30:21 +02:00
#include <Ladybird/Utilities.h>
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
#include <LibArchive/TarStream.h>
#include <LibCore/DirIterator.h>
#include <LibCore/Directory.h>
Ladybird/Android: Add EventLoopImplementation for ALooper Timers run in their own thread, to take advantage of existing Java Executor features. By hooking into ALooper, we can spin the main Activity's UI thread event loop without causing a fuss, or spinning the CPU by just polling our event loop constantly.
2023-09-08 22:12:42 -06:00
#include <LibCore/EventLoop.h>
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
#include <LibCore/System.h>
Ladybird/Android: Add EventLoopImplementation for ALooper Timers run in their own thread, to take advantage of existing Java Executor features. By hooking into ALooper, we can spin the main Activity's UI thread event loop without causing a fuss, or spinning the CPU by just polling our event loop constantly.
2023-09-08 22:12:42 -06:00
#include <LibCore/Timer.h>
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
#include <LibFileSystem/FileSystem.h>
Android: Create a WebView::Application object to placate LibWebView LibWebView uses the Application object in WebContentClient.cpp, so we need one to exist. It doesn't really do anything, since we never add processes to it, but it just has to exist.
2024-07-03 17:31:23 -04:00
#include <LibWebView/Application.h>
Ladybird: Add new template Kotlin Android application without Qt This template app from Android Studio should hopefully be more fun to work on than the Qt wrapped application we were using before. :^) It currently builds the native code using gradle rules, and has a stub WebViewImplementationNative class that will wrap a c++ class of the same name that inhertis from WebView::ViewImplementation. Spawning helper processes and creating proper views in Kotlin is next on the list.
2023-09-02 17:30:21 +02:00
#include <jni.h>
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
static ErrorOr<void> extract_tar_archive(String archive_file, ByteString output_directory);
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
Ladybird/Android: Explicitly schedule Core::EventLoop in main activity Instead of having an annoying loop that constantly reschedules a Core::EventLoop trigger, have the ALooperEventLoopManager do it itself in the did_post_event() function. We cannot simply re-use the Unix implementation directly because that implementation expects to actually be called all the time in order to service timers. If you don't call its' pump() method, timers do not get triggered. So, we do still need the seconary thread for Timers that was added earlier.
2023-09-15 19:55:59 -06:00
JavaVM* global_vm;
Android: Create a WebView::Application object to placate LibWebView LibWebView uses the Application object in WebContentClient.cpp, so we need one to exist. It doesn't really do anything, since we never add processes to it, but it just has to exist.
2024-07-03 17:31:23 -04:00
static OwnPtr<WebView::Application> s_application;
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
static OwnPtr<Core::EventLoop> s_main_event_loop;
Ladybird/Android: Explicitly schedule Core::EventLoop in main activity Instead of having an annoying loop that constantly reschedules a Core::EventLoop trigger, have the ALooperEventLoopManager do it itself in the did_post_event() function. We cannot simply re-use the Unix implementation directly because that implementation expects to actually be called all the time in order to service timers. If you don't call its' pump() method, timers do not get triggered. So, we do still need the seconary thread for Timers that was added earlier.
2023-09-15 19:55:59 -06:00
static jobject s_java_instance;
static jmethodID s_schedule_event_loop_method;
Ladybird/Android: Add EventLoopImplementation for ALooper Timers run in their own thread, to take advantage of existing Java Executor features. By hooking into ALooper, we can spin the main Activity's UI thread event loop without causing a fuss, or spinning the CPU by just polling our event loop constantly.
2023-09-08 22:12:42 -06:00
Ladybird: Add new template Kotlin Android application without Qt This template app from Android Studio should hopefully be more fun to work on than the Qt wrapped application we were using before. :^) It currently builds the native code using gradle rules, and has a stub WebViewImplementationNative class that will wrap a c++ class of the same name that inhertis from WebView::ViewImplementation. Spawning helper processes and creating proper views in Kotlin is next on the list.
2023-09-02 17:30:21 +02:00
extern "C" JNIEXPORT void JNICALL
Ladybird/Android: Explicitly schedule Core::EventLoop in main activity Instead of having an annoying loop that constantly reschedules a Core::EventLoop trigger, have the ALooperEventLoopManager do it itself in the did_post_event() function. We cannot simply re-use the Unix implementation directly because that implementation expects to actually be called all the time in order to service timers. If you don't call its' pump() method, timers do not get triggered. So, we do still need the seconary thread for Timers that was added earlier.
2023-09-15 19:55:59 -06:00
Java_org_serenityos_ladybird_LadybirdActivity_initNativeCode(JNIEnv* env, jobject thiz, jstring resource_dir, jstring tag_name, jobject timer_service)
Ladybird: Add new template Kotlin Android application without Qt This template app from Android Studio should hopefully be more fun to work on than the Qt wrapped application we were using before. :^) It currently builds the native code using gradle rules, and has a stub WebViewImplementationNative class that will wrap a c++ class of the same name that inhertis from WebView::ViewImplementation. Spawning helper processes and creating proper views in Kotlin is next on the list.
2023-09-02 17:30:21 +02:00
{
char const* raw_resource_dir = env->GetStringUTFChars(resource_dir, nullptr);
s_serenity_resource_root = raw_resource_dir;
env->ReleaseStringUTFChars(resource_dir, raw_resource_dir);
Ladybird/Android: Add EventLoopImplementation for ALooper Timers run in their own thread, to take advantage of existing Java Executor features. By hooking into ALooper, we can spin the main Activity's UI thread event loop without causing a fuss, or spinning the CPU by just polling our event loop constantly.
2023-09-08 22:12:42 -06:00
Ladybird/Android: Implement enough of WebContent to load local files The local files can only be loaded by calling loadURL on the WebView, but it's a start.
2023-09-13 23:22:44 -06:00
char const* raw_tag_name = env->GetStringUTFChars(tag_name, nullptr);
AK::set_log_tag_name(raw_tag_name);
env->ReleaseStringUTFChars(tag_name, raw_tag_name);
dbgln("Set resource dir to {}", s_serenity_resource_root);
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
auto file_or_error = Core::System::open(MUST(String::formatted("{}/res/icons/16x16/app-browser.png", s_serenity_resource_root)), O_RDONLY);
if (file_or_error.is_error()) {
dbgln("No resource files, extracting assets...");
MUST(extract_tar_archive(MUST(String::formatted("{}/ladybird-assets.tar", s_serenity_resource_root)), s_serenity_resource_root));
} else {
dbgln("Found app-browser.png, not re-extracting assets.");
dbgln("Hopefully no developer changed the asset files and expected them to be re-extracted!");
}
Ladybird/Android: Explicitly schedule Core::EventLoop in main activity Instead of having an annoying loop that constantly reschedules a Core::EventLoop trigger, have the ALooperEventLoopManager do it itself in the did_post_event() function. We cannot simply re-use the Unix implementation directly because that implementation expects to actually be called all the time in order to service timers. If you don't call its' pump() method, timers do not get triggered. So, we do still need the seconary thread for Timers that was added earlier.
2023-09-15 19:55:59 -06:00
env->GetJavaVM(&global_vm);
VERIFY(global_vm);
s_java_instance = env->NewGlobalRef(thiz);
jclass clazz = env->GetObjectClass(s_java_instance);
VERIFY(clazz);
s_schedule_event_loop_method = env->GetMethodID(clazz, "scheduleEventLoop", "()V");
VERIFY(s_schedule_event_loop_method);
env->DeleteLocalRef(clazz);
Ladybird/Android: Add EventLoopImplementation for ALooper Timers run in their own thread, to take advantage of existing Java Executor features. By hooking into ALooper, we can spin the main Activity's UI thread event loop without causing a fuss, or spinning the CPU by just polling our event loop constantly.
2023-09-08 22:12:42 -06:00
jobject timer_service_ref = env->NewGlobalRef(timer_service);
Ladybird/Android: Explicitly schedule Core::EventLoop in main activity Instead of having an annoying loop that constantly reschedules a Core::EventLoop trigger, have the ALooperEventLoopManager do it itself in the did_post_event() function. We cannot simply re-use the Unix implementation directly because that implementation expects to actually be called all the time in order to service timers. If you don't call its' pump() method, timers do not get triggered. So, we do still need the seconary thread for Timers that was added earlier.
2023-09-15 19:55:59 -06:00
auto* event_loop_manager = new Ladybird::ALooperEventLoopManager(timer_service_ref);
event_loop_manager->on_did_post_event = [] {
Ladybird/Android: Move JavaEnvironment helper to Ladybird namespace
2023-09-23 22:48:24 -06:00
Ladybird::JavaEnvironment env(global_vm);
Ladybird/Android: Explicitly schedule Core::EventLoop in main activity Instead of having an annoying loop that constantly reschedules a Core::EventLoop trigger, have the ALooperEventLoopManager do it itself in the did_post_event() function. We cannot simply re-use the Unix implementation directly because that implementation expects to actually be called all the time in order to service timers. If you don't call its' pump() method, timers do not get triggered. So, we do still need the seconary thread for Timers that was added earlier.
2023-09-15 19:55:59 -06:00
env.get()->CallVoidMethod(s_java_instance, s_schedule_event_loop_method);
};
Core::EventLoopManager::install(*event_loop_manager);
Ladybird/Android: Add EventLoopImplementation for ALooper Timers run in their own thread, to take advantage of existing Java Executor features. By hooking into ALooper, we can spin the main Activity's UI thread event loop without causing a fuss, or spinning the CPU by just polling our event loop constantly.
2023-09-08 22:12:42 -06:00
s_main_event_loop = make<Core::EventLoop>();
Android: Create a WebView::Application object to placate LibWebView LibWebView uses the Application object in WebContentClient.cpp, so we need one to exist. It doesn't really do anything, since we never add processes to it, but it just has to exist.
2024-07-03 17:31:23 -04:00
// FIXME: We are not making use of this Application object to track our processes.
// So, right now, the Application's ProcessManager is constantly empty.
// (However, LibWebView depends on an Application object existing, so we do have to actually create one.)
s_application = make<WebView::Application>(0, nullptr);
Ladybird/Android: Add EventLoopImplementation for ALooper Timers run in their own thread, to take advantage of existing Java Executor features. By hooking into ALooper, we can spin the main Activity's UI thread event loop without causing a fuss, or spinning the CPU by just polling our event loop constantly.
2023-09-08 22:12:42 -06:00
}
extern "C" JNIEXPORT void JNICALL
Java_org_serenityos_ladybird_LadybirdActivity_execMainEventLoop(JNIEnv*, jobject /* thiz */)
{
Ladybird/Android: Explicitly schedule Core::EventLoop in main activity Instead of having an annoying loop that constantly reschedules a Core::EventLoop trigger, have the ALooperEventLoopManager do it itself in the did_post_event() function. We cannot simply re-use the Unix implementation directly because that implementation expects to actually be called all the time in order to service timers. If you don't call its' pump() method, timers do not get triggered. So, we do still need the seconary thread for Timers that was added earlier.
2023-09-15 19:55:59 -06:00
if (s_main_event_loop) {
s_main_event_loop->pump(Core::EventLoop::WaitMode::PollForEvents);
}
}
extern "C" JNIEXPORT void JNICALL
Java_org_serenityos_ladybird_LadybirdActivity_disposeNativeCode(JNIEnv* env, jobject /* thiz */)
{
s_main_event_loop = nullptr;
s_schedule_event_loop_method = nullptr;
Android: Create a WebView::Application object to placate LibWebView LibWebView uses the Application object in WebContentClient.cpp, so we need one to exist. It doesn't really do anything, since we never add processes to it, but it just has to exist.
2024-07-03 17:31:23 -04:00
s_application = nullptr;
Ladybird/Android: Explicitly schedule Core::EventLoop in main activity Instead of having an annoying loop that constantly reschedules a Core::EventLoop trigger, have the ALooperEventLoopManager do it itself in the did_post_event() function. We cannot simply re-use the Unix implementation directly because that implementation expects to actually be called all the time in order to service timers. If you don't call its' pump() method, timers do not get triggered. So, we do still need the seconary thread for Timers that was added earlier.
2023-09-15 19:55:59 -06:00
env->DeleteGlobalRef(s_java_instance);
delete &Core::EventLoopManager::the();
Ladybird: Add new template Kotlin Android application without Qt This template app from Android Studio should hopefully be more fun to work on than the Qt wrapped application we were using before. :^) It currently builds the native code using gradle rules, and has a stub WebViewImplementationNative class that will wrap a c++ class of the same name that inhertis from WebView::ViewImplementation. Spawning helper processes and creating proper views in Kotlin is next on the list.
2023-09-02 17:30:21 +02:00
}
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
ErrorOr<void> extract_tar_archive(String archive_file, ByteString output_directory)
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
{
constexpr size_t buffer_size = 4096;
auto file = TRY(Core::InputBufferedFile::create(TRY(Core::File::open(archive_file, Core::File::OpenMode::Read))));
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
ByteString old_pwd = TRY(Core::System::getcwd());
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
TRY(Core::System::chdir(output_directory));
ScopeGuard go_back = [&old_pwd] { MUST(Core::System::chdir(old_pwd)); };
auto tar_stream = TRY(Archive::TarInputStream::construct(move(file)));
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
HashMap<ByteString, ByteString> global_overrides;
HashMap<ByteString, ByteString> local_overrides;
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
auto get_override = [&](StringView key) -> Optional<ByteString> {
Optional<ByteString> maybe_local = local_overrides.get(key);
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
if (maybe_local.has_value())
return maybe_local;
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
Optional<ByteString> maybe_global = global_overrides.get(key);
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
if (maybe_global.has_value())
return maybe_global;
return {};
};
while (!tar_stream->finished()) {
Archive::TarFileHeader const& header = tar_stream->header();
// Handle meta-entries earlier to avoid consuming the file content stream.
if (header.content_is_like_extended_header()) {
switch (header.type_flag()) {
case Archive::TarFileType::GlobalExtendedHeader: {
TRY(tar_stream->for_each_extended_header([&](StringView key, StringView value) {
if (value.length() == 0)
global_overrides.remove(key);
else
global_overrides.set(key, value);
}));
break;
}
case Archive::TarFileType::ExtendedHeader: {
TRY(tar_stream->for_each_extended_header([&](StringView key, StringView value) {
local_overrides.set(key, value);
}));
break;
}
default:
warnln("Unknown extended header type '{}' of {}", (char)header.type_flag(), header.filename());
VERIFY_NOT_REACHED();
}
TRY(tar_stream->advance());
continue;
}
Archive::TarFileStream file_stream = tar_stream->file_contents();
// Handle other header types that don't just have an effect on extraction.
switch (header.type_flag()) {
case Archive::TarFileType::LongName: {
StringBuilder long_name;
Array<u8, buffer_size> buffer;
while (!file_stream.is_eof()) {
auto slice = TRY(file_stream.read_some(buffer));
long_name.append(reinterpret_cast<char*>(slice.data()), slice.size());
}
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
local_overrides.set("path", long_name.to_byte_string());
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
TRY(tar_stream->advance());
continue;
}
default:
// None of the relevant headers, so continue as normal.
break;
}
LexicalPath path = LexicalPath(header.filename());
if (!header.prefix().is_empty())
path = path.prepend(header.prefix());
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
ByteString filename = get_override("path"sv).value_or(path.string());
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
Ladybird: Update Android build to work with current LibWebView/LibCore Also update to the latest gradle plugin versions and other dependencies as recommended by Android Studio Jellyfish.
2024-05-04 06:08:53 -06:00
ByteString absolute_path = TRY(FileSystem::absolute_path(filename));
Ladybird/Android: Revive extract_tar_archive function This function used to live in AndroidPlatform.cpp, but was removed during the transition to the new app. We still need to extract the assets from the tarball that CMake creates. At least, until we come up with a generic "Resource" concept in LibCore.
2023-09-14 12:15:28 -06:00
auto parent_path = LexicalPath(absolute_path).parent();
auto header_mode = TRY(header.mode());
switch (header.type_flag()) {
case Archive::TarFileType::NormalFile:
case Archive::TarFileType::AlternateNormalFile: {
MUST(Core::Directory::create(parent_path, Core::Directory::CreateDirectories::Yes));
int fd = TRY(Core::System::open(absolute_path, O_CREAT | O_WRONLY, header_mode));
Array<u8, buffer_size> buffer;
while (!file_stream.is_eof()) {
auto slice = TRY(file_stream.read_some(buffer));
TRY(Core::System::write(fd, slice));
}
TRY(Core::System::close(fd));
break;
}
case Archive::TarFileType::SymLink: {
MUST(Core::Directory::create(parent_path, Core::Directory::CreateDirectories::Yes));
TRY(Core::System::symlink(header.link_name(), absolute_path));
break;
}
case Archive::TarFileType::Directory: {
MUST(Core::Directory::create(parent_path, Core::Directory::CreateDirectories::Yes));
auto result_or_error = Core::System::mkdir(absolute_path, header_mode);
if (result_or_error.is_error() && result_or_error.error().code() != EEXIST)
return result_or_error.release_error();
break;
}
default:
// FIXME: Implement other file types
warnln("file type '{}' of {} is not yet supported", (char)header.type_flag(), header.filename());
VERIFY_NOT_REACHED();
}
// Non-global headers should be cleared after every file.
local_overrides.clear();
TRY(tar_stream->advance());
}
return {};
}
Reference in a new issue Copy permalink