/* * WiVRn VR streaming * Copyright (C) 2022-2024 Guillaume Meunier * Copyright (C) 2022-2024 Patrick Nicolas * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "wifi_lock.h" #ifdef __ANDROID__ #include "application.h" #include "spdlog/spdlog.h" #include #include #include "android/jnipp.h" wifi_lock::wifi_lock(decltype(multicast_) m, decltype(wifi_) w) : multicast_(std::move(m)), wifi_(std::move(w)) {} std::shared_ptr wifi_lock::make_wifi_lock(jobject activity) { jni::object<""> act(application::native_app()->activity->clazz); jni::string lock_name("WiVRn"); static int api_level = jni::klass("android/os/Build$VERSION").field("SDK_INT"); auto app = act.call>("getApplication"); auto ctx = app.call>("getApplicationContext"); auto wifi_service_id = ctx.klass().field("WIFI_SERVICE"); auto system_service = ctx.call>("getSystemService", wifi_service_id); return std::shared_ptr(new wifi_lock( system_service.call>("createMulticastLock", lock_name), system_service.call>( "createWifiLock", jni::Int(api_level >= 29 ? 4 /*WIFI_MODE_FULL_LOW_LATENCY*/ : 3 /*WIFI_MODE_FULL_HIGH_PERF*/), lock_name))); } void wifi_lock::print_wifi() { if (wifi_.call("isHeld")) spdlog::info("WifiLock low latency acquired"); else spdlog::info("WifiLock low latency released"); } void wifi_lock::print_multicast() { if (multicast_.call("isHeld")) spdlog::info("MulticastLock acquired"); else spdlog::info("MulticastLock released"); } std::shared_ptr wifi_lock::get_wifi_lock() { std::lock_guard lock(mutex); if (auto l = wifi_weak.lock()) return l; wifi_.call("acquire"); print_wifi(); // The shared pointer has a separate reference counter: destructor only calls a method auto res = std::shared_ptr( this, [self = shared_from_this()](void *) { std::lock_guard lock(self->mutex); self->wifi_.call("release"); self->print_wifi(); }); wifi_weak = res; return res; } std::shared_ptr wifi_lock::get_multicast_lock() { std::lock_guard lock(mutex); if (auto l = multicast_weak.lock()) return l; multicast_.call("acquire"); print_multicast(); // The shared pointer has a separate reference counter: destructor only calls a method auto res = std::shared_ptr( this, [self = shared_from_this()](void *) { std::lock_guard lock(self->mutex); self->multicast_.call("release"); self->print_multicast(); }); multicast_weak = res; return res; } #else std::shared_ptr wifi_lock::get_wifi_lock() { return nullptr; } std::shared_ptr wifi_lock::get_multicast_lock() { return nullptr; } #endif