fix padding

src/common/input.h

@@ -24,7 +24,6 @@ enum class InputType {
     Analog,
     Trigger,
     Motion,
-    VirtualMotion,
     Touch,
     Color,
     Vibration,

src/core/hid/input_converter.cpp

@@ -5,8 +5,6 @@
 #include <random>
 
 #include "common/input.h"
-#include "common/math_util.h"
-#include "common/quaternion.h"
 #include "core/hid/input_converter.h"
 
 namespace Core::HID {
@@ -83,7 +81,7 @@ Common::Input::MotionStatus TransformToMotion(const Common::Input::CallbackStatu
     Common::Input::MotionStatus status{};
     switch (callback.type) {
     case Common::Input::InputType::Button: {
-       const Common::Input::AnalogProperties properties{
+        Common::Input::AnalogProperties properties{
             .deadzone = 0.0f,
             .range = 1.0f,
             .offset = 0.0f,
@@ -95,18 +93,31 @@ Common::Input::MotionStatus TransformToMotion(const Common::Input::CallbackStatu
             .raw_value = 0.0f,
             .properties = properties,
         };
-        status.delta_timestamp = 5000;
+        status.accel.y = {
-        status.force_update = true;
+            .value = 0.0f,
-        status.accel.x = default_analog_status;
+            .raw_value = 0.0f,
-        status.accel.y = default_analog_status;
+            .properties = properties,
+        };
         status.accel.z = {
             .value = 0.0f,
             .raw_value = -1.0f,
             .properties = properties,
         };
-        status.gyro.x = default_analog_status;
+        status.gyro.x = {
-        status.gyro.y = default_analog_status;
+            .value = 0.0f,
-        status.gyro.z = default_analog_status;
+            .raw_value = 0.0f,
+            .properties = properties,
+        };
+        status.gyro.y = {
+            .value = 0.0f,
+            .raw_value = 0.0f,
+            .properties = properties,
+        };
+        status.gyro.z = {
+            .value = 0.0f,
+            .raw_value = 0.0f,
+            .properties = properties,
+        };
         if (TransformToButton(callback).value) {
             std::random_device device;
             std::mt19937 gen(device());
@@ -123,9 +134,6 @@ Common::Input::MotionStatus TransformToMotion(const Common::Input::CallbackStatu
     case Common::Input::InputType::Motion:
         status = callback.motion_status;
         break;
-    case Common::Input::InputType::VirtualMotion:
-        status = GetVirtualMotion(callback.motion_status);
-        break;
     default:
         LOG_ERROR(Input, "Conversion from type {} to motion not implemented", callback.type);
         break;
@@ -429,32 +437,4 @@ void SanitizeStick(Common::Input::AnalogStatus& analog_x, Common::Input::AnalogS
     }
 }
 
-Common::Input::MotionStatus GetVirtualMotion(Common::Input::MotionStatus input_data,
-                                             Common::Vec3f last_giro) {
-    Common::Input::MotionStatus motion_status = input_data;
-
-    // Axis data is stored in the gyro value
-    float wx = input_data.gyro.x.raw_value;
-    float wy = input_data.gyro.y.raw_value;
-
-    float rotX = (wy * 2 - 1.0f) * 135.0f;  // up/down best
-    float rotY = (wx * 2 - 1.0f) * -180.0f; // left/right
-    float rotZ = input_data.gyro.y.raw_value * 14.0f + m_lastGyroRotation.z;
-
-    Common::Vec3f rotation(rotX - m_lastGyroRotation.x, (rotY - m_lastGyroRotation.y) * 15.0f,
-                       rotZ - m_lastGyroRotation.z);
-
-    rotation.x = std::min(1.0f, std::max(-1.0f, rotation.x / 360.0f));
-    rotation.y = std::min(1.0f, std::max(-1.0f, rotation.y / 360.0f));
-    rotation.z = std::min(1.0f, std::max(-1.0f, rotation.z / 360.0f));
-
-    motion_status.gyro.x.raw_value = rotation.x;
-    motion_status.gyro.y.raw_value = rotation.y;
-    motion_status.gyro.z.raw_value = rotation.z;
-
-    motion_status.accel.x.raw_value = 0.0f;
-    motion_status.accel.y.raw_value = 0.0f;
-    motion_status.accel.z.raw_value = -1.0f;
-}
-
 } // namespace Core::HID

src/core/hid/input_converter.h

@@ -116,21 +116,4 @@ void SanitizeAnalog(Common::Input::AnalogStatus& analog, bool clamp_value);
 void SanitizeStick(Common::Input::AnalogStatus& analog_x, Common::Input::AnalogStatus& analog_y,
                    bool clamp_value);
 
-/**
- * Converts raw stick data into a valid stick value
- * @param analog_x raw analog data and properties for the x-axis
- * @param analog_y raw analog data and properties for the y-axis
- * @param clamp_value bool that determines if the value needs to be clamped into the unit circle.
- */
-void SanitizeStick(Common::Input::AnalogStatus& analog_x, Common::Input::AnalogStatus& analog_y,
-                   bool clamp_value);
-
-/**
- * Calculates the accelerometer value needed to reach the axis position as if it was a pointer to a screen
- *
- * @param input_data Motion status containing the position of all 3 axis
- * @return Motion status with accelerometer data
- */
-Common::Input::MotionStatus GetVirtualMotion(Common::Input::MotionStatus input_data);
-
 } // namespace Core::HID

src/core/hle/service/ns/ns.cpp

@@ -3,6 +3,7 @@
 
 #include "common/logging/log.h"
 #include "common/settings.h"
+#include "common/uuid.h"
 #include "core/core.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
@@ -548,6 +549,84 @@ IDownloadTaskInterface::IDownloadTaskInterface(Core::System& system_)
 
 IDownloadTaskInterface::~IDownloadTaskInterface() = default;
 
+IReadOnlyApplicationControlDataInterface::IReadOnlyApplicationControlDataInterface(
+    Core::System& system_)
+    : ServiceFramework{system_, "IReadOnlyApplicationControlDataInterface"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, &IReadOnlyApplicationControlDataInterface::GetApplicationControlData, "GetApplicationControlData"},
+        {1, nullptr, "GetApplicationDesiredLanguage"},
+        {2, nullptr, "ConvertApplicationLanguageToLanguageCode"},
+        {3, nullptr, "ConvertLanguageCodeToApplicationLanguage"},
+        {4, nullptr, "SelectApplicationDesiredLanguage"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IReadOnlyApplicationControlDataInterface::~IReadOnlyApplicationControlDataInterface() = default;
+
+void IReadOnlyApplicationControlDataInterface::GetApplicationControlData(
+    Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto flag = rp.PopRaw<u64>();
+    LOG_DEBUG(Service_NS, "called with flag={:016X}", flag);
+
+    const auto title_id = rp.PopRaw<u64>();
+
+    const auto size = ctx.GetWriteBufferSize();
+
+    const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
+                                   system.GetContentProvider()};
+    const auto control = pm.GetControlMetadata();
+
+    std::vector<u8> out;
+
+    if (control.first != nullptr) {
+        if (size < 0x4000) {
+            LOG_ERROR(Service_NS,
+                      "output buffer is too small! (actual={:016X}, expected_min=0x4000)", size);
+            IPC::ResponseBuilder rb{ctx, 2};
+            // TODO(DarkLordZach): Find a better error code for this.
+            rb.Push(ResultUnknown);
+            return;
+        }
+
+        out.resize(0x4000);
+        const auto bytes = control.first->GetRawBytes();
+        std::memcpy(out.data(), bytes.data(), bytes.size());
+    } else {
+        LOG_WARNING(Service_NS, "missing NACP data for title_id={:016X}, defaulting to zeros.",
+                    title_id);
+        out.resize(std::min<u64>(0x4000, size));
+    }
+
+    if (control.second != nullptr) {
+        if (size < 0x4000 + control.second->GetSize()) {
+            LOG_ERROR(Service_NS,
+                      "output buffer is too small! (actual={:016X}, expected_min={:016X})", size,
+                      0x4000 + control.second->GetSize());
+            IPC::ResponseBuilder rb{ctx, 2};
+            // TODO(DarkLordZach): Find a better error code for this.
+            rb.Push(ResultUnknown);
+            return;
+        }
+
+        out.resize(0x4000 + control.second->GetSize());
+        control.second->Read(out.data() + 0x4000, control.second->GetSize());
+    } else {
+        LOG_WARNING(Service_NS, "missing icon data for title_id={:016X}, defaulting to zeros.",
+                    title_id);
+    }
+
+    ctx.WriteBuffer(out);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push<u32>(static_cast<u32>(out.size()));
+}
+
 IECommerceInterface::IECommerceInterface(Core::System& system_)
     : ServiceFramework{system_, "IECommerceInterface"} {
     // clang-format off
@@ -785,6 +864,79 @@ private:
     }
 };
 
+class PDM_QRY final : public ServiceFramework<PDM_QRY> {
+public:
+    explicit PDM_QRY(Core::System& system_) : ServiceFramework{system_, "pdm:qry"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "QueryAppletEvent"},
+            {1, nullptr, "QueryPlayStatistics"},
+            {2, nullptr, "QueryPlayStatisticsByUserAccountId"},
+            {3, nullptr, "QueryPlayStatisticsByNetworkServiceAccountId"},
+            {4, nullptr, "QueryPlayStatisticsByApplicationId"},
+            {5, &PDM_QRY::QueryPlayStatisticsByApplicationIdAndUserAccountId, "QueryPlayStatisticsByApplicationIdAndUserAccountId"},
+            {6, nullptr, "QueryPlayStatisticsByApplicationIdAndNetworkServiceAccountId"},
+            {7, nullptr, "QueryLastPlayTimeV0"},
+            {8, nullptr, "QueryPlayEvent"},
+            {9, nullptr, "GetAvailablePlayEventRange"},
+            {10, nullptr, "QueryAccountEvent"},
+            {11, nullptr, "QueryAccountPlayEvent"},
+            {12, nullptr, "GetAvailableAccountPlayEventRange"},
+            {13, nullptr, "QueryApplicationPlayStatisticsForSystemV0"},
+            {14, nullptr, "QueryRecentlyPlayedApplication"},
+            {15, nullptr, "GetRecentlyPlayedApplicationUpdateEvent"},
+            {16, nullptr, "QueryApplicationPlayStatisticsByUserAccountIdForSystemV0"},
+            {17, nullptr, "QueryLastPlayTime"},
+            {18, nullptr, "QueryApplicationPlayStatisticsForSystem"},
+            {19, nullptr, "QueryApplicationPlayStatisticsByUserAccountIdForSystem"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+    ~PDM_QRY() override = default;
+
+private:
+    struct PlayStadistics {
+        u64 application_id; ///< ApplicationId.
+
+        u32 first_entry_index;      ///< Entry index for the first time the application was played.
+        u32 first_timestampUser;    ///< See PdmAppletEvent::timestampUser
+        u32 first_timestampNetwork; ///< See PdmAppletEvent::timestampNetwork
+
+        u32 last_entry_index;      ///< Entry index for the last time the application was played.
+        u32 last_timestampUser;    ///< See PdmAppletEvent::timestampUser
+        u32 last_timestampNetwork; ///< See PdmAppletEvent::timestampNetwork
+
+        u32 play_time_in_minutes;
+        u32 total_launches;
+    };
+    static_assert(sizeof(PlayStadistics) == 0x28, "PlayStadistics is an invalid size");
+
+    void QueryPlayStatisticsByApplicationIdAndUserAccountId(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto unknown = rp.Pop<bool>();
+        const auto unknown2 = rp.Pop<bool>();
+        const auto application_id = rp.Pop<u64>();
+        const auto user_account_uid = rp.PopRaw<Common::UUID>();
+
+        PlayStadistics stadistics{
+            .application_id = application_id,
+            .play_time_in_minutes = 120,
+            .total_launches = 15,
+        };
+
+        LOG_WARNING(Service_NS,
+                    "(STUBBED) called. unknown={}. application_id=0x{:016X}, user_account_uid=0x{}",
+                    unknown, application_id, user_account_uid.Format());
+
+        IPC::ResponseBuilder rb{ctx, 12};
+        rb.Push(ResultSuccess);
+        rb.PushRaw(stadistics);
+    }
+};
+
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
 

src/core/hle/service/ns/ns.h

@@ -61,6 +61,16 @@ public:
     ~IDownloadTaskInterface() override;
 };
 
+class IReadOnlyApplicationControlDataInterface final
+    : public ServiceFramework<IReadOnlyApplicationControlDataInterface> {
+public:
+    explicit IReadOnlyApplicationControlDataInterface(Core::System& system_);
+    ~IReadOnlyApplicationControlDataInterface() override;
+
+private:
+    void GetApplicationControlData(Kernel::HLERequestContext& ctx);
+};
+
 class IECommerceInterface final : public ServiceFramework<IECommerceInterface> {
 public:
     explicit IECommerceInterface(Core::System& system_);

src/core/hle/service/ptm/psm.cpp

@@ -169,4 +169,57 @@ void PSM::OpenSession(HLERequestContext& ctx) {
     rb.PushIpcInterface<IPsmSession>(system);
 }
 
-} // namespace Service::PTM
+    enum class ChargerType : u32 {
+        Unplugged = 0,
+        RegularCharger = 1,
+        LowPowerCharger = 2,
+        Unknown = 3,
+    };
+
+    u32 battery_charge_percentage{100}; // 100%
+    ChargerType charger_type{ChargerType::RegularCharger};
+};
+
+
+class TS final : public ServiceFramework<TS> {
+public:
+    explicit TS(Core::System& system_) : ServiceFramework{system_, "ts"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetTemperatureRange"},
+            {1, nullptr, "GetTemperature"},
+            {2, nullptr, "SetMeasurementMode"},
+            {3, &TS::GetTemperatureMilliC, "GetTemperatureMilliC"},
+            {4, nullptr, "Unknown"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+    ~TS() override = default;
+
+private:
+    enum class Location : u8 {
+        Internal,
+        External,
+    };
+    void GetTemperatureMilliC(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto location = rp.PopEnum<Location>();
+        s32 temperature = 25000;
+
+        LOG_WARNING(Service_PSM, "called location={}, temperature={}",location, temperature);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push(temperature);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
+    std::make_shared<PSM>(system)->InstallAsService(sm);
+    std::make_shared<TS>(system)->InstallAsService(sm);
+}
+
+} // namespace Service::PSM

src/input_common/input_poller.cpp

@@ -674,7 +674,7 @@ public:
 
     void ForceUpdate() override {
         const Common::Input::CallbackStatus status{
-            .type = Common::Input::InputType::VirtualMotion,
+            .type = Common::Input::InputType::Motion,
             .motion_status = GetStatus(),
         };
 
@@ -686,7 +686,7 @@ public:
 
     void OnChange() {
         const Common::Input::CallbackStatus status{
-            .type = Common::Input::InputType::VirtualMotion,
+            .type = Common::Input::InputType::Motion,
             .motion_status = GetStatus(),
         };
 
@@ -1039,28 +1039,21 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateColorDevice(
 }
 
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateMotionDevice(
-    const Common::ParamPackage& params) {
+    Common::ParamPackage params) {
     const PadIdentifier identifier = {
         .guid = Common::UUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
 
-    const auto motion_sensor = params.Get("motion", 0);
+    if (params.Has("motion")) {
-    const auto gyro_threshold = params.Get("threshold", 0.007f);
+        const auto motion_sensor = params.Get("motion", 0);
-    input_engine->PreSetController(identifier);
+        const auto gyro_threshold = params.Get("threshold", 0.007f);
-    input_engine->PreSetMotion(identifier, motion_sensor);
+        input_engine->PreSetController(identifier);
-    return std::make_unique<InputFromMotion>(identifier, motion_sensor, gyro_threshold,
+        input_engine->PreSetMotion(identifier, motion_sensor);
-                                             input_engine.get());
+        return std::make_unique<InputFromMotion>(identifier, motion_sensor, gyro_threshold,
-}
+                                                 input_engine.get());
-
+    }
-std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateVirtualMotionDevice(
-    const Common::ParamPackage& params) {
-    const PadIdentifier identifier = {
-        .guid = Common::UUID{params.Get("guid", "")},
-        .port = static_cast<std::size_t>(params.Get("port", 0)),
-        .pad = static_cast<std::size_t>(params.Get("pad", 0)),
-    };
 
     const auto deadzone = std::clamp(params.Get("deadzone", 0.15f), 0.0f, 1.0f);
     const auto range = std::clamp(params.Get("range", 1.0f), 0.25f, 1.50f);
@@ -1154,7 +1147,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::Create(
         return CreateHatButtonDevice(params);
     }
     if (params.Has("axis_x") && params.Has("axis_y") && params.Has("axis_z")) {
-        return CreateVirtualMotionDevice(params);
+        return CreateMotionDevice(params);
     }
     if (params.Has("motion")) {
         return CreateMotionDevice(params);

src/input_common/input_poller.h

@@ -204,19 +204,6 @@ private:
     /**
      * Creates a motion device from the parameters given.
      * @param params contains parameters for creating the device:
-     *               - "motion": index of the motion sensor
-     *               - "threshold": gyro deadzone to avoid drifting
-     *               - "guid": text string for identifying controllers
-     *               - "port": port of the connected device
-     *               - "pad": slot of the connected controller
-     * @returns a unique input device with the parameters specified
-     */
-    std::unique_ptr<Common::Input::InputDevice> CreateMotionDevice(
-        const Common::ParamPackage& params);
-
-    /**
-     * Creates a virtual motion device from the parameters given.
-     * @param params contains parameters for creating the device:
      *               - "axis_x": the controller horizontal axis id to bind with the input
      *               - "axis_y": the controller vertical axis id to bind with the input
      *               - "axis_z": the controller forward axis id to bind with the input
@@ -233,8 +220,7 @@ private:
      *               - "pad": slot of the connected controller
      * @returns a unique input device with the parameters specified
      */
-    std::unique_ptr<Common::Input::InputDevice> CreateVirtualMotionDevice(
+    std::unique_ptr<Common::Input::InputDevice> CreateMotionDevice(Common::ParamPackage params);
-        const Common::ParamPackage& params);
 
     /**
      * Creates a camera device from the parameters given.